Let there be let

Introduced the (let[rec] ((name expr) ...) body) forms, which evaluate
body in an environment where all the name(s) ... are bound to the result
of evaluating the corresponding expr(s) ..., either in the surrounding
environment (let) or in the body's environment as it's being built (letrec).

Author: mtornwall

tinylisp.js

@@ -38,6 +38,16 @@
     };
   };
 
+  var let = function(input, ctx, rec) {
+    var letCtx = new Ctx({}, ctx);
+    input[1].forEach(function(binding) {
+      var name = binding[0].value;
+      var init = binding[1];
+      letCtx.scope[name] = interpret(init, rec ? letCtx : ctx);
+    });
+    return interpret(input[2], letCtx);
+  }
+
   var fn = function(input, ctx) {
     return {
       type: "function",
@@ -51,9 +61,11 @@
     if (ctx === undefined) {
       return interpret(input, new Ctx(library));
     } else if (input instanceof Array) {
-      if (input[0].value === "lambda") {
-        return lambda(input, ctx);
-      } else {
+      switch (input[0].value) {
+      case "lambda": return lambda(input, ctx);
+      case "letrec": return let(input, ctx, true);
+      case "let":    return let(input, ctx, false);
+      default:
         var list = input.map(function(x) { return interpret(x, ctx); });
         if (list[0].type === "function") {
           return list[0].value(list.slice(1));

tinylisp.spec.js

@@ -127,5 +127,35 @@ describe('tinyLisp', function() {
           .toEqual(1);
       });
     });
+
+    describe('let', function() {
+      it('should eval inner expression w names bound', function() {
+        expect(t.interpret(t.parse("(let ((x 1) (y 2)) (x y))"))).toEqual([1, 2]);
+      });
+
+      it('should not expose parallel bindings to each other', function() {
+        // Expecting undefined for y to be consistent with normal
+        // identifier resolution in tinyLisp.
+        expect(t.interpret(t.parse("(let ((x 1) (y x)) (x y))"))).toEqual([1, undefined]);
+      });
+
+      it('should accept empty binding list', function() {
+        expect(t.interpret(t.parse("(let () 42)"))).toEqual(42);
+      });
+    });
+
+    describe('letrec', function() {
+      it('should expose previous bindings to later ones', function() {
+        expect(t.interpret(t.parse("(letrec ((x 42) (y x)) y)"))).toEqual(42);
+      });
+
+      it('should not expose later bindings to previous ones', function() {
+        expect(t.interpret(t.parse("(letrec ((x y) (y 42)) x)"))).toEqual(undefined);
+      });
+
+      it('should accept empty binding list', function() {
+        expect(t.interpret(t.parse("(letrec () 42)"))).toEqual(42);
+      });
+    });
   });
 });