Teknik Makale

HotXLS: Delphi ile LAMBDA, LET ve Formül Kapanışları

Hücre =NetOf(B2, C2) okur, B2 1250 tutar, C2 0.19, Excel 1012.5 gösterir ve çalışma kitabında ne VBA modülü ne eklenti vardır. NetOf, Ad Yöneticisi'nde yaşar: metni LAMBDA(amount, rate, amount*(1-rate)) olan bir tanımlı addır. Her tanımlı adı aralık ya da sabit sayan sunucu tarafı bir hesaplayıcı, orada çağırabileceği bir şey bulamaz ve hücre #NAME? olarak döner

Bu hücreyi doğru değerlendirmek, LAMBDA kelimesini kabul eden bir ayrıştırıcıdan fazlasını gerektirir. Klasik bir elektronik tablo değerlendiricisi beş tür değer bilir: sayılar, metin, boole değerleri, hatalar ve bunları tutan hücrelere başvurular. LAMBDA altıncıyı ekler: parametre adlarını, gövdesini ve yazıldığı anda görünür olan adları taşıyan bir işlev değeri. LET ise hikayenin öteki yarısıdır; çünkü kullanıcılar o işlevleri LET ile kısa yerel adlara bağlar ve birkaç simge sonra çağırır, çoğu zaman üç katman derinlikte

Bir işlev adının çözülebileceği üç yer

HotXLS formül motoru, yerleşik işlev olmayan bir ada yapılan çağrıyla karşılaştığında üç kaynağı sabit bir sırada dener. Birincisi geçerli LET ya da LAMBDA kapsamıdır: f, kapanış tutan bir yerel bağlamaysa f(21) onu uygular. İkincisi metni LAMBDA ile başlayan bir çalışma kitabı tanımlı adıdır; NetOf(1250, 0.19) adın gövdesini derler ve iki argümana uygular. Üçüncüsü, özel Delphi işlevleri için hâlihazırda kullandığınız kullanıcı-işlevi işleyicisidir; HotXLS formül motorunda özel işlevler yazısında anlatılır. Ancak üçü de adı bulamadığında hücre #NAME? olur

Sıra, tek bir durumda önem taşır. Yerel bir ad, aynı yazıma sahip bir çalışma kitabı adını her zaman yener; yerel bağlama sıradan bir sayı tuttuğunda bile. O durumda tanımlı ad araması tamamen atlanır, çağrı doğrudan kullanıcı-işlevi işleyicisine gider ve aynı ada sahip bir çalışma kitabı LAMBDA'sı o çağrı için hiç sorgulanmaz

Delphi'de f(21) gibi bilinmeyen bir işlev adı için sırayla denenen üç HotXLS çağrı çözümleme yolunun şeması: kapanış tutan yerel bir LET ya da LAMBDA kapsam bağlaması, RefersTo metni LAMBDA ile başlayan bir çalışma kitabı tanımlı adı ve klasik kullanıcı-işlevi işleyicisi; sayı tutan bir yerel bağlama hiçbir zaman işlev olarak uygulanmaz ve kullanıcı-işlevi işleyicisi adı üstlenmediğinde çağrı #NAME? ile biter
HotXLS önce yerel kapsamı, sonra LAMBDA tanımlı adlarını, sonra klasik kullanıcı-işlevi işleyicisini dener ve kapanış tutmayan bir bağlamayı çağırmayı reddeder

Delphi tarafı kısadır. Adlandırılmış bir işlev, TXLSXDefinedNames.Add ile eklenen sıradan bir tanımlı addır ve tek bir formül içindeki kapanış hiçbir kayıt gerektirmez:

var
  Book: TXLSXWorkbook;
  Sheet: TXLSXWorksheet;
begin
  Book := TXLSXWorkbook.Create;
  try
    Sheet := Book.Sheets.Add('Model');

    // İki argümanlı Add = çalışma kitabı kapsamı; ada göre çağrının baktığı yer burası
    Book.DefinedNames.Add('NetOf', 'LAMBDA(amount, rate, amount*(1-rate))');

    // 1250 * (1 - 0.19) = 1012.5
    Sheet.Cells[2, 2].Formula := 'NetOf(1250, 0.19)';

    // Tek bir formülde bağlanan ve uygulanan bir kapanış: 42
    Sheet.Cells[3, 2].Formula := 'LET(double, LAMBDA(x, x*2), double(21))';

    // bump, base = 100 yakalar; bump(5) = 105, step*2 = 210
    Sheet.Cells[4, 2].Formula :=
      'LET(base, 100, bump, LAMBDA(v, v+base), LET(step, bump(5), step*2))';

    // Sonek uygulaması, hiç ad yok: 42
    Sheet.Cells[5, 2].Formula := 'LAMBDA(x, x*2)(21)';

    Book.Recalculate;
    Book.SaveAs('lambda-model.xlsx');
  finally
    Book.Free;
  end;
end;

Son hücre, insanların çoğunlukla unuttuğu bir biçimi gösterir. Excel, bir LAMBDA ifadesini hemen ardından argüman listesini yazarak doğrudan uygulamanıza izin verir ve HotXLS, LAMBDA(x, x*2)(21)'i aynı şekilde ayrıştırır. Ayrıştırıcı, o sondaki argüman listesini yalnızca işlev üretebilecek bir şeyin ardından kabul eder: bir ad, bir LET ya da IF ifadesi ya da başka bir uygulama gibi. (1+2)(3) yazmak, değerlendirme anında değil derleme anında başarısız olur

Bir kapanış neyi hatırlar, parametreler neden kazanır?

HotXLS'te bir LAMBDA ifadesini değerlendirmek bir kapanış değeri üretir: parametre adları, gövdenin bir kopyası, yazıldığı sayfa ve o anda görünür olan her LET ya da LAMBDA bağlamasının anlık görüntüsü. Yukarıdaki dördüncü hücrede bump, base hâlâ 100'e bağlıyken oluşturulur; dolayısıyla kapanış base = 100'ü yanında taşır. bump(5) iç LET'in içinde çalıştığında gövde o 100'ü görmeye devam eder; iç LET, base'i adıyla hiç bilmese bile

Çağrı sonra üç adımda olur. Önce argüman ifadeleri, çağıranın kapsamında değerlendirilir. Sonra yakalanan ortam itilir, üstüne parametreler konur ve gövde değerlendirilir. Aramalar yukarıdan aşağıya yapılır; dolayısıyla rate adlı bir parametre, rate adlı yakalanmış bir bağlamayı gizler ve yakalanmış bağlama, çağıranın aynı adla bağladığı her şeyi gizler. Gövde döndüğünde ya da başarısız olduğunda kapsam, çağrının başladığı yere kesilir

Delphi'de bir HotXLS LAMBDA kapanış çağrısının şeması: kapanış değeri parametresini, gövdesini ve çevresindeki LET'ten yakalanan base bağlamasını taşır; çağrı, yakalanan ortamı v = 5 argümanından önce iter, gövde 105 değerini üretir ve kapsam yığını, finally koruması içindeki giriş işaretine kadar kesilir
Bir kapanışı çağırmak, yakalanan ortamı argüman bağlamalarından önce iter ve parametrelerin dış adları gölgelemesini sağlayan tam olarak bu sıralamadır

Bağlamalardan herhangi biri kurulmadan önce argümanları değerlendirmek ayrıntı gibi gelir; ta ki LET(x, 10, f, LAMBDA(x, x+1), f(x*2)) yazana dek. x*2 argümanı dıştaki x'i ifade etmek zorundadır; bu 20 verir ve sonuç 21 olur. Parametre önce kurulsaydı argüman, tanımlamak üzere olduğu parametreyi okurdu. Ortaya çıkan kural, Excel kullanıcılarının beklediği kuraldır: adlandırılmış bir işlevin hesapladığı şey, argümanlarına ve yazıldığı anda yakaladığı şeylere bağlıdır; çağıranın öteki yerel adları ona hiç sızmaz

f bir sayı tutarken f(21) neden başarısız olur?

Kapanıştan başka bir şey tutan yerel bir bağlama hiçbir zaman işlev olarak uygulanmaz. LET(f, 3, f(21)), 3'ü 21 ile çarpmaz ve f adlı bir çalışma kitabı adına da düşmez. Çağrı kullanıcı-işlevi işleyicisine yoluna devam eder ve hiçbir işleyici adı üstlenmezse hücre #NAME? olarak biter. Bu sonuç bir elektronik tablo için doğrusudur: bir işlev çağrısını sessizce çarpmaya çeviren bir yazım hatası, kimsenin sorgulamayacağı inandırıcı bir sayı üretirdi

Sonek uygulaması daha da katıdır. Argüman listesinin önünde ne varsa değerlendirilir ve sonuç bir kapanış değilse hücre #VALUE! alır; dolayısıyla LET(g, 3, (g)(21)) ile LET(g, 3, g(21)) farklı hatalarla başarısız olur. Boş bir çalışma kitabında yeniden üretebileceğiniz diğer başarısızlıklar:

  • Yanlış argüman sayısı: LET(add, LAMBDA(a, b, a+b), add(1)), argüman ifadesi değerlendirilmeden #VALUE! döndürür
  • Argümanların içindeki hatalar değer olarak yol alır: LET(safe, LAMBDA(x, IFERROR(x, 0)), safe(1/0)) içinde #DIV/0! x'e bağlanır ve gövdedeki IFERROR onu 0'a çevirir
  • Başvurular başvuru olarak kalır: A1 gibi bir argüman gövdeye hücre başvurusu olarak ulaşır; böylece başvuru kimliğiyle ilgilenen işlevler, ISREF de dahil, hücrenin değeri değil bir başvuru görür
  • Bir LAMBDA tanımı en çok 253 parametre alır; Excel'in LAMBDA için belgelediği tavan da aynıdır
  • Kaçak özyineleme durur: kendini çağıran adlandırılmış bir lambda, sıradan formül iç içeliğiyle ortak olan 256 iç içe düzeylik varsayılan tavanı paylaşır ve ötesinde çağrı, Delphi yığınını tüketmek yerine kaynak sınırı hatasıyla biter
// Log sizin kendi günlükleme yordamınızdır, HotXLS'in parçası değildir
procedure ProbeLambdaErrors(Sheet: TXLSXWorksheet; Book: TXLSXWorkbook);
begin
  Sheet.Cells[2, 4].Formula := 'LET(f, 3, f(21))';                       // işleyici yokken #NAME?
  Sheet.Cells[3, 4].Formula := 'LET(g, 3, (g)(21))';                     // #VALUE!, sonek
  Sheet.Cells[4, 4].Formula := 'LET(add, LAMBDA(a, b, a+b), add(1))';     // #VALUE!, argüman sayısı
  Sheet.Cells[5, 4].Formula := 'LET(safe, LAMBDA(x, IFERROR(x, 0)), safe(1/0))'; // 0
  Book.Recalculate;
  Log(Sheet.Cells[2, 4].FormattedText);
  Log(Sheet.Cells[3, 4].FormattedText);
  Log(Sheet.Cells[4, 4].FormattedText);
  Log(Sheet.Cells[5, 4].FormattedText);
end;

HotXLS'te LET bağlamaları: iç içe ve kısmi

HotXLS, LET'i soldan sağa değerlendirir: her bağlama, o ana kadarki bütün bağlamalar kapsamdayken değerlendirilir, itilir ve son argüman, tam kümenin altında değerlendirilir. Böylece LET(a, 1, b, a+1, LET(c, b*2, c)) 4 döndürür ve iç LET hem a'yı hem b'yi görür. Dış LET bittiğinde bağlamaları kaybolur; yani komşu hücredeki bir formül boş bir kapsamdan başlar

Hiçbir şey çalışmadan önce iki biçim kuralı uygulanır. LET, en az üç olmak üzere tek sayıda argüman ister; dolayısıyla LET(a, 1) #VALUE!'dir. Ve her ad yuvası sade bir ad olmalıdır: LET(A1, 5, A1*2) reddedilir, çünkü A1 bir hücre başvurusudur; buna karşılık LET ve LAMBDA içinde x ya da ab gibi, sütun harfleriyle de aynı yazıma gelen kısa adlar yerel ad olarak okunur. Bir aralığa yapılan bağlama aralığı korur; dolayısıyla LET(r, A1:A10, ROWS(r)) 10 döndürür ve SUM(r) hücreleri toplar

Aynı kapanış değerleri, onlar için kurulmuş yardımcı işlevleri besler: MAP, REDUCE, SCAN, MAKEARRAY, BYROW ve BYCOL. MAP(A2:A6, LAMBDA(v, v*2)) beş ikiye katlanmış değer taşırır ve REDUCE(0, A2:A6, LAMBDA(acc, v, acc+v)) onları tek bir toplama katlar. Yakalanan ortam, doğrudan bir çağrıda izlediği yolun aynısını izler; dolayısıyla LET ile bağlanmış bir rate, MAP gövdesinin içinde de görünür kalır

Virgüller, noktalı virgüller ve SaveAs ne yazar

HotXLS formül ayrıştırıcısı, argüman ayırıcı olarak virgülle noktalı virgülü birbirinin yerine kabul eder. Formül metni kontrolünüzde olmayan yerlerden gelir: Alman yerel ayarlı bir makinede yazılmış bir destek talebi, Excel'in kuralı virgülleri kullanan bir dokümantasyon, formül dizeleri üreten bir betik, baştan sona noktalı virgülle yazılmış eski HotXLS kodu. SUM(A1,A2) ile SUM(A1;A2) aynı şeye derlenir; her iki yazımla yazılmış bir LAMBDA da öyle

Satır içi dizi sabitleri istisnadır. Süslü parantezlerin içinde noktalı virgül, Excel'in satır ayırıcı anlamını korur; dolayısıyla {1,2;3,4} dört argümanlı bir liste değil, ikiye iki bir dizidir. Argüman ayırıcı olarak noktalı virgülle formül üretiyorsanız dizi sabitlerini Excel sözdiziminde tutun; ikisi hiç çarpışmaz

Cell.Formula atadığınız metni döndürür. SaveAs bir XLSX dosyası yazarken, süslü parantezlerin dışında argüman ayırıcı olarak kullanılan noktalı virgüller virgül olarak yazılır; çünkü OOXML dosya biçimi formülleri Excel'in virgül sözdizimiyle saklar ve Excel'in _xlfn. önekiyle sakladığı işlevler çıkışta o öneki alır. Dosyadan yüklenmiş ve dokunulmamış bir formül, özgün XML metninden geri yazılır

Müşteri çalışma kitaplarındaki adlandırılmış lambdaları okumak

Excel'de yazılmış çalışma kitapları, LAMBDA adlarını Excel'in yazdığı şekilde saklar: işlev adında _xlfn. öneki ve çoğunlukla parametrelerde _xlpm. önekiyle. HotXLS adı değerlendirirken bu ön ekleri soyar ama TXLSXDefinedName.Formula, tanım metnini dosyanın verdiği gibi döndürür. Copy(Name.Formula, 1, 6) = 'LAMBDA' yazılmış bir kontrol, kodla oluşturduğunuz adlar için geçer ve Excel'den gelen hiçbir adı yakalamaz. Bu uyumsuzluğu gözden kaçırmak kolaydır: hesaplanan değerler her iki durumda da doğrudur ve ayrışan yalnızca kendi denetim kodunuzdur

// IsLambdaDefinition kendi eklediğiniz bir yardımcıdır, HotXLS API'si değildir
function IsLambdaDefinition(const Text: WideString): Boolean;
var
  S: WideString;
begin
  S := UpperCase(Trim(Text));
  if (S <> '') and (S[1] = '=') then
    Delete(S, 1, 1);
  if Copy(S, 1, 6) = '_XLFN.' then
    Delete(S, 1, 6);
  Result := Copy(S, 1, 7) = 'LAMBDA(';
end;

procedure AuditLambdas(const FileName: string);
var
  Book: TXLSXWorkbook;
  Name: TXLSXDefinedName;
  I: Integer;
begin
  // Log sizin kendi günlükleme yordamınızdır
  Book := TXLSXWorkbook.Create;
  try
    if Book.Open(FileName) = 1 then
    begin
      for I := 0 to Book.DefinedNames.Count - 1 do
      begin
        Name := Book.DefinedNames[I];
        if IsLambdaDefinition(Name.Formula) and (Name.SheetIndex >= 0) then
          Log('Sheet-scoped lambda, not callable by name: ' + Name.Name);
      end;
      Book.Recalculate;
      Log(VarToStr(Book.Sheets[1].Cells[2, 2].Value));
    end;
  finally
    Book.Free;
  end;
end;

O döngüdeki kapsam kontrolü oradadır, çünkü HotXLS'te ada göre çağrı, çağrılanı çalışma kitabı düzeyi adlar arasında arar. Adlandırılmış işlevleri çalışma kitabı kapsamında tutun. Sayfa kapsamlı bir LAMBDA adını FindByName(AName, ASheetIndex) ile yine okuyabilirsiniz ama birkaç sayfadan çağrılan bir işlev çalışma kitabına aittir; arkasındaki kapsam kuralları tanımlı adlar ve sayfalar arası formüller yazısında sıralanır

Bir lambda'yı sonra düzenlemek ucuzdur. TXLSXDefinedName.Formula'ya yeni bir metin atamak bağımlılık grafiğini geçersiz kılar; bir sonraki Recalculate onu yeniden kurar ve işlevi çağıran hücreleri yeniden değerlendirir. Mekanik, artımlı yeniden hesaplama ve bağımlılık grafiği yazısındadır. Formülü çıplak bir kapanışa değerlenen hücre — çağrısız =LAMBDA(x, x*2) gibi — hiç önbellek değeri almaz, saklanacak sayı ya da metin yoktur; Excel aynı hücre için #CALC! gösterir. LAMBDA desteği olmayan araçlarda açılması gereken raporlar için sonuçları, Sheet.Cells.ConvertFormulasToValues ile, son Recalculate'in ardından dondurun; o, her önbellek değerini tutar ve formül metnini düşürür

LAMBDA, LET, yardımcı işlevler ve tanımlı ad API'si, Excel kurulu olmadan XLS, XLSX ve ODS okuyup yazan aynı yerel Delphi ve C++Builder kütüphanesinde gelir. Tam formül işlev listesi HotXLS elektronik tablo bileşeni sayfasındadır