Another Issue with previous row/column references

djclements 

Though I would try to apply some 'previously prepared ingredients' to this challenge.  My worksheet formula is simply

= SCANVλ(initRow,initCol,
    LAMBDA(priorRow, init,
        SCAN(init, priorRow, LAMBDA(acc, v, v - acc))
    )
  )

The Lambda function calculates the row that follows 'priorRow'.  What is hidden is that the wrapper function SCANVλ modifies the Lambda function to cause it to return thunks before passing it to the real SCAN Lambda helper function.  

Pretty much all problems of interest will have an array of arrays within its solution.  Although Excel fails to handle an array of arrays [TYPE 64], it will accept an array of functions [TYPE 128], including but not limited to, thunks.  The function is executed once its parameter string is provided and may return an array at that point.

The SCANVλ Lambda function has the same signature as SCAN but hides complexity from the user.

/*  FUNCTION NAME:  SCANVλ
    DESCRIPTION:    Implements a version of SCAN that will return a column of arrays */
/*  REVISIONS:      Date            Developer           Description
                    19 May 2024     Peter Bartholomew   Original Development
*/

SCANVλ = LAMBDA(
//  Parameter Declarations     
    [y₀], [x], [FNλ],
//  Procedure
    LET(help,       TRIM(TEXTSPLIT(
                        "DESCRIPTION:   →Implements a version of SCAN that will return an column of arrays.¶" &
                        "VERSION:       →19 May 2024 ¶" &
                        "PARAMETERS:    →¶" &
                        "  y₀           →(Required) A row vector of initial values. ¶" &
                        "  x            →(Required) A two dimensional array of values. ¶" &
                        "  fnλ          →(Required) A lambda function that accepts a row array as input.",
                        "→", "¶" )
                    ),
    //  Check inputs
        y₀,     IF(OR(ISOMITTED(y₀), y₀=""), #Value!, y₀),
        x,      IF(OR(ISOMITTED(x),  x= ""), #Value!, x),
        fnλ,    IF(OR(ISOMITTED(fnλ), TYPE(fnλ)<>128),  #Value!, fnλ),
    //  Procedure
        n,      ROWS(x),
        Fλ, LAMBDA(yϑ, x,
            LET(y, yϑ(),
                z, FNλ(y, x),
                zϑ, THUNK(z),
                zϑ )
            ),
        yϑ₀, THUNK(y₀),
        thunkArrayϑ, SCAN(yϑ₀, x, Fλ),
    
    //  Recombine pairs of thunks as a binary tree until the root node is reached
        k,              SEQUENCE(LEN(BASE(n - 1, 2))),
        recombinedϑ,    @REDUCE(thunkArrayϑ, k, JOINPAIRSλ),
        result,         recombinedϑ(),
        //  Handle Error
        error,          MAX(IsError(result)+1),
        //  Return result
        CHOOSE(error, result, Help)
    )
);


/*  FUNCTION NAME:  JOINPAIRSλ
    DESCRIPTION:    Called by BYROW to stack the contents of thunks pairwise */
/*  REVISIONS:      Date            Developer           Description
                    09 May 2024     Peter Bartholomew   Original Development  
                    16 May 2024     Peter Bartholomew   Test for unpaired thunk
*/
JOINPAIRSλ
= LAMBDA(thunkArray, [k],
    LET(

        alternate, WRAPROWS(thunkArray, 2, thunk("")),
        firstpart, TAKE(alternate, , 1),
        finalpart, TAKE(alternate, , -1),

        MAP(
            firstpart,
            finalpart,
            LAMBDA(ϑ₁, ϑ₂, 
                LET(
                    x₁, (@ϑ₁)(),
                    x₂, (@ϑ₂)(),
                    v, IF(@x₂="", x₁, VSTACK(x₁, x₂)),
                    LAMBDA(v)
                )
            )
        )
    )
);


THUNK
= LAMBDA(x, LAMBDA(x));

Besides building an array of thunks that contain elements of the solution, SCANVλ combines the thunk array as a binary tree until only a single thunk (containing the entire solution) remains.

If it makes anyone feel better about this, it took be an age to develop it and rederiving it from scratch would still be challenging.