La celda lee =NetOf(B2, C2), B2 tiene 1250, C2 tiene 0.19, Excel muestra 1012.5, y el libro de trabajo no contiene ningún módulo VBA ni add-in. NetOf vive en el Name Manager: es un nombre definido cuyo texto es LAMBDA(amount, rate, amount*(1-rate)). Un calculador del lado del servidor que trata cada nombre definido como un rango o una constante no encuentra nada invocable ahí, y la celda regresa como #NAME?
Hacer que esa celda funcione toma más que un parser que acepte la palabra LAMBDA. Un evaluador de hojas de cálculo clásico conoce cinco tipos de valor: números, texto, booleanos, errores y referencias a celdas que los contienen. LAMBDA agrega un sexto, un valor de función que carga sus nombres de parámetro, su cuerpo y los nombres que eran visibles donde fue escrito. 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 lugares donde un nombre de función puede resolverse
Cuando el motor de fórmulas de HotXLS se encuentra con una llamada a un nombre que no es una función incorporada, prueba tres fuentes en un orden fijo. La primera es el alcance LET o LAMBDA actual: si f es un enlace local que contiene un closure, f(21) lo aplica. La segunda es un nombre definido del libro de trabajo cuyo texto empieza con LAMBDA, así que NetOf(1250, 0.19) compila el cuerpo del nombre y lo aplica a los dos argumentos. La tercera es el manejador de funciones de usuario que usted quizás ya usa para funciones Delphi personalizadas, descrito en funciones personalizadas en el motor de fórmulas de HotXLS. Solo cuando las tres pasan la celda se vuelve #NAME?
El orden importa en una situación específica. Un nombre local siempre vence a un nombre del libro de trabajo con la misma grafía, incluso cuando el enlace local contiene un número ordinario. En ese caso la búsqueda por nombre definido se salta por completo y la llamada va directo al manejador de funciones de usuario, y un LAMBDA del libro de trabajo con el mismo nombre jamás se consulta para esa llamada
El lado Delphi es corto. Una función con nombre es solo un nombre definido agregado con TXLSXDefinedNames.Add, y un closure dentro de una sola fórmula no necesita ningún registro:
var
Book: TXLSXWorkbook;
Sheet: TXLSXWorksheet;
begin
Book := TXLSXWorkbook.Create;
try
Sheet := Book.Sheets.Add('Model');
// Add de dos argumentos = alcance de libro de trabajo, que es lo que busca 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)';
// Un closure vinculado y aplicado dentro de una sola 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 postfix, 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 tiende a olvidar. Excel le deja aplicar una expresión LAMBDA directamente escribiendo la lista de argumentos justo después, y HotXLS parsea LAMBDA(x, x*2)(21) de la misma manera. El parser acepta esa lista de argumentos final solo despué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 en lugar de en tiempo de evaluación
Qué recuerda un closure, y por qué ganan los parámetros
Evaluar una expresión LAMBDA en HotXLS produce un valor closure: los nombres de los parámetros, una copia del cuerpo, la hoja donde fue escrito, y una instantánea de cada enlace LET o LAMBDA visible en ese momento. En la cuarta celda de arriba, bump se crea mientras base ya está vinculado a 100, así que el closure carga base = 100 consigo. Cuando bump(5) corre dentro del LET interior, el cuerpo todavía ve ese 100, aunque el LET interior no sabe nada de base por nombre
Una llamada luego ocurre en tres pasos. Las expresiones de los argumentos se evalúan primero, en el alcance del que llama. Luego se apila el entorno capturado, después los parámetros encima de él, y el cuerpo se evalúa. Las búsquedas van de arriba hacia abajo, así que un parámetro llamado rate oculta un enlace capturado llamado rate, y un enlace capturado oculta cualquier cosa que el que llama haya vinculado bajo el mismo nombre. Cuando el cuerpo regresa, o falla, el alcance se corta de vuelta a donde la llamada empezó
Evaluar los argumentos antes de instalar ningún enlace suena a detalle hasta que usted escribe LET(x, 10, f, LAMBDA(x, x+1), f(x*2)). El argumento x*2 tiene que significar el x externo, 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 sale 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 fue escrita, y los demás nombres locales del que llama jamás se le filtran
¿Por qué falla f(21) cuando f contiene un número?
Un enlace local que contiene algo distinto de un closure jamás se aplica como función. LET(f, 3, f(21)) no multiplica 3 por 21, y tampoco cae de vuelta a un nombre del libro de trabajo llamado f. La llamada sigue hacia el manejador de funciones de usuario, y si ningún manejador reclama el nombre, la celda termina como #NAME?. Ese resultado es el correcto para una hoja de cálculo: un error de tipeo que convirtiera silenciosamente una llamada a función en una multiplicación produciría un número plausible que nadie cuestiona
La aplicación postfix es todavía más estricta. Lo que quede delante de la lista de argumentos se evalúa, y si el resultado no es un closure, la celda recibe #VALUE!, así que LET(g, 3, (g)(21)) y LET(g, 3, g(21)) fallan con errores distintos. Otros fallos que usted puede reproducir en un libro de trabajo de pruebas:
- Conteo de argumentos equivocado:
LET(add, LAMBDA(a, b, a+b), add(1))devuelve #VALUE! antes de que la expresión del argumento se evalúe - Los errores dentro de argumentos viajan como valores: en
LET(safe, LAMBDA(x, IFERROR(x, 0)), safe(1/0))el #DIV/0! se vincula axy el IFERROR dentro del cuerpo lo convierte en 0 - Las referencias siguen siendo referencias: un argumento como
A1llega al cuerpo como referencia de celda, así que las funciones que se preocupan por la identidad de referencias, ISREF entre ellas, ven una referencia en lugar del 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: un lambda con nombre que se llama a sí mismo comparte un techo predeterminado de 256 niveles anidados con el anidamiento ordinario de fórmulas, y pasado eso la llamada termina con un error de límite de recursos en lugar de agotar la pila de Delphi
// Log es su propia rutina de logging, no es parte de HotXLS
procedure ProbeLambdaErrors(Sheet: TXLSXWorksheet; Book: TXLSXWorkbook);
begin
Sheet.Cells[2, 4].Formula := 'LET(f, 3, f(21))'; // #NAME? sin manejador
Sheet.Cells[3, 4].Formula := 'LET(g, 3, (g)(21))'; // #VALUE!, postfix
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 alcance, 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 externo termina, sus enlaces se van, lo que significa que una fórmula hermana en la siguiente celda arranca desde un alcance vacío
Dos reglas de forma se verifican antes de que algo corra. LET necesita un número impar de argumentos, al menos tres, así que LET(a, 1) es #VALUE!. Y cada ranura de nombre debe ser un nombre simple: 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 closure alimentan las funciones helper construidas para ellos: MAP, REDUCE, SCAN, MAKEARRAY, BYROW y BYCOL. MAP(A2:A6, LAMBDA(v, v*2)) desborda 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 como lo hace para una llamada directa, así que una tasa vinculada por LET sigue visible dentro del cuerpo del MAP
Comas, puntos y comas y lo que SaveAs escribe
El parser de fórmulas de HotXLS toma la coma y el punto y coma como separadores de argumentos de forma intercambiable. El texto de fórmulas llega de lugares que usted no controla: un ticket de soporte escrito 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órmulas, código HotXLS viejo que usaba puntos y comas por todas partes. SUM(A1,A2) y SUM(A1;A2) compilan a lo mismo, y también un LAMBDA escrito de cualquiera de las dos formas
Las constantes de arreglo inline 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 arreglo de dos por dos, no una lista de cuatro argumentos. Si usted genera fórmulas con puntos y comas como separadores de argumentos, mantenga las constantes de arreglo en la sintaxis de Excel y las dos cosas jamás chocan
Cell.Formula devuelve el texto que usted asignó. 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 almacena 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 dejada intacta se escribe de vuelta desde su texto XML original
Leer lambdas con nombre de libros de trabajo de clientes
Los libros de trabajo autorados en Excel guardan los nombres LAMBDA de la forma en que 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 el archivo lo suministró. Una revisión escrita como Copy(Name.Formula, 1, 6) = 'LAMBDA' pasa para los nombres que usted creó en código y se pierde cada nombre que salió de Excel. Ese desajuste es fácil de perder, porque los valores calculados son correctos de cualquier forma y solo su propio código de auditoría discrepa
// IsLambdaDefinition es un helper que usted agrega, 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 su propia rutina de logging
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 revisión de alcance en ese ciclo está ahí porque la llamada por nombre en HotXLS busca al callee entre los nombres a nivel de libro de trabajo. Mantenga las funciones con nombre en alcance de libro de trabajo. Un nombre LAMBDA con alcance de hoja todavía se puede leer con FindByName(AName, ASheetIndex), pero una función que la gente llama desde varias hojas pertenece al libro de trabajo, y las reglas de alcance detrás de eso están trazadas en nombres definidos y fórmulas entre hojas
Editar un lambda después es barato. Asignar un texto nuevo a TXLSXDefinedName.Formula invalida el grafo de dependencias, así que el próximo Recalculate lo reconstruye y reevalúa las celdas que llaman a la función; la mecánica está en recálculo incremental y el grafo de dependencias. Una celda cuya fórmula evalúa a un closure desnudo, como =LAMBDA(x, x*2) sin llamada, no recibe ningún valor en caché, dado que no hay ningún número ni texto que guardar; Excel muestra #CALC! para la misma celda. Para reportes que deben abrir en herramientas sin soporte de LAMBDA, congele los resultados con Sheet.Cells.ConvertFormulasToValues después del último Recalculate, que conserva cada valor en caché y suelta el texto de la fórmula
LAMBDA, LET, las funciones helper y la API de nombres definidos todos vienen en la misma librería nativa para Delphi y C++Builder, que lee y escribe XLS, XLSX y ODS sin Excel instalado. La lista completa de funciones de fórmulas está en la página del componente de hojas de cálculo HotXLS