javascript mcarthy etc

nodelisp.js

var util = require("util");

var Cons = function(a,b) {
    var cons = function(fn) { return fn(a,b); };
    return cons;
};

var Car = function(cons) {    
    var car = function(a,b) { return a; };
    return cons(car); 
};

var Caar = function(cons) {
    var car = Car(cons)
    if (car === null) {
	return null;
    };
    
    return Car(car)
};

var Cdr = function(cons) {
    var cdr = function(a,b) { return b; };
    return cons(cdr);
};

var Cadr = function(cons) {
    //console.log(">>", cons(printCons))
    var tail = Cdr(cons)
    if (tail === null) {
	return null
    };

    return Car(tail)
};

var Cddr = function(cons) {
    //console.log(">>", cons(printCons))
    var tail = Cdr(cons)
    if (tail === null) {
	return null
    };

    return Cdr(tail)
};

var Caddr = function(cons) {
    var tail = Cddr(cons)
    if (tail === null) {
	return null;
    };
    return Car(tail);
};

var Cdar = function(cons) {
    var head = Car(cons)
    if (head === null) {
	return null;
    };
    
    return Cdr(head);
};

var Cadar = function(cons) {
    var cdar= Cdar(cons)
    if (cdar === null) {
	return null;
    };
    return Car(cdar);
};

var Atom = function(e) {
    if ((typeof e === "boolean") ||
	(typeof e === "number") ||
	(typeof e === "string")) {
	return true;
    }
    return false;
}

//var List 
var List = function() {
    var args = Array.prototype.slice.call(arguments)
    var head = args[0]
    if (args.length  === 1) {
	return Cons(head,null)
    }

    var tail = args.slice(1)
    return Cons(head, List.apply(null,tail))
};


// pair[x; y] = [null[x]∧null[y] → NIL; ¬atom[x]∧¬atom[y] → cons[list[car[x]; car[y]]; pair[cdr[x]; cdr[y]]]
var Pair = function(x,y) {
    if  ( x === null && y === null) {
	return null;
    }
    console.log(x(printCons),y(printCons))
    
    if (!Atom(x)  && !Atom(y) ) {
	console.log("...",Car(x), Car(y))
	return Cons(List(Car(x), Car(y)), Pair(Cdr(x), Cdr(y)))
    }

    return null;
}


// assoc[x; y] = eq[caar[y]; x] → cadar[y]; T → assoc[x; cdr[y]]]
var Assoc = function(x,y) {
    if (Eq(Caar(y), x) === true) {
	return Cdar(y);
    }
    return Assoc(x, Cdr(y))
};

var printCons = function(a,b) {
    var aresult = "";  
    var bresult = "";
    if (typeof b === "function") {
	bresult = b(printCons);
    } else {
	bresult = b;
    };

    if (typeof a === "function") {
	aresult = a(printCons);
    } else {
	aresult = a;
    };
    
    aresult = aresult || "|"
    bresult = bresult || "|"
    return util.format("(%s,%s)", aresult, bresult)
};


var Eq = function(a,b) {
    return a === b;
};

var QUOTE = "'"
var ATOM = "atom"
var EQ = "="
var CAR = "car"
var CDR = "cdr"
var CONS = "cons"
var COND = "cond"
var LAMBDA = "lambda"
var LABEL = "label"
var Eval = function(e, a) {
    if (Atom(e)) {
	//console.log("ATOM!",e)
	return Assoc(e,a);
    };
    var carE = Car(e)
    //console.log(carE, typeof carE)
    if (Atom(carE)) {

	if (Eq(carE, QUOTE)) {
	    //console.log("QUOTE", Cadr(e))
	    return Cadr(e);
	};

	if (Eq(carE, ATOM)) {
	    //console.log("Atom", Cadr(e))
	    return Atom(Eval(Cadr(e), a));
	};
	
	if (Eq(carE, EQ)) {
	    //console.log("EQ",Cadr(e), Caddr(e)) //Eval(Cadr(e), a), Eval(Caddr(e), a))
	    return Eval(Cadr(e), a) === Eval(Caddr(e), a);
	};
	
	if (Eq(carE, CAR)) {
	    return Car(Eval(Cadr(e), a));
	};
	
	if (Eq(carE, CDR)) {
	    return Cdr(Eval(Cadr(e), a));
	};
	
	if (Eq(carE, CONS)) {
	    return Cons(Eval(Cadr(e), a), Eval(Caddr(e),a));
	};
	
	if (Eq(carE, COND)) {
	    return EvCon(Cdr(e), a);
	};
	// untested
	return Eval( Cons( Assoc(carE, a), EvLis(Cdr(e), a)), a)
    };
    // untested
    if (Eq(Caar(e), LABEL)) {
	return Eval(Cons(Caddar(e), Cdr(e)), Cons( List( Cadar(e), Car(e)), a));
    };
    //untested
    // if (Eq(Caar(e), LAMBDA)) {
    // 	return Eval(Caddar(e), Append(Pari
};


// evcon[c; a] = [eval[caar[c]; a] → eval[cadar[c]; a]; T → evcon[cdr[c]; a]]
var EvCon = function(c, a) {
    console.log(".....",Caar(c)(printCons),a)
    if (Eval(Caar(c),a)) {
	return Eval(Cadar(c),a);
    };
    return EvCon(Cdr(c),a);
};

// evlis[m; a] = [null[m] → NIL; T → cons[eval[car[m]; a]; evlis[cdr[m]; a]]]
var EvLis = function(m, a) {
    if (m === null) {
	return null;
    }
    return Cons(Eval(Car(m), a), EvLis(Cdr(m), a))
};

/*
eval[e; a] = [
     atom [e] → assoc [e; a];
     atom [car [e]] → [
          eq [car [e]; QUOTE] → cadr [e];
          eq [car [e]; ATOM] → atom [eval [cadr [e]; a]];
          eq [car [e]; EQ] → [eval [cadr [e]; a] = eval [caddr [e]; a]];
          eq [car [e]; COND] → evcon [cdr [e]; a];
          eq [car [e]; CAR] → car [eval [cadr [e]; a]];
          eq [car [e]; CDR] → cdr [eval [cadr [e]; a]];
          eq [car [e]; CONS] → cons [eval [cadr [e]; a]; eval [caddr [e];a]];
          T → eval [cons [assoc [car [e]; a]; evlis [cdr [e]; a]]; a]
      ];
      eq [caar [e]; LABEL] → eval [cons [caddar [e]; cdr [e]]; cons [list [cadar [e]; car [e]; a]];
      eq [caar [e]; LAMBDA] → eval [caddar [e];append [pair [cadar [e]; evlis [cdr [e]; a]; a]]]
*/

var list = List(1,"test",3)
console.log(list(printCons),"..", Car(list),"..", Cadr(list));
console.log(Cons("a",12)(printCons));
var pairs = Pair(List(1,2,3), List("bla", "yadda", "wawa"));
console.log(pairs(printCons))
var testcdar = List(Cons(1,2),3)
var cdartest = Cdar(testcdar)
console.log(testcdar(printCons), cdartest)  // === 2

var testcadar = List(Cons(1,Cons("Wa","BLA"),3))
var cadartest = Cadar(testcadar)
console.log(testcadar(printCons), cadartest)  // === Wa

var testcaar = List(Cons(101, "test2"))
var caartest = Caar(testcaar)
console.log(testcaar(printCons), caartest) // === 101

var testassoc = List(Cons("this",12),Cons("is", 100))
var assoctest1 = Assoc("this",testassoc)
var assoctest2 = Assoc("is",testassoc)
console.log(testassoc(printCons),"answ1= ", assoctest1, "answ2= ",assoctest2)


var testquote =  Cons(QUOTE,Cons(12,null))
console.log("...",testquote(printCons),Eval(testquote))


var testatomTRUE = Cons(ATOM,Cons("blavar",null))
var testatomFALSE = Cons(ATOM,Cons("notAtom",null))
var vars = List(Cons("blavar",12), Cons("blavar2",13), Cons("blavar3",12), Cons("notAtom",Cons(12,13)))
console.log("atomtrue = ", Eval(testatomTRUE, vars), "atomfalse= ", Eval(testatomFALSE, vars))


var testeq = List(EQ,List(QUOTE,10),List(QUOTE,10))
console.log(Eval(testeq, null))  // true

var testeq = List(EQ,List(QUOTE,10),List(QUOTE,14))
console.log(Eval(testeq, null))  // false

var testeq = List(EQ,"blavar","blavar2")
console.log(Eval(testeq, vars))  // false

var testeq = List(EQ,"blavar","blavar3")
console.log(Eval(testeq, vars))  // true


var testcons = List(CONS, List(QUOTE,12), List(QUOTE, 133))
console.log(Eval(testcons,null)(printCons))  // (12,13)

var testcons = List(CONS, "blavar", "blavar2")
console.log(Eval(testcons,vars)(printCons))  // (12,13)

var testcons = List(CONS, "blavar3", "blavar")
console.log(Eval(testcons,vars)(printCons))  // (12,13)

var testcondparams = List(List(List(QUOTE,false), List(QUOTE,"hello")), List(List(QUOTE,true), List(QUOTE,"nope")))
console.log(EvCon(testcondparams, null))  // nope


var testcond = List(COND, List(List(QUOTE,true), List(QUOTE,"hello")), List(List(QUOTE,false), List(QUOTE,"nope")))
console.log(Eval(testcond, null))  // hello