[LAMBDA] NACHZEILE NACHSPALTE kombiniert

[LCohen]

Sieht gut aus.

Vielleicht kannst Du da aber die spezifische Funktion/den Nutzen eines Thunks noch erwähnen oder beschreiben?

Denn es ist nicht so leicht, das unkommentiert nachzuvollziehen. OK, ich gebe zu: Ein bisschen Faulheit ist vermutlich auch immer dabei, die Lösungen anderer zu verstehen  , wozu man insbesondere bei LET-Konstrukten (etwas unberechtigt: "Monsterformeln", da ja eine Formel alles erledigt, und zwar nicht nur in einer Zelle) neigt. Man kann ja eigentlich gut selbst debuggen. Aber nur, wenn die LET-Schritte auch minimal sind.

Ich bin leider kein Informatiker. Sonst hätte ich von "Thunk" auch schon eher gehört, wie aufgrund Googelns feststellbar.

[maninweb]

Moin,

ok, ich probiere es mal. Du kannst Dir einen Thunk als verschachtelte Funktionen vorstellen, wo eine Funktion als eine Art Container
gesehen werden kann. Was dann im Container drin ist, kann ein einfacher Datentyp oder eben halt ein komplexer Datentyp sein.

Gebe mal in Zellen folgende Konstrukte ein.

PHP-Code:

=LAMBDA(X;LAMBDA(X))
=LAMBDA(X;LAMBDA(X))("Hallo")
=LAMBDA(X;LAMBDA(X))("Hallo")() 


Die ersten beiden Formeln liefern #KALK!, denn es fehlt im ersten Fall der Aufruf vom der äußeren LAMBDA-Funktion und im zweiten
Fall der Aufruf der inneren LAMBDA-Funktion. Die dritte Formel liefert den Wert Hallo, denn Hallo wird an die äußere LAMBDA-Funktion
übergeben, an die innere LAMBDA-Funktion weiter gereicht und diese per () aufgerufen.

Daraus ergibt sich aber auch, dass das Argument, das an das äußere LAMBDA übergeben wurde, im inneren LAMBDA abgelegt wird,
also quasi zur Laufzeit gespeichert wird. Das ist das Interessante.

Verkomplizieren wir das jetzt mal ein bißchen, indem wir das in ein LET verpacken und statt dem Wert ein Array übergeben.

PHP-Code:

=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);Debug;vnSequence;Debug)
=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);Debug;fnThunk(vnSequence);Debug)
=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);Debug;fnThunk(vnSequence)();Debug) 


Wie erwartet, liefern die erste und dritte Formel die Sequenz als dynamisches Array. Die zweite Formel liefert hingegen #KALK!, da ja
der Aufruf () der inneren LAMBDA-Funktion fehlt. Und, es lassen sich somit auch Arrays zwischenspeichern.

Machen wir es nun noch komplizierter und lassen ein Array von Arrays generieren. Zum Durchlaufen von vnSequence nehmen wir
dann mal SCAN. Wobei dann zu beachten wäre, dass das Eingangsarray in SCAN nur eine Spalte hat. Ziel wäre dann, dass das
Ergebnis aus der Zahlenfolge 1, 2 und 3 zeilenweise Arrays macht und dann folgendes entsteht:

PHP-Code:

S
1 > 11 | 12 | 13
2 > 21 | 22 | 23
3 > 31 | 32 | 33 


Wenn in A1, A2 und A3 die Zahlen 1, 2, und 3 stehen würden, ließe sich folgende Formel in B1 erstellen und auf B2 und B3 per
AutoAusfüllen erweitern.

PHP-Code:

=MATRIXERSTELLEN(1;3;LAMBDA(X;Y;10*A1+Y)) 


Mit SCAN, wo die Zahlenfolge 1, 2 und 3 per SEQUENZ erzeugt würde, sähe das dann erstmal wie folgt aus:

PHP-Code:

=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);
     vnScan;SCAN(0;vnSequence;LAMBDA(V;A;MATRIXERSTELLEN(1;3;LAMBDA(X;Y;10*A+Y))));
     Debug;vnScan;Debug) 


Das liefert erwartungsgemäß #KALK!. Jetzt kapseln wir mal das Erstellen der Matrix in SCAN mit fnThunk.

PHP-Code:

=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);
     vnScan;SCAN(0;vnSequence;LAMBDA(V;A;fnThunk(MATRIXERSTELLEN(1;3;LAMBDA(X;Y;10*A+Y)))));
     Debug;vnScan;Debug) 


Das Ergebnis ist jetzt dreimal #KALK! untereinander. Wir haben jetzt ein Array von dreimal dem Aufruf von fnThunk. Also ein Array von Thunks.
Und jedes dieser Elemente im Array von Thunks hat das pro Zeile mit MATRIXERSTELLEN generierte Array in sich zwischengespeichert.

Excel kann das jedoch nicht auflösen, da ja noch der Aufruf der inneren LAMBDA-Funktion fehlt. Um die Elemente dieser Arrays zu extrahieren,
muss man zudem erst die Ausgabematrix erzeugen, um dann die Elemente darin zu platzieren. Das macht dann vnExtract in folgender Formel:

PHP-Code:

=LET(fnThunk;LAMBDA(X;LAMBDA(X));vnSequence;SEQUENZ(3);
     vnScan;SCAN(0;vnSequence;LAMBDA(V;A;fnThunk(MATRIXERSTELLEN(1;3;LAMBDA(X;Y;10*A+Y)))));
     vnExtract;MATRIXERSTELLEN(3;3;LAMBDA(X;Y;INDEX(INDEX(vnScan;X;1)();1;Y)));
     Debug;vnExtract;Debug) 


Zu beachten ist der Aufruf von () bei INDEX(vnScan;X;1)(), wo INDEX(vnScan;X;1) dem X-ten Thunk entspricht, dass dann per () vervollständigt
wird und dessen Positionen abgerufen werden.

Hoffe mal, das ist jetzt verständlicher.

Gruß

[LCohen]

=MATRIXERSTELLEN(3;3;LAMBDA(X;Y;10*X+Y))

ergibt aber doch auch

11 12 13
21 22 23
31 32 33

so, wie Deine letzte Formel. Worin liegt dann deren Vorteil? 

Und außerdem: Jeder Zwischenschritt in einem LET führt doch auch zu (Ergebnissen oder) Arrays, die nicht ausgegeben werden müssen (aber additiv Platz belegen, da man sie ja jederzeit auch danach verwerten und debuggen kann).

Für mich läge der Knaller von Thunks darin, dass ich in einer Zelle ein Array habe und wiederum mit dem LET ein Array aus diesen arraygefüllten Zellen erzeugen kann. Und wenn man letzteres dann wieder in eine Zelle packen könnte und dann wieder aus solchen Zellen ein Array erhielte ...

[maninweb]

Hallo,

klar kann man die Matrix nur mit MATRIXERSTELLEN produzieren. Das war ja auch nur ein konstruiertes Beispiel.

Für mich läge der Knaller von Thunks darin, dass ich in einer Zelle ein Array habe und wiederum mit dem LET ein Array aus diesen arraygefüllten Zellen erzeugen kann.

Wenn Du Dir das Beispiel davor mit dem verbesserten Texttrenner anschaust, hast Du ja die Arrays in einem Array.
Wohlgemerkt zur Laufzeit. Steht das bereits in einer Zelle, kann man es m. W.nicht extrahieren. Ich sehe als
mögliche Einsatzgebiet für Thunks eben solche Problematiken, wie Textbereiche trennen.

Gruß