THUNKIT

[tboulden]

Link to Wikipedia on thunks

=LAMBDA(x,LAMBDA(x))

Some LAMBDA helpers have limitations on what can be returned due to constraints based on the shape of the starting array. For example, if some calculation creates a series of 2-d arrays, Excel will throw an error if we try to pass those back through SCAN/BYROW/BYCOL. Thunking a value by wrapping it in a LAMBDA with no parameter "stores" a complex value in a single cell in an array, which can be passed around in calculations; we trade error-handling constructions for thunking.

I'll add some helper functions for use with thunks soon.

LAMBDA_pairwise_thunks_summarize_pivot.xlsx
	A	B	C	D	E	F	G
1
2		=LAMBDA(x,LAMBDA(x))("anything")	#CALC!
3		=LAMBDA(x,LAMBDA(x))("anything")()	anything
4
5		=LET( thunkIt,LAMBDA(x,LAMBDA(x)), thunkIt(10) )	#CALC!
6
7
8
9		=thunkIt(10)()	10
10
11		=thunkIt(SEQUENCE(4,4))	#CALC!
12		=thunkIt(SEQUENCE(4,4))()	1	2	3	4
13			5	6	7	8
14			9	10	11	12
15			13	14	15	16
16
17		=MAP(SEQUENCE(4), LAMBDA(num,CHAR(SEQUENCE(num,num,65,1))))	#CALC!
18
19
20		=LET( thunks, MAP(SEQUENCE(4), LAMBDA(num, thunkIt(CHAR(SEQUENCE(num,num,65,1))))), REDUCE(,thunks, LAMBDA(stacked,thunk, vStack(IFERROR(stacked(),stacked),thunk()))) )	A
21			A	B
22			C	D
23			A	B	C
24			D	E	F
25			G	H	I
26			A	B	C	D
27			E	F	G	H
28			I	J	K	L
29			M	N	O	P
thunkIt

Cell Formulas
Range	Formula
B2:B3,B20,B17,B11:B12,B9,B5	B2	=FORMULATEXT(C2)
C2	C2	=LAMBDA(x,LAMBDA(x))("anything")
C3	C3	=LAMBDA(x,LAMBDA(x))("anything")()
C5	C5	=LET( thunkIt,LAMBDA(x,LAMBDA(x)), thunkIt(10) )
C9	C9	=thunkIt(10)()
C11	C11	=thunkIt(SEQUENCE(4,4))
C12:F15	C12	=thunkIt(SEQUENCE(4,4))()
C17	C17	=MAP(SEQUENCE(4), LAMBDA(num,CHAR(SEQUENCE(num,num,65,1))))
C20:F29	C20	=LET( thunks, MAP(SEQUENCE(4), LAMBDA(num, thunkIt(CHAR(SEQUENCE(num,num,65,1))))), REDUCE(,thunks, LAMBDA(stacked,thunk, vStack(IFERROR(stacked(),stacked),thunk()))) )
Dynamic array formulas.

 

[tboulden]

expandThunks - Retrieve and stack stored thunks in row-major order.

=LAMBDA(array_of_thunks,
    IF(
        AND(ROWS(array_of_thunks)=1,COLUMNS(array_of_thunks)=1),
            INDEX(array_of_thunks,1,1)(),
        LET(
            expand_rows,
                BYROW(array_of_thunks,
                    LAMBDA(row_,
                        thunkIt(
                            REDUCE(
                                ,
                                row_,
                                LAMBDA(stacked,thunk,
                                    hStack(IFERROR(stacked(),stacked),thunk())
                                )
                            )
                        )
                    )
                ),
            IF(
                ROWS(array_of_thunks)=1,
                    INDEX(expand_rows,1,1)(),
                LET(
                    stack_expanded_rows,
                        REDUCE(
                            ,
                            IF(COLUMNS(array_of_thunks)=1,array_of_thunks,expand_rows),
                            LAMBDA(stacked,thunk,
                                vStack(IFERROR(stacked(),stacked),thunk())
                            )
                        ),
                    stack_expanded_rows
                )
            )
        )
    )
)

alignExpandThunks - Adjust dimensions of thunked arrays and ensure INDEX(thunk,1,1)() lines up with others in same row and column.

=LAMBDA(array_of_thunks,
    LET(
        getDimCt,
            LAMBDA(dim,
               LAMBDA(thunk,
                   CHOOSE(dim,ROWS(thunk()),COLUMNS(thunk())))),
        row_cts,MAP(array_of_thunks,getDimCt(1)),
        col_cts,MAP(array_of_thunks,getDimCt(2)),
        max_row_ct_by_row,BYROW(row_cts,LAMBDA(row_,MAX(row_))),
        max_col_ct_by_col,BYCOL(col_cts,LAMBDA(col_,MAX(col_))),
        row_idxs,
          pairWise(max_row_ct_by_row,max_col_ct_by_col,
            LAMBDA(x,y,thunkIt(QUOTIENT(SEQUENCE(x,y)-1,y)+1))),
        col_idxs,
          pairWise(max_row_ct_by_row,max_col_ct_by_col,
            LAMBDA(x,y,thunkIt(MOD(SEQUENCE(x,y)-1,y)+1))),
        aligned,
          MAP(array_of_thunks,row_idxs,col_idxs,
            LAMBDA(thunk,row_idx,col_idx,
              thunkIt(
                IFERROR(
                  INDEX(thunk(),row_idx(),col_idx()),
                  "")))),
        expandThunks(aligned)
    )
)

LAMBDA_pairwise_thunks_summarize_pivot.xlsx
	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	AA
1	A	B	A	B	C										A	B					A	B	C
2			D	E	F																D	E	F
3	A	B	C	D	A	B	C	D	E						A	B	C	D			A	B	C	D	E
4	E	F	G	H	F	G	H	I	J						E	F	G	H			F	G	H	I	J
5	I	J	K	L	K	L	M	N	O						I	J	K	L			K	L	M	N	O
6					P	Q	R	S	T												P	Q	R	S	T
7	A	B	C	D	E	F	A	B	C	D	E	F	G		A	B	C	D	E	F	A	B	C	D	E	F	G
8	G	H	I	J	K	L	H	I	J	K	L	M	N		G	H	I	J	K	L	H	I	J	K	L	M	N
9	M	N	O	P	Q	R	O	P	Q	R	S	T	U		M	N	O	P	Q	R	O	P	Q	R	S	T	U
10	S	T	U	V	W	X	V	W	X	Y	Z	[	\		S	T	U	V	W	X	V	W	X	Y	Z	[	\
11	Y	Z	[	\	]	^	]	^	_	`	a	b	c		Y	Z	[	\	]	^	]	^	_	`	a	b	c
12							d	e	f	g	h	i	j								d	e	f	g	h	i	j
expandThunks

Cell Formulas
Range	Formula
A1:M12	A1	=expandThunks(MAP(SEQUENCE(3,2), LAMBDA(num, thunkIt(CHAR(SEQUENCE(num,num+1,65,1))))))
O1:AA12	O1	=alignExpandThunks(MAP(SEQUENCE(3,2), LAMBDA(num, thunkIt(CHAR(SEQUENCE(num,num+1,65,1))))))
Dynamic array formulas.

 

[realflexyourdata]

I keep coming back to this page every time I'm doubting if I understand thunking in Lambda. I think it might be (finally) starting to sink in! Thanks for writing this up. It's an invaluable resource.

 

[vincethesun]

Hi tboulden,

I was wondering if this "thunkit" method can be further extrapolated to a multi-layer (more than 2 levels) thunking like LAMBDA(x,LAMBDA(x, LAMBDA(x))) and even LAMBDA(x,LAMBDA(x, LAMBDA(x, LAMBDA(x)))) etc.?

Of course we hardly encounter such complex calculations in practice. I just wanted to push it a little further and see how for example a 3-layer array thunking plays out.

Appreciate if you could shed some light and give an example if possible.

Many thanks.

Vince

 

[tboulden]

Hi tboulden,

I was wondering if this "thunkit" method can be further extrapolated to a multi-layer (more than 2 levels) thunking like LAMBDA(x,LAMBDA(x, LAMBDA(x))) and even LAMBDA(x,LAMBDA(x, LAMBDA(x, LAMBDA(x)))) etc.?

Of course we hardly encounter such complex calculations in practice. I just wanted to push it a little further and see how for example a 3-layer array thunking plays out.

Appreciate if you could shed some light and give an example if possible.

Many thanks.

Vince

Perhaps, but I think for it to be truly useful, it will depend on the problem being addressed. What experimenting have you done? The recycling of x as the parameter means that essentially all values passed in are lost except the last one, so not sure what the specific value is in this example.