LAMBDA: Fibonacci sin recursividad

Quizá pienses que este es un tema muy 'trillado' (y seguramente lo sea)... Pero este artículo es distinto a otros, ya que se persigue obtener una secuencia de valores (la secuencia de Fibonacci en el ejemplo) evitando el uso recursivo que nos ofrece LAMBDA.
Hay artículos publicados muy buenos sobre el uso recursivo explícito de LAMBDA, por ejemplo el de mi amigo Segun Miguens (serie fibonacci) y muchos otros en español o inglés...
Todos emplean esta técnica de recursividad, esto es, que una función se llame a sí misma.

En mi ejemplo he optado por un desvío, basándome en dos ideas o procesos:
1-Ser capaz de sumar los dos últimos elementos de cualquier vector dado.
2-Poder anexar dos vectores cualesquiera.

Para el primer proceso: sumar dos últimos valores de un vector crearemos una función LAMBDA básica que llamaré: lmbSUMA_x_x-1 con la siguiente fórmula (añadida en el administrador de nombres):

 =LAMBDA(matriz;            
                    LET(eltos;CONTARA(matriz);           
                             INDICE(matriz;eltos)+INDICE(matriz;eltos-1)))

Para el segundo proceso: anexar dos vectores crearemos una función LAMBDA básica que llamaré: lmbANEXA con la siguiente fórmula (añadida en el administrador de nombres):

 =LAMBDA(matriz1;matriz2; 
                  LET(filasTotal;FILAS(matriz1)+FILAS(matriz2); 
                          X;SECUENCIA(1;1); 
                          Y;SECUENCIA(filasTotal); 
                         SI(Y<FILAS(matriz1)+1;   INDICE(matriz1;Y;X);    INDICE(matriz2;Y-FILAS(matriz1);X))))

Estas funciones en sí mismas ya son operativas y creo que tiene bastante utilidad...
Por ejemplo, para acumular los dos últimos valores del vector {1;3;9;17} podríamos escribir en cualquier celda:
=lmbSUMA_x_x_1({1;3;9;17})
devolviendo el resultado de 26 (=9+17)

O la función lmbANEXA que nos permitiría anexar dos vectores cualquiera.
Ejemplo. Anexar en un solo vector resultante el vector {1;3;9;17} y el vector o valor 26:
=lmbANEXA({1;3;9;17};26)
obteniendo un vector único de cinco elementos {1;3;9;17;26}

Sobre estas funciones se basa mi idea de obtener secuencias... y en particular la Secuencia de Fibonacci.
Ya que esta secuencia se basa, para ir creciendo, en los dos valores previos, nuestra secuencia debe ir anexando a la secuencia previa el resultado de sumar los dos últimos elementos de la secuencia previa (menudo trabalenguas!!).
Así pues, una nueva función LAMBDA debe nacer, función que debe anexar al vector previo un nuevo elemento, en concreto la suma de los últimos elementos de ese vector previo.
Llamaré a esta nueva función lmbFIBO que dentro del administrador de nombres tendrá esta formulación:

=LAMBDA(matriz;
                    lmbANEXA(matriz;lmbSUMA_x_x_1(matriz)))

Esta es una función intermedia, sin uso práctico directo... pero que nos servirá al aplicar el siguiente paso.
Empleando la función REDUCE conseguimos nuestra recursividad (implícita en la función).
Podríamos escribir en una celda:
=LET(matriz;SECUENCIA(15);REDUCE(1;lmbFIBO(matriz);LAMBDA(x;ac;lmbFIBO(x))))
resultando el vector siguiente: {1;2;3;5;8;13;21;34;55;89;144;233;377;610;987;1597;2584}...
y si, es prácticamente la secuencia de Fibonacci.. excepto por el primer valor. Nos falta un 1.

Solución fácil, se lo anexamos con nuestra recién creada función 'lmbANEXA':
=lmbANEXA(1;LET(matriz;SECUENCIA(15);REDUCE(1;lmbFIBO(matriz);LAMBDA(x;ac;lmbFIBO(x)))))

Para parecer más profesional, incluso podríamos crear una última función LAMBDA que recopile el paso anterior, y dinamizar así el número de elementos a devolver...
Desde el administrador de nombres creamos una última función Lambda que llamaré 'lmbSUC_FIBO' con la siguiente fórmula:

=LAMBDA(NumEltos;lmbANEXA(1;LET(matriz;SECUENCIA(NumEltos);REDUCE(1;lmbFIBO(matriz);LAMBDA(x;ac;lmbFIBO(x))))))

Con esta última función bastará, como se veía en la imagen del inicio, escribir en una celda:
=lmbSUC_FIBO(15)
O cualquier otro número de elementos a recuperar.

Una breve explicación de qué hace REDUCE en este ejemplo es procesar n veces los valores 1,2,3,4, ... hasta 15 en el ejemplo (o el número que indiquemos).
Para cada uno de esos valores generar un vector cuyo último elemento es la suma de los dos anteriores, y sobre ese valor acumulado, lanza de nuevo el proceso de generar un nuevo vector, cuyo nuevo elemento es la suma de los dos previos, y sucesivamente.
REDUCE se encarga de devolver únicamente el último valor de cada proceso... que es lo que necesitamos.

Quizá muy retorcido, pero me parece un buen ejercicio para comprender estas nuevas funciones LAMBDA ;-)