Sugar-free loops: not a breakfast cereal.

I've recently been playing with a minimalist language that eschews pretty much all syntactic sugar. It has no classes (or typeclasses), no mutable state, no jumps or labels, no modules or packages. It has no libraries—and if it did, they'd be useless, because it has no identifiers with which to name the contents of the libraries.

The language is basically the lambda calculus, plus built-in integers, a few integer functions, and a conditional `If`. Variables are represented as zero-based De Bruijn indices, using the notation `V(`*i*`)` for the variable in the *i*th enclosing scope. `V` is actually a special case of the `Var` operator, whose argument can be an arbitrary expression rather than just an integer constant—useful if you want to invent arrays.

Calling this thing a “language” is probably an abuse of the term; it's just a data structure with an interpreter.

Although I wouldn't want to program such a thing on a regular basis, I did want to be able to process sequences of varying lengths with it. Given the pure functional nature of the language, this requires recursion. And given the lack of identifiers, the language doesn't do the recursion for me; I need to use an explicit fixpoint combinator. The call-by-value Y combinator in this language looks like:

fix = Lam( Lam(V(1)(Lam(V(1)(V(1))(V(0)))))( Lam(V(1)(Lam(V(1)(V(1))(V(0)))))))

So I know I'll apply this to my looping function, but what does the looping function look like? Well, you can generally view a loop that computes a value as a fold. But unlike folds in high-level languages, there aren't have any prepackaged sequence operations to use in the fold, so I have to take those operations as parameters. Specifically, my fold (as passed to the Y comnbinator to create a usable recursive fold) will look like:

λf.λmore?.λhead.λtail.λstep.λaccum.λnext. if not more? next then accum else f more? head tail step (step accum (head next)) (tail next)

where `more?` applied to a sequence tells whether there are any more elements (the sequence is not empty), `head` provides the current element of the sequence and `tail` the rest, `step` performs one step of the fold operation, `accum` is the value accumulated by the fold, and `next` is the sequence from which to get the next element. Stripped of sugar, this becomes:

unfixedFold = Lam( // f (fold itself): V(6) Lam( // more: V(5) Lam( // head: V(4) Lam( // tail: V(3) Lam( // step: V(2) Lam( // accum: V(1) Lam( // next: V(0) If( Not(V(5)(V(0))), // not more? V(1), // no more, return accum V(6)( // else apply f to V(5))(V(4))(V(3))(V(2))( // same more?, head, tail, step, V(2)(V(1))(V(4)(V(0))))( // step(accum,head(next)), V(3)(V(0))))))))))) // and tail(next)

The only form of input in this language is to bind the input to variables, as if the program were called from within a series of nested functions applied to the inputs. A program to iterate through such inputs and compute the maximum value looks like:

fix(unfixedFold)( Lam(Lt(V(0),Minus(Depth,I(1)))))( // more?: variable index less // than lexical depth Lam(Var(Plus(V(0),I(1)))))( // head: index into inputs (add // 1 to index to account for // head function itself) Lam(Plus(V(0),I(1))))( // tail: increment index Lam(If(Gt(V(0),V(1)),V(0),V(1))))( // step: max of arguments V(0))( // accum starts as zeroth input I(1)) // index after zeroth input

Four out of five dentists do not recommend sugar-free languages, at least for their patients without patience.