goodguide-gibbon 0.6.3 → 0.6.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26638ccdac2b7fd84c9e103ae7943f2c7f9db804
+  data.tar.gz: 46759bac41cb0d02ef3d080e4bf22d9b0d0ea034
+SHA512:
+  metadata.gz: 84699372110c0383dab2c46d753e29abe7f02e1385952b3fadb07182439828333057ad1bbbce838ee3d391f80aadf9fa1bfc39e78fe3d9d85108036daeca0fd5
+  data.tar.gz: c52e4ebea106a7194bd4e445da5521e6ff062f8bbfb1c40f2af9661786d1acf509a8191274acdc7b2baebbb9f2896070a2d1daa4a129f41a5ce057ba65cd46e6

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.6.3'
+      '0.6.4'
     end
   end
 end

data/vendor/gibbon/lib/gibbon.browser.dev.js

@@ -100,7 +100,43 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   // construct your Parser from the base parsers and the
   // parser combinator methods.
 
-  function parseError(stream, i, expected) {
+  function makeSuccess(index, value) {
+    return {
+      status: true,
+      index: index,
+      value: value,
+      furthest: -1,
+      expected: ''
+    };
+  }
+
+  function makeFailure(index, expected) {
+    return {
+      status: false,
+      index: -1,
+      value: null,
+      furthest: index,
+      expected: expected
+    };
+  }
+
+  function furthestBacktrackFor(result, last) {
+    if (!last) return result;
+    if (result.furthest >= last.furthest) return result;
+
+    return {
+      status: result.status,
+      index: result.index,
+      value: result.value,
+      furthest: last.furthest,
+      expected: last.expected
+    }
+  }
+
+  function parseError(stream, result) {
+    var expected = result.expected;
+    var i = result.furthest;
+
     if (i === stream.length) {
       var message = 'expected ' + expected + ', got the end of the string';
     }
@@ -116,54 +152,32 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   _.init = function(body) { this._ = body; };
 
   _.parse = function(stream) {
-    return this.skip(eof)._(stream, 0, success, parseError);
+    var result = this.skip(eof)._(stream, 0);
 
-    function success(stream, i, result) { return result; }
+    return result.status ? result.value : parseError(stream, result);
   };
 
-  function furthestFailure(onFailure, myI, myExpected) {
-    return function(stream, yourI, yourExpected) {
-      if (myI > yourI) return onFailure(stream, myI, myExpected);
-      else return onFailure.apply(this, arguments);
-    };
-  }
-
-  function furthestFailureSuccess(onSuccess, myFurthestFailureI, myFurthestExpected) {
-    return function(stream, i, result, yourFurthestFailureI, yourFurthestExpected) {
-      if (myFurthestFailureI > yourFurthestFailureI) {
-        return onSuccess(stream, i, result, myFurthestFailureI, myFurthestExpected);
-      }
-      else return onSuccess.apply(this, arguments);
-    };
-  }
-
   // -*- primitive combinators -*- //
   _.or = function(alternative) {
     var self = this;
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
-      return self._(stream, i, onSuccess, failure);
+    return Parser(function(stream, i) {
+      var result = self._(stream, i);
 
-      function failure(stream, newI, expected) {
-        var altSuccess = furthestFailureSuccess(onSuccess, newI, expected);
-        var altFailure = furthestFailure(onFailure, newI, expected);
-        return alternative._(stream, i, altSuccess, altFailure);
-      }
+      return result.status ? result : furthestBacktrackFor(alternative._(stream, i), result);
     });
   };
 
   _.then = function(next) {
     var self = this;
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
-      return self._(stream, i, success, onFailure);
+    return Parser(function(stream, i) {
+      var result = self._(stream, i);
 
-      function success(stream, newI, result, furthestFailureI, furthestExpected) {
-        var nextParser = (next instanceof Parser ? next : next(result));
-        var nextSuccess = furthestFailureSuccess(onSuccess, furthestFailureI, furthestExpected);
-        var nextFailure = furthestFailure(onFailure, furthestFailureI, furthestExpected);
-        return nextParser._(stream, newI, nextSuccess, nextFailure);
-      }
+      if (!result.status) return result;
+
+      var nextParser = (next instanceof Parser ? next : next(result.value));
+      return furthestBacktrackFor(nextParser._(stream, result.index), result);
     });
   };
 
@@ -184,26 +198,21 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   _.many = function() {
     var self = this;
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
-      var xs = [];
-      while (self._(stream, i, success, failure));
-      var furthestFailureI, furthestExpected;
-      return onSuccess(stream, i, xs, furthestFailureI, furthestExpected);
-
-      function success(stream, newI, x, successFurthestFailureI, successFurthestExpected) {
-        i = newI;
-        xs.push(x);
-        furthestFailureI = successFurthestFailureI;
-        furthestExpected = successFurthestExpected;
-        return true;
-      }
+    return Parser(function(stream, i) {
+      var accum = [];
+      var result;
+      var prevResult;
+
+      for (;;) {
+        result = furthestBacktrackFor(self._(stream, i), result);
 
-      function failure(stream, newI, expected) {
-        if (!(furthestFailureI > newI)) {
-          furthestFailureI = newI;
-          furthestExpected = expected;
+        if (result.status) {
+          i = result.index;
+          accum.push(result.value);
+        }
+        else {
+          return furthestBacktrackFor(makeSuccess(i, accum), result);
         }
-        return false;
       }
     });
   };
@@ -232,37 +241,37 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     if (arguments.length < 2) max = min;
     var self = this;
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
-      var xs = [];
-      var result = true;
-      var furthestFailureI, furthestExpected;
+    return Parser(function(stream, i) {
+      var accum = [];
+      var start = i;
+      var result;
+      var prevResult;
 
       for (var times = 0; times < min; times += 1) {
-        result = self._(stream, i, success, failure);
-        if (!result) return onFailure(stream, furthestFailureI, furthestExpected);
+        result = self._(stream, i);
+        prevResult = furthestBacktrackFor(result, prevResult);
+        if (result.status) {
+          i = result.index;
+          accum.push(result.value);
+        }
+        else {
+          return prevResult;
+        }
       }
 
       for (; times < max && result; times += 1) {
-        result = self._(stream, i, success, failure);
-      }
-
-      return onSuccess(stream, i, xs, furthestFailureI, furthestExpected);
-
-      function success(stream, newI, x, successFurthestFailureI, successFurthestExpected) {
-        i = newI;
-        xs.push(x);
-        furthestFailureI = successFurthestFailureI;
-        furthestExpected = successFurthestExpected;
-        return true;
-      }
-
-      function failure(stream, newI, expected) {
-        if (!(furthestFailureI > newI)) {
-          furthestFailureI = newI;
-          furthestExpected = expected;
+        result = self._(stream, i);
+        prevResult = furthestBacktrackFor(result, prevResult);
+        if (result.status) {
+          i = result.index;
+          accum.push(result.value);
+        }
+        else {
+          break;
         }
-        return false;
       }
+
+      return furthestBacktrackFor(makeSuccess(i, accum), prevResult);
     });
   };
 
@@ -271,19 +280,28 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   _.atMost = function(n) { return this.times(0, n); };
   _.atLeast = function(n) {
     var self = this;
-    return self.times(n).then(function(start) {
-      return self.many().map(function(end) {
-        return start.concat(end);
-      });
+    return seq([this.times(n), this.many()]).map(function(results) {
+      return results[0].concat(results[1]);
     });
   };
 
   _.map = function(fn) {
-    return this.then(function(result) { return succeed(fn(result)); });
+    var self = this;
+    return Parser(function(stream, i) {
+      var result = self._(stream, i);
+      if (!result.status) return result;
+      return furthestBacktrackFor(makeSuccess(result.index, fn(result.value)), result);
+    });
+  };
+
+  _.skip = function(next) {
+    return seq([this, next]).map(function(results) { return results[0]; });
   };
 
-  _.skip = function(two) {
-    return this.then(function(result) { return two.result(result); });
+  _.mark = function() {
+    return seq([index, this, index]).map(function(results) {
+      return { start: results[0], value: results[1], end: results[2] };
+    });
   };
 
   // -*- primitive parsers -*- //
@@ -291,70 +309,113 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     var len = str.length;
     var expected = "'"+str+"'";
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
+    return Parser(function(stream, i) {
       var head = stream.slice(i, i+len);
 
       if (head === str) {
-        return onSuccess(stream, i+len, head, -1);
+        return makeSuccess(i+len, head);
       }
       else {
-        return onFailure(stream, i, expected);
+        return makeFailure(i, expected);
       }
     });
   };
 
   var regex = Parsimmon.regex = function(re) {
-    if (re.source[0] !== '^') throw 'regex '+re+' must be anchored';
-
-    var expected = ''+re;
+    var anchored = RegExp('^(?:'+re.source+')', (''+re).slice((''+re).lastIndexOf('/')+1));
 
-    return Parser(function(stream, i, onSuccess, onFailure) {
-      var match = re.exec(stream.slice(i));
+    return Parser(function(stream, i) {
+      var match = anchored.exec(stream.slice(i));
 
       if (match) {
         var result = match[0];
-        return onSuccess(stream, i+result.length, result, -1);
+        return makeSuccess(i+result.length, result);
       }
       else {
-        return onFailure(stream, i, expected);
+        return makeFailure(i, re);
       }
     });
   };
 
-  var succeed = Parsimmon.succeed = function(result) {
-    return Parser(function(stream, i, onSuccess) {
-      return onSuccess(stream, i, result);
+  var succeed = Parsimmon.succeed = function(value) {
+    return Parser(function(stream, i) {
+      return makeSuccess(i, value);
     });
   };
 
   var fail = Parsimmon.fail = function(expected) {
-    return Parser(function(stream, i, _, onFailure) {
-      return onFailure(stream, i, expected);
-    });
+    return Parser(function(stream, i) { return makeFailure(i, expected); });
   };
 
-  var letter = Parsimmon.letter = regex(/^[a-z]/i);
-  var letters = Parsimmon.letters = regex(/^[a-z]*/i);
-  var digit = Parsimmon.digit = regex(/^[0-9]/);
-  var digits = Parsimmon.digits = regex(/^[0-9]*/);
-  var whitespace = Parsimmon.whitespace = regex(/^\s+/);
-  var optWhitespace = Parsimmon.optWhitespace = regex(/^\s*/);
+  var letter = Parsimmon.letter = regex(/[a-z]/i);
+  var letters = Parsimmon.letters = regex(/[a-z]*/i);
+  var digit = Parsimmon.digit = regex(/[0-9]/);
+  var digits = Parsimmon.digits = regex(/[0-9]*/);
+  var whitespace = Parsimmon.whitespace = regex(/\s+/);
+  var optWhitespace = Parsimmon.optWhitespace = regex(/\s*/);
 
-  var any = Parsimmon.any = Parser(function(stream, i, onSuccess, onFailure) {
-    if (i >= stream.length) return onFailure(stream, i, 'any character');
+  var any = Parsimmon.any = Parser(function(stream, i) {
+    if (i >= stream.length) return makeFailure(i, 'any character');
 
-    return onSuccess(stream, i+1, stream.charAt(i), -1);
+    return makeSuccess(i+1, stream.charAt(i));
   });
 
-  var all = Parsimmon.all = Parser(function(stream, i, onSuccess, onFailure) {
-    return onSuccess(stream, stream.length, stream.slice(i), -1);
+  var all = Parsimmon.all = Parser(function(stream, i) {
+    return makeSuccess(stream.length, stream.slice(i));
   });
 
-  var eof = Parsimmon.eof = Parser(function(stream, i, onSuccess, onFailure) {
-    if (i < stream.length) return onFailure(stream, i, 'EOF');
+  var eof = Parsimmon.eof = Parser(function(stream, i) {
+    if (i < stream.length) return makeFailure(i, 'EOF');
 
-    return onSuccess(stream, i, '', -1);
+    return makeSuccess(i, null);
   });
+
+  var lazy = Parsimmon.lazy = function(f) {
+    var parser = Parser(function(stream, i) {
+      parser._ = f()._;
+      return parser._(stream, i);
+    });
+
+    return parser;
+  };
+
+  // [Parser a] -> Parser [a]
+  var seq = Parsimmon.seq = function(parsers) {
+    return Parser(function(stream, i) {
+      var result;
+      var accum = new Array(parsers.length);
+
+      for (var j = 0; j < parsers.length; j += 1) {
+        result = furthestBacktrackFor(parsers[j]._(stream, i), result);
+        if (!result.status) return result;
+        accum[j] = result.value
+        i = result.index;
+      }
+
+      return furthestBacktrackFor(makeSuccess(i, accum), result);
+    });
+  }
+
+  var index = Parsimmon.index = Parser(function(stream, i) {
+    return makeSuccess(i, i);
+  });
+
+  //- fantasyland compat
+
+  //- Semigroup
+  _.concat = _.then;
+
+  //- Applicative
+  _.of = Parser.of = Parsimmon.of = succeed
+
+  _.ap = function(other) {
+    return seq([this, other]).map(function(results) {
+      return results[0](results[1]);
+    });
+  };
+
+  //- Monad
+  _.chain = _.then;
 });
   return Parsimmon;
 })()
@@ -1033,22 +1094,22 @@ Gibbon.AST = AST = (function(_super) {
   }
 
   AST.variants({
-    integer: ['value'],
-    decimal: ['value'],
-    percent: ['value'],
-    fraction: ['numerator', 'denominator'],
-    string: ['value'],
-    subst: ['flow'],
-    block: ['flow'],
-    list: ['elements', 'squish'],
-    defaulted: ['body', 'alternative'],
-    query: ['type', 'args'],
-    func: ['name', 'args'],
-    pair: ['first', 'second'],
-    flow: ['head', 'tail'],
-    metadata: ['key', 'text'],
-    definition: ['metadata', 'name', 'frame'],
-    frame: ['definitions', 'flow']
+    integer: ['loc', 'value'],
+    decimal: ['loc', 'value'],
+    percent: ['loc', 'value'],
+    fraction: ['loc', 'numerator', 'denominator'],
+    string: ['loc', 'value'],
+    subst: ['loc', 'flow'],
+    block: ['loc', 'flow'],
+    list: ['loc', 'elements', 'squish'],
+    defaulted: ['loc', 'body', 'alternative'],
+    query: ['loc', 'type', 'args'],
+    func: ['loc', 'name', 'args'],
+    pair: ['loc', 'first', 'second'],
+    flow: ['loc', 'head', 'tail'],
+    metadata: ['loc', 'key', 'text'],
+    definition: ['loc', 'metadata', 'name', 'frame'],
+    frame: ['loc', 'definitions', 'flow']
   });
 
   inspectDefinitions = function(defs) {
@@ -1063,34 +1124,34 @@ Gibbon.AST = AST = (function(_super) {
   };
 
   AST.prototype.inspect = function() {
-    var id;
-    id = function(x) {
+    var useValue;
+    useValue = function(_, x) {
       return x;
     };
     return this.cases({
-      integer: id,
-      decimal: id,
-      percent: id,
-      fraction: function(num, denom) {
+      integer: useValue,
+      decimal: useValue,
+      percent: useValue,
+      fraction: function(_, num, denom) {
         return "" + num + "/" + denom;
       },
-      string: function(s) {
+      string: function(_, s) {
         return "'" + s + "'";
       },
-      query: function(query, args) {
+      query: function(_, query, args) {
         if (query === 'access') {
           return "@" + args[0];
         } else {
           return "." + query + " " + (args.join(' '));
         }
       },
-      subst: function(flow) {
+      subst: function(_, flow) {
         return "(" + (flow.inspect()) + ")";
       },
-      block: function(flow) {
+      block: function(_, flow) {
         return "{ " + (flow.inspect()) + " }";
       },
-      list: function(els, squish) {
+      list: function(_, els, squish) {
         var close, el, open;
         open = squish ? '[*' : '[';
         close = squish ? '*]' : ']';
@@ -1104,10 +1165,10 @@ Gibbon.AST = AST = (function(_super) {
           return _results;
         })()).join(', ')) + " " + close;
       },
-      defaulted: function(body, alt) {
+      defaulted: function(_, body, alt) {
         return "" + (body.inspect()) + " | " + (alt.inspect());
       },
-      func: function(name, args) {
+      func: function(_, name, args) {
         var arg;
         args = (function() {
           var _i, _len, _results;
@@ -1120,10 +1181,10 @@ Gibbon.AST = AST = (function(_super) {
         })();
         return "" + name + " " + (args.join(' '));
       },
-      pair: function(first, second) {
+      pair: function(_, first, second) {
         return "" + (first.inspect()) + " : " + (second.inspect());
       },
-      flow: function(head, tail) {
+      flow: function(_, head, tail) {
         if (tail) {
           tail = "" + (tail.inspect()) + " -> ";
         } else {
@@ -1131,10 +1192,10 @@ Gibbon.AST = AST = (function(_super) {
         }
         return "" + tail + (head.inspect());
       },
-      metadata: function(key, text) {
+      metadata: function(_, key, text) {
         return "" + key + ": " + text;
       },
-      definition: function(metadata, name, frame) {
+      definition: function(_, metadata, name, frame) {
         var m, out, _i, _len;
         out = [];
         for (_i = 0, _len = metadata.length; _i < _len; _i++) {
@@ -1146,7 +1207,7 @@ Gibbon.AST = AST = (function(_super) {
         out.push(frame.inspect());
         return out.join('');
       },
-      frame: function(definitions, flow) {
+      frame: function(_, definitions, flow) {
         var out;
         out = [];
         out.push("(");
@@ -1173,7 +1234,6 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
   TypeAST.variants({
     concrete: ['name'],
     variable: ['name'],
-    "native": ['id'],
     wildcard: [],
     list: ['of'],
     func: ['input', 'args', 'output'],
@@ -1186,37 +1246,58 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
     return parse.type(str);
   };
 
-  TypeAST.parseUnit = function(str) {
-    return parse.unitType(str);
-  };
-
   return TypeAST;
 
 })(Variant);
 
 parse = Gibbon.parse = (function() {
-  var accessor, accessorExpr, arrow, arrowType, assertString, bang, blankLines, blockExpr, blockType, comma, commaSepFlows, comment, component, concrete, decimal, decimalExpr, defaulted, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, innerFrame, integer, integerExpr, isString, label, labelVal, lbrace, lbrack, lexeme, lines, listExpr, listType, lparen, lsplat, metadata, multiline, name, nativeId, nativeType, nonDefaultedFlow, nonPairedFlow, numericExpr, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, queryArg, queryExpr, rbrace, rbrack, regex, rparen, rsplat, signature, simpleType, singletonFlow, squishListExpr, str, string, stringExpr, substExpr, succeed, tag, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
+  var accessor, accessorExpr, arrow, arrowType, assertString, blankLines, blockExpr, blockType, comma, commaSepFlows, comment, component, concrete, decimal, decimalExpr, defaulted, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, innerFrame, integer, integerExpr, isString, label, labelVal, lazy, lbrace, lbrack, lexeme, lines, listExpr, listType, lparen, lsplat, metadata, multiline, name, nonDefaultedFlow, nonPairedFlow, numericExpr, opt, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, queryArg, queryExpr, rbrace, rbrack, regex, rparen, rsplat, seq, signature, simpleType, singletonFlow, spanLoc, squishListExpr, str, string, stringExpr, substExpr, succeed, tag, tassign, type, typeVar, variable, whitespace, wildType, wildcard, withLoc,
+    _this = this;
   tag = function(name, parser) {
-    return parser.tag(name);
+    return Parsimmon.Parser(function(stream, i) {
+      var result;
+      result = parser._(stream, i);
+      if (!result.status) {
+        result.expected = name;
+      }
+      return result;
+    });
   };
-  Parsimmon.Parser.prototype.tag = function(name) {
-    var _this = this;
-    return Parsimmon.Parser(function(stream, i, onSuccess, onFailure) {
-      return _this._(stream, i, onSuccess, function(stream, newI, expected) {
-        return onFailure(stream, newI, name);
-      });
+  Parsimmon.Parser.prototype.tryChain = function(f) {
+    return this.chain(function(res) {
+      return f(res).or(succeed(res));
     });
   };
   string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
+  seq = Parsimmon.seq, lazy = Parsimmon.lazy;
   whitespace = regex(/^[ \t]*/);
   blankLines = regex(/^[\n\s]+/);
   comment = regex(/^#.*?(\n|$)/);
   lines = (blankLines.or(comment)).many();
   lexeme = function(p) {
-    return p.skip(whitespace);
+    return p.mark().skip(whitespace);
   };
   multiline = function(p) {
-    return p.skip(lines);
+    return p.mark().skip(lines);
+  };
+  opt = function(p) {
+    return p.or(succeed(null));
+  };
+  withLoc = function(p, f) {
+    return p.map(function(_arg) {
+      var end, start, value;
+      start = _arg.start, value = _arg.value, end = _arg.end;
+      return f({
+        start: start,
+        end: end
+      }, value);
+    });
+  };
+  spanLoc = function(l, r) {
+    return {
+      start: l.start,
+      end: r.end
+    };
   };
   identifier = tag('an identifier', regex(/^[a-z][\w-]*[?]?/i));
   arrow = multiline(string('->'));
@@ -1228,7 +1309,7 @@ parse = Gibbon.parse = (function() {
   rbrack = lexeme(string(']'));
   lparen = multiline(string('('));
   rparen = lexeme(string(')'));
-  comma = lexeme(string(','));
+  comma = multiline(string(','));
   defaulted = multiline(string('|'));
   lsplat = multiline(string('[*'));
   rsplat = lexeme(string('*]'));
@@ -1246,154 +1327,187 @@ parse = Gibbon.parse = (function() {
   variable = lexeme(string('%').then(identifier));
   wildcard = lexeme(string('%'));
   funcPlaceholder = lexeme(string('&'));
-  integerExpr = integer.map(function(i) {
-    return AST.integer(parseInt(i));
+  integerExpr = withLoc(integer, function(loc, i) {
+    return AST.integer(loc, parseInt(i));
   });
-  decimalExpr = decimal.map(function(d) {
-    return AST.decimal(parseFloat(d));
+  decimalExpr = withLoc(decimal, function(loc, d) {
+    return AST.decimal(loc, parseFloat(d));
   });
-  percentExpr = percent.map(function(p) {
-    return AST.percent(parseInt(p));
+  percentExpr = withLoc(percent, function(loc, p) {
+    return AST.percent(loc, parseInt(p));
   });
-  fractionExpr = fraction.map(function(f) {
+  fractionExpr = withLoc(fraction, function(loc, f) {
     var denom, num, _ref5;
     _ref5 = f.split('/'), num = _ref5[0], denom = _ref5[1];
-    return AST.fraction(num, denom);
+    return AST.fraction(loc, num, denom);
   });
-  stringExpr = str.map(function(s) {
-    return AST.string(s);
+  stringExpr = withLoc(str, function(loc, s) {
+    return AST.string(loc, s);
   });
-  accessorExpr = accessor.map(function(name) {
-    return AST.query('access', [name]);
+  accessorExpr = withLoc(accessor, function(loc, name) {
+    return AST.query(loc, 'access', [name]);
   });
-  queryExpr = query.then(function(q) {
-    return queryArg.many().map(function(args) {
-      return AST.query(q, args);
-    });
+  queryExpr = seq([query, queryArg.many()]).map(function(_arg) {
+    var a, args, loc, q, _ref5;
+    q = _arg[0], args = _arg[1];
+    loc = spanLoc(q, ((_ref5 = args[args.length - 1]) != null ? _ref5.end : void 0) || q);
+    return AST.query(loc, q.value, (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = args.length; _i < _len; _i++) {
+        a = args[_i];
+        _results.push(a.value);
+      }
+      return _results;
+    })());
   });
   numericExpr = percentExpr.or(decimalExpr.or(fractionExpr.or(integerExpr)));
-  parenFlow = lparen.then(function() {
-    return flow.skip(rparen);
+  parenFlow = lazy(function() {
+    return lparen.then(flow).skip(rparen);
+  });
+  substExpr = lazy(function() {
+    return seq([lparen, flow, rparen]).map(function(_arg) {
+      var fl, l, r;
+      l = _arg[0], fl = _arg[1], r = _arg[2];
+      return AST.subst(spanLoc(l, r), fl);
+    });
   });
-  substExpr = parenFlow.map(function(fl) {
-    return AST.subst(fl);
+  listExpr = lazy(function() {
+    return seq([lbrack, commaSepFlows, rbrack]).map(function(_arg) {
+      var els, l, r;
+      l = _arg[0], els = _arg[1], r = _arg[2];
+      return AST.list(spanLoc(l, r), els, false);
+    });
   });
-  listExpr = lbrack.then(function() {
-    return commaSepFlows.then(function(els) {
-      return rbrack.result(AST.list(els, false));
+  squishListExpr = lazy(function() {
+    return seq([lsplat, commaSepFlows, rsplat]).map(function(_arg) {
+      var els, l, r;
+      l = _arg[0], els = _arg[1], r = _arg[2];
+      return AST.list(spanLoc(l, r), els, true);
     });
   });
-  squishListExpr = lsplat.then(function() {
-    return commaSepFlows.then(function(els) {
-      return rsplat.result(AST.list(els, true));
+  blockExpr = lazy(function() {
+    return seq([lbrace, flow, rbrace]).map(function(_arg) {
+      var flow, l, r;
+      l = _arg[0], flow = _arg[1], r = _arg[2];
+      return AST.block(spanLoc(l, r), flow);
     });
   });
-  blockExpr = lbrace.then(function() {
-    return flow.skip(rbrace);
-  }).map(AST.block);
   expr = tag('an expr', queryExpr.or(accessorExpr.or(substExpr.or(squishListExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr))))))));
   singletonFlow = expr.map(function(e) {
-    return AST.flow(e, null);
+    return AST.flow(e.loc, e, null);
   });
-  func = name.then(function(funcName) {
-    return parenFlow.or(singletonFlow).many().map(function(args) {
-      return AST.func(funcName, args);
-    });
+  func = seq([name, parenFlow.or(singletonFlow).many()]).map(function(_arg) {
+    var args, loc, name;
+    name = _arg[0], args = _arg[1];
+    loc = {
+      start: name.start,
+      end: name.end
+    };
+    if (args.length) {
+      loc.end = args[args.length - 1].loc.end;
+    }
+    return AST.func(loc, name.value, args);
   });
-  component = multiline(expr.or(func));
-  nonPairedFlow = component.then(function(first) {
-    return arrow.then(component).many().map(function(rest) {
-      var comp, cursor, _i, _len;
-      cursor = AST.flow(first, null);
-      for (_i = 0, _len = rest.length; _i < _len; _i++) {
-        comp = rest[_i];
-        cursor = AST.flow(comp, cursor);
-      }
-      return cursor;
-    });
+  component = expr.or(func).skip(lines);
+  nonPairedFlow = seq([component, arrow.then(component).many()]).map(function(_arg) {
+    var comp, cursor, first, rest, _i, _len;
+    first = _arg[0], rest = _arg[1];
+    cursor = AST.flow(first.loc, first, null);
+    for (_i = 0, _len = rest.length; _i < _len; _i++) {
+      comp = rest[_i];
+      cursor = AST.flow(spanLoc(first.loc, comp.loc), comp, cursor);
+    }
+    return cursor;
   });
-  nonDefaultedFlow = nonPairedFlow.then(function(first) {
+  nonDefaultedFlow = nonPairedFlow.tryChain(function(first) {
     return pair.then(nonDefaultedFlow).map(function(second) {
-      return AST.flow(AST.pair(first, second), null);
-    }).or(succeed(first));
+      var loc;
+      loc = spanLoc(first.loc, second.loc);
+      return AST.flow(loc, AST.pair(loc, first, second), null);
+    });
   });
-  flow = tag('a flow', nonDefaultedFlow.then(function(body) {
+  flow = tag('a flow', nonDefaultedFlow.tryChain(function(body) {
     return defaulted.then(flow).map(function(alternative) {
-      return AST.flow(AST.defaulted(body, alternative), null);
-    }).or(succeed(body));
-  }));
-  commaSepFlows = flow.skip(comma.or(succeed(null)).then(lines)).many().then(function(els) {
-    return flow.or(succeed(null)).map(function(final) {
-      if (final) {
-        els.push(final);
-      }
-      return els;
+      var loc;
+      loc = spanLoc(body.loc, alternative.loc);
+      return AST.flow(loc, AST.defaulted(loc, body, alternative), null);
     });
+  }));
+  commaSepFlows = seq([flow.skip(seq([opt(comma, lines)])).many(), opt(flow)]).map(function(_arg) {
+    var els, final;
+    els = _arg[0], final = _arg[1];
+    if (final) {
+      els.push(final);
+    }
+    return els;
   });
-  metadata = label.then(function(key) {
-    return labelVal.map(function(text) {
-      return AST.metadata(key, text);
-    });
+  metadata = seq([label, labelVal]).map(function(key, text) {
+    return AST.metadata(spanLoc(key, text), key.value, text.value);
   });
-  definition = tag('a definition', metadata.many().then(function(md) {
-    return name.then(function(n) {
-      return define.then(innerFrame).map(function(fl) {
-        return AST.definition(md, n, fl);
-      });
-    });
-  }));
-  frame = definition.many().then(function(defs) {
-    return flow.map(function(fl) {
-      return AST.frame(defs, fl);
+  definition = lazy(function() {
+    return seq([metadata.many(), name, define.then(innerFrame)]).map(function(_arg) {
+      var fl, loc, md, n, _ref5;
+      md = _arg[0], n = _arg[1], fl = _arg[2];
+      loc = spanLoc(((_ref5 = md[0]) != null ? _ref5.loc : void 0) || n, fl);
+      return AST.definition(loc, md, n.value, fl);
     });
   });
-  parenFrame = lparen.then(frame).skip(rparen.then(lines));
+  frame = seq([definition.many(), flow]).map(function(_arg) {
+    var defs, flow, loc;
+    defs = _arg[0], flow = _arg[1];
+    loc = spanLoc((defs[0] || flow).loc, flow.loc);
+    return AST.frame(loc, defs, flow);
+  });
+  parenFrame = seq([lparen, frame, rparen, lines]).map(function(_arg) {
+    var fr, l, r, _;
+    l = _arg[0], fr = _arg[1], r = _arg[2], _ = _arg[3];
+    fr.loc = spanLoc(l, r);
+    return fr;
+  });
   freeFrame = flow.map(function(fl) {
-    return AST.frame([], fl);
+    return AST.frame(fl.loc, [], fl);
   });
   innerFrame = parenFrame.or(freeFrame);
   program = lines.then(frame);
   tassign = lexeme(string('='));
-  bang = lexeme(string('!'));
-  nativeId = lexeme(regex(/^\w+/));
   concrete = name.map(function(n) {
-    return TypeAST.concrete(n);
+    return TypeAST.concrete(n.value);
   });
   typeVar = variable.map(function(v) {
-    return TypeAST.variable(v);
+    return TypeAST.variable(v.value);
   });
   wildType = wildcard.result(TypeAST.wildcard());
-  listType = lbrack.then(function() {
-    return type.skip(rbrack).map(function(t) {
+  listType = lazy(function() {
+    return seq([lbrack, type, rbrack]).map(function(_arg) {
+      var t, _, __;
+      _ = _arg[0], t = _arg[1], __ = _arg[2];
       return TypeAST.list(t);
     });
   });
-  parenType = lparen.then(function() {
-    return type.skip(rparen);
+  parenType = lazy(function() {
+    return lparen.then(type).skip(rparen);
   });
-  blockType = lbrace.then(function() {
-    return arrowType.skip(rbrace).map(function(t) {
+  blockType = lazy(function() {
+    return lbrace.then(arrowType).skip(rbrace).map(function(t) {
       return TypeAST.block(t);
     });
   });
-  nativeType = bang.then(nativeId).map(TypeAST["native"]);
-  simpleType = typeVar.or(wildType.or(listType.or(parenType.or(blockType.or(concrete.or(nativeType))))));
-  type = simpleType.then(function(first) {
+  simpleType = typeVar.or(wildType.or(listType.or(parenType.or(blockType.or(concrete)))));
+  type = simpleType.tryChain(function(first) {
     return pair.then(type).map(function(second) {
       return TypeAST.pair(first, second);
-    }).or(succeed(first));
-  });
-  arrowType = type.then(function(first) {
-    return arrow.then(type).map(function(second) {
-      return TypeAST.arrow(first, second);
     });
   });
-  signature = name.then(function(n) {
-    return type.many().then(function(argTypes) {
-      return tassign.then(arrowType).map(function(ftype) {
-        return TypeAST.func(ftype.from, argTypes, ftype.to);
-      });
-    });
+  arrowType = seq([type, arrow, type]).map(function(_arg) {
+    var first, second, _;
+    first = _arg[0], _ = _arg[1], second = _arg[2];
+    return TypeAST.arrow(first, second);
+  });
+  signature = seq([name, type.many(), tassign.then(arrowType)]).map(function(_arg) {
+    var argTypes, ftype, name;
+    name = _arg[0], argTypes = _arg[1], ftype = _arg[2];
+    return TypeAST.func(ftype.from, argTypes, ftype.to);
   });
   fullSignature = lines.then(signature);
   isString = function(s) {
@@ -1412,10 +1526,6 @@ parse = Gibbon.parse = (function() {
     assertString(str);
     return fullSignature.parse(str);
   };
-  parse.unitType = function(str) {
-    assertString(str);
-    return type.parse(str);
-  };
   return parse;
 })();
 
@@ -1971,12 +2081,12 @@ analyze = Gibbon.analyze = (function() {
             input = flow.tail ? TypeExpr.expr(flow.tail) : global;
             return push(TypeExpr.expr(flow), TypeExpr.query(input, _this, flow.head));
           },
-          pair: function(first, second) {
+          pair: function(_, first, second) {
             _this.analyzeFlow(first, global, push);
             _this.analyzeFlow(second, global, push);
             return push(TypeExpr.expr(flow), TypeExpr.param('pair', [TypeExpr.expr(first), TypeExpr.expr(second)]));
           },
-          func: function(name, args) {
+          func: function(_, name, args) {
             var arg, ast, func, i, input, scope, _i, _len, _results;
             if (!stdlib.hasOwnProperty(name)) {
               push(TypeExpr.expr(flow.head), TypeExpr.error('func', [flow.head]));
@@ -2010,11 +2120,11 @@ analyze = Gibbon.analyze = (function() {
           string: function() {
             return push(TypeExpr.expr(flow), TypeExpr.param('string', []));
           },
-          subst: function(subFlow) {
+          subst: function(_, subFlow) {
             push(TypeExpr.expr(flow), TypeExpr.expr(subFlow));
             return _this.analyzeFlow(subFlow, global, push);
           },
-          list: function(elements) {
+          list: function(_, elements) {
             var el, elVar, _i, _len, _results;
             elVar = TypeExpr.variable('el');
             push(TypeExpr.expr(flow), TypeExpr.param('list', [elVar]));
@@ -2026,13 +2136,13 @@ analyze = Gibbon.analyze = (function() {
             }
             return _results;
           },
-          block: function(subFlow) {
+          block: function(_, subFlow) {
             var input;
             input = TypeExpr.variable('.input');
             push(TypeExpr.expr(flow), TypeExpr.param('block', [input, TypeExpr.expr(subFlow)]));
             return _this.analyzeFlow(subFlow, input, push);
           },
-          defaulted: function(body, alt) {
+          defaulted: function(_, body, alt) {
             push(TypeExpr.expr(body), TypeExpr.expr(alt));
             push(TypeExpr.expr(flow), TypeExpr.expr(alt));
             _this.analyzeFlow(body, global, push);
@@ -2104,7 +2214,7 @@ analyze = Gibbon.analyze = (function() {
 
     })(Variant);
     DEBUG.logConstraint = function(prefix, lhs, rhs) {
-      return console.log(prefix, lhs.inspect(), '=', rhs.inspect());
+      return DEBUG.log(prefix, lhs.inspect(), '=', rhs.inspect());
     };
     consume = function(array, next, body) {
       var loop_, push;
@@ -2256,19 +2366,19 @@ analyze = Gibbon.analyze = (function() {
           };
           toSemanticTree = function(expr) {
             return expr.cases({
-              frame: function(_, flow) {
+              frame: function(_, __, flow) {
                 return Semantic.definition(dependencies, toSemanticTree(flow));
               },
-              flow: function(head, tail) {
+              flow: function(_, head, tail) {
                 return Semantic.flow(flowType(TypeExpr.expr(this)), toSemanticTree(head), tail && toSemanticTree(tail));
               },
-              query: function(type, name) {
+              query: function(_, type, name) {
                 if (!(errors.length || semanticAccessors.has(this))) {
                   throw "unsolved with no errors!";
                 }
                 return semanticAccessors.get(this);
               },
-              func: function(name, args) {
+              func: function(_, name, args) {
                 var a, scope, semArgs, solvedScope;
                 scope = this.__scope__;
                 solvedScope = new Hash;
@@ -2286,16 +2396,16 @@ analyze = Gibbon.analyze = (function() {
                 })();
                 return Semantic.func(name, semArgs, solvedScope);
               },
-              pair: function(first, second) {
+              pair: function(_, first, second) {
                 return Semantic.pair(toSemanticTree(first), toSemanticTree(second));
               },
-              block: function(flow) {
+              block: function(_, flow) {
                 return Semantic.block(toSemanticTree(flow));
               },
-              subst: function(subFlow) {
+              subst: function(_, subFlow) {
                 return toSemanticTree(subFlow);
               },
-              list: function(elements, squish) {
+              list: function(_, elements, squish) {
                 var e;
                 return Semantic.list((function() {
                   var _i, _len, _results;
@@ -2307,7 +2417,7 @@ analyze = Gibbon.analyze = (function() {
                   return _results;
                 })(), squish);
               },
-              defaulted: function(body, alt) {
+              defaulted: function(_, body, alt) {
                 return Semantic.defaulted(toSemanticTree(body), toSemanticTree(alt));
               },
               integer: function() {
@@ -2565,6 +2675,9 @@ Value = Gibbon.Value = Value = (function(_super) {
         }
         return Value.boolean(o);
       },
+      block: function(from, to) {
+        return Value.block(o);
+      },
       other: function() {
         throw "could not return object of type " + (type.inspect());
       }
@@ -3584,7 +3697,6 @@ Gibbon.Core = Core = (function(_super) {
         _ref14 = this.subtrees();
         for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
           subtree = _ref14[_i];
-          console.log("checking alwaysSucceeds " + (subtree.inspect()));
           if (!subtree.alwaysSucceeds()) {
             return false;
           }
@@ -3609,6 +3721,9 @@ Gibbon.Core = Core = (function(_super) {
       fail: function() {
         return true;
       },
+      branch: function(ifTrue, ifFalse) {
+        return ifTrue.alwaysFails() && ifFalse.alwaysFails();
+      },
       rescue: function(e, default_) {
         return e.alwaysFails() && default_.alwaysFails();
       },
@@ -3620,7 +3735,6 @@ Gibbon.Core = Core = (function(_super) {
         _ref14 = this.subtrees();
         for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
           subtree = _ref14[_i];
-          console.log("checking alwaysFails " + (subtree.inspect()));
           if (subtree.alwaysFails()) {
             return true;
           }
@@ -3755,7 +3869,7 @@ Gibbon.Core = Core = (function(_super) {
         return Core.foldList(f(l), f(o), a, i, aa, f(b));
       },
       mapList: function(l, a, i, b) {
-        return Core.mapList(f(l), i, a, f(b));
+        return Core.mapList(f(l), a, i, f(b));
       },
       zipLists: function(l, r) {
         return Core.zipLists(f(l), f(r));
@@ -4433,16 +4547,35 @@ Gibbon.optimize = (function() {
         });
       },
       op2: function(op, left, right) {
-        var checkIdent, identFold, l, r, _ref14;
+        var checkConst, checkIdent, identFold, l, r, _ref14;
         left = partialEval(left);
         right = partialEval(right);
-        checkIdent = function(opTest, val, ident, identVal) {
-          return op === opTest && val._tag === 'constant' && val.value === ident && identVal;
+        checkConst = function(val, f) {
+          return val._tag === 'constant' && f(val.value);
         };
-        identFold = checkIdent('*', right, 1, left) || checkIdent('*', left, 1, right) || checkIdent('*', right, 0, Core.constant(0)) || checkIdent('*', left, 0, Core.constant(0)) || checkIdent('+', left, 0, right) || checkIdent('+', right, 0, left) || checkIdent('/', right, 1, left);
-        if (identFold) {
-          DEBUG.log("identity-folding " + (this.inspect()) + " to " + (identFold.inspect()));
-          return identFold;
+        if (op === '>' || op === '<' || op === '>=' || op === '<=') {
+          if (checkConst(left, function(x) {
+            return !isFinite(x);
+          })) {
+            DEBUG.log("reducing comparison with infinite values");
+            right = Core.constant(0);
+          } else if (checkConst(right, function(x) {
+            return !isFinite(x);
+          })) {
+            DEBUG.log("reducing comparison with infinite values");
+            left = Core.constant(0);
+          }
+        } else {
+          checkIdent = function(opTest, val, ident, identVal) {
+            return op === opTest && checkConst(val, function(x) {
+              return x === ident;
+            }) && identVal;
+          };
+          identFold = checkIdent('*', right, 1, left) || checkIdent('*', left, 1, right) || checkIdent('*', right, 0, Core.constant(0)) || checkIdent('*', left, 0, Core.constant(0)) || checkIdent('+', left, 0, right) || checkIdent('+', right, 0, left) || checkIdent('/', right, 1, left);
+          if (identFold) {
+            DEBUG.log("identity-folding " + (this.inspect()) + " to " + (identFold.inspect()));
+            return identFold;
+          }
         }
         if (!(left._tag === 'constant' && right._tag === 'constant')) {
           return Core.op2(op, left, right);
@@ -4476,18 +4609,19 @@ Gibbon.optimize = (function() {
       }).reverse();
     };
     genSubstitutions = function(expr) {
-      var newTrace, queue, sub, substitutions, trace, _i, _len, _ref14, _ref15;
-      substitutions = new ObjHash;
+      var newTrace, occurrences, queue, sub, substitutions, trace, _i, _len, _ref14, _ref15;
+      occurrences = new ObjHash;
+      substitutions = new Hash;
       queue = [[expr, List.empty()]];
       while (queue.length) {
         _ref14 = queue.shift(), expr = _ref14[0], trace = _ref14[1];
-        if (expr.isSimple()) {
+        if (expr.isSimple() || expr.alwaysFails()) {
           continue;
         }
-        if (substitutions.has(expr)) {
-          substitutions.get(expr).push(makeCrumbs(trace));
+        if (occurrences.has(expr)) {
+          occurrences.get(expr).push(makeCrumbs(trace));
         } else {
-          substitutions.set(expr, [makeCrumbs(trace)]);
+          occurrences.set(expr, [makeCrumbs(trace)]);
           newTrace = trace.cons(expr);
           _ref15 = expr.subtrees();
           for (_i = 0, _len = _ref15.length; _i < _len; _i++) {
@@ -4496,6 +4630,17 @@ Gibbon.optimize = (function() {
           }
         }
       }
+      occurrences.each(function(expr, crumbs) {
+        var insertionPoint;
+        if (!(crumbs.length >= 2)) {
+          return;
+        }
+        insertionPoint = findLastCommon(crumbs);
+        substitutions.cache(insertionPoint, function() {
+          return [];
+        });
+        return substitutions.get(insertionPoint).push(expr);
+      });
       return substitutions;
     };
     findLastCommon = function(_arg) {
@@ -4515,27 +4660,49 @@ Gibbon.optimize = (function() {
       return refCrumb;
     };
     simplify = function(expr, substitutions) {
-      substitutions.each(function(subExpr, crumbs) {
-        var lastCommon, name, recurse;
-        if (!(crumbs.length >= 2)) {
-          return;
+      var recurse;
+      return (recurse = function(expr) {
+        var bindable, bindableExprs, i, names, out, recurseInner, _, _i, _len;
+        bindableExprs = substitutions.get(expr.hash());
+        if (!bindableExprs) {
+          return expr.map(recurse);
         }
-        lastCommon = findLastCommon(crumbs);
-        name = nameGen('b');
-        DEBUG.log("eliminating common expression " + (expr.inspect()) + " as " + name);
-        return expr = (recurse = function(expr) {
-          var hash;
-          hash = expr.hash();
-          if (hash === lastCommon) {
-            return Core.bind(name, subExpr, expr.map(recurse));
-          } else if (hash === subExpr.hash()) {
-            return Core.variable(name);
-          } else {
-            return expr.map(recurse);
+        names = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = bindableExprs.length; _i < _len; _i++) {
+            _ = bindableExprs[_i];
+            _results.push(nameGen('b'));
+          }
+          return _results;
+        })();
+        DEBUG(function() {
+          var bindable, i, _i, _len, _results;
+          _results = [];
+          for (i = _i = 0, _len = bindableExprs.length; _i < _len; i = ++_i) {
+            bindable = bindableExprs[i];
+            _results.push(DEBUG.log("binding " + (bindable.inspect()) + " as " + names[i]));
+          }
+          return _results;
+        });
+        out = (recurseInner = function(boundExpr) {
+          var bindable, hash, i, _i, _len;
+          hash = boundExpr.hash();
+          for (i = _i = 0, _len = bindableExprs.length; _i < _len; i = ++_i) {
+            bindable = bindableExprs[i];
+            if (hash === bindable.hash()) {
+              return Core.variable(names[i]);
+            }
           }
+          return boundExpr.map(recurseInner);
         })(expr);
-      });
-      return expr;
+        for (i = _i = 0, _len = bindableExprs.length; _i < _len; i = ++_i) {
+          bindable = bindableExprs[i];
+          out = Core.bind(names[i], bindable, out);
+        }
+        DEBUG.log("=> " + (out.inspect()));
+        return out.map(recurse);
+      })(expr);
     };
     return function(expr) {
       return simplify(expr, genSubstitutions(expr));
@@ -5020,7 +5187,8 @@ VarTrace = (function(_super) {
 
   VarTrace.variants({
     value: ['val'],
-    continued: ['continuation', 'index']
+    continued: ['continuation', 'index'],
+    lambda: []
   });
 
   VarTrace.prototype.equals = function(other) {
@@ -5340,7 +5508,7 @@ RVal = (function(_super) {
     });
   };
 
-  RVal.prototype.mapSteps = function() {
+  RVal.prototype.mapSteps = function(f) {
     return this.cases({
       lambda: function(a, r, n, b) {
         return RVal.lambda(a, r, n, f(b));
@@ -5510,9 +5678,11 @@ Gibbon.sequence = (function() {
         });
       },
       block: function(argName, body) {
-        return bind(RVal.makeLambda(argName, function(rescue, next) {
+        var lambda;
+        lambda = RVal.makeLambda([argName], function(rescue, next) {
           return sequenceTail(body, rescue, next);
-        }));
+        });
+        return Step.makeVar(lambda, bind);
       },
       app: function(block, arg) {
         return Step.makeCont(1, bind, function(cont) {
@@ -6247,9 +6417,6 @@ Gibbon.codegen = (function() {
     var extended, varToJS;
     varToJS = function(varName) {
       return trace.getVar(varName).cases({
-        continued: function() {
-          return JS.ident(varName);
-        },
         value: function(val) {
           return val.cases({
             constant: function(v) {
@@ -6258,8 +6425,18 @@ Gibbon.codegen = (function() {
             global: function() {
               return JS.ident('$');
             },
-            lambda: function() {
-              throw 'TODO';
+            lambda: function(args, rescue, next, body) {
+              var arg, bodyTrace, lambdaStatements, _i, _len;
+              lambdaStatements = [];
+              bodyTrace = trace;
+              for (_i = 0, _len = args.length; _i < _len; _i++) {
+                arg = args[_i];
+                bodyTrace = bodyTrace.traceVar(arg, VarTrace.lambda());
+              }
+              generate(body, bodyTrace, function(statement) {
+                return lambdaStatements.push(statement);
+              });
+              return JS.func(null, __slice.call(args).concat([rescue], [next]), JS.block(lambdaStatements));
             },
             prim: function(arity, name, args) {
               var a, jsArgs;
@@ -6299,6 +6476,9 @@ Gibbon.codegen = (function() {
               return JS.ident(varName);
             }
           });
+        },
+        other: function() {
+          return JS.ident(varName);
         }
       });
     };