function A(){return 3}
A.valueOf = function(){return 2}
console.log(A,A(),A()*A)

This, together with bind, was heavily used in my Rami language. Thanks to this duality of function and value, I could easily create a JS evaluator which kept the syntax. mult(add(2)(4)(6))(4). A kind of polish notation JavaScript.

Both λ and \ works as lambda and short-hand for multiple arguments must be separated with space (eg. \x y. y).  Recursive function with an if-test must use lazy evaluation in order to  work, made possible by wrapping the clauses in a function evaluated on  the outside of the if (eq. if(\_.A)(\_.B)(_))

Because the code inludes a lot of pointless fluff, here's a small  standalone evaluator. Beneath is an example. By running, it should  evaluate to 120, the factorial of 5.

function λCalculus(calculus){
    var nextLambda = calculus.search(/[#λ\\]/)
    if(nextLambda == 0){
        var delim = calculus.search(/[.:]/);
        if(!~delim) throw Error("Missing body delimiter");
        var head = calculus.slice(1,delim)  
                           .split(/[^a-zA-Z0-9]+[0-9]*/);
        var body = λCalculus(calculus.slice(delim+1))
        var func = "#2#"
        for(var i in head){
            func = func.replace(/#2#/,
                   "function anonymous(#1#){ return #2#; }"
                   .replace(/#1#/,head[i]));
        }
        return func.replace(/#2#/,body);
    } else if(nextLambda > 0){
        var left = 1;
        var i = nextLambda;
        while(left>0&&++i<calculus.length){
            if(calculus[i] == "(") left++;
            else if(calculus[i] == ")") left--;
        }
        return calculus.slice(0,nextLambda)
             + λCalculus(calculus.slice(nextLambda,i))
             + λCalculus(calculus.slice(i));
    }
    return calculus;
}

// Some lambdas
var wrapper = "(λR cond zerop succ pred mult T F.@)(λx.x(x))(λc a b.c(a)(b))(λn.n(λx a b.b)(λa b.a))(λn f x. n(f)(f(x)))(λn f x. n(λg h.h(g(f)))(λu.x)(λu.u))(λa b c d.a(b(c))(d))(λx y.x)(λx y.y)"
var fac = wrapper.replace(/@/,"(λfac.fac)(R(λself n.cond(zerop(n))(λblank.succ(F))(λblank.mult(n)(R(self)(pred(n))))(0)))")
var three = "(λf x.f(f(f(x))))"
var five = "(λf x.f(f(f(f(f(x))))))"

// evaluation of (5!)
var js = λCalculus("("+fac+")"+"(λf x.f(f(f(f(f(x))))))")
function evalAsInteger(a){ return a(increment)(0); }
function increment(a){ return (a-0||0) + 1; }
console.log(js,evalAsInteger(eval(js)))

It is quite a while since I last updated my site. I've almost done it  multiple times in the last couple of years, but I had yet to actually  implement the changes I made. In order to push myself to do it this  time, I've decided to upload with still unfinished parts.

After I finish stitching up the code, I'm planning on gradually releasing posts about my earlier projects.