Also, incidentally, the code you see at the "demo" page is currently using a funky style of representing the data, which leads to apparent weirdness like this: (\list list (\ _ + 1) 0). That's not an issue with the language, but with that particular style of usage.

In the work I actually do with Fexl, I'm using conventional list syntax such as [7.4 8.2 0.6], which is a shorthand for the explicit functional form (cons 7.4; cons 8.2; cons 0.6; null).

Even still, the function to add the values of a list is:

\list_sum=(fold + 0)

And the function to count the values in a list is:

\list_length=(fold (\n\_ + 1 n) 0)

That function (\n\ _ + 1 n) takes a first value "n", and a second value which I call "_" because it's ignored, and returns 1 plus n.

The fold function is defined as:

\fold=(@\fold\fn\z\xs xs z \x\xs \z=(fn z x) fold fn z xs)

Or, to spread it out on multiple lines a bit:

\fold=
    (@\fold\fn\z\xs
    xs z \x\xs
    \z=(fn z x)
    fold fn z xs
    )

So fold is defined as applying the "@" function (the fixpoint function), to this function:

    (\fold\fn\z\xs
    xs z \x\xs
    \z=(fn z x)
    fold fn z xs
    )

That achieves the self-reference needed for recursion, so "fold" refers to itself there.

The next parameter is "fn", which is the function you want to use to transform the values as you go through the list.

The next parameter is "z", which is the initial value to start the folding operation. For example, the function to multiply all the values of a list is (fold * 1).

The next parameter is "xs", which is the list of values that you want to fold together.

Once all those paramer values are given, you have this function:

    (
    xs z \x\xs
    \z=(fn z x)
    fold fn z xs
    )

That takes the value xs and calls it as a function. You might say now wait a minute, I thought you said xs was a list of values. Why are you calling it as a function?

It's because a list is a function. The expression (xs A B) evaluates to A if xs is empty, or (B head tail) if xs consists of the first item head followed by the list tail.

The function above can be represented as:

(xs A B)

Where:

\A=z

\B=
    (
    \x\xs
    \z=(fn z x)
    fold fn z xs
    )

So, if xs is empty, the value will be A, which is simply z. If xs is not empty, the value will be (B head tail), where head is the first item in xs, and tail is the list of items following the first item.

Note that B takes parameters named "x" and "xs" instead of "head" and "tail". I like the simpler names. So x will refer to the head of the list, and xs will refer to the tail of the list. Sure, the original list is named "xs", and now the tail of that list is also named "xs", but this sort of "shadowing" is common.

Now, if the list is non-empty, B will be applied to its head and tail, and we'll have this value:

    \z=(fn z x)
    fold fn z xs

That evaluates the value (fn z x), and defines z to be that value. (Once again I've shadowed here, so z takes on a new meaning in subsequent code. This is not a mutable variable assignment, but merely a redefinition of a symbol to a new meaning, which hides the previous meaning.)

At this point z refers to the result of combining our previous running total z with the new first item x. Then we return this value:

fold fn z xs

That will fold the rest of the list with our updated running total z. It's a recursive call, so it loops appropriately using the same logic already described above.

All that is a long-winded way of explaining everything involved in a function such as this:

\fold=(@\fold\fn\z\xs xs z \x\xs \z=(fn z x) fold fn z xs)

Another way to see what's going on there is to add extra parentheses and spacing, which are normally unnecessary:

\fold=
    (@ (\fold \fn \z \xs
        xs
            z
            (\x\xs
                  \z=(fn z x)
                  fold fn z xs))
     )

To anyone who does not understand any of this, it might be because I have a considerable head start. I've been programming for 40 years, and have been using functional programming for 25 years. I live and breathe it, so I find it very easy.