Artículo técnico

LAMBDA y LET en Delphi: clausuras de fórmulas de HotXLS

La celda contiene =NetOf(B2, C2), B2 guarda 1250, C2 guarda 0.19, Excel muestra 1012.5, y el libro no contiene ningún módulo VBA ni complemento. NetOf vive en el Administrador de nombres: es un nombre definido cuyo texto es LAMBDA(amount, rate, amount*(1-rate)). Una calculadora del lado servidor que trata cada nombre definido como un rango o una constante no encuentra ahí nada que poder llamar, y la celda vuelve como #NAME?

Hacer que esa celda funcione requiere más que un parser que acepte la palabra LAMBDA. Un evaluador de hoja de cálculo clásico conoce cinco clases de valor: números, texto, booleanos, errores y referencias a celdas que contienen eso. LAMBDA añade una sexta, un valor de función que lleva sus nombres de parámetro, su cuerpo y los nombres que eran visibles donde se escribió. LET es la otra mitad de la historia, porque LET es donde los usuarios vinculan esas funciones a nombres locales cortos y las llaman unos tokens después, a menudo tres niveles de profundidad

Tres sitios donde puede resolverse un nombre de función

Cuando el motor de fórmulas de HotXLS se encuentra una llamada a un nombre que no es una función incorporada, prueba tres fuentes en un orden fijo. La primera es el ámbito LET o LAMBDA actual: si f es un enlace local que contiene una clausura, f(21) la aplica. La segunda es un nombre definido de libro cuyo texto empieza por LAMBDA, así que NetOf(1250, 0.19) compila el cuerpo del nombre y lo aplica a los dos argumentos. La tercera es el handler de funciones de usuario que quizá ya uses para funciones Delphi personalizadas, descrito en funciones personalizadas en el motor de fórmulas de HotXLS. Solo cuando las tres pasan se convierte la celda en #NAME?

El orden importa en una situación concreta. Un nombre local siempre gana a un nombre de libro con la misma grafía, aunque el enlace local guarde un número corriente. En ese caso la búsqueda de nombres definidos se salta por completo y la llamada va directa al handler de funciones de usuario, y una LAMBDA de libro con el mismo nombre nunca se consulta para esa llamada

Diagrama de las tres rutas de resolución de llamadas de HotXLS en Delphi probadas en orden para un nombre de función desconocido como f(21): una vinculación de ámbito LET o LAMBDA local que contiene un cierre, un nombre definido de libro cuyo texto RefersTo empieza por LAMBDA, y el manejador clásico de funciones de usuario, mientras una vinculación que contiene un número nunca se aplica como función y la llamada acaba en #NAME? cuando ningún manejador de funciones de usuario reclama el nombre
HotXLS prueba primero el ámbito local, después los nombres definidos LAMBDA, luego el handler clásico de funciones de usuario, y se niega a llamar a un enlace que no contenga una closure

El lado Delphi es corto. Una función con nombre es simplemente un nombre definido añadido con TXLSXDefinedNames.Add, y una clausura dentro de una fórmula no necesita registro alguno:

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

    // Add de dos argumentos = ámbito de libro, que es lo que consulta la llamada por nombre
    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)';

    // Una clausura vinculada y aplicada dentro de una fórmula: 42
    Sheet.Cells[3, 2].Formula := 'LET(double, LAMBDA(x, x*2), double(21))';

    // bump captura base = 100; 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))';

    // Aplicación sufija, sin ningún nombre: 42
    Sheet.Cells[5, 2].Formula := 'LAMBDA(x, x*2)(21)';

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

La última celda muestra una forma que la gente suele olvidar. Excel permite aplicar una expresión LAMBDA directamente escribiendo la lista de argumentos justo detrás, y HotXLS parsea LAMBDA(x, x*2)(21) de la misma manera. El parser acepta esa lista de argumentos final solo detrás de algo que pueda producir una función, como un nombre, una expresión LET o IF, u otra aplicación. Escribir (1+2)(3) falla en tiempo de compilación y no en tiempo de evaluación

Qué recuerda una clausura y por qué ganan los parámetros

Evaluar una expresión LAMBDA en HotXLS produce un valor de clausura: los nombres de parámetro, una copia del cuerpo, la hoja donde se escribió y una instantánea de cada enlace LET o LAMBDA visible en ese momento. En la cuarta celda de arriba, bump se crea con base ya vinculada a 100, así que la clausura lleva consigo base = 100. Cuando bump(5) corre dentro del LET interior, el cuerpo sigue viendo ese 100, aunque el LET interior no sepa nada de base por nombre

Una llamada ocurre luego en tres pasos. Las expresiones de los argumentos se evalúan primero, en el ámbito de quien llama. Después se apila el entorno capturado, encima los parámetros, y se evalúa el cuerpo. Las búsquedas van de arriba abajo, así que un parámetro llamado rate tapa un enlace capturado llamado rate, y un enlace capturado tapa cualquier cosa que quien llama hubiera vinculado con el mismo nombre. Cuando el cuerpo retorna, o falla, el ámbito se recorta hasta donde empezó la llamada

Diagrama de una llamada de cierre LAMBDA de HotXLS en Delphi: el valor de cierre lleva su parámetro, cuerpo y la vinculación base capturada del LET circundante, la llamada empuja el entorno capturado antes del argumento v = 5, el cuerpo evalúa a 105, y la pila de ámbitos se trunca de vuelta a su marca de entrada dentro de una guarda finally
Llamar a una closure apila el entorno capturado antes de los enlaces de argumentos, y ese orden es exactamente lo que hace que los parámetros den sombra a los nombres exteriores

Evaluar los argumentos antes de instalar ningún enlace suena a detalle hasta que escribes LET(x, 10, f, LAMBDA(x, x+1), f(x*2)). El argumento x*2 tiene que referirse al x exterior, lo que da 20, y el resultado es 21. Si el parámetro se instalara primero, el argumento leería el parámetro que está a punto de definir. La regla que cae de ahí es la que los usuarios de Excel esperan: lo que calcula una función con nombre depende de sus argumentos y de lo que capturó cuando se escribió, y los demás nombres locales de quien llama nunca se cuelan dentro

¿Por qué falla f(21) cuando f guarda un número?

Un enlace local que guarda algo distinto de una clausura nunca se aplica como función. LET(f, 3, f(21)) no multiplica 3 por 21, y tampoco recurre a un nombre de libro llamado f. La llamada pasa al handler de funciones de usuario, y si ningún handler reclama el nombre, la celda acaba como #NAME?. Ese resultado es el correcto para una hoja de cálculo: una errata que convirtiera silenciosamente una llamada de función en una multiplicación produciría un número plausible que nadie cuestiona

La aplicación sufija es aún más estricta. Lo que esté delante de la lista de argumentos se evalúa, y si el resultado no es una clausura, la celda recibe #VALUE!, así que LET(g, 3, (g)(21)) y LET(g, 3, g(21)) fallan con errores distintos. Otros fallos que puedes reproducir en un libro de pruebas:

  • Recuento de argumentos equivocado: LET(add, LAMBDA(a, b, a+b), add(1)) devuelve #VALUE! antes de evaluar la expresión del argumento
  • Los errores dentro de los argumentos viajan como valores: en LET(safe, LAMBDA(x, IFERROR(x, 0)), safe(1/0)) el #DIV/0! se vincula a x y el IFERROR del cuerpo lo convierte en 0
  • Las referencias siguen siendo referencias: un argumento como A1 llega al cuerpo como referencia de celda, así que las funciones que se fijan en la identidad de referencia, ISREF entre ellas, ven una referencia y no el valor de la celda
  • Una definición LAMBDA acepta hasta 253 parámetros, el mismo techo que Excel documenta para LAMBDA
  • La recursión desbocada se detiene: una lambda con nombre que se llama a sí misma comparte un techo por defecto de 256 niveles anidados con el anidamiento ordinario de fórmulas, y pasado ese límite la llamada termina con un error de límite de recursos en vez de agotar la pila de Delphi
// Log es tu propia rutina de registro, no forma parte de HotXLS
procedure ProbeLambdaErrors(Sheet: TXLSXWorksheet; Book: TXLSXWorkbook);
begin
  Sheet.Cells[2, 4].Formula := 'LET(f, 3, f(21))';                       // #NAME? sin handler
  Sheet.Cells[3, 4].Formula := 'LET(g, 3, (g)(21))';                     // #VALUE!, sufija
  Sheet.Cells[4, 4].Formula := 'LET(add, LAMBDA(a, b, a+b), add(1))';     // #VALUE!, aridad
  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;

Enlaces LET en HotXLS, anidados y parciales

HotXLS evalúa LET de izquierda a derecha: cada enlace se evalúa con todos los enlaces anteriores en ámbito, se apila, y el último argumento se evalúa bajo el conjunto completo. Así LET(a, 1, b, a+1, LET(c, b*2, c)) devuelve 4, y el LET interior ve tanto a como b. Cuando el LET exterior termina, sus enlaces desaparecen, lo que significa que una fórmula hermana en la celda siguiente empieza desde un ámbito vacío

Dos reglas de forma se exigen antes de que nada corra. LET necesita un número impar de argumentos, al menos tres, así que LET(a, 1) es #VALUE!. Y cada hueco de nombre debe ser un nombre llano: LET(A1, 5, A1*2) se rechaza porque A1 es una referencia de celda, mientras que nombres cortos como x o ab, que también deletrean letras de columna, se leen como nombres locales dentro de LET y LAMBDA. Un enlace a un rango conserva el rango, así que LET(r, A1:A10, ROWS(r)) devuelve 10 y SUM(r) suma las celdas

Los mismos valores de clausura alimentan las funciones auxiliares construidas para ellos: MAP, REDUCE, SCAN, MAKEARRAY, BYROW y BYCOL. MAP(A2:A6, LAMBDA(v, v*2)) derrama cinco valores doblados, y REDUCE(0, A2:A6, LAMBDA(acc, v, acc+v)) los pliega en una sola suma. El entorno capturado viaja a esas llamadas exactamente igual que en una llamada directa, así que un rate vinculado por LET sigue visible dentro del cuerpo del MAP

Comas, puntos y comas y lo que escribe SaveAs

El parser de fórmulas de HotXLS toma la coma y el punto y coma como separadores de argumentos intercambiables. El texto de fórmula llega de sitios que no controlas: una incidencia de soporte escrita en una máquina con locale alemán, documentación que usa las comas canónicas de Excel, un script que genera cadenas de fórmula, código HotXLS viejo que usaba puntos y comas por todas partes. SUM(A1,A2) y SUM(A1;A2) compilan lo mismo, y también una LAMBDA escrita de cualquiera de las dos formas

Las constantes de array en línea son la excepción. Dentro de llaves el punto y coma conserva su significado de Excel como separador de filas, así que {1,2;3,4} es un array de dos por dos, no una lista de cuatro argumentos. Si generas fórmulas con puntos y comas como separadores de argumentos, mantén las constantes de array en la sintaxis de Excel y ambas nunca colisionan

Cell.Formula devuelve el texto que asignaste. Cuando SaveAs escribe un archivo XLSX, los puntos y comas usados como separadores de argumentos fuera de llaves se escriben como comas, porque el formato de archivo OOXML guarda las fórmulas en la sintaxis de comas de Excel, y las funciones que Excel guarda bajo un prefijo _xlfn. reciben ese prefijo a la salida. Una fórmula cargada de un archivo y sin tocar se escribe de vuelta desde su texto XML original

Leer lambdas con nombre de libros de clientes

Los libros creados en Excel guardan los nombres LAMBDA como Excel los escribe: con un prefijo _xlfn. en el nombre de función y a menudo _xlpm. en los parámetros. HotXLS quita esos prefijos cuando evalúa el nombre, pero TXLSXDefinedName.Formula devuelve el texto de definición tal como lo trajo el archivo. Una comprobación escrita como Copy(Name.Formula, 1, 6) = 'LAMBDA' pasa para los nombres que creaste en código y se pierde todos los nombres que salieron de Excel. Ese desajuste es fácil de perder, porque los valores calculados son correctos de ambas formas y solo tu propio código de auditoría discrepa

// IsLambdaDefinition es un helper que añades tú, no es una API de HotXLS
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 es tu propia rutina de registro
  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;

La comprobación de ámbito en ese bucle está ahí porque la llamada por nombre en HotXLS busca al destinatario entre los nombres de nivel de libro. Mantén las funciones con nombre en ámbito de libro. Un nombre LAMBDA con ámbito de hoja todavía se puede leer mediante FindByName(AName, ASheetIndex), pero una función que la gente llama desde varias hojas pertenece al libro, y las reglas de ámbito detrás de eso están trazadas en nombres definidos y fórmulas entre hojas

Editar una lambda después sale barato. Asignar un texto nuevo a TXLSXDefinedName.Formula invalida el grafo de dependencias, así que el siguiente Recalculate lo reconstruye y reevalúa las celdas que llaman a la función; la mecánica está en recálculo incremental y grafo de dependencias. Una celda cuya fórmula evalúa a una clausura desnuda, como =LAMBDA(x, x*2) sin llamada, no recibe valor en caché alguno, ya que no hay número ni texto que guardar; Excel muestra #CALC! para la misma celda. Para informes que deben abrirse en herramientas sin soporte de LAMBDA, congela los resultados con Sheet.Cells.ConvertFormulasToValues tras el último Recalculate, que conserva cada valor en caché y suelta el texto de fórmula

LAMBDA, LET, las funciones auxiliares y la API de nombres definidos vienen todos en la misma biblioteca nativa para Delphi y C++Builder, que lee y escribe XLS, XLSX y ODS sin Excel instalado. La lista completa de funciones de fórmula está en la página del componente de hojas de cálculo de HotXLS