goodguide-gibbon 0.5.1 → 0.6.0

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

@@ -359,14 +359,13 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   return Parsimmon;
 })()
 // Generated by CoffeeScript 1.6.3
-var Gibbon;
-
-Gibbon = {};
-// Generated by CoffeeScript 1.6.3
-var CompMap, DEBUG, Hash, Map, Union, allocate, asyncMap, catLists, contIter, contMap, genId, isArray, uniq, _ref,
+var AST, CachingPromise, CompMap, CompiledCode, ContinuationTrace, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, Promise, RVal, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, UnitPromise, Value, VarTrace, Variant, allocate, analyze, applyOp1, applyOp2, asyncMap, catLists, contIter, contMap, equalArrays, eval_, genId, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
   __slice = [].slice,
   __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+Gibbon = {};
 
 genId = (function() {
   var id;
@@ -376,11 +375,29 @@ genId = (function() {
   };
 })();
 
+Thunk = (function() {
+  Thunk.trampoline = function(t) {
+    while (t instanceof Thunk) {
+      t = t.run();
+    }
+    return t;
+  };
+
+  function Thunk(run) {
+    this.run = run;
+  }
+
+  return Thunk;
+
+})();
+
 DEBUG = function(f) {
   return f();
 };
 
-DEBUG.log = console.log;
+DEBUG.log = function() {
+  return console.log.apply(console, arguments);
+};
 
 DEBUG.assert = function(msg, cond) {
   if (!cond) {
@@ -406,6 +423,53 @@ catLists = function(lists) {
   return out;
 };
 
+equalArrays = function(a1, a2) {
+  var e, i, _i, _len;
+  for (i = _i = 0, _len = a1.length; _i < _len; i = ++_i) {
+    e = a1[i];
+    if (e !== a2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+applyOp1 = function(op, arg) {
+  switch (op) {
+    case '!':
+      return !arg;
+    case '-':
+      return -arg;
+    default:
+      throw "unknown operator " + op;
+  }
+};
+
+applyOp2 = function(op, l, r) {
+  switch (op) {
+    case '+':
+      return l + r;
+    case '*':
+      return l * r;
+    case '/':
+      return l / r;
+    case '%':
+      return l % r;
+    case '===':
+      return l === r;
+    case '<':
+      return l < r;
+    case '>':
+      return l > r;
+    case '<=':
+      return l <= r;
+    case '>=':
+      return l >= r;
+    default:
+      throw "unknown operator " + op;
+  }
+};
+
 uniq = function(list, eq) {
   var el, out, u, _i, _j, _len, _len1;
   if (eq == null) {
@@ -435,34 +499,34 @@ uniq = function(list, eq) {
 
 allocate = Object.create || function(proto) {
   var dummy;
-  dummy = function() {};
+  dummy = (function() {});
   dummy.prototype = proto;
   return new dummy;
 };
 
 asyncMap = function(list, mapper, cb) {
-  var el, i, output, response, seen, _i, _len, _results;
+  var el, i, output, response, retVal, seen, _i, _len;
   if (list.length === 0) {
     return cb(list);
   }
   seen = 0;
   output = [];
+  retVal = null;
   response = function(i) {
     return function(el) {
       seen += 1;
       output[i] = el;
       if (seen >= list.length) {
-        cb(output);
+        retVal = cb(output);
       }
       return null;
     };
   };
-  _results = [];
   for (i = _i = 0, _len = list.length; _i < _len; i = ++_i) {
     el = list[i];
-    _results.push(mapper(el, response(i), i));
+    mapper(el, response(i), i);
   }
-  return _results;
+  return retVal;
 };
 
 contMap = function(list, mapper, cb) {
@@ -492,10 +556,12 @@ contIter = function(list, f, cb) {
   return loop_(0);
 };
 
-Union = (function() {
+Variant = (function() {
   var castJSON;
 
-  Union.specialize = function(tag, names) {
+  Variant.prototype.__isVariant__ = true;
+
+  Variant.specialize = function(tag, names) {
     var klass, name, subclass, _i, _len;
     klass = this;
     subclass = function(values) {
@@ -517,19 +583,20 @@ Union = (function() {
     };
   };
 
-  Union.types = function(tags) {
+  Variant.variants = function(tagSpec) {
     var names, tag, _results;
-    this.tags = tags;
+    this.prototype._type = this.name;
+    this.tags = tagSpec;
     _results = [];
-    for (tag in tags) {
-      if (!__hasProp.call(tags, tag)) continue;
-      names = tags[tag];
+    for (tag in tagSpec) {
+      if (!__hasProp.call(tagSpec, tag)) continue;
+      names = tagSpec[tag];
       _results.push(this[tag] = this.specialize(tag, names));
     }
     return _results;
   };
 
-  function Union(_names, _values) {
+  function Variant(_names, _values) {
     var i, name, _i, _len, _ref;
     this._names = _names;
     this._values = _values;
@@ -540,7 +607,7 @@ Union = (function() {
     }
   }
 
-  Union.prototype.cases = function(cases) {
+  Variant.prototype.cases = function(cases) {
     var fn;
     fn = cases[this._tag] || cases.other;
     if (!fn) {
@@ -565,11 +632,12 @@ Union = (function() {
     }
   };
 
-  Union.prototype.asJSON = function() {
+  Variant.prototype.asJSON = function() {
     var name, out, _i, _len, _ref;
     out = {
+      __isVariant__: true,
       _tag: this._tag,
-      _union: this.constructor.name
+      _type: this.constructor.name
     };
     _ref = this._names;
     for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -579,7 +647,7 @@ Union = (function() {
     return out;
   };
 
-  Union.fromJSON = function(o) {
+  Variant.fromJSON = function(o) {
     var constructor, e, name, names, vals;
     if (isArray(o)) {
       return (function() {
@@ -595,7 +663,7 @@ Union = (function() {
     if (!(typeof o === 'object' && (o != null) && '_tag' in o)) {
       return o;
     }
-    constructor = Gibbon[o._union];
+    constructor = Gibbon[o._type];
     names = constructor.tags[o._tag];
     vals = (function() {
       var _i, _len, _results;
@@ -609,14 +677,14 @@ Union = (function() {
     return constructor[o._tag].apply(constructor, vals);
   };
 
-  Union.wrap = function(o) {
+  Variant.wrap = function(o) {
     if (o instanceof this) {
       return o;
     }
     return this.fromJSON(o);
   };
 
-  return Union;
+  return Variant;
 
 })();
 
@@ -701,7 +769,7 @@ Map = (function() {
 })();
 
 Gibbon.Hash = Hash = (function(_super) {
-  var salt;
+  var salt, saltLen;
 
   __extends(Hash, _super);
 
@@ -714,13 +782,15 @@ Gibbon.Hash = Hash = (function(_super) {
 
   salt = '<key>';
 
+  saltLen = salt.length;
+
   Hash.prototype.loadKey = function(k) {
     return salt + k;
   };
 
   Hash.prototype.dumpKey = function(k) {
     if (k.indexOf(salt) === 0) {
-      return k.slice(salt.length);
+      return k.slice(saltLen);
     }
   };
 
@@ -742,10 +812,9 @@ Gibbon.Hash = Hash = (function(_super) {
     for (k in this) {
       if (!__hasProp.call(this, k)) continue;
       v = this[k];
-      if (k.indexOf(salt) !== 0) {
-        continue;
+      if (k.slice(0, saltLen) === salt) {
+        _results.push(f(k.slice(saltLen), v));
       }
-      _results.push(f(k.slice(salt.length), v));
     }
     return _results;
   };
@@ -754,6 +823,45 @@ Gibbon.Hash = Hash = (function(_super) {
 
 })(Map);
 
+Gibbon.ObjHash = ObjHash = (function(_super) {
+  __extends(ObjHash, _super);
+
+  function ObjHash() {
+    _ref1 = ObjHash.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  ObjHash.prototype.get = function(k) {
+    var _ref2;
+    return (_ref2 = this[k.hash()]) != null ? _ref2.value : void 0;
+  };
+
+  ObjHash.prototype.set = function(k, v) {
+    return this[k.hash()] = {
+      key: k,
+      value: v
+    };
+  };
+
+  ObjHash.prototype.has = function(k) {
+    return this.hasOwnProperty(k.hash());
+  };
+
+  ObjHash.prototype.each = function(f) {
+    var k, v, _results;
+    _results = [];
+    for (k in this) {
+      if (!__hasProp.call(this, k)) continue;
+      v = this[k];
+      _results.push(f(v.key, v.value));
+    }
+    return _results;
+  };
+
+  return ObjHash;
+
+})(Hash);
+
 CompMap = (function(_super) {
   __extends(CompMap, _super);
 
@@ -776,10 +884,10 @@ CompMap = (function(_super) {
   };
 
   CompMap.prototype.keyIndex = function(k) {
-    var i, key, _i, _len, _ref1;
-    _ref1 = this.keys;
-    for (i = _i = 0, _len = _ref1.length; _i < _len; i = ++_i) {
-      key = _ref1[i];
+    var i, key, _i, _len, _ref2;
+    _ref2 = this.keys;
+    for (i = _i = 0, _len = _ref2.length; _i < _len; i = ++_i) {
+      key = _ref2[i];
       if (this.compare(key, k)) {
         return i;
       }
@@ -808,37 +916,37 @@ CompMap = (function(_super) {
   };
 
   CompMap.prototype.each = function(f) {
-    var i, k, _i, _len, _ref1, _results;
-    _ref1 = this.keys;
+    var i, k, _i, _len, _ref2, _results;
+    _ref2 = this.keys;
     _results = [];
-    for (i = _i = 0, _len = _ref1.length; _i < _len; i = ++_i) {
-      k = _ref1[i];
+    for (i = _i = 0, _len = _ref2.length; _i < _len; i = ++_i) {
+      k = _ref2[i];
       _results.push(f(k, this.values[i]));
     }
     return _results;
   };
 
   CompMap.prototype.eachAsync = function(f, cb) {
-    var i, k, keys, responder, seen, _i, _len, _results;
+    var i, k, keys, output, responder, seen, _i, _len;
     keys = this.keys;
     if (keys.length === 0) {
       return;
     }
+    output = null;
     seen = 0;
     responder = function(i) {
       return function() {
         seen += 1;
         if (seen >= keys.length) {
-          return cb();
+          return output = cb();
         }
       };
     };
-    _results = [];
     for (i = _i = 0, _len = keys.length; _i < _len; i = ++_i) {
       k = keys[i];
-      _results.push(f(k, this.values[i], responder(i)));
+      f(k, this.values[i], responder(i));
     }
-    return _results;
+    return output;
   };
 
   CompMap.prototype.fetch = function(k, f) {
@@ -871,10 +979,48 @@ CompMap = (function(_super) {
   return CompMap;
 
 })(Map);
-// Generated by CoffeeScript 1.6.3
-var AST, TypeAST, parse, _ref, _ref1,
-  __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+List = (function(_super) {
+  __extends(List, _super);
+
+  function List() {
+    _ref2 = List.__super__.constructor.apply(this, arguments);
+    return _ref2;
+  }
+
+  List.variants({
+    empty: [],
+    cons: ['head', 'tail']
+  });
+
+  List.single = function(el) {
+    return List.empty().cons(el);
+  };
+
+  List.prototype.cons = function(el) {
+    return List.cons(el, this);
+  };
+
+  List.prototype.toArray = function() {
+    return this.mapArray(function(x) {
+      return x;
+    });
+  };
+
+  List.prototype.mapArray = function(f) {
+    var out, tr;
+    out = [];
+    tr = this;
+    while (tr._tag === 'cons') {
+      out.push(f(tr.head));
+      tr = tr.tail;
+    }
+    return out;
+  };
+
+  return List;
+
+})(Variant);
 
 Gibbon.AST = AST = (function(_super) {
   var inspectDefinitions;
@@ -882,11 +1028,11 @@ Gibbon.AST = AST = (function(_super) {
   __extends(AST, _super);
 
   function AST() {
-    _ref = AST.__super__.constructor.apply(this, arguments);
-    return _ref;
+    _ref3 = AST.__super__.constructor.apply(this, arguments);
+    return _ref3;
   }
 
-  AST.types({
+  AST.variants({
     integer: ['value'],
     decimal: ['value'],
     percent: ['value'],
@@ -1014,17 +1160,17 @@ Gibbon.AST = AST = (function(_super) {
 
   return AST;
 
-})(Union);
+})(Variant);
 
 Gibbon.TypeAST = TypeAST = (function(_super) {
   __extends(TypeAST, _super);
 
   function TypeAST() {
-    _ref1 = TypeAST.__super__.constructor.apply(this, arguments);
-    return _ref1;
+    _ref4 = TypeAST.__super__.constructor.apply(this, arguments);
+    return _ref4;
   }
 
-  TypeAST.types({
+  TypeAST.variants({
     concrete: ['name'],
     variable: ['name'],
     "native": ['id'],
@@ -1046,10 +1192,10 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
 
   return TypeAST;
 
-})(Union);
+})(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, 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, 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;
   tag = function(name, parser) {
     return parser.tag(name);
   };
@@ -1087,6 +1233,7 @@ parse = Gibbon.parse = (function() {
   lsplat = multiline(string('[*'));
   rsplat = lexeme(string('*]'));
   query = lexeme(string('.').then(identifier));
+  queryArg = lexeme(regex(/^[\w-]+/));
   accessor = lexeme(string('@').then(identifier));
   name = lexeme(identifier);
   str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'")));
@@ -1109,8 +1256,8 @@ parse = Gibbon.parse = (function() {
     return AST.percent(parseInt(p));
   });
   fractionExpr = fraction.map(function(f) {
-    var denom, num, _ref2;
-    _ref2 = f.split('/'), num = _ref2[0], denom = _ref2[1];
+    var denom, num, _ref5;
+    _ref5 = f.split('/'), num = _ref5[0], denom = _ref5[1];
     return AST.fraction(num, denom);
   });
   stringExpr = str.map(function(s) {
@@ -1120,7 +1267,7 @@ parse = Gibbon.parse = (function() {
     return AST.query('access', [name]);
   });
   queryExpr = query.then(function(q) {
-    return name.many().map(function(args) {
+    return queryArg.many().map(function(args) {
       return AST.query(q, args);
     });
   });
@@ -1271,21 +1418,16 @@ parse = Gibbon.parse = (function() {
   };
   return parse;
 })();
-// Generated by CoffeeScript 1.6.3
-var Semantic, Type, TypeExpr, TypeLookup, analyze, _ref, _ref1, _ref2, _ref3,
-  __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
-  __slice = [].slice;
 
 Gibbon.Semantic = Semantic = (function(_super) {
   __extends(Semantic, _super);
 
   function Semantic() {
-    _ref = Semantic.__super__.constructor.apply(this, arguments);
-    return _ref;
+    _ref5 = Semantic.__super__.constructor.apply(this, arguments);
+    return _ref5;
   }
 
-  Semantic.types({
+  Semantic.variants({
     definition: ['dependencies', 'flow'],
     literal: ['syntax'],
     query: ['annotations'],
@@ -1299,37 +1441,127 @@ Gibbon.Semantic = Semantic = (function(_super) {
     defaulted: ['body', 'alternative']
   });
 
+  Semantic.prototype.inspect = function() {
+    return this.cases({
+      definition: function(deps, flow) {
+        var d;
+        return "<" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = deps.length; _i < _len; _i++) {
+            d = deps[_i];
+            _results.push(d.inspect());
+          }
+          return _results;
+        })()).join(', ')) + "> " + (flow.inspect());
+      },
+      literal: function(syntax) {
+        return syntax.inspect();
+      },
+      query: function(annotations) {
+        return "(? " + (JSON.stringify(annotations)) + ")";
+      },
+      localAccessor: function(name) {
+        return "@" + name;
+      },
+      pair: function(first, second) {
+        return "(" + (first.inspect()) + " : " + (second.inspect()) + ")";
+      },
+      block: function(body) {
+        return "{ " + (body.inspect()) + " }";
+      },
+      list: function(elements, squish) {
+        var e, l, r;
+        if (squish) {
+          l = "[*";
+          r = "*]";
+        } else {
+          l = "[";
+          r = "]";
+        }
+        return "" + l + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(e.inspect());
+          }
+          return _results;
+        })()).join(', ')) + r;
+      },
+      flow: function(type, head, tail) {
+        if (tail) {
+          return "" + (tail.inspect()) + " -> " + (head.inspect()) + " :: " + (type.inspect());
+        } else {
+          return "" + (head.inspect()) + " :: " + (type.inspect());
+        }
+      },
+      func: function(name, args, scope) {
+        var a;
+        return "" + name + " " + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push("(" + (a.inspect()) + ")");
+          }
+          return _results;
+        })()).join(' '));
+      },
+      subst: function(flow) {
+        return flow.inspect();
+      },
+      defaulted: function(body, alt) {
+        return "" + (body.inspect()) + " | " + (alt.inspect());
+      }
+    });
+  };
+
   return Semantic;
 
-})(Union);
+})(Variant);
 
 Gibbon.TypeLookup = TypeLookup = (function(_super) {
   __extends(TypeLookup, _super);
 
   function TypeLookup() {
-    _ref1 = TypeLookup.__super__.constructor.apply(this, arguments);
-    return _ref1;
+    _ref6 = TypeLookup.__super__.constructor.apply(this, arguments);
+    return _ref6;
   }
 
-  TypeLookup.types({
+  TypeLookup.variants({
     response: ['query', 'analysis'],
     local: ['name'],
     error: ['error']
   });
 
+  TypeLookup.prototype.inspect = function() {
+    return this.cases({
+      response: function(query, analysis) {
+        return "" + (query.inspect()) + (JSON.stringify(analysis.annotations)) + "::" + (analysis.type.inspect());
+      },
+      local: function(name) {
+        return "@" + name;
+      },
+      error: function(e) {
+        return "!" + e;
+      }
+    });
+  };
+
   return TypeLookup;
 
-})(Union);
+})(Variant);
 
 Gibbon.Type = Type = (function(_super) {
   __extends(Type, _super);
 
   function Type() {
-    _ref2 = Type.__super__.constructor.apply(this, arguments);
-    return _ref2;
+    _ref7 = Type.__super__.constructor.apply(this, arguments);
+    return _ref7;
   }
 
-  Type.types({
+  Type.variants({
     block: ['from', 'to'],
     pair: ['first', 'second'],
     list: ['of'],
@@ -1363,17 +1595,17 @@ Gibbon.Type = Type = (function(_super) {
 
   return Type;
 
-})(Union);
+})(Variant);
 
 Gibbon.TypeExpr = TypeExpr = (function(_super) {
   __extends(TypeExpr, _super);
 
   function TypeExpr() {
-    _ref3 = TypeExpr.__super__.constructor.apply(this, arguments);
-    return _ref3;
+    _ref8 = TypeExpr.__super__.constructor.apply(this, arguments);
+    return _ref8;
   }
 
-  TypeExpr.types({
+  TypeExpr.variants({
     expr: ['expr'],
     variable: ['name'],
     query: ['input', 'scope', 'query'],
@@ -1412,6 +1644,18 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
       expr: function(e) {
         return "<" + (e.inspect()) + ">";
       },
+      error: function(t, args) {
+        var a;
+        return "?" + t + "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push(a.inspect());
+          }
+          return _results;
+        })()).join(' ')) + ")";
+      },
       variable: function(name) {
         return "%" + name;
       },
@@ -1440,6 +1684,18 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
         })();
         return "(" + name + " " + (exprs.join(' ')) + ")";
       },
+      error: function(t, args) {
+        var a;
+        return "?" + t + "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push(a.inspect());
+          }
+          return _results;
+        })()).join(' ')) + ")";
+      },
       any: function() {
         return '*';
       }
@@ -1537,11 +1793,11 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
       return TypeExpr["native"](t.id);
     }
     return TypeExpr.param(t._tag, (function() {
-      var _i, _len, _ref4, _results;
-      _ref4 = t._values;
+      var _i, _len, _ref9, _results;
+      _ref9 = t._values;
       _results = [];
-      for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
-        st = _ref4[_i];
+      for (_i = 0, _len = _ref9.length; _i < _len; _i++) {
+        st = _ref9[_i];
         _results.push(this.fromType(st));
       }
       return _results;
@@ -1599,7 +1855,7 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
 
   return TypeExpr;
 
-})(Union);
+})(Variant);
 
 analyze = Gibbon.analyze = (function() {
   var generate, solve;
@@ -1614,9 +1870,9 @@ analyze = Gibbon.analyze = (function() {
       NativeContext.prototype.query = function(id, query, cb) {
         return this.externalLookup.call(null, id, query, Type, function(err, analysis) {
           if (err) {
-            return cb(TypeLookup.error(err));
+            return Thunk.trampoline(cb(TypeLookup.error(err)));
           } else {
-            return cb(TypeLookup.response(query, analysis));
+            return Thunk.trampoline(cb(TypeLookup.response(query, analysis)));
           }
         });
       };
@@ -1688,10 +1944,10 @@ analyze = Gibbon.analyze = (function() {
       };
 
       Scope.prototype.analyze = function(push) {
-        var def, frame, frameScope, global, key, _i, _len, _ref4;
-        _ref4 = this.frame.definitions;
-        for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
-          def = _ref4[_i];
+        var def, frame, frameScope, global, key, _i, _len, _ref9;
+        _ref9 = this.frame.definitions;
+        for (_i = 0, _len = _ref9.length; _i < _len; _i++) {
+          def = _ref9[_i];
           frameScope = this.extend(def.name, def.frame);
           frameScope.analyze(push);
           this.bindings.set(def.name, frameScope);
@@ -1759,19 +2015,14 @@ analyze = Gibbon.analyze = (function() {
             return _this.analyzeFlow(subFlow, global, push);
           },
           list: function(elements) {
-            var el, expected, rest, _i, _len, _results;
-            if (elements.length === 0) {
-              push(TypeExpr.expr(flow), TypeExpr.param('list', [TypeExpr.variable('el')]));
-              return;
-            }
-            expected = elements[0], rest = 2 <= elements.length ? __slice.call(elements, 1) : [];
-            push(TypeExpr.expr(flow), TypeExpr.param('list', [TypeExpr.expr(expected)]));
-            _this.analyzeFlow(expected, global, push);
+            var el, elVar, _i, _len, _results;
+            elVar = TypeExpr.variable('el');
+            push(TypeExpr.expr(flow), TypeExpr.param('list', [elVar]));
             _results = [];
-            for (_i = 0, _len = rest.length; _i < _len; _i++) {
-              el = rest[_i];
+            for (_i = 0, _len = elements.length; _i < _len; _i++) {
+              el = elements[_i];
               _this.analyzeFlow(el, global, push);
-              _results.push(push(TypeExpr.expr(el), TypeExpr.expr(expected)));
+              _results.push(push(TypeExpr.expr(el), elVar));
             }
             return _results;
           },
@@ -1812,16 +2063,16 @@ analyze = Gibbon.analyze = (function() {
     };
   })();
   solve = (function() {
-    var TypeError, consume, _ref4;
+    var TypeError, consume, _ref9;
     TypeError = (function(_super) {
       __extends(TypeError, _super);
 
       function TypeError() {
-        _ref4 = TypeError.__super__.constructor.apply(this, arguments);
-        return _ref4;
+        _ref9 = TypeError.__super__.constructor.apply(this, arguments);
+        return _ref9;
       }
 
-      TypeError.types({
+      TypeError.variants({
         match: ['lhs', 'rhs'],
         destructure: ['type'],
         lookup: ['query', 'id', 'error'],
@@ -1829,9 +2080,29 @@ analyze = Gibbon.analyze = (function() {
         func: ['node']
       });
 
+      TypeError.prototype.inspect = function() {
+        return this.cases({
+          match: function(lhs, rhs) {
+            return "could not match " + (lhs.inspect()) + " with " + (rhs.inspect());
+          },
+          destructure: function(type) {
+            return "failure to destructure " + (type.inspect());
+          },
+          lookup: function(query, id, error) {
+            return "error looking up " + (query.inspect()) + " on " + id + ": " + error;
+          },
+          circular: function(crumbs) {
+            return "circular reference: " + (crumbs.join(' -> '));
+          },
+          func: function(node) {
+            return "no such function " + node.name + " (in " + (node.inspect()) + ")";
+          }
+        });
+      };
+
       return TypeError;
 
-    })(Union);
+    })(Variant);
     DEBUG.logConstraint = function(prefix, lhs, rhs) {
       return console.log(prefix, lhs.inspect(), '=', rhs.inspect());
     };
@@ -1841,14 +2112,16 @@ analyze = Gibbon.analyze = (function() {
         return array.push([x, y]);
       };
       loop_ = function() {
-        var lhs, rhs, _ref5;
+        var lhs, rhs, _ref10;
         if (!(array.length > 0)) {
           return next();
         }
-        _ref5 = array.pop(), lhs = _ref5[0], rhs = _ref5[1];
-        return body(lhs, rhs, push, loop_);
+        _ref10 = array.pop(), lhs = _ref10[0], rhs = _ref10[1];
+        return body(lhs, rhs, push, function() {
+          return new Thunk(loop_);
+        });
       };
-      return loop_();
+      return Thunk.trampoline(loop_());
     };
     return function(constraintMap, finish) {
       var errors, frameTypes, initialCrumbs, k, locks, semantics, solutions, solveEntry;
@@ -1860,22 +2133,22 @@ analyze = Gibbon.analyze = (function() {
       frameTypes = new Hash;
       locks = new Hash;
       solveEntry = function(crumbs, solved) {
-        var constraints, dependencies, done, error, frame, fullSubstitute, key, nextCrumbs, semanticAccessors, simplify, substitute, _ref5;
+        var constraints, dependencies, done, error, frame, fullSubstitute, key, nextCrumbs, semanticAccessors, simplify, substitute, _ref10;
         key = crumbs[crumbs.length - 1];
         if (semantics.has(key)) {
           return solved();
         }
         nextCrumbs = crumbs.concat([key]);
-        _ref5 = constraintMap.get(key), frame = _ref5.frame, constraints = _ref5.constraints;
+        _ref10 = constraintMap.get(key), frame = _ref10.frame, constraints = _ref10.constraints;
         DEBUG.log('locking', key);
         locks.set(key, true);
         semanticAccessors = new CompMap;
         dependencies = [];
         DEBUG(function() {
-          var lhs, rhs, _i, _len, _ref6, _results;
+          var lhs, rhs, _i, _len, _ref11, _results;
           _results = [];
           for (_i = 0, _len = constraints.length; _i < _len; _i++) {
-            _ref6 = constraints[_i], lhs = _ref6[0], rhs = _ref6[1];
+            _ref11 = constraints[_i], lhs = _ref11[0], rhs = _ref11[1];
             _results.push(DEBUG.logConstraint('-> ', lhs, rhs));
           }
           return _results;
@@ -1948,8 +2221,12 @@ analyze = Gibbon.analyze = (function() {
                             return cb(error('circular', nextCrumbs));
                           }
                           localFrame = constraintMap.get(key).frame;
-                          return solveEntry(nextCrumbs, function() {
-                            return cb(frameTypes.get(key));
+                          return new Thunk(function() {
+                            return solveEntry(nextCrumbs, function() {
+                              return new Thunk(function() {
+                                return cb(frameTypes.get(key));
+                              });
+                            });
                           });
                         }
                       });
@@ -1986,12 +2263,9 @@ analyze = Gibbon.analyze = (function() {
                 return Semantic.flow(flowType(TypeExpr.expr(this)), toSemanticTree(head), tail && toSemanticTree(tail));
               },
               query: function(type, name) {
-                var _this = this;
-                DEBUG(function() {
-                  if (!semanticAccessors.has(_this)) {
-                    debugger;
-                  }
-                });
+                if (!(errors.length || semanticAccessors.has(this))) {
+                  throw "unsolved with no errors!";
+                }
                 return semanticAccessors.get(this);
               },
               func: function(name, args) {
@@ -2136,22 +2410,22 @@ analyze = Gibbon.analyze = (function() {
             param: function() {
               return rhs.cases({
                 param: function() {
-                  var constraint, i, _i, _len, _ref6;
+                  var constraint, i, _i, _len, _ref11;
                   if (lhs.name !== rhs.name) {
                     return matchError();
                   }
-                  _ref6 = lhs.constraints;
-                  for (i = _i = 0, _len = _ref6.length; _i < _len; i = ++_i) {
-                    constraint = _ref6[i];
+                  _ref11 = lhs.constraints;
+                  for (i = _i = 0, _len = _ref11.length; _i < _len; i = ++_i) {
+                    constraint = _ref11[i];
                     push(constraint, rhs.constraints[i]);
                   }
                   return next();
                 },
                 query: function() {
-                  var c, i, _i, _len, _ref6;
-                  _ref6 = lhs.constraints;
-                  for (i = _i = 0, _len = _ref6.length; _i < _len; i = ++_i) {
-                    c = _ref6[i];
+                  var c, i, _i, _len, _ref11;
+                  _ref11 = lhs.constraints;
+                  for (i = _i = 0, _len = _ref11.length; _i < _len; i = ++_i) {
+                    c = _ref11[i];
                     push(c, TypeExpr.destructure(rhs, lhs.type(i)));
                   }
                   return next();
@@ -2166,11 +2440,11 @@ analyze = Gibbon.analyze = (function() {
         });
       };
       initialCrumbs = (function() {
-        var _i, _len, _ref5, _results;
-        _ref5 = constraintMap.keys();
+        var _i, _len, _ref10, _results;
+        _ref10 = constraintMap.keys();
         _results = [];
-        for (_i = 0, _len = _ref5.length; _i < _len; _i++) {
-          k = _ref5[_i];
+        for (_i = 0, _len = _ref10.length; _i < _len; _i++) {
+          k = _ref10[_i];
           _results.push([k]);
         }
         return _results;
@@ -2193,20 +2467,16 @@ analyze = Gibbon.analyze = (function() {
     return solve(constraints, cb);
   };
 })();
-// Generated by CoffeeScript 1.6.3
-var CachingPromise, Dependency, Failure, Promise, Thunk, UnitPromise, Value, eval_, _ref, _ref1, _ref2, _ref3,
-  __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
 Value = Gibbon.Value = Value = (function(_super) {
   __extends(Value, _super);
 
   function Value() {
-    _ref = Value.__super__.constructor.apply(this, arguments);
-    return _ref;
+    _ref9 = Value.__super__.constructor.apply(this, arguments);
+    return _ref9;
   }
 
-  Value.types({
+  Value.variants({
     string: ['value'],
     number: ['value'],
     boolean: ['value'],
@@ -2247,6 +2517,121 @@ Value = Gibbon.Value = Value = (function(_super) {
     throw new Error('invalid value: ' + o);
   };
 
+  Value.interpret = function(o, type) {
+    var _this = this;
+    return type.cases({
+      pair: function(first, second) {
+        if (!('first' in o && 'second' in o)) {
+          throw 'bad value';
+        }
+        return Value.pair(_this.interpret(o.first, first), _this.interpret(o.second, second));
+      },
+      list: function(listOf) {
+        var e;
+        if (!isArray(o)) {
+          throw 'bad value';
+        }
+        return Value.list((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = o.length; _i < _len; _i++) {
+            e = o[_i];
+            _results.push(this.interpret(e, listOf));
+          }
+          return _results;
+        }).call(_this));
+      },
+      entity: function(type) {
+        if (typeof o !== 'number') {
+          throw 'bad value';
+        }
+        return Value.entity(type, o);
+      },
+      numeric: function() {
+        if (typeof o !== 'number') {
+          throw 'bad value';
+        }
+        return Value.number(o);
+      },
+      string: function() {
+        if (typeof o !== 'string') {
+          throw 'bad value';
+        }
+        return Value.string(o);
+      },
+      bool: function() {
+        if (typeof o !== 'boolean') {
+          throw 'bad value';
+        }
+        return Value.boolean(o);
+      },
+      other: function() {
+        throw "could not return object of type " + (type.inspect());
+      }
+    });
+  };
+
+  Value.prototype.asPrimitive = function() {
+    return this.cases({
+      string: function(v) {
+        return v;
+      },
+      number: function(v) {
+        return v;
+      },
+      boolean: function(v) {
+        return v;
+      },
+      block: function(v) {
+        return v;
+      },
+      list: function(els) {
+        var e, _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = els.length; _i < _len; _i++) {
+          e = els[_i];
+          _results.push(e.asPrimitive());
+        }
+        return _results;
+      },
+      pair: function(first, second) {
+        return {
+          first: first.asPrimitive(),
+          second: second.asPrimitive()
+        };
+      },
+      entity: function(_, id) {
+        return id;
+      }
+    });
+  };
+
+  Value.prototype.inspect = function() {
+    return this.cases({
+      list: function(els) {
+        var e;
+        return "(list " + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            e = els[_i];
+            _results.push(e.inspect());
+          }
+          return _results;
+        })()).join(' ')) + ")";
+      },
+      pair: function(first, second) {
+        return "(pair " + (first.inspect()) + " " + (second.inspect()) + ")";
+      },
+      entity: function(id) {
+        return "(entity " + id + ")";
+      },
+      other: function() {
+        return '' + this.asPrimitive();
+      }
+    });
+  };
+
   Value.prototype.promise = function() {
     return Promise.unit(this.map(function(x) {
       return x.promise();
@@ -2346,23 +2731,7 @@ Value = Gibbon.Value = Value = (function(_super) {
 
   return Value;
 
-})(Union);
-
-Thunk = (function() {
-  Thunk.trampoline = function(t) {
-    while (t instanceof Thunk) {
-      t = t.run();
-    }
-    return t;
-  };
-
-  function Thunk(run) {
-    this.run = run;
-  }
-
-  return Thunk;
-
-})();
+})(Variant);
 
 Promise = (function() {
   function Promise(forceRaw) {
@@ -2541,8 +2910,8 @@ UnitPromise = (function(_super) {
   __extends(UnitPromise, _super);
 
   function UnitPromise() {
-    _ref1 = UnitPromise.__super__.constructor.apply(this, arguments);
-    return _ref1;
+    _ref10 = UnitPromise.__super__.constructor.apply(this, arguments);
+    return _ref10;
   }
 
   UnitPromise.prototype.cache = function() {
@@ -2592,11 +2961,11 @@ Gibbon.Failure = Failure = (function(_super) {
   __extends(Failure, _super);
 
   function Failure() {
-    _ref2 = Failure.__super__.constructor.apply(this, arguments);
-    return _ref2;
+    _ref11 = Failure.__super__.constructor.apply(this, arguments);
+    return _ref11;
   }
 
-  Failure.types({
+  Failure.variants({
     query: ['id', 'annotations'],
     composite: ['failures'],
     message: ['message']
@@ -2633,17 +3002,17 @@ Gibbon.Failure = Failure = (function(_super) {
 
   return Failure;
 
-})(Union);
+})(Variant);
 
 Gibbon.Dependency = Dependency = (function(_super) {
   __extends(Dependency, _super);
 
   function Dependency() {
-    _ref3 = Dependency.__super__.constructor.apply(this, arguments);
-    return _ref3;
+    _ref12 = Dependency.__super__.constructor.apply(this, arguments);
+    return _ref12;
   }
 
-  Dependency.types({
+  Dependency.variants({
     query: ['entity', 'query'],
     lexical: ['key'],
     failure: ['failure']
@@ -2658,7 +3027,7 @@ Gibbon.Dependency = Dependency = (function(_super) {
         if (entity.id !== other.entity.id) {
           return false;
         }
-        if (query.annotations !== other.query.annotations) {
+        if (JSON.stringify(query) !== JSON.stringify(other.query)) {
           return false;
         }
         return true;
@@ -2674,8 +3043,8 @@ Gibbon.Dependency = Dependency = (function(_super) {
 
   Dependency.prototype.inspect = function() {
     return this.cases({
-      lookup: function(entity, query) {
-        return "" + (query.inspect()) + "<" + entity.id + ">";
+      query: function(entity, query) {
+        return "" + (JSON.stringify(query)) + "<" + entity + ">";
       },
       lexical: function(definition) {
         return "@" + definition.name;
@@ -2688,7 +3057,7 @@ Gibbon.Dependency = Dependency = (function(_super) {
 
   return Dependency;
 
-})(Union);
+})(Variant);
 
 eval_ = Gibbon["eval"] = (function() {
   var Context, Scope, combine, unit, vFalse, vTrue;
@@ -2707,10 +3076,10 @@ eval_ = Gibbon["eval"] = (function() {
     Context.prototype.evalAll = function() {
       var results, toForce,
         _this = this;
-      this.definitions.each(function(key, ir) {
+      this.definitions.each(function(key, expr) {
         var lazy;
         lazy = Promise.lazy(function() {
-          return _this.rootScope["eval"](ir).then(function(x) {
+          return _this.rootScope["eval"](expr).then(function(x) {
             return x.resolve();
           });
         });
@@ -2730,8 +3099,8 @@ eval_ = Gibbon["eval"] = (function() {
         }));
       });
       return combine(toForce).then(function() {
-        var deps, val, _ref4;
-        _ref4 = results.get('/'), val = _ref4[0], deps = _ref4[1];
+        var deps, val, _ref13;
+        _ref13 = results.get('/'), val = _ref13[0], deps = _ref13[1];
         if (val) {
           return Promise.unit(results);
         } else {
@@ -2791,10 +3160,10 @@ eval_ = Gibbon["eval"] = (function() {
     };
 
     Scope.prototype["let"] = function(bindings) {
-      var ext, k, v, _i, _len, _ref4;
+      var ext, k, v, _i, _len, _ref13;
       ext = new Hash;
       for (_i = 0, _len = bindings.length; _i < _len; _i++) {
-        _ref4 = bindings[_i], k = _ref4[0], v = _ref4[1];
+        _ref13 = bindings[_i], k = _ref13[0], v = _ref13[1];
         ext.set(k, v.cache());
       }
       return this.extend(ext);
@@ -2850,9 +3219,9 @@ eval_ = Gibbon["eval"] = (function() {
       return this.get(varName);
     };
 
-    Scope.prototype["eval"] = function(ir) {
+    Scope.prototype["eval"] = function(expr) {
       var _this = this;
-      return ir.cases({
+      return expr.cases({
         global: function() {
           return _this.get('@');
         },
@@ -2872,16 +3241,14 @@ eval_ = Gibbon["eval"] = (function() {
           });
         },
         bind: function(name, val, expr) {
-          return _this["eval"](val).then(function(v) {
-            return _this["let"]([[name, v]])["eval"](expr);
-          });
+          return _this["let"]([[name, _this["eval"](val)]])["eval"](expr);
         },
         delist: function(expr, index) {
           var evaled;
           evaled = [_this["eval"](expr), _this["eval"](index)];
           return combine(evaled).then(function(_arg) {
-            var elements, value, _ref4, _ref5;
-            (_ref4 = _arg[0], elements = _ref4.elements), (_ref5 = _arg[1], value = _ref5.value);
+            var elements, value, _ref13, _ref14;
+            (_ref13 = _arg[0], elements = _ref13.elements), (_ref14 = _arg[1], value = _ref14.value);
             return elements[value];
           });
         },
@@ -2910,7 +3277,13 @@ eval_ = Gibbon["eval"] = (function() {
               if (i >= elements.length) {
                 return _this["eval"](out);
               }
-              return _this["let"]([[idxArg, unit(Value.number(i))], [arg, elements[i]], [accumArg, _loop(i + 1)]])["eval"](body);
+              return _this["let"]([
+                [idxArg, unit(Value.number(i))], [arg, elements[i]], [
+                  accumArg, Promise.lazy(function() {
+                    return _loop(i + 1);
+                  })
+                ]
+              ])["eval"](body);
             };
             return _loop(0);
           });
@@ -2938,11 +3311,11 @@ eval_ = Gibbon["eval"] = (function() {
             var el, first, i, pairs, second;
             first = _arg[0], second = _arg[1];
             pairs = (function() {
-              var _i, _len, _ref4, _results;
-              _ref4 = first.elements;
+              var _i, _len, _ref13, _results;
+              _ref13 = first.elements;
               _results = [];
-              for (i = _i = 0, _len = _ref4.length; _i < _len; i = ++_i) {
-                el = _ref4[i];
+              for (i = _i = 0, _len = _ref13.length; _i < _len; i = ++_i) {
+                el = _ref13[i];
                 _results.push(Value.pair(el, second.elements[i]));
               }
               return _results;
@@ -2989,14 +3362,25 @@ eval_ = Gibbon["eval"] = (function() {
                 promise = elements[_i];
                 _results.push(promise.then(function(e) {
                   return e.resolve().map(function(e) {
-                    return [e.promise()];
+                    return e.promise();
                   });
-                }).or(unit([])));
+                }).or(unit(null)));
               }
               return _results;
             }).call(_this);
-            return combine(wrapped).map(function(lists) {
-              return Value.list(catLists(lists));
+            return combine(wrapped).map(function(withNulls) {
+              var e;
+              return Value.list((function() {
+                var _i, _len, _results;
+                _results = [];
+                for (_i = 0, _len = withNulls.length; _i < _len; _i++) {
+                  e = withNulls[_i];
+                  if (e) {
+                    _results.push(e);
+                  }
+                }
+                return _results;
+              })());
             });
           });
         },
@@ -3032,18 +3416,18 @@ eval_ = Gibbon["eval"] = (function() {
         fail: function(message) {
           return Promise.fail(Failure.message(message));
         },
-        binop: function(op, lhs, rhs) {
+        op1: function(name, value) {
+          return _this["eval"](value).map(function(v) {
+            return EXTERN[name](v.value);
+          });
+        },
+        op2: function(op, lhs, rhs) {
           return combine([_this["eval"](lhs), _this["eval"](rhs)]).map(function(_arg) {
             var l, r;
             l = _arg[0], r = _arg[1];
             return OPERATORS[op](l.value, r.value);
           });
         },
-        extern: function(name, value) {
-          return _this["eval"](value).map(function(v) {
-            return EXTERN[name](v.value);
-          });
-        },
         rescue: function(expr, default_) {
           return _this["eval"](expr).or(_this["eval"](default_));
         }
@@ -3054,46 +3438,25 @@ eval_ = Gibbon["eval"] = (function() {
 
   })();
   return function(semantics, table, id, client, finish) {
-    var allCompiled, compile, entity, onFailure, onSuccess, optimize;
-    optimize = Gibbon.optimize, compile = Gibbon.compile;
-    allCompiled = new Hash;
-    semantics.each(function(key, semantic) {
-      var compiled;
-      compiled = optimize(compile(semantic));
-      return allCompiled.set(key, compiled);
-    });
-    entity = Value.entity(table, id);
-    onFailure = function(fail) {
-      return finish(fail);
-    };
-    onSuccess = function(vals) {
-      DEBUG.log("final stack size: " + (DEBUG.getStackSize()));
-      return finish(null, vals);
-    };
-    return new Context(client, entity, allCompiled).evalAll().force(onFailure, onSuccess);
+    return Gibbon.compile(semantics).run('/', id, client, finish);
   };
 })();
-// Generated by CoffeeScript 1.6.3
-var IR, _ref,
-  __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
-Gibbon.IR = IR = (function(_super) {
+Gibbon.Core = Core = (function(_super) {
   var nameGen;
 
-  __extends(IR, _super);
+  __extends(Core, _super);
 
-  function IR() {
-    _ref = IR.__super__.constructor.apply(this, arguments);
-    return _ref;
+  function Core() {
+    _ref13 = Core.__super__.constructor.apply(this, arguments);
+    return _ref13;
   }
 
-  IR.types({
+  Core.variants({
     global: [],
     constant: ['value'],
     variable: ['name'],
     branch: ['cond', 'ifTrue', 'ifFalse'],
-    bind: ['name', 'value', 'expr'],
     delist: ['expr', 'index'],
     depair: ['expr', 'key'],
     list: ['elements'],
@@ -3109,52 +3472,58 @@ Gibbon.IR = IR = (function(_super) {
     query: ['expr', 'annotations'],
     localQuery: ['key'],
     fail: ['message'],
-    binop: ['op', 'lhs', 'rhs'],
-    extern: ['name', 'value'],
-    rescue: ['expr', 'default']
+    op1: ['op', 'arg'],
+    op2: ['op', 'lhs', 'rhs'],
+    rescue: ['expr', 'default'],
+    next: ['cont', 'args'],
+    bind: ['name', 'value', 'expr']
   });
 
-  IR.makeVariable = function(name) {
-    return IR.variable(nameGen(name));
+  Core.makeVariable = function(name) {
+    return Core.variable(nameGen(name));
+  };
+
+  Core.prototype.branch = function(ifTrue, ifFalse) {
+    return Core.branch(this, ifTrue, ifFalse);
   };
 
-  IR.prototype.branch = function(ifTrue, ifFalse) {
-    return IR.branch(this, ifTrue, ifFalse);
+  Core.prototype.delist = function(index) {
+    return Core.delist(this, index);
   };
 
-  IR.prototype.delist = function(index) {
-    return IR.delist(this, index);
+  Core.prototype.depair = function(key) {
+    return Core.depair(this, key);
   };
 
-  IR.prototype.depair = function(key) {
-    return IR.depair(this, key);
+  Core.prototype.query = function(annotations) {
+    return Core.query(this, annotations);
   };
 
-  IR.prototype.query = function(annotations) {
-    return IR.query(this, annotations);
+  Core.prototype.op1 = function(op) {
+    return Core.op1(op, this);
   };
 
-  IR.prototype.binop = function(op, other) {
-    return IR.binop(op, this, other);
+  Core.prototype.op2 = function(op, other) {
+    return Core.op2(op, this, other);
   };
 
-  IR.prototype.extern = function(name) {
-    return IR.extern(name, this);
+  Core.prototype.app = function(arg) {
+    return Core.app(this, arg);
   };
 
-  IR.prototype.app = function(arg) {
-    return IR.app(this, arg);
+  Core.prototype.squish = function() {
+    return Core.squishList(this);
   };
 
-  IR.prototype.squish = function() {
-    return IR.squishList(this);
+  Core.prototype.len = function() {
+    return Core.len(this);
   };
 
-  IR.prototype.len = function() {
-    return IR.len(this);
+  Core.prototype.rescue = function(alt) {
+    return Core.rescue(this, alt);
   };
 
-  IR.prototype.isAsync = function() {
+  Core.prototype.isAsync = function() {
     return this.cases({
       query: function() {
         return true;
@@ -3163,10 +3532,10 @@ Gibbon.IR = IR = (function(_super) {
         return true;
       },
       other: function() {
-        var sub, _i, _len, _ref1;
-        _ref1 = this.subtrees();
-        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-          sub = _ref1[_i];
+        var sub, _i, _len, _ref14;
+        _ref14 = this.subtrees();
+        for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
+          sub = _ref14[_i];
           if (sub.isAsync()) {
             return true;
           }
@@ -3176,7 +3545,7 @@ Gibbon.IR = IR = (function(_super) {
     });
   };
 
-  IR.prototype.isSimple = function() {
+  Core.prototype.isSimple = function() {
     return this.cases({
       variable: function() {
         return true;
@@ -3187,50 +3556,125 @@ Gibbon.IR = IR = (function(_super) {
       global: function() {
         return true;
       },
-      binop: function(op, l, r) {
-        return l.isSimple() && r.isSimple();
+      other: function() {
+        return false;
+      }
+    });
+  };
+
+  Core.prototype.alwaysSucceeds = function() {
+    return this.cases({
+      query: function() {
+        return false;
+      },
+      localQuery: function() {
+        return false;
+      },
+      fail: function() {
+        return false;
+      },
+      rescue: function(e, default_) {
+        return e.alwaysSucceeds() || default_.alwaysSucceeds();
+      },
+      squishList: function() {
+        return true;
+      },
+      other: function() {
+        var subtree, _i, _len, _ref14;
+        _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;
+          }
+        }
+        return true;
+      }
+    });
+  };
+
+  Core.prototype.alwaysFails = function() {
+    return this.cases({
+      query: function() {
+        return false;
+      },
+      localQuery: function() {
+        return false;
+      },
+      fail: function() {
+        return true;
+      },
+      rescue: function(e, default_) {
+        return e.alwaysFails() && default_.alwaysFails();
       },
-      extern: function(n, v) {
-        return v.isSimple();
+      squishList: function() {
+        return false;
       },
       other: function() {
+        var subtree, _i, _len, _ref14;
+        _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;
+          }
+        }
         return false;
       }
     });
   };
 
-  IR.prototype.seq = function(name, f) {
+  Core.prototype.seq = function(name, f) {
     name = nameGen(name);
-    return IR.bind(name, this, f(IR.variable(name)));
+    return Core.bind(name, this, f(Core.variable(name)));
   };
 
-  IR.prototype.mapList = function(f) {
+  Core.prototype.mapList = function(f) {
     var elName, ixName;
     elName = nameGen('el');
     ixName = nameGen('i');
-    return IR.mapList(this, elName, ixName, f(IR.variable(elName), IR.variable(ixName)));
+    return Core.mapList(this, elName, ixName, f(Core.variable(elName), Core.variable(ixName)));
   };
 
-  IR.prototype.foldList = function(init, f) {
+  Core.prototype.foldList = function(init, f) {
     var accumName, body, elName, ixName;
     elName = nameGen('el');
     ixName = nameGen('i');
     accumName = nameGen('next');
-    body = f(IR.variable(elName), IR.variable(accumName), IR.variable(ixName));
-    return IR.foldList(this, init, elName, accumName, ixName, body);
+    body = f(Core.variable(elName), Core.variable(accumName), Core.variable(ixName));
+    return Core.foldList(this, init, elName, accumName, ixName, body);
   };
 
-  IR.prototype.zipList = function(other) {
-    return IR.zipLists(this, other);
+  Core.prototype.zipList = function(other) {
+    return Core.zipLists(this, other);
   };
 
-  IR.prototype.filterList = function(f) {
+  Core.prototype.filterList = function(f) {
     var name;
     name = nameGen('el');
-    return IR.filterList(this, name, f(IR.variable(name)));
+    return Core.filterList(this, name, f(Core.variable(name)));
+  };
+
+  Core.prototype.variables = function() {
+    var s;
+    if (this._tag === 'variable') {
+      return [this];
+    }
+    return catLists((function() {
+      var _i, _len, _ref14, _results;
+      _ref14 = this.subtrees();
+      _results = [];
+      for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
+        s = _ref14[_i];
+        _results.push(s.variables());
+      }
+      return _results;
+    }).call(this));
   };
 
-  IR.prototype.subtrees = function() {
+  Core.prototype.subtrees = function() {
     var double, single;
     single = function(x) {
       return [x];
@@ -3264,12 +3708,12 @@ Gibbon.IR = IR = (function(_super) {
       },
       app: double,
       query: single,
-      binop: function(op, l, r) {
-        return [l, r];
-      },
-      extern: function(n, v) {
+      op1: function(op, v) {
         return [v];
       },
+      op2: function(op, l, r) {
+        return [l, r];
+      },
       rescue: double,
       other: function() {
         return [];
@@ -3277,23 +3721,23 @@ Gibbon.IR = IR = (function(_super) {
     });
   };
 
-  IR.prototype.map = function(f) {
+  Core.prototype.map = function(f) {
     return this.cases({
       branch: function(c, tr, fa) {
-        return IR.branch(f(c), f(tr), f(fa));
+        return Core.branch(f(c), f(tr), f(fa));
       },
       bind: function(n, v, e) {
-        return IR.bind(n, f(v), f(e));
+        return Core.bind(n, f(v), f(e));
       },
       delist: function(e, i) {
-        return IR.delist(f(e), i);
+        return Core.delist(f(e), i);
       },
       depair: function(e, k) {
-        return IR.depair(f(e), k);
+        return Core.depair(f(e), k);
       },
       list: function(els) {
         var e;
-        return IR.list((function() {
+        return Core.list((function() {
           var _i, _len, _results;
           _results = [];
           for (_i = 0, _len = els.length; _i < _len; _i++) {
@@ -3304,34 +3748,40 @@ Gibbon.IR = IR = (function(_super) {
         })());
       },
       foldList: function(l, o, a, i, aa, b) {
-        return IR.foldList(f(l), f(o), a, i, aa, f(b));
+        return Core.foldList(f(l), f(o), a, i, aa, f(b));
       },
       mapList: function(l, a, i, b) {
-        return IR.mapList(f(l), i, a, f(b));
+        return Core.mapList(f(l), i, a, f(b));
       },
       zipLists: function(l, r) {
-        return IR.zipLists(f(l), f(r));
+        return Core.zipLists(f(l), f(r));
+      },
+      filterList: function(l, a, b) {
+        return Core.filterList(f(l), a, f(b));
       },
       len: function(l) {
-        return IR.len(f(l));
+        return Core.len(f(l));
       },
       pair: function(x, y) {
-        return IR.pair(f(x), f(y));
+        return Core.pair(f(x), f(y));
       },
       block: function(n, b) {
-        return IR.block(n, f(b));
+        return Core.block(n, f(b));
       },
       app: function(b, a) {
-        return IR.app(f(b), f(a));
+        return Core.app(f(b), f(a));
       },
       query: function(e, a) {
-        return IR.query(f(e), a);
+        return Core.query(f(e), a);
+      },
+      op1: function(o, v) {
+        return Core.op1(o, f(v));
       },
-      binop: function(o, l, r) {
-        return IR.binop(o, f(l), f(r));
+      op2: function(o, l, r) {
+        return Core.op2(o, f(l), f(r));
       },
-      extern: function(n, v) {
-        return IR.extern(n, f(v));
+      squishList: function(l) {
+        return Core.squishList(f(l));
       },
       other: function() {
         return this;
@@ -3339,7 +3789,7 @@ Gibbon.IR = IR = (function(_super) {
     });
   };
 
-  IR.prototype.replace = function(expr, other) {
+  Core.prototype.replace = function(expr, other) {
     if (this.equals(expr)) {
       return other;
     }
@@ -3348,7 +3798,7 @@ Gibbon.IR = IR = (function(_super) {
     });
   };
 
-  IR.prototype.subst = function(varName, expr) {
+  Core.prototype.subst = function(varName, expr) {
     if (this._tag === 'variable' && this.name === varName) {
       return expr;
     }
@@ -3357,7 +3807,58 @@ Gibbon.IR = IR = (function(_super) {
     });
   };
 
-  IR.prototype.equals = function(other) {
+  Core.prototype.isStrictIn = function(needle) {
+    if (this.equals(needle)) {
+      return true;
+    }
+    return this.cases({
+      branch: function(cond, ifTrue, ifFalse) {
+        return cond.isStrictIn(needle) || (ifTrue.isStrictIn(needle) && ifFalse.isStrictIn(needle));
+      },
+      other: function() {
+        var subtree, _i, _len, _ref14;
+        _ref14 = this.subtrees();
+        for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
+          subtree = _ref14[_i];
+          if (subtree.isStrictIn(needle)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    });
+  };
+
+  Core.prototype.contains = function(needle) {
+    var subtree, _i, _len, _ref14;
+    if (this.equals(needle)) {
+      return true;
+    }
+    _ref14 = this.subtrees();
+    for (_i = 0, _len = _ref14.length; _i < _len; _i++) {
+      subtree = _ref14[_i];
+      if (subtree.contains(needle)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  Core.prototype.containsInNonTailPosition = function(needle) {
+    if (this.equals(needle)) {
+      return false;
+    }
+    return this.cases({
+      branch: function(cond, ifTrue, ifFalse) {
+        return cond.contains(needle) || ifTrue.containsInNonTailPosition(needle) || ifFalse.containsInNonTailPosition(needle);
+      },
+      other: function() {
+        return this.contains(needle);
+      }
+    });
+  };
+
+  Core.prototype.equals = function(other) {
     if (this._tag !== other._tag) {
       return false;
     }
@@ -3379,7 +3880,7 @@ Gibbon.IR = IR = (function(_super) {
         if (!val.equals(other.value)) {
           return false;
         }
-        subst = other.expr.subst(other.name, IR.variable(name));
+        subst = other.expr.subst(other.name, Core.variable(name));
         return expr.equals(subst);
       },
       delist: function(expr, index) {
@@ -3406,7 +3907,7 @@ Gibbon.IR = IR = (function(_super) {
         if (!out.equals(other.out)) {
           return false;
         }
-        subst = other.body.subst(other.arg, IR.variable(arg)).subst(other.accumArg, IR.variable(accumArg)).subst(other.idxArg, IR.variable(idxArg));
+        subst = other.body.subst(other.arg, Core.variable(arg)).subst(other.accumArg, Core.variable(accumArg)).subst(other.idxArg, Core.variable(idxArg));
         return body.equals(subst);
       },
       mapList: function(list, arg, idxArg, body) {
@@ -3414,7 +3915,7 @@ Gibbon.IR = IR = (function(_super) {
         if (!list.equals(other.list)) {
           return false;
         }
-        subst = other.body.subst(other.arg, IR.variable(arg)).subst(other.idxArg, IR.variable(idxArg));
+        subst = other.body.subst(other.arg, Core.variable(arg)).subst(other.idxArg, Core.variable(idxArg));
         return body.equals(subst);
       },
       zipLists: function(first, second) {
@@ -3424,7 +3925,7 @@ Gibbon.IR = IR = (function(_super) {
         if (!list.equals(other.list)) {
           return false;
         }
-        return body.equals(other.body.subst(other.arg, IR.variable(arg)));
+        return body.equals(other.body.subst(other.arg, Core.variable(arg)));
       },
       squishList: function(list) {
         return list.equals(other.list);
@@ -3450,11 +3951,11 @@ Gibbon.IR = IR = (function(_super) {
       fail: function() {
         return false;
       },
-      binop: function(op, lhs, rhs) {
+      op2: function(op, lhs, rhs) {
         return op === other.op && lhs.equals(other.lhs) && rhs.equals(other.rhs);
       },
-      extern: function(name, value) {
-        return name === other.name && value.equals(other.value);
+      op1: function(op, arg) {
+        return op === other.op && arg.equals(other.arg);
       },
       rescue: function(expr, default_) {
         return expr.equals(other.expr) && default_.equals(other["default"]);
@@ -3470,7 +3971,7 @@ Gibbon.IR = IR = (function(_super) {
     };
   })();
 
-  IR.prototype.inspect = function(indent) {
+  Core.prototype.inspect = function(indent) {
     if (indent == null) {
       indent = 0;
     }
@@ -3541,50 +4042,155 @@ Gibbon.IR = IR = (function(_super) {
       fail: function(m) {
         return "(FAIL " + m + ")";
       },
-      binop: function(op, l, r) {
-        return "(`" + op + "` " + (l.inspect()) + " " + (r.inspect()) + ")";
+      op1: function(op, arg) {
+        return "(`" + op + "` " + (arg.inspect()) + ")";
       },
-      extern: function(name, val) {
-        return "(`" + name + "` " + (val.inspect()) + ")";
+      op2: function(op, l, r) {
+        return "(`" + op + "` " + (l.inspect()) + " " + (r.inspect()) + ")";
       },
       rescue: function(e, d) {
         return "(RESCUE " + (e.inspect()) + " " + (d.inspect()) + ")";
       },
       constant: function(v) {
         return '' + v;
+      },
+      next: function() {
+        return 'NEXT';
       }
     });
   };
 
-  return IR;
+  Core.prototype.hash = function() {
+    var mkVar, r,
+      _this = this;
+    mkVar = (function() {
+      var i;
+      i = 0;
+      return function() {
+        return Core.variable("" + (i += 1));
+      };
+    })();
+    return this.__hash__ || (this.__hash__ = (r = function(el) {
+      return el.cases({
+        global: function() {
+          return '$';
+        },
+        branch: function(cond, ifTrue, ifFalse) {
+          return "(IF " + (r(cond)) + " " + (r(ifTrue)) + " " + (r(ifFalse)) + ")";
+        },
+        bind: function(name, val, expr) {
+          expr = expr.subst(name, mkVar());
+          return "(LET " + (r(val)) + " " + (r(expr)) + ")";
+        },
+        variable: function(name) {
+          return name;
+        },
+        delist: function(e, i) {
+          return "([" + (r(i)) + "] " + (r(e)) + ")";
+        },
+        depair: function(e, k) {
+          return "([" + k + "] " + (r(e)) + ")";
+        },
+        list: function(els) {
+          var e;
+          return "(LIST " + (((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = els.length; _i < _len; _i++) {
+              e = els[_i];
+              _results.push(r(e));
+            }
+            return _results;
+          })()).join(' ')) + ")";
+        },
+        len: function(e) {
+          return "(LEN " + (r(e)) + ")";
+        },
+        mapList: function(list, arg, i, body) {
+          body = body.subst(arg, mkVar()).subst(i, mkVar());
+          return "(MAP " + (r(list)) + " " + (r(body)) + ")";
+        },
+        foldList: function(list, out, arg, next, i, body) {
+          body = body.subst(arg, mkVar()).subst(next, mkVar()).subst(i, mkVar());
+          return "(FOLDR " + (r(list)) + " " + (r(out)) + " " + (r(body)) + ")";
+        },
+        filterList: function(list, arg, body) {
+          body = body.subst(arg, mkVar());
+          return "(FILTER " + (r(list)) + " " + (r(body)) + ")";
+        },
+        zipLists: function(x, y) {
+          return "(ZIP " + (r(x)) + " " + (r(y)) + ")";
+        },
+        squishList: function(l) {
+          return "(SQUISH " + (r(l)) + ")";
+        },
+        pair: function(x, y) {
+          return "(PAIR " + (r(x)) + " " + (r(y)) + ")";
+        },
+        query: function(e, a) {
+          return "(QUERY " + (JSON.stringify(a)) + " " + (r(e)) + ")";
+        },
+        block: function(arg, body) {
+          body = body.subst(arg, mkVar());
+          return "(LAMBDA " + (r(body)) + ")";
+        },
+        app: function(b, a) {
+          return "(APPLY " + (r(b)) + " " + (r(a)) + ")";
+        },
+        localQuery: function(k) {
+          return "@" + k;
+        },
+        fail: function(m) {
+          return "(FAIL)";
+        },
+        op1: function(op, arg) {
+          return "(OP1 " + op + " " + (r(arg)) + ")";
+        },
+        op2: function(op, lhs, rhs) {
+          return "(OP2 " + op + " " + (r(lhs)) + " " + (r(rhs)) + ")";
+        },
+        rescue: function(e, d) {
+          return "(RESCUE " + (r(e)) + " " + (r(d)) + ")";
+        },
+        constant: function(v) {
+          return '' + v;
+        },
+        next: function() {
+          return 'NEXT';
+        }
+      });
+    })(this));
+  };
+
+  return Core;
 
-})(Union);
+})(Variant);
 
-Gibbon.compile = (function() {
-  var compile;
-  compile = function(semantic, input, context) {
+Gibbon.translate = (function() {
+  var translate;
+  translate = function(semantic, input, context) {
     if (input == null) {
-      input = IR.global();
+      input = Core.global();
     }
     if (context == null) {
       context = input;
     }
     return semantic.cases({
       definition: function(_, flow) {
-        return compile(flow, input, context);
+        return translate(flow, input, context);
       },
       flow: function(_, head, tail) {
         if (tail) {
-          return compile(head, compile(tail, input, context), context);
+          return translate(head, translate(tail, input, context), context);
         } else {
-          return compile(head, input, context);
+          return translate(head, input, context);
         }
       },
       query: function(annotations) {
         return input.query(annotations);
       },
       localAccessor: function(key) {
-        return IR.localQuery(key);
+        return Core.localQuery(key);
       },
       func: function(name, args, tvars) {
         var arg, compArgs;
@@ -3593,23 +4199,23 @@ Gibbon.compile = (function() {
           _results = [];
           for (_i = 0, _len = args.length; _i < _len; _i++) {
             arg = args[_i];
-            _results.push(compile(arg, context));
+            _results.push(translate(arg, context));
           }
           return _results;
         })();
         return stdlib[name].compile(input, compArgs, tvars);
       },
       literal: function(syntax) {
-        return IR.constant(syntax.value);
+        return Core.constant(syntax.value);
       },
       list: function(elements, squish) {
         var e, list;
-        list = IR.list((function() {
+        list = Core.list((function() {
           var _i, _len, _results;
           _results = [];
           for (_i = 0, _len = elements.length; _i < _len; _i++) {
             e = elements[_i];
-            _results.push(compile(e, context));
+            _results.push(translate(e, context));
           }
           return _results;
         })());
@@ -3620,28 +4226,25 @@ Gibbon.compile = (function() {
         }
       },
       pair: function(x, y) {
-        return IR.pair(compile(x, context), compile(y, context));
+        return Core.pair(translate(x, context), translate(y, context));
       },
       block: function(body) {
         var arg;
-        arg = IR.makeVariable('arg');
-        return IR.block(arg.name, compile(body, arg, arg));
+        arg = Core.makeVariable('arg');
+        return Core.block(arg.name, translate(body, arg, arg));
       },
       defaulted: function(body, alternative) {
-        return IR.rescue(compile(body, context), compile(alternative, context));
+        return Core.rescue(translate(body, context), translate(alternative, context));
       }
     });
   };
   return function(semantic) {
-    return compile(semantic);
+    return translate(semantic);
   };
 })();
-// Generated by CoffeeScript 1.6.3
+
 Gibbon.optimize = (function() {
   var insertBindings, partialEval;
-  insertBindings = function(expr) {
-    return expr;
-  };
   partialEval = function(expr) {
     return expr.cases({
       depair: function(expr, key) {
@@ -3695,7 +4298,7 @@ Gibbon.optimize = (function() {
               return this.branch(ifTrue, ifFalse);
             }
           },
-          extern: function(name, arg) {
+          op1: function(name, arg) {
             if (name === '!') {
               DEBUG.log("eliminating if negation in condition " + (this.inspect()));
               return partialEval(arg.branch(ifFalse, ifTrue));
@@ -3711,6 +4314,7 @@ Gibbon.optimize = (function() {
       app: function(block, arg) {
         return partialEval(block).cases({
           block: function(argName, body) {
+            DEBUG.log("inlining application of " + (this.inspect()) + " to " + (arg.inspect()));
             return partialEval(body.subst(argName, arg));
           },
           other: function() {
@@ -3726,7 +4330,7 @@ Gibbon.optimize = (function() {
             for (i = _i = 0, _len = elements.length; _i < _len; i = ++_i) {
               el = elements[i];
               DEBUG.log(("subst " + arg + "=" + (el.inspect()) + " ") + ("" + ixName + "=" + i + " " + (body.inspect())));
-              partialEval(body.subst(arg, el).subst(ixName, IR.constant(i)));
+              partialEval(body.subst(arg, el).subst(ixName, Core.constant(i)));
             }
             mapped = (function() {
               var _j, _len1, _results;
@@ -3737,10 +4341,16 @@ Gibbon.optimize = (function() {
               }
               return _results;
             })();
-            return partialEval(IR.list(mapped));
+            return partialEval(Core.list(mapped));
+          },
+          mapList: function(innerList, innerArg, innerIdxArg, innerBody) {
+            var newBody;
+            DEBUG.log("fusing MAP of " + (this.inspect()));
+            newBody = body.subst(arg, innerBody).subst(ixName, Core.variable(innerIdxArg));
+            return Core.mapList(innerList, innerArg, innerIdxArg, newBody);
           },
           other: function() {
-            return IR.mapList(this, arg, ixName, partialEval(body));
+            return Core.mapList(this, arg, ixName, partialEval(body));
           }
         });
       },
@@ -3756,12 +4366,18 @@ Gibbon.optimize = (function() {
               }
               next = _loop(i + 1);
               DEBUG.log(("subst " + arg + "=" + (elements[i].inspect()) + " ") + ("" + accum + "=" + (next.inspect()) + " ") + ("" + ixName + "=i " + (body.inspect())));
-              return body.subst(arg, elements[i]).subst(accum, next).subst(ixName, IR.constant(i));
+              return body.subst(arg, elements[i]).subst(accum, next).subst(ixName, Core.constant(i));
             };
             return partialEval(_loop(0));
           },
+          mapList: function(innerList, innerArg, innerIdxArg, mapBody) {
+            var newBody;
+            DEBUG.log("fusing FOLDR of " + (this.inspect()));
+            newBody = body.subst(arg, mapBody).subst(ixName, Core.variable(innerIdxArg));
+            return Core.foldList(innerList, out, innerArg, accum, innerIdxArg, newBody);
+          },
           other: function() {
-            return IR.foldList(this, partialEval(out), arg, accum, ixName, partialEval(body));
+            return Core.foldList(this, partialEval(out), arg, accum, ixName, partialEval(body));
           }
         });
       },
@@ -3769,7 +4385,7 @@ Gibbon.optimize = (function() {
         return partialEval(list).cases({
           list: function(elements) {
             DEBUG.log("optimizing out len from " + (this.inspect()));
-            return IR.constant(elements.length);
+            return Core.constant(elements.length);
           },
           mapList: function(list) {
             DEBUG.log("optimizing MAP out of len");
@@ -3789,146 +4405,58 @@ Gibbon.optimize = (function() {
         l = partialEval(l);
         r = partialEval(r);
         if (!(l._tag === 'list' && r._tag === 'list')) {
-          return IR.zipLists(l, r);
+          return Core.zipLists(l, r);
         }
         elements = (function() {
           var _i, _len, _results;
           _results = [];
           for (i = _i = 0, _len = l.length; _i < _len; i = ++_i) {
             e = l[i];
-            _results.push(IR.pair(e, r[i]));
+            _results.push(Core.pair(e, r[i]));
           }
           return _results;
         })();
-        return partialEval(IR.list(elements));
+        return partialEval(Core.list(elements));
       },
-      extern: function(op, arg) {
+      op1: function(op, arg) {
         return partialEval(arg).cases({
           constant: function(value) {
-            if (/Math\.(\w+)/.test(op)) {
-              return IR.constant(Math[RegExp.$1](value));
-            }
-            return IR.constant((function() {
-              switch (op) {
-                case '!':
-                  return !value;
-                case '-':
-                  return -value;
-                default:
-                  throw "unknown operator " + op;
-              }
-            })());
+            return Core.constant(applyOp1(op, value));
           },
           other: function() {
-            return IR.extern(op, this);
+            return Core.op1(op, this);
           }
         });
       },
-      binop: function(op, left, right) {
-        var l, r, _ref;
+      op2: function(op, left, right) {
+        var 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;
+        };
+        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 IR.binop(op, left, right);
+          return Core.op2(op, left, right);
         }
-        DEBUG.log("constant-folding " + (left.binop(op, right).inspect()));
-        _ref = [left.value, right.value], l = _ref[0], r = _ref[1];
-        return IR.constant((function() {
-          switch (op) {
-            case '+':
-              return l + r;
-            case '*':
-              return l * r;
-            case '/':
-              return l / r;
-            case '%':
-              return l % r;
-            case '===':
-              return l === r;
-            case '<':
-              return l < r;
-            case '>':
-              return l > r;
-            case '<=':
-              return l <= r;
-            case '>=':
-              return l >= r;
-          }
-        })());
+        DEBUG.log("constant-folding " + (left.op2(op, right).inspect()));
+        _ref14 = [left.value, right.value], l = _ref14[0], r = _ref14[1];
+        return Core.constant(applyOp2(op, left.value, right.value));
       },
       rescue: function(expr, default_) {
-        var alwaysFails, alwaysSucceeds;
         expr = partialEval(expr);
-        alwaysSucceeds = function(e) {
-          return e.cases({
-            query: function() {
-              return false;
-            },
-            localQuery: function() {
-              return false;
-            },
-            fail: function() {
-              return false;
-            },
-            rescue: function() {
-              return true;
-            },
-            squishList: function() {
-              return true;
-            },
-            other: function() {
-              var subtree, _i, _len, _ref;
-              _ref = this.subtrees();
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                subtree = _ref[_i];
-                console.log("checking alwaysSucceeds " + (subtree.inspect()));
-                if (!alwaysSucceeds(subtree)) {
-                  return false;
-                }
-              }
-              return true;
-            }
-          });
-        };
-        alwaysFails = function(e) {
-          return e.cases({
-            query: function() {
-              return false;
-            },
-            localQuery: function() {
-              return false;
-            },
-            fail: function() {
-              return true;
-            },
-            rescue: function() {
-              return false;
-            },
-            squishList: function() {
-              return false;
-            },
-            other: function() {
-              var subtree, _i, _len, _ref;
-              _ref = this.subtrees();
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                subtree = _ref[_i];
-                console.log("checking alwaysFails " + (subtree.inspect()));
-                if (alwaysFails(subtree)) {
-                  return true;
-                }
-              }
-              return false;
-            }
-          });
-        };
-        if (alwaysSucceeds(expr)) {
+        if (expr.alwaysSucceeds()) {
           DEBUG.log("eliminating dead default branch of " + (this.inspect()));
           return expr;
-        } else if (alwaysFails(expr)) {
+        } else if (expr.alwaysFails()) {
           DEBUG.log("eliminating dead main branch of " + (this.inspect()));
           return partialEval(default_);
         } else {
-          return IR.rescue(expr, partialEval(default_));
+          return Core.rescue(expr, partialEval(default_));
         }
       },
       other: function() {
@@ -3936,6 +4464,79 @@ Gibbon.optimize = (function() {
       }
     });
   };
+  insertBindings = (function() {
+    var findLastCommon, genSubstitutions, makeCrumbs, simplify;
+    makeCrumbs = function(trace) {
+      return trace.mapArray(function(e) {
+        return e.hash();
+      }).reverse();
+    };
+    genSubstitutions = function(expr) {
+      var newTrace, queue, sub, substitutions, trace, _i, _len, _ref14, _ref15;
+      substitutions = new ObjHash;
+      queue = [[expr, List.empty()]];
+      while (queue.length) {
+        _ref14 = queue.shift(), expr = _ref14[0], trace = _ref14[1];
+        if (expr.isSimple()) {
+          continue;
+        }
+        if (substitutions.has(expr)) {
+          substitutions.get(expr).push(makeCrumbs(trace));
+        } else {
+          substitutions.set(expr, [makeCrumbs(trace)]);
+          newTrace = trace.cons(expr);
+          _ref15 = expr.subtrees();
+          for (_i = 0, _len = _ref15.length; _i < _len; _i++) {
+            sub = _ref15[_i];
+            queue.push([sub, newTrace]);
+          }
+        }
+      }
+      return substitutions;
+    };
+    findLastCommon = function(_arg) {
+      var i, last, refCrumb, reference, rest, testCrumbs, _i, _j, _len, _len1;
+      reference = _arg[0], rest = 2 <= _arg.length ? __slice.call(_arg, 1) : [];
+      last = null;
+      for (i = _i = 0, _len = reference.length; _i < _len; i = ++_i) {
+        refCrumb = reference[i];
+        for (_j = 0, _len1 = rest.length; _j < _len1; _j++) {
+          testCrumbs = rest[_j];
+          if (refCrumb !== testCrumbs[i]) {
+            return last;
+          }
+        }
+        last = refCrumb;
+      }
+      return refCrumb;
+    };
+    simplify = function(expr, substitutions) {
+      substitutions.each(function(subExpr, crumbs) {
+        var lastCommon, name, recurse;
+        if (!(crumbs.length >= 2)) {
+          return;
+        }
+        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);
+          }
+        })(expr);
+      });
+      return expr;
+    };
+    return function(expr) {
+      return simplify(expr, genSubstitutions(expr));
+    };
+  })();
   return function(expr) {
     var out;
     DEBUG.log("=== OPTIMIZING " + (expr.inspect()));
@@ -3944,66 +4545,1921 @@ Gibbon.optimize = (function() {
     return out;
   };
 })();
-// Generated by CoffeeScript 1.6.3
-var stdlib;
 
-stdlib = Gibbon.stdlib = (function() {
-  var compEquals, iFalse, iTrue, vFalse, vTrue;
-  vTrue = Value.boolean(true);
-  vFalse = Value.boolean(false);
-  iTrue = IR.constant(true);
-  iFalse = IR.constant(false);
-  compEquals = function(x, y, type) {
-    var direct;
-    direct = function() {
-      return x.binop('===', y);
-    };
-    return type.cases({
-      entity: direct,
-      numeric: direct,
-      string: direct,
-      bool: direct,
-      block: function() {
-        return iFalse;
+nameGen = (function(i) {
+  return function(name) {
+    return "" + name + (i += 1);
+  };
+})(0);
+
+Step = (function(_super) {
+  __extends(Step, _super);
+
+  function Step() {
+    _ref14 = Step.__super__.constructor.apply(this, arguments);
+    return _ref14;
+  }
+
+  Step.variants({
+    "let": ['lval', 'value', 'expr'],
+    fork: ['forks'],
+    each: ['length', 'cont'],
+    letCont: ['name', 'args', 'body', 'expr'],
+    letJoin: ['name', 'order', 'cont', 'expr'],
+    next: ['cont', 'args'],
+    app: ['fn', 'args', 'rescue', 'next'],
+    query: ['annotations', 'arg', 'rescue', 'next'],
+    localQuery: ['key', 'rescue', 'next'],
+    "if": ['cond', 'trueCont', 'falseCont']
+  });
+
+  Step.prototype.inspect = function() {
+    return this.cases({
+      "let": function(varName, value, expr) {
+        return "(LET " + varName + " " + (value.inspect()) + " " + (expr.inspect()) + ")";
       },
-      pair: function() {
-        var eqx, eqy;
-        eqx = compEquals(input.depair('first'), input.depair('second'), type.first);
-        eqy = compEquals(input.depair('first'), input.depair('second'), type.first);
-        return eqx.branch(eqy, iFalse);
+      letCont: function(name, args, body, expr) {
+        return "(LETC " + name + " \\" + (args.join(',')) + " " + (body.inspect()) + " " + (expr.inspect()) + ")";
       },
-      list: function() {
-        var eqEls, eqLength;
-        eqLength = compEquals(x.len(), y.len(), Type.numeric());
-        eqEls = x.zipList(y).foldList(iTrue, function(pair) {
-          return compEquals(pair.depair('first'), pair.depair('second'), type.of);
-        });
-        return eqLength.branch(eqEls, iFalse);
+      fork: function(forks) {
+        var f;
+        return "(FORK " + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = forks.length; _i < _len; _i++) {
+            f = forks[_i];
+            _results.push("->" + f);
+          }
+          return _results;
+        })()).join(' ')) + ")";
+      },
+      each: function(list, cont) {
+        return "(EACH " + list + " ->" + cont + ")";
+      },
+      letJoin: function(name, order, cont, expr) {
+        return "(LETJ " + name + "/" + order + " ->" + cont + " " + (expr.inspect()) + ")";
+      },
+      letMap: function(name, list, joinName, arg, body, expr) {
+        return "(LETM " + name + " " + list + " " + joinName + "<- \\" + arg + " " + (body.inspect()) + " " + (expr.inspect()) + ")";
+      },
+      next: function(cont, args) {
+        return "(->" + cont + " " + (args.join(' ')) + ")";
+      },
+      app: function(fn, args, rescue, next) {
+        return "(" + fn + " " + (args.join(' ')) + " !->" + rescue + " ->" + next + ")";
+      },
+      query: function(annotations, arg, rescue, next) {
+        return "(Q " + (JSON.stringify(annotations)) + " !->" + rescue + " ->" + next + ")";
+      },
+      localQuery: function(key, rescue, next) {
+        return "(@" + key + " !->" + rescue + ", ->" + next + ")";
+      },
+      "if": function(cond, trueCont, falseCont) {
+        return "(IF " + cond + " ->" + trueCont + " ->" + falseCont + ")";
       }
     });
   };
-  return {
-    "case": {
-      type: parse.type('case [bool : %b] = % -> %b'),
-      compile: function(_, _arg) {
-        var alts;
-        alts = _arg[0];
-        return alts.foldList(IR.fail('non-exhaustive cases'), function(el, next) {
-          return el.depair('first').branch(el.depair('second'), next);
-        });
-      }
-    },
-    "case-eq": {
-      type: parse.type('case-eq [%a : %b] = %a -> %b'),
-      compile: function(input, _arg, tvars) {
+
+  Step.prototype.inspectLines = function(indent) {
+    var i;
+    if (indent == null) {
+      indent = 0;
+    }
+    i = new Array(indent + 1).join('    ');
+    return this.cases({
+      "let": function(varName, value, expr) {
+        return "" + i + "let " + varName + " = " + (value.inspect()) + "\n" + (expr.inspectLines(indent));
+      },
+      letCont: function(name, args, body, expr) {
+        return "" + i + name + " " + (args.join(' ')) + ":\n" + (body.inspectLines(indent + 1)) + "\n" + (expr.inspectLines(indent));
+      },
+      letJoin: function(name, order, cont, expr) {
+        return "" + i + name + ": join/" + order + " ->" + cont + "\n" + (expr.inspectLines(indent));
+      },
+      fork: function(conts) {
+        var c;
+        return "" + i + "fork " + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = conts.length; _i < _len; _i++) {
+            c = conts[_i];
+            _results.push("->" + c);
+          }
+          return _results;
+        })()).join(' '));
+      },
+      each: function(length, cont) {
+        return "" + i + "each/" + length + " ->" + cont;
+      },
+      map: function(name, list, arg, joinName, body, expr) {
+        return "" + i + name + " = map " + list + " \\" + joinName + ":\n" + (body.inspectLines(indent + 1)) + "\n" + (expr.inspectLines(indent));
+      },
+      next: function(name, args) {
+        return "" + i + "go " + name + " " + (args.join(' '));
+      },
+      app: function(fn, args, rescue, next) {
+        return "" + i + "app " + fn + " " + (args.join(' ')) + " !->" + rescue + " ->" + next;
+      },
+      query: function(annotations, arg, rescue, next) {
+        return "" + i + "query " + (JSON.stringify(annotations)) + " " + arg + " !->" + rescue + " ->" + next;
+      },
+      localQuery: function(key, rescue, next) {
+        return "" + i + "@" + key + " !->" + rescue + ", ->" + next;
+      },
+      "if": function(cond, trueCont, falseCont) {
+        return "" + i + "if " + cond + " ->" + trueCont + " else ->" + falseCont;
+      }
+    });
+  };
+
+  Step.prototype.search = function(f) {
+    if (f(this)) {
+      return true;
+    }
+    return this.cases({
+      "let": function(_, __, expr) {
+        return expr.search(f);
+      },
+      project: function(_, __, ___, expr) {
+        return expr.search(f);
+      },
+      letCont: function(_, __, body, expr) {
+        return body.search(f) || expr.search(f);
+      },
+      letJoin: function(_, __, ___, expr) {
+        return expr.search(f);
+      },
+      other: function() {
+        return false;
+      }
+    });
+  };
+
+  Step.prototype.map = function(f) {
+    return this.cases({
+      "let": function(lval, value, expr) {
+        return Step["let"](lval, value.mapSteps(f), f(expr));
+      },
+      project: function(lval, value, index, expr) {
+        return Step.project(lval, value, index, f(expr));
+      },
+      letCont: function(name, args, body, expr) {
+        return Step.letCont(name, args, f(body), f(expr));
+      },
+      other: function() {
+        return this;
+      }
+    });
+  };
+
+  Step.prototype.hasFree = function(varName) {
+    return this.search(function(step) {
+      return step.cases({
+        "let": function(_, value, __) {
+          return value.hasFree(varName);
+        },
+        next: function(cont, args) {
+          return varName === cont || __indexOf.call(args, varName) >= 0;
+        },
+        app: function(fn, args, rescue, next) {
+          return (varName === fn || varName === rescue || varName === next) || __indexOf.call(args, varName) >= 0;
+        },
+        query: function(annotations, arg, rescue, next) {
+          return varName === arg || varName === rescue || varName === next;
+        },
+        localQuery: function(key, rescue, next) {
+          return varName === rescue || varName === next;
+        },
+        "if": function(cond, trueCont, falseCont) {
+          return varName === cond || varName === trueCont || varName === falseCont;
+        },
+        letJoin: function(name, order, cont) {
+          return varName === order || varName === cont;
+        },
+        fork: function(conts) {
+          return __indexOf.call(conts, varName) >= 0;
+        },
+        each: function(name, cont) {
+          return varName === name || varName === cont;
+        },
+        other: function() {
+          return false;
+        }
+      });
+    });
+  };
+
+  Step.prototype.genTrace = function(contName) {
+    return this.cases({
+      "let": function(_, __, e) {
+        return e.genTrace(contName);
+      },
+      letCont: function(_, __, body, expr) {
+        return body.genTrace(contName).concat(expr.genTrace(contName));
+      },
+      letJoin: function(_, __, cont, e) {
+        var calls;
+        calls = e.genTrace(contName);
+        if (cont === contName) {
+          return [ContinuationTrace.simple(this)].concat(calls);
+        } else {
+          return calls;
+        }
+      },
+      app: function(_, __, rescue, next) {
+        if (contName === rescue) {
+          return [ContinuationTrace.key(this, 'rescue')];
+        } else if (contName === next) {
+          return [ContinuationTrace.key(this, 'next')];
+        } else {
+          return [];
+        }
+      },
+      query: function(_, __, rescue, next) {
+        if (contName === rescue) {
+          return [ContinuationTrace.key(this, 'rescue')];
+        } else if (contName === next) {
+          return [ContinuationTrace.key(this, 'next')];
+        } else {
+          return [];
+        }
+      },
+      localQuery: function(_, rescue, next) {
+        if (contName === rescue) {
+          return [ContinuationTrace.key(this, 'rescue')];
+        } else if (contName === next) {
+          return [ContinuationTrace.key(this, 'next')];
+        } else {
+          return [];
+        }
+      },
+      next: function(name, _) {
+        if (contName === name) {
+          return [ContinuationTrace.simple(this)];
+        } else {
+          return [];
+        }
+      },
+      fork: function(forks) {
+        var fork, i, _i, _len;
+        for (i = _i = 0, _len = forks.length; _i < _len; i = ++_i) {
+          fork = forks[i];
+          if (contName === fork) {
+            return [ContinuationTrace.index(this, 'forks', i)];
+          }
+        }
+        return [];
+      },
+      each: function(length, cont) {
+        if (contName === cont) {
+          return [ContinuationTrace.key(this, 'cont')];
+        } else {
+          return [];
+        }
+      },
+      "if": function(_, trueCont, falseCont) {
+        if (contName === trueCont) {
+          return [ContinuationTrace.key(this, 'trueCont')];
+        } else if (contName === falseCont) {
+          return [ContinuationTrace.key(this, 'falseCont')];
+        } else {
+          return [];
+        }
+      }
+    });
+  };
+
+  Step.prototype.subst = function(varName, target) {
+    return this.cases({
+      "let": function(lval, value, expr) {
+        value = value.subst(varName, target);
+        if (varName === lval) {
+          return Step["let"](lval, value, expr);
+        }
+        return Step["let"](lval, value, expr.subst(varName, target));
+      },
+      letJoin: function(name, order, cont, expr) {
+        if (order === varName) {
+          order = target;
+        }
+        if (cont === varName) {
+          cont = target;
+        }
+        expr = expr.subst(varName, target);
+        return Step.letJoin(name, order, cont, expr);
+      },
+      next: function(cont, args) {
+        var arg, newArgs;
+        if (cont === varName) {
+          cont = target;
+        }
+        newArgs = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            if (arg === varName) {
+              _results.push(target);
+            } else {
+              _results.push(arg);
+            }
+          }
+          return _results;
+        })();
+        return Step.next(cont, newArgs);
+      },
+      app: function(fn, args, rescue, next) {
+        var arg;
+        if (fn === varName) {
+          fn = target;
+        }
+        if (rescue === varName) {
+          rescue = target;
+        }
+        if (next === varName) {
+          next = target;
+        }
+        args = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            if (arg === varName) {
+              _results.push(target);
+            } else {
+              _results.push(arg);
+            }
+          }
+          return _results;
+        })();
+        return Step.app(fn, args, rescue, next);
+      },
+      query: function(annotations, arg, rescue, next) {
+        if (arg === varName) {
+          arg = target;
+        }
+        if (rescue === varName) {
+          rescue = target;
+        }
+        if (next === varName) {
+          next = target;
+        }
+        return Step.query(annotations, arg, rescue, next);
+      },
+      localQuery: function(key, rescue, next) {
+        if (rescue === varName) {
+          rescue = target;
+        }
+        if (next === varName) {
+          next = target;
+        }
+        return Step.localQuery(key, rescue, next);
+      },
+      "if": function(cond, trueCont, falseCont) {
+        if (cond === varName) {
+          cond = target;
+        }
+        if (trueCont === varName) {
+          trueCont = target;
+        }
+        if (falseCont === varName) {
+          falseCont = target;
+        }
+        return Step["if"](cond, trueCont, falseCont);
+      },
+      each: function(name, cont) {
+        if (name === varName) {
+          name = target;
+        }
+        if (cont === varName) {
+          cont = target;
+        }
+        return Step.each(name, cont);
+      },
+      other: function() {
+        return this.map(function(x) {
+          return x.subst(varName, target);
+        });
+      }
+    });
+  };
+
+  Step.prototype.substAll = function(varNames, targets) {
+    var i, replaced, varName, _i, _len;
+    replaced = this;
+    for (i = _i = 0, _len = varNames.length; _i < _len; i = ++_i) {
+      varName = varNames[i];
+      replaced = replaced.subst(varName, targets[i]);
+    }
+    return replaced;
+  };
+
+  Step.makeCont = function(arity, fBody, fExpr) {
+    var contName, varNames;
+    contName = nameGen('k');
+    varNames = (function() {
+      var _i, _results;
+      _results = [];
+      for (_i = 0; 0 <= arity ? _i < arity : _i > arity; 0 <= arity ? _i++ : _i--) {
+        _results.push(nameGen('t'));
+      }
+      return _results;
+    })();
+    return Step.letCont(contName, varNames, fBody.apply(null, varNames), fExpr(contName));
+  };
+
+  Step.makeVar = function(val, f) {
+    var varName;
+    varName = nameGen('t');
+    return Step["let"](varName, val, f(varName));
+  };
+
+  Step.makeJoin = function(order, outCont, f) {
+    var joinName, mkBody;
+    joinName = nameGen('j');
+    mkBody = function(index) {
+      return f(index, function(mappedVal) {
+        return Step.next(joinName, [index, mappedVal]);
+      });
+    };
+    return Step.makeCont(1, mkBody, function(bodyCont) {
+      return Step.letJoin(joinName, order, outCont, Step.each(order, bodyCont));
+    });
+  };
+
+  Step.prototype.extendTrace = function(trace) {
+    return this.cases;
+  };
+
+  Step.prototype.walk = function(f) {
+    var recurse;
+    return (recurse = function(step, trace) {
+      return f(step, trace, function(newStep) {
+        var newTrace;
+        newTrace = trace.extendWith(step);
+        return recurse(newStep, newTrace);
+      });
+    })(this, Trace.empty());
+  };
+
+  return Step;
+
+})(Variant);
+
+VarTrace = (function(_super) {
+  __extends(VarTrace, _super);
+
+  function VarTrace() {
+    _ref15 = VarTrace.__super__.constructor.apply(this, arguments);
+    return _ref15;
+  }
+
+  VarTrace.variants({
+    value: ['val'],
+    continued: ['continuation', 'index']
+  });
+
+  VarTrace.prototype.equals = function(other) {
+    if (this._tag !== other._tag) {
+      return false;
+    }
+    return this.cases({
+      value: function(val) {
+        return val.equals(other.val);
+      },
+      continued: function(continuation, index) {
+        return continuation === other.continuation && index === other.index;
+      }
+    });
+  };
+
+  return VarTrace;
+
+})(Variant);
+
+ContinuationTrace = (function(_super) {
+  __extends(ContinuationTrace, _super);
+
+  function ContinuationTrace() {
+    _ref16 = ContinuationTrace.__super__.constructor.apply(this, arguments);
+    return _ref16;
+  }
+
+  ContinuationTrace.variants({
+    simple: ['node'],
+    key: ['node', 'key'],
+    index: ['node', 'key', 'index']
+  });
+
+  return ContinuationTrace;
+
+})(Variant);
+
+Trace = (function(_super) {
+  __extends(Trace, _super);
+
+  function Trace() {
+    _ref17 = Trace.__super__.constructor.apply(this, arguments);
+    return _ref17;
+  }
+
+  Trace.variants({
+    empty: [],
+    contTrace: ['parent', 'name', 'calls'],
+    varTrace: ['parent', 'name', 'traces']
+  });
+
+  Trace.prototype.boundNames = function() {
+    return this.cases({
+      empty: function() {
+        return [];
+      },
+      contTrace: function(parent, name, _, __) {
+        return parent.boundNames().concat([name]);
+      },
+      varTrace: function(parent, name, _) {
+        return parent.boundNames().concat([name]);
+      }
+    });
+  };
+
+  Trace.prototype.extendWith = function(step) {
+    var _this = this;
+    return step.cases({
+      "let": function(lval, value, _) {
+        return _this.traceVar(lval, VarTrace.value(value));
+      },
+      letCont: function(contName, argNames, body, expr) {
+        var i, name, traced, _i, _len;
+        traced = _this.traceCont(contName, step.genTrace(contName));
+        for (i = _i = 0, _len = argNames.length; _i < _len; i = ++_i) {
+          name = argNames[i];
+          traced = traced.traceVar(name, VarTrace.continued(contName, i));
+        }
+        return traced;
+      },
+      letJoin: function(name) {
+        return _this.traceCont(step.genTrace(name));
+      },
+      other: function() {
+        return _this;
+      }
+    });
+  };
+
+  Trace.prototype.inspect = function() {
+    return "<" + (this.boundNames().join(' ')) + ">";
+  };
+
+  Trace.prototype.traceCont = function(name, traces) {
+    return Trace.contTrace(this, name, traces);
+  };
+
+  Trace.prototype.traceVar = function(name, trace) {
+    return Trace.varTrace(this, name, trace);
+  };
+
+  Trace.prototype.findVarTrace = function(needle) {
+    return this.cases({
+      empty: function() {
+        return null;
+      },
+      contTrace: function(parent) {
+        return parent.findVarTrace(needle);
+      },
+      varTrace: function(parent, name, trace) {
+        if (needle.equals(trace)) {
+          return name;
+        } else {
+          return parent.findVarTrace(needle);
+        }
+      }
+    });
+  };
+
+  Trace.prototype.getVar = function(needle) {
+    return this.cases({
+      empty: function() {
+        throw "no such variable " + needle;
+      },
+      contTrace: function(parent) {
+        return parent.getVar(needle);
+      },
+      varTrace: function(parent, name, subst) {
+        if (name === needle) {
+          return subst;
+        } else {
+          return parent.getVar(needle);
+        }
+      }
+    });
+  };
+
+  Trace.prototype.getCont = function(needle) {
+    return this.cases({
+      empty: function() {
+        throw "no such continuation " + needle;
+      },
+      contTrace: function(parent, name, traces) {
+        if (name === needle) {
+          return traces;
+        } else {
+          return parent.getCont(needle);
+        }
+      },
+      varTrace: function(parent) {
+        return parent.getCont(needle);
+      }
+    });
+  };
+
+  return Trace;
+
+})(Variant);
+
+RVal = (function(_super) {
+  __extends(RVal, _super);
+
+  function RVal() {
+    _ref18 = RVal.__super__.constructor.apply(this, arguments);
+    return _ref18;
+  }
+
+  RVal.variants({
+    constant: ['value'],
+    global: [],
+    lambda: ['args', 'rescue', 'next', 'body'],
+    prim: ['arity', 'name', 'args'],
+    list: ['elements'],
+    project: ['val', 'index'],
+    pair: ['first', 'second'],
+    depair: ['val', 'key'],
+    compact: ['val']
+  });
+
+  RVal.prototype.equals = function(other) {
+    if (this._tag !== other._tag) {
+      return false;
+    }
+    return this.cases({
+      constant: function(val) {
+        return val === other.value;
+      },
+      global: function() {
+        return true;
+      },
+      lambda: function() {
+        return false;
+      },
+      prim: function(arity, name, args) {
+        return arity === other.arity && name === other.name && equalArrays(args, other.args);
+      },
+      list: function(elements) {
+        return equalArrays(elements, other.elements);
+      },
+      project: function(val, index) {
+        return val === other.val && index === other.index;
+      },
+      pair: function(first, second) {
+        return first === other.first && second === other.second;
+      },
+      depair: function(val, key) {
+        return val === other.val;
+      },
+      compact: function(val) {
+        return val === other.val;
+      }
+    });
+  };
+
+  RVal.prototype.hasFree = function(varName) {
+    return this.cases({
+      lambda: function(args, rescue, next, body) {
+        return __indexOf.call(args, varName) < 0 && (varName !== rescue && varName !== next) && body.hasFree(varName);
+      },
+      prim: function(_, __, args) {
+        return __indexOf.call(args, varName) >= 0;
+      },
+      list: function(els) {
+        return __indexOf.call(els, varName) >= 0;
+      },
+      project: function(val, index) {
+        return varName === val || varName === index;
+      },
+      pair: function(first, second) {
+        return varName === first || varName === second;
+      },
+      depair: function(val, key) {
+        return varName === val;
+      },
+      compact: function(val) {
+        return val === varName;
+      },
+      other: function() {
+        return false;
+      }
+    });
+  };
+
+  RVal.prototype.subst = function(varName, target) {
+    return this.cases({
+      prim: function(arity, name, args) {
+        var arg, newArgs;
+        newArgs = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            if (arg === varName) {
+              _results.push(target);
+            } else {
+              _results.push(arg);
+            }
+          }
+          return _results;
+        })();
+        return RVal.prim(arity, name, newArgs);
+      },
+      list: function(els) {
+        var el, newEls;
+        newEls = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            el = els[_i];
+            if (el === varName) {
+              _results.push(target);
+            } else {
+              _results.push(el);
+            }
+          }
+          return _results;
+        })();
+        return RVal.list(newEls);
+      },
+      project: function(val, index) {
+        if (val === varName) {
+          val = target;
+        }
+        if (index === varName) {
+          index = target;
+        }
+        return RVal.project(val, index);
+      },
+      compact: function(val) {
+        if (val === varName) {
+          val = target;
+        }
+        return RVal.compact(val);
+      },
+      pair: function(first, second) {
+        if (first === varName) {
+          first = target;
+        }
+        if (second === varName) {
+          second = target;
+        }
+        return RVal.pair(first, second);
+      },
+      depair: function(val, key) {
+        if (val === varName) {
+          val = target;
+        }
+        return RVal.depair(val, key);
+      },
+      lambda: function() {
+        throw 'TODO';
+      },
+      other: function() {
+        return this;
+      }
+    });
+  };
+
+  RVal.prototype.mapSteps = function() {
+    return this.cases({
+      lambda: function(a, r, n, b) {
+        return RVal.lambda(a, r, n, f(b));
+      },
+      other: function() {
+        return this;
+      }
+    });
+  };
+
+  RVal.makeLambda = function(argNames, f) {
+    var body, nextName, rescueName;
+    rescueName = nameGen('rescue');
+    nextName = nameGen('next');
+    body = f(rescueName, nextName);
+    return RVal.lambda(argNames, rescueName, nextName, body);
+  };
+
+  RVal.prototype.inspect = function() {
+    return this.cases({
+      constant: function(value) {
+        return "" + value;
+      },
+      global: function() {
+        return '$';
+      },
+      prim: function(arity, name, args) {
+        return "(`" + name + "`/" + arity + " " + (args.join(' ')) + ")";
+      },
+      project: function(val, index) {
+        return "" + val + "[" + index + "]";
+      },
+      lambda: function(args, rescue, next, body) {
+        return "(\\" + (args.join(' ')) + " =>" + rescue + " =>" + next + " " + (body.inspect()) + ")";
+      },
+      compact: function(val) {
+        return "(COMPACT " + val + ")";
+      },
+      pair: function(first, second) {
+        return "(PAIR " + first + " " + second + ")";
+      },
+      depair: function(val, key) {
+        return "" + val + "." + key;
+      },
+      list: function(els) {
+        return "[" + (els.join(', ')) + "]";
+      }
+    });
+  };
+
+  return RVal;
+
+})(Variant);
+
+Gibbon.sequence = (function() {
+  var bindExprs, sequence, sequenceTail;
+  bindExprs = function(exprs, rescue, f) {
+    var asyncExprs, asyncVars, bindAsyncVars, bound, collectionName, contName, expr, forkBodies, forks, i, idx, joinName, name, recurse, syncExprs, syncStep, syncVars, _, _i, _len;
+    syncExprs = [];
+    asyncExprs = [];
+    bound = [];
+    for (idx = _i = 0, _len = exprs.length; _i < _len; idx = ++_i) {
+      expr = exprs[idx];
+      if (expr.isAsync()) {
+        asyncExprs.push([idx, expr]);
+      } else {
+        syncExprs.push([idx, expr]);
+      }
+    }
+    if (asyncExprs.length === 1) {
+      syncExprs.push(asyncExprs[0]);
+      asyncExprs = [];
+    }
+    syncVars = (function() {
+      var _j, _len1, _ref19, _results;
+      _results = [];
+      for (_j = 0, _len1 = syncExprs.length; _j < _len1; _j++) {
+        _ref19 = syncExprs[_j], idx = _ref19[0], expr = _ref19[1];
+        name = nameGen('t');
+        bound[idx] = name;
+        _results.push(name);
+      }
+      return _results;
+    })();
+    asyncVars = (function() {
+      var _j, _len1, _ref19, _results;
+      _results = [];
+      for (_j = 0, _len1 = asyncExprs.length; _j < _len1; _j++) {
+        _ref19 = asyncExprs[_j], idx = _ref19[0], expr = _ref19[1];
+        _results.push(bound[idx] = nameGen('t'));
+      }
+      return _results;
+    })();
+    syncStep = (recurse = function(i) {
+      var expr_, idx_, _ref19;
+      if (i >= syncExprs.length) {
+        return f(bound);
+      }
+      _ref19 = syncExprs[i], idx_ = _ref19[0], expr_ = _ref19[1];
+      return sequence(expr_, rescue, function(boundExpr) {
+        bound[idx_] = boundExpr;
+        return recurse(i + 1);
+      });
+    })(0);
+    if (!asyncExprs.length) {
+      return syncStep;
+    }
+    joinName = nameGen('j');
+    contName = nameGen('k');
+    forkBodies = (function() {
+      var _j, _len1, _ref19, _results;
+      _results = [];
+      for (i = _j = 0, _len1 = asyncExprs.length; _j < _len1; i = ++_j) {
+        _ref19 = asyncExprs[i], _ = _ref19[0], expr = _ref19[1];
+        _results.push(Step.makeVar(RVal.constant(i), function(boundI) {
+          return sequence(expr, rescue, function(boundExpr) {
+            return Step.next(joinName, [boundI, boundExpr]);
+          });
+        }));
+      }
+      return _results;
+    })();
+    collectionName = nameGen('c');
+    bindAsyncVars = (recurse = function(i) {
+      if (i >= asyncVars.length) {
+        return syncStep;
+      }
+      return sequence(Core.constant(i), rescue, function(boundIndex) {
+        var projection;
+        projection = RVal.project(collectionName, boundIndex);
+        return Step["let"](asyncVars[i], projection, recurse(i + 1));
+      });
+    })(0);
+    forks = (function() {
+      var _j, _len1, _results;
+      _results = [];
+      for (_j = 0, _len1 = forkBodies.length; _j < _len1; _j++) {
+        _ = forkBodies[_j];
+        _results.push(nameGen('f'));
+      }
+      return _results;
+    })();
+    return Step.letCont(contName, [collectionName], bindAsyncVars, Step.makeVar(RVal.constant(asyncExprs.length), function(order) {
+      return Step.letJoin(joinName, order, contName, (recurse = function(i) {
+        if (i >= forkBodies.length) {
+          return Step.fork(forks);
+        } else {
+          return Step.letCont(forks[i], [], forkBodies[i], recurse(i + 1));
+        }
+      })(0));
+    }));
+  };
+  sequence = function(core, rescue, bind) {
+    return core.cases({
+      variable: function(name) {
+        return bind(name);
+      },
+      constant: function(val) {
+        return Step.makeVar(RVal.constant(val), bind);
+      },
+      global: function() {
+        return Step.makeVar(RVal.global(), bind);
+      },
+      bind: function(varName, valExpr, expr) {
+        return sequence(valExpr, rescue, function(bound) {
+          return sequence(expr.subst(varName, Core.variable(bound)), rescue, bind);
+        });
+      },
+      block: function(argName, body) {
+        return bind(RVal.makeLambda(argName, function(rescue, next) {
+          return sequenceTail(body, rescue, next);
+        }));
+      },
+      app: function(block, arg) {
+        return Step.makeCont(1, bind, function(cont) {
+          return bindExprs([block, arg], rescue, function(_arg) {
+            var boundArg, boundBlock;
+            boundBlock = _arg[0], boundArg = _arg[1];
+            return Step.app(boundBlock, [boundArg], rescue, cont);
+          });
+        });
+      },
+      len: function(expr) {
+        return sequence(expr, rescue, function(boundExpr) {
+          return Step.makeVar(RVal.prim(1, 'length', [boundExpr]), bind);
+        });
+      },
+      op1: function(op, arg) {
+        return sequence(arg, rescue, function(boundArg) {
+          return Step.makeVar(RVal.prim(1, op, [boundArg]), bind);
+        });
+      },
+      op2: function(op, lhs, rhs) {
+        return bindExprs([lhs, rhs], rescue, function(_arg) {
+          var l, r;
+          l = _arg[0], r = _arg[1];
+          return Step.makeVar(RVal.prim(2, op, [l, r]), bind);
+        });
+      },
+      query: function(expr, annotations) {
+        return sequence(expr, rescue, function(boundExpr) {
+          return Step.makeCont(1, bind, function(outCont) {
+            return Step.query(annotations, boundExpr, rescue, outCont);
+          });
+        });
+      },
+      localQuery: function(key) {
+        return Step.makeCont(1, bind, function(outCont) {
+          return Step.localQuery(key, rescue, outCont);
+        });
+      },
+      branch: function(cond, ifTrue, ifFalse) {
+        return sequence(cond, rescue, function(boundCond) {
+          return Step.makeCont(1, bind, function(joinCont) {
+            var falseBody, trueBody;
+            trueBody = sequenceTail(ifTrue, rescue, joinCont);
+            falseBody = sequenceTail(ifFalse, rescue, joinCont);
+            return Step.makeCont(0, (function() {
+              return trueBody;
+            }), function(trueCont) {
+              return Step.makeCont(0, (function() {
+                return falseBody;
+              }), function(falseCont) {
+                return Step["if"](boundCond, trueCont, falseCont);
+              });
+            });
+          });
+        });
+      },
+      fail: function(message) {
+        return Step.makeVar(RVal.constant(message), function(boundMessage) {
+          return Step.next(rescue, [boundMessage]);
+        });
+      },
+      pair: function(first, second) {
+        return bindExprs([first, second], rescue, function(_arg) {
+          var f, s;
+          f = _arg[0], s = _arg[1];
+          return Step.makeVar(RVal.pair(f, s), bind);
+        });
+      },
+      list: function(elements) {
+        return bindExprs(elements, rescue, function(boundEls) {
+          return Step.makeVar(RVal.list(boundEls), bind);
+        });
+      },
+      squishList: function(list) {
+        return list.cases({
+          list: function(elements) {
+            var NULL, e, rescued;
+            NULL = Core.constant(null);
+            rescued = (function() {
+              var _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                e = elements[_i];
+                _results.push(e.rescue(NULL));
+              }
+              return _results;
+            })();
+            return bindExprs(rescued, rescue, function(boundExprs) {
+              return Step.makeVar(RVal.list(boundExprs), function(boundList) {
+                return Step.makeVar(RVal.compact(boundList), bind);
+              });
+            });
+          },
+          other: function() {
+            return sequence(list, rescue, function(boundList) {
+              return Step.makeVar(RVal.compact(boundList), bind);
+            });
+          }
+        });
+      },
+      mapList: function(list, arg, idxArg, body) {
+        var joinName;
+        joinName = nameGen('j');
+        return sequence(list, rescue, function(boundList) {
+          return Step.makeVar(RVal.prim(1, 'length', [boundList]), function(boundLen) {
+            return Step.makeCont(1, bind, function(outCont) {
+              return Step.makeJoin(boundLen, outCont, function(index, bindJoin) {
+                var delistExpr, substBody;
+                delistExpr = Core.variable(boundList).delist(Core.variable(index));
+                substBody = body.subst(arg, delistExpr).subst(idxArg, Core.variable(index));
+                return sequence(substBody, rescue, bindJoin);
+              });
+            });
+          });
+        });
+      },
+      filterList: function(list, arg, body) {
+        var joinName, nullName;
+        joinName = nameGen('j');
+        nullName = nameGen('NULL');
+        return sequence(list, rescue, function(boundList) {
+          return Step["let"](nullName, RVal.constant(null), Step.makeVar(RVal.prim(1, 'length', [boundList]), function(boundLen) {
+            var mkCompact;
+            mkCompact = function(v) {
+              return Step.makeVar(RVal.compact(v), bind);
+            };
+            return Step.makeCont(1, mkCompact, function(outCont) {
+              return Step.makeJoin(boundLen, outCont, function(index, bindJoin) {
+                var delistExpr, substBody;
+                delistExpr = Core.variable(boundList).delist(Core.variable(index));
+                substBody = body.subst(arg, delistExpr);
+                return sequence(substBody, rescue, function(mappedBool) {
+                  var mkDelete, mkKeep;
+                  mkDelete = function() {
+                    return bindJoin(nullName);
+                  };
+                  mkKeep = function() {
+                    return sequence(delistExpr, rescue, bindJoin);
+                  };
+                  return Step.makeCont(0, mkDelete, function(deleteCont) {
+                    return Step.makeCont(0, mkKeep, function(keepCont) {
+                      return Step["if"](mappedBool, keepCont, deleteCont);
+                    });
+                  });
+                });
+              });
+            });
+          }));
+        });
+      },
+      delist: function(expr, idxExpr) {
+        return bindExprs([expr, idxExpr], rescue, function(_arg) {
+          var boundExpr, boundIdx, e;
+          boundExpr = _arg[0], boundIdx = _arg[1];
+          e = nameGen('e');
+          return Step["let"](e, RVal.project(boundExpr, boundIdx), bind(e));
+        });
+      },
+      depair: function(expr, key) {
+        return sequence(expr, rescue, function(boundExpr) {
+          return Step.makeVar(RVal.depair(boundExpr, key), bind);
+        });
+      },
+      rescue: function(expr, default_) {
+        return Step.makeCont(1, bind, function(joinCont) {
+          var defaultBody;
+          defaultBody = sequenceTail(default_, rescue, joinCont);
+          return Step.makeCont(0, (function() {
+            return defaultBody;
+          }), function(innerRescue) {
+            return sequenceTail(expr, innerRescue, joinCont);
+          });
+        });
+      },
+      foldList: function(list, out, arg, accumArg, idxArg, body) {
+        var v;
+        v = Core.variable;
+        if (body.isStrictIn(Core.variable(accumArg))) {
+          return sequence(list, rescue, function(boundList) {
+            return sequence(out, rescue, function(boundOut) {
+              var decrIdx, lenExpr, loopName;
+              loopName = nameGen('loop');
+              decrIdx = Core.variable(idxArg).op2('-', Core.constant(1));
+              lenExpr = Core.variable(boundList).len();
+              return sequence(lenExpr, rescue, function(boundLen) {
+                var escapeCond, loopBody;
+                escapeCond = Core.variable(idxArg).op2('===', Core.constant(0));
+                loopBody = sequence(escapeCond, rescue, function(boundEscape) {
+                  var continueBody, escapeBody;
+                  escapeBody = function() {
+                    return bind(accumArg);
+                  };
+                  continueBody = function() {
+                    return sequence(decrIdx, rescue, function(nextIdx) {
+                      var substBody;
+                      substBody = body.subst(arg, Core.delist(v(boundList), v(nextIdx))).subst(idxArg, Core.variable(nextIdx));
+                      return sequence(substBody, rescue, function(nextAccum) {
+                        return Step.next(loopName, [nextIdx, nextAccum]);
+                      });
+                    });
+                  };
+                  return Step.makeCont(0, escapeBody, function(escapeCont) {
+                    return Step.makeCont(0, continueBody, function(continueCont) {
+                      return Step["if"](boundEscape, escapeCont, continueCont);
+                    });
+                  });
+                });
+                return Step.letCont(loopName, [idxArg, accumArg], loopBody, Step.next(loopName, [boundLen, boundOut]));
+              });
+            });
+          });
+        } else if (!body.containsInNonTailPosition(Core.variable(accumArg))) {
+          return sequence(list, rescue, function(boundList) {
+            var lenExpr;
+            lenExpr = Core.variable(boundList).len();
+            return sequence(lenExpr, rescue, function(boundLen) {
+              return Step.makeCont(1, bind, function(outCont) {
+                var escapeBody, loopBody, loopName, processBody, testExpr;
+                loopName = nameGen('l');
+                escapeBody = function() {
+                  return sequenceTail(out, rescue, outCont);
+                };
+                processBody = function() {
+                  return sequence(v(idxArg).op2('+', Core.constant(1)), rescue, function(incr) {
+                    var substBody;
+                    substBody = body.subst(arg, Core.delist(v(boundList), v(idxArg))).subst(accumArg, Core.next(loopName, [incr]));
+                    return sequenceTail(substBody, rescue, outCont);
+                  });
+                };
+                testExpr = v(idxArg).op2('<', v(boundLen));
+                loopBody = Step.makeCont(0, escapeBody, function(escape) {
+                  return Step.makeCont(0, processBody, function(process) {
+                    return sequence(testExpr, rescue, function(test) {
+                      return Step["if"](test, process, escape);
+                    });
+                  });
+                });
+                return Step.letCont(loopName, [idxArg], loopBody, Step.makeVar(RVal.constant(0), function(zero) {
+                  return Step.next(loopName, [zero]);
+                }));
+              });
+            });
+          });
+        } else {
+          debugger;
+          body.isStrictIn(accumArg);
+          throw 'TODO';
+        }
+      }
+    });
+  };
+  sequenceTail = function(core, rescue, next) {
+    return core.cases({
+      next: function(cont, args) {
+        return Step.next(cont, args);
+      },
+      other: function() {
+        return sequence(core, rescue, function(bound) {
+          return Step.next(next, [bound]);
+        });
+      }
+    });
+  };
+  return function(core) {
+    return sequenceTail(core, 'FAIL', 'RETURN');
+  };
+})();
+
+Gibbon.reduce = (function() {
+  var betaReduce, reduceWithTrace;
+  betaReduce = function(name, params, body, expr) {
+    return expr.cases({
+      next: function(contName, args) {
+        if (name === contName) {
+          DEBUG.log("beta-reducing " + contName + "(" + (params.join(' ')) + ") with " + (args.join(',')));
+          return body.substAll(params, args);
+        } else {
+          return this;
+        }
+      },
+      other: function() {
+        return this.map(function(x) {
+          return betaReduce(name, params, body, x);
+        });
+      }
+    });
+  };
+  reduceWithTrace = function(step, trace) {
+    return step.cases({
+      "let": function(lval, value, expr) {
+        var checkDup, goAbort, goConst, goSubst;
+        checkDup = function(val) {
+          var dupVar;
+          dupVar = trace.findVarTrace(value);
+          if (dupVar) {
+            DEBUG.log("replacing duplicate variable " + lval + " with " + dupVar);
+            return reduceWithTrace(expr.subst(lval, dupVar), trace);
+          }
+        };
+        goSubst = function(varName) {
+          return reduceWithTrace(expr.subst(lval, varName), trace);
+        };
+        goConst = function(c) {
+          var constVal, dup, newTrace;
+          constVal = RVal.constant(c);
+          if ((dup = checkDup(constVal))) {
+            return dup;
+          }
+          newTrace = trace.traceVar(lval, VarTrace.value(constVal));
+          return Step["let"](lval, constVal, reduceWithTrace(expr, newTrace));
+        };
+        goAbort = function() {
+          var dup, reduced;
+          if ((dup = checkDup(value))) {
+            return dup;
+          }
+          reduced = reduceWithTrace(expr, trace.extendWith(step));
+          if (reduced.hasFree(lval)) {
+            return Step["let"](lval, value, reduced);
+          } else {
+            DEBUG.log("removing dead variable " + lval);
+            return reduced;
+          }
+        };
+        return value.cases({
+          prim: function(arity, op, args) {
+            var checkIdent, constFold, identFold, left, leftTrace, leftVal, right, rightTrace, rightVal, vTrace;
+            if (arity === 1) {
+              vTrace = trace.getVar(args[0]);
+              if (vTrace._tag === 'value' && vTrace.val._tag === 'constant') {
+                return goConst(applyOp1(op, vTrace.val.value));
+              } else {
+                return goAbort();
+              }
+            } else if (arity === 2) {
+              left = args[0], right = args[1];
+              leftTrace = trace.getVar(left);
+              rightTrace = trace.getVar(right);
+              leftVal = leftTrace._tag === 'value' && leftTrace.val;
+              rightVal = rightTrace._tag === 'value' && rightTrace.val;
+              checkIdent = function(opTest, val, ident, identVal) {
+                return op === opTest && val && val._tag === 'constant' && val.value === ident && identVal();
+              };
+              identFold = checkIdent('*', leftVal, 0, function() {
+                return goConst(0);
+              }) || checkIdent('*', rightVal, 0, function() {
+                return goConst(0);
+              }) || checkIdent('*', leftVal, 1, function() {
+                return goSubst(right);
+              }) || checkIdent('*', rightVal, 1, function() {
+                return goSubst(left);
+              }) || checkIdent('+', leftVal, 0, function() {
+                return goSubst(right);
+              }) || checkIdent('+', rightVal, 0, function() {
+                return goSubst(left);
+              }) || checkIdent('/', rightVal, 1, function() {
+                return goSubst(left);
+              });
+              if (identFold) {
+                DEBUG.log("identity-folding " + (this.inspect()) + " to " + identFold);
+                return identFold;
+              }
+              if (leftVal && leftVal._tag === 'constant' && rightVal && rightVal._tag === 'constant') {
+                constFold = applyOp2(op, leftVal.value, rightVal.value);
+                DEBUG.log("constant-folding " + (this.inspect()) + " to " + constFold);
+                return goConst(constFold);
+              }
+              return goAbort();
+            }
+          },
+          other: function() {
+            return goAbort();
+          }
+        });
+      },
+      letCont: function(contName, argNames, body, expr) {
+        var extended, reducedBody, tryBeta;
+        extended = trace.extendWith(this);
+        tryBeta = function() {
+          var betaReduced, reduced;
+          if (reducedBody.hasFree(contName)) {
+            DEBUG.log("skipping beta-reduction for recursive " + contName);
+            betaReduced = expr;
+          } else {
+            betaReduced = betaReduce(contName, argNames, reducedBody, expr);
+          }
+          reduced = reduceWithTrace(betaReduced, extended);
+          if (!reduced.hasFree(contName)) {
+            DEBUG.log("removing dead continuation " + contName);
+            return reduced;
+          }
+          return Step.letCont(contName, argNames, reducedBody, reduced);
+        };
+        reducedBody = reduceWithTrace(body, extended);
+        return reducedBody.cases({
+          next: function(innerName, innerArgs) {
+            if (equalArrays(innerArgs, argNames)) {
+              DEBUG.log("eta-reducing " + contName + " with " + innerName);
+              return reduceWithTrace(expr.subst(contName, innerName), trace);
+            } else {
+              return tryBeta();
+            }
+          },
+          other: function() {
+            return tryBeta();
+          }
+        });
+      },
+      other: function() {
+        var _this = this;
+        return this.map(function(x) {
+          return reduceWithTrace(x, trace.extendWith(_this));
+        });
+      }
+    });
+  };
+  return function(step) {
+    var reduced;
+    DEBUG.log("before:");
+    DEBUG.log(step.inspectLines());
+    DEBUG.log();
+    reduced = reduceWithTrace(step, Trace.empty());
+    DEBUG.log("reduced to:");
+    DEBUG.log(reduced.inspectLines());
+    return reduced;
+  };
+})();
+
+Gibbon.JS = JS = (function(_super) {
+  var inspectString, oldBlock, validIdent;
+
+  __extends(JS, _super);
+
+  function JS() {
+    _ref19 = JS.__super__.constructor.apply(this, arguments);
+    return _ref19;
+  }
+
+  JS.variants({
+    func: ['name', 'args', 'block'],
+    json: ['obj'],
+    block: ['statements'],
+    ident: ['name'],
+    funcall: ['callee', 'args'],
+    literal: ['value'],
+    array: ['elements'],
+    object: ['keys', 'vals'],
+    access: ['expr', 'name'],
+    bind: ['lhs', 'rhs'],
+    ternary: ['cond', 'ifTrue', 'ifFalse'],
+    "if": ['cond', 'ifTrue', 'ifFalse'],
+    "return": ['expr'],
+    operator: ['operator', 'lhs', 'rhs'],
+    forLoop: ['len', 'arg', 'body'],
+    whileLoop: ['cond', 'body'],
+    varDecl: ['name']
+  });
+
+  oldBlock = JS.block;
+
+  JS.block = function(s) {
+    if (!isArray(s)) {
+      throw 'lol';
+    }
+    return oldBlock(s);
+  };
+
+  JS.prototype.toFunction = function() {
+    return this.cases({
+      func: function(name, args, block) {
+        return (function(func, args, ctor) {
+          ctor.prototype = func.prototype;
+          var child = new ctor, result = func.apply(child, args);
+          return Object(result) === result ? result : child;
+        })(Function, __slice.call(args).concat([block.toJS()]), function(){});
+      },
+      other: function() {
+        return JS.func('tmp', [], this).toFunction();
+      }
+    });
+  };
+
+  JS.trap = function(cond) {
+    return JS["if"](cond, JS["return"](null), null);
+  };
+
+  JS.iife = function(statements) {
+    return JS.funcall(JS.func(null, [], JS.block(statements)), []);
+  };
+
+  JS.tailcall = function(fn, args) {
+    return JS["return"](JS.funcall(fn, args));
+  };
+
+  JS.prototype.op = function(o, other) {
+    return JS.operator(o, this, other);
+  };
+
+  JS.prototype.eq = function(other) {
+    return this.op('===', other);
+  };
+
+  JS.prototype.lt = function(other) {
+    return this.op('<', other);
+  };
+
+  JS.prototype.funcall = function(args) {
+    return JS.funcall(this, args);
+  };
+
+  JS.prototype.tailcall = function(args) {
+    return JS.tailcall(this, args);
+  };
+
+  JS.prototype.methodcall = function(name, args) {
+    return this.access(JS.literal(name)).funcall(args);
+  };
+
+  JS.prototype.access = function(key) {
+    return JS.access(this, key);
+  };
+
+  JS.trampoline = function(varName) {
+    var cond, v;
+    v = JS.ident(varName);
+    cond = JS.ident('typeof').funcall([v]).op('===', JS.literal('function'));
+    return JS.whileLoop(cond, JS.bind(v, v.funcall([])));
+  };
+
+  inspectString = function(str) {
+    var escaped;
+    escaped = str.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n");
+    return "\"" + escaped + "\"";
+  };
+
+  JS.prototype.inspect = function() {
+    return "[JS " + (this.toJS()) + "]";
+  };
+
+  validIdent = /^[\w$][\w\d$]*$/;
+
+  JS.prototype.toJS = function(indent, block) {
+    var I, i;
+    if (indent == null) {
+      indent = 0;
+    }
+    i = Array(indent + 1).join('  ');
+    I = block ? i : '';
+    return this.cases({
+      func: function(name, args, block) {
+        var header;
+        header = name ? "function " + name : "function";
+        return "" + I + header + "(" + (args.join(', ')) + ") " + (block.toJS(indent));
+      },
+      json: function(obj) {
+        return JSON.stringify(obj);
+      },
+      ident: function(name) {
+        return name;
+      },
+      array: function(els) {
+        var e;
+        return "" + I + "[" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            e = els[_i];
+            _results.push(e.toJS(indent));
+          }
+          return _results;
+        })()).join(', ')) + "]";
+      },
+      object: function(keys, vals) {
+        var k, pairs;
+        pairs = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (i = _i = 0, _len = keys.length; _i < _len; i = ++_i) {
+            k = keys[i];
+            _results.push("" + (inspectString(k)) + ": " + (vals[i].toJS()));
+          }
+          return _results;
+        })();
+        return "" + I + "{ " + (pairs.join(', ')) + " }";
+      },
+      funcall: function(callee, args) {
+        var a;
+        args = ((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push(a.toJS(indent));
+          }
+          return _results;
+        })()).join(', ');
+        return "" + I + (callee.toJS(indent)) + "(" + args + ")";
+      },
+      literal: function(value) {
+        if (typeof value === 'string') {
+          return inspectString(value);
+        }
+        return '' + value;
+      },
+      "if": function(cond, ifTrue, ifFalse) {
+        var elseBranch;
+        elseBranch = "";
+        if (ifFalse) {
+          elseBranch = "\n" + i + "else " + (ifFalse.toJS(indent));
+        }
+        return "" + I + "if (" + (cond.toJS(indent, true)) + ") " + (ifTrue.toJS(indent)) + elseBranch;
+      },
+      block: function(statements) {
+        var s;
+        return "" + I + "{\n" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = statements.length; _i < _len; _i++) {
+            s = statements[_i];
+            _results.push(s.toJS(indent + 1, true) + ';');
+          }
+          return _results;
+        })()).join('\n')) + "\n" + i + "}";
+      },
+      forLoop: function(len, arg, body) {
+        arg = arg.toJS(indent);
+        len = len.toJS(indent);
+        body = body.toJS(indent);
+        return "" + i + "for (var " + arg + "=0; " + arg + "<" + len + "; " + arg + "+=1) " + body;
+      },
+      whileLoop: function(cond, body) {
+        return "" + I + "while (" + (cond.toJS(indent)) + ") " + (body.toJS(indent));
+      },
+      varDecl: function(name) {
+        return "" + i + "var " + name;
+      },
+      access: function(expr, name) {
+        var access;
+        access = name._tag === 'literal' && typeof name.value === 'string' && validIdent.test(name.value) ? "." + name.value : "[" + (name.toJS(indent)) + "]";
+        return "" + (expr.toJS(indent)) + access;
+      },
+      bind: function(lhs, rhs) {
+        return "" + i + (lhs.toJS(indent)) + " = " + (rhs.toJS(indent));
+      },
+      "return": function(expr) {
+        if (expr) {
+          return "" + I + "return " + (expr.toJS(indent));
+        } else {
+          return "" + I + "return";
+        }
+      },
+      operator: function(op, lhs, rhs) {
+        return "(" + (lhs.toJS(indent)) + ")" + op + "(" + (rhs.toJS(indent)) + ")";
+      }
+    });
+  };
+
+  return JS;
+
+})(Variant);
+
+Gibbon.codegen = (function() {
+  var generate, inlinePrim;
+  inlinePrim = {
+    2: {
+      '+': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('+', r);
+      },
+      '*': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('*', r);
+      },
+      '-': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('-', r);
+      },
+      '/': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('/', r);
+      },
+      '<': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('<', r);
+      },
+      '<=': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('<=', r);
+      },
+      '>': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('>', r);
+      },
+      '>=': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('>=', r);
+      },
+      '===': function(_arg) {
+        var l, r;
+        l = _arg[0], r = _arg[1];
+        return l.op('===', r);
+      }
+    },
+    1: {
+      length: function(_arg) {
+        var l;
+        l = _arg[0];
+        return l.access(JS.literal('length'));
+      },
+      '!': function(_arg) {
+        var a;
+        a = _arg[0];
+        return JS.funcall(JS.ident('!'), [a]);
+      },
+      '-': function(_arg) {
+        var a;
+        a = _arg[0];
+        return JS.funcall(JS.ident('-'), [a]);
+      }
+    }
+  };
+  generate = function(term, trace, push) {
+    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) {
+              return JS.literal(v);
+            },
+            global: function() {
+              return JS.ident('$');
+            },
+            lambda: function() {
+              throw 'TODO';
+            },
+            prim: function(arity, name, args) {
+              var a, jsArgs;
+              jsArgs = (function() {
+                var _i, _len, _results;
+                _results = [];
+                for (_i = 0, _len = args.length; _i < _len; _i++) {
+                  a = args[_i];
+                  _results.push(varToJS(a));
+                }
+                return _results;
+              })();
+              return inlinePrim[arity][name](jsArgs);
+            },
+            list: function(els) {
+              var e;
+              return JS.array((function() {
+                var _i, _len, _results;
+                _results = [];
+                for (_i = 0, _len = els.length; _i < _len; _i++) {
+                  e = els[_i];
+                  _results.push(varToJS(e));
+                }
+                return _results;
+              })());
+            },
+            pair: function(first, second) {
+              return JS.object(['first', 'second'], [varToJS(first), varToJS(second)]);
+            },
+            depair: function(val, key) {
+              return varToJS(val).access(JS.literal(key));
+            },
+            project: function(val, index) {
+              return varToJS(val).access(varToJS(index));
+            },
+            compact: function() {
+              return JS.ident(varName);
+            }
+          });
+        }
+      });
+    };
+    extended = trace.extendWith(term);
+    return term.cases({
+      "let": function(name, val, expr) {
+        var _compact, _i, _len, _push;
+        if (val._tag === 'compact') {
+          val = varToJS(val.val);
+          _i = JS.ident('_i');
+          _compact = JS.ident('_compact');
+          _len = JS.ident('_len');
+          _push = JS.access(_compact, JS.literal('push'));
+          push(JS.varDecl(name));
+          push(JS.bind(JS.ident(name), JS.iife([JS.varDecl('_compact'), JS.varDecl('_len'), JS.bind(_len, JS.access(val, JS.literal('length'))), JS.bind(_compact, JS.array([])), JS.forLoop(_len, _i, JS.block([JS["if"](JS.access(val, _i).op('!=', JS.literal(null)), JS.funcall(_push, [JS.access(val, _i)]), null)])), JS["return"](_compact)])));
+        }
+        return generate(expr, extended, push);
+      },
+      letCont: function(name, args, body, expr) {
+        var bodyStatements;
+        bodyStatements = [];
+        generate(body, extended, function(s) {
+          return bodyStatements.push(s);
+        });
+        push(JS.func(name, args, JS.block(bodyStatements)));
+        return generate(expr, extended, push);
+      },
+      letJoin: function(name, order, cont, expr) {
+        var counterName, resultsName;
+        counterName = "" + name + "$counter";
+        resultsName = "" + name + "$results";
+        push(JS.varDecl(counterName));
+        push(JS.varDecl(resultsName));
+        push(JS.bind(JS.ident(counterName), varToJS(order)));
+        push(JS.bind(JS.ident(resultsName), JS.array([])));
+        push(JS.func(name, ['idx', 'el'], JS.block([JS.bind(JS.access(JS.ident(resultsName), JS.ident('idx')), JS.ident('el')), JS.trap(JS.ident(counterName).op('-=', JS.literal(1)).op('>', JS.literal(0))), JS.ident(cont).tailcall([JS.ident(resultsName)])])));
+        return generate(expr, extended, push);
+      },
+      fork: function(forks) {
+        var cont, head, last, thunk, _i, _j, _len;
+        head = 2 <= forks.length ? __slice.call(forks, 0, _i = forks.length - 1) : (_i = 0, []), last = forks[_i++];
+        thunk = nameGen('_thunk');
+        push(JS.varDecl(thunk));
+        for (_j = 0, _len = head.length; _j < _len; _j++) {
+          cont = head[_j];
+          push(JS.bind(JS.ident(thunk), JS.ident(cont).funcall([])));
+          push(JS.trampoline(thunk));
+        }
+        return push(JS.ident(last).tailcall([]));
+      },
+      each: function(length, cont) {
+        var minus1, thunk, _i;
+        _i = JS.ident('_i');
+        thunk = nameGen('_thunk');
+        push(JS.varDecl(thunk));
+        minus1 = varToJS(length).op('+', JS.literal(-1));
+        push(JS.forLoop(minus1, _i, JS.block([JS.bind(JS.ident(thunk), JS.ident(cont).funcall([_i])), JS.trampoline(thunk)])));
+        return push(JS.ident(cont).tailcall([minus1]));
+      },
+      next: function(cont, args) {
+        var a;
+        return push(JS.ident(cont).tailcall((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push(varToJS(a));
+          }
+          return _results;
+        })()));
+      },
+      app: function(fn, args, rescue, next) {
+        var a;
+        args = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            a = args[_i];
+            _results.push(varToJS(a));
+          }
+          return _results;
+        })();
+        return push(varToJS(fn).tailcall(__slice.call(args).concat([JS.ident(rescue)], [JS.ident(next)])));
+      },
+      query: function(annotations, arg, rescue, next) {
+        return push(JS.ident('QUERY').tailcall([varToJS(arg), JS.json(annotations), JS.ident(rescue), JS.ident(next)]));
+      },
+      localQuery: function(key, rescue, next) {
+        return push(JS.ident('QUERY').tailcall([JS.literal(null), JS.literal(key), JS.ident(rescue), JS.ident(next)]));
+      },
+      "if": function(cond, trueCont, falseCont) {
+        return push(JS["if"](varToJS(cond), JS.ident(trueCont).tailcall([]), JS.ident(falseCont).tailcall([])));
+      }
+    });
+  };
+  return function(term) {
+    var out, statements;
+    statements = [];
+    generate(term, Trace.empty(), function(s) {
+      return statements.push(s);
+    });
+    out = JS.func('compiled', ['$', 'QUERY', 'FAIL', 'RETURN'], JS.block(statements));
+    DEBUG.log('GENERATED:');
+    DEBUG.log(out.toJS());
+    return out;
+  };
+})();
+
+stdlib = Gibbon.stdlib = (function() {
+  var FALSE, TRUE, equals;
+  TRUE = Core.constant(true);
+  FALSE = Core.constant(false);
+  equals = function(x, y, type) {
+    var direct;
+    direct = function() {
+      return x.op2('===', y);
+    };
+    return type.cases({
+      entity: direct,
+      numeric: direct,
+      string: direct,
+      bool: direct,
+      block: function() {
+        return FALSE;
+      },
+      pair: function() {
+        var eq1, eq2;
+        eq1 = equals(x.depair('first'), y.depair('first'), type.first);
+        eq2 = equals(x.depair('first'), y.depair('second'), type.second);
+        return eq1.branch(eq2, FALSE);
+      },
+      list: function() {
+        var eqEls, eqLength;
+        eqLength = equals(x.len(), y.len(), Type.numeric());
+        eqEls = x.zipList(y).foldList(TRUE, function(pair, next) {
+          var eq;
+          eq = equals(pair.depair('first'), pair.depair('second'), type.of);
+          return next.branch(FALSE, eq);
+        });
+        return eqLength.branch(eqEls, FALSE);
+      }
+    });
+  };
+  return {
+    "case": {
+      type: parse.type('case [bool : %b] = % -> %b'),
+      compile: function(_, _arg) {
+        var alts;
+        alts = _arg[0];
+        return alts.foldList(Core.fail('non-exhaustive cases'), function(el, next) {
+          return el.depair('first').branch(el.depair('second'), next);
+        });
+      }
+    },
+    "case-eq": {
+      type: parse.type('case-eq [%a : %b] = %a -> %b'),
+      compile: function(input, _arg, tvars) {
         var alts, eqType;
         alts = _arg[0];
         eqType = tvars.get('a');
-        return alts.foldList(IR.fail('non-exhaustive cases'), function(el, next) {
+        return alts.foldList(Core.fail('non-exhaustive cases'), function(el, next) {
           var first, second;
           first = el.depair('first');
           second = el.depair('second');
-          return compEquals(input, first, eqType).branch(second, next);
+          return equals(input, first, eqType).branch(second, next);
         });
       }
     },
@@ -4017,23 +6473,23 @@ stdlib = Gibbon.stdlib = (function() {
           var first, second;
           first = el.depair('first');
           second = el.depair('second');
-          return compEquals(input, first, eqType).branch(second, next);
+          return equals(input, first, eqType).branch(second, next);
         });
       }
     },
     "any-true?": {
       type: parse.type('any-true? = [bool] -> bool'),
       compile: function(list) {
-        return list.foldList(iFalse, function(el, next) {
-          return el.branch(iTrue, next);
+        return list.foldList(FALSE, function(el, next) {
+          return el.branch(TRUE, next);
         });
       }
     },
     "all-true?": {
       type: parse.type('all-true? = [bool] -> bool'),
       compile: function(list) {
-        return list.foldList(iTrue, function(el, next) {
-          return el.branch(next, iFalse);
+        return list.foldList(TRUE, function(el, next) {
+          return el.branch(next, FALSE);
         });
       }
     },
@@ -4042,8 +6498,8 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(list, _arg) {
         var block;
         block = _arg[0];
-        return list.foldList(iFalse, function(el, next) {
-          return block.app(el).branch(iTrue, next);
+        return list.foldList(FALSE, function(el, next) {
+          return block.app(el).branch(TRUE, next);
         });
       }
     },
@@ -4052,8 +6508,8 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(list, _arg) {
         var block;
         block = _arg[0];
-        return list.foldList(iTrue, function(el, next) {
-          return block.app(el).branch(next, iFalse);
+        return list.foldList(TRUE, function(el, next) {
+          return block.app(el).branch(next, FALSE);
         });
       }
     },
@@ -4063,17 +6519,15 @@ stdlib = Gibbon.stdlib = (function() {
         var elType, needle;
         needle = _arg[0];
         elType = tvars.get('a');
-        return list.foldList(iFalse, function(el, next) {
-          return compEquals(el, needle, elType).branch(iTrue, next);
+        return list.foldList(FALSE, function(el, next) {
+          return next.branch(TRUE, equals(el, needle, elType));
         });
       }
     },
     "empty?": {
       type: parse.type('empty? = [%] -> bool'),
       compile: function(list) {
-        return list.foldList(iTrue, function() {
-          return iFalse;
-        });
+        return list.len().op2('===', Core.constant(0));
       }
     },
     weight: {
@@ -4081,16 +6535,16 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(_, _arg) {
         var ratio, weights;
         weights = _arg[0];
-        ratio = weights.foldList(IR.pair(IR.constant(0), IR.constant(0)), function(el, next) {
+        ratio = weights.foldList(Core.pair(Core.constant(0), Core.constant(0)), function(el, next) {
           var denominator, numerator, value, weight, weighted;
           value = el.depair('first');
           weight = el.depair('second');
           numerator = next.depair('first');
           denominator = next.depair('second');
-          weighted = value.binop('*', weight);
-          return IR.pair(numerator.binop('+', weighted), denominator.binop('+', weight));
+          weighted = value.op2('*', weight);
+          return Core.pair(numerator.op2('+', weighted), denominator.op2('+', weight));
         });
-        return ratio.depair('first').binop('/', ratio.depair('second'));
+        return ratio.depair('first').op2('/', ratio.depair('second'));
       }
     },
     filter: {
@@ -4112,13 +6566,13 @@ stdlib = Gibbon.stdlib = (function() {
         domHigh = dom.depair('second');
         rangeLow = range.depair('first');
         rangeHigh = range.depair('second');
-        input = input.binop('<', domLow).branch(domLow, input);
-        input = input.binop('>', domHigh).branch(domHigh, input);
-        domSize = domHigh.binop('+', domLow.extern('-'));
-        rangeSize = rangeHigh.binop('+', rangeLow.extern('-'));
-        translated = input.binop('+', domLow.extern('-'));
-        scaled = translated.binop('*', rangeSize.binop('/', domSize));
-        retranslated = scaled.binop('+', rangeLow);
+        input = input.op2('<', domLow).branch(domLow, input);
+        input = input.op2('>', domHigh).branch(domHigh, input);
+        domSize = domHigh.op2('+', domLow.op1('-'));
+        rangeSize = rangeHigh.op2('+', rangeLow.op1('-'));
+        translated = input.op2('+', domLow.op1('-'));
+        scaled = translated.op2('*', rangeSize.op2('/', domSize));
+        retranslated = scaled.op2('+', rangeLow);
         return retranslated;
       }
     },
@@ -4141,8 +6595,8 @@ stdlib = Gibbon.stdlib = (function() {
     sum: {
       type: parse.type('sum = [numeric] -> numeric'),
       compile: function(list) {
-        return list.foldList(IR.constant(0), function(el, next) {
-          return el.binop('+', next);
+        return list.foldList(Core.constant(0), function(el, next) {
+          return el.op2('+', next);
         });
       }
     },
@@ -4151,24 +6605,18 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(_, _arg) {
         var list;
         list = _arg[0];
-        return list.foldList(IR.constant(0), function(el, next) {
+        return list.foldList(Core.constant(0), function(el, next) {
           var cond, val;
           cond = el.depair('first');
           val = el.depair('second');
-          return cond.branch(val.binop('+', next), next);
+          return cond.branch(val.op2('+', next), next);
         });
       }
     },
     first: {
       type: parse.type('first = [%a] -> %a'),
       compile: function(list) {
-        return list.delist(IR.constant(0));
-      }
-    },
-    squish: {
-      type: parse.type('squish = [%a] -> [%a]'),
-      compile: function(list) {
-        return list.squishList();
+        return list.delist(Core.constant(0));
       }
     },
     add: {
@@ -4176,7 +6624,7 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
-        return input.binop('+', num);
+        return input.op2('+', num);
       }
     },
     sub: {
@@ -4184,7 +6632,7 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
-        return input.binop('+', num.extern('-'));
+        return input.op2('+', num.op1('-'));
       }
     },
     id: {
@@ -4196,13 +6644,13 @@ stdlib = Gibbon.stdlib = (function() {
     "else": {
       type: parse.type('else = % -> bool'),
       compile: function(_) {
-        return iTrue;
+        return TRUE;
       }
     },
     not: {
       type: parse.type('not = bool -> bool'),
       compile: function(input) {
-        return input.extern('!');
+        return input.op1('!');
       }
     },
     gt: {
@@ -4210,7 +6658,7 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
-        return input.binop('>', num);
+        return input.op2('>', num);
       }
     },
     lt: {
@@ -4218,7 +6666,7 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
-        return input.binop('<', num);
+        return input.op2('<', num);
       }
     },
     eq: {
@@ -4226,12 +6674,156 @@ stdlib = Gibbon.stdlib = (function() {
       compile: function(input, _arg, tvars) {
         var obj;
         obj = _arg[0];
-        return compEquals(input, obj, tvars.get('a'));
+        return equals(input, obj, tvars.get('a'));
+      }
+    },
+    neq: {
+      type: parse.type('neq %a = %a -> bool'),
+      compile: function(input, _arg, tvars) {
+        var obj;
+        obj = _arg[0];
+        return equals(input, obj, tvars.get('a')).op1('!');
       }
     }
   };
 })();
-// Generated by CoffeeScript 1.6.3
+
+Gibbon.CompiledCode = CompiledCode = (function() {
+  var idFor, trampoline;
+
+  idFor = function(key) {
+    return 'local' + key.replace(/\//g, '$$$$').replace(/-/g, '$$_');
+  };
+
+  trampoline = function(x) {
+    while (typeof x === 'function') {
+      x = x();
+    }
+    return x;
+  };
+
+  function CompiledCode(semantics, blocks) {
+    var _this = this;
+    this.semantics = semantics;
+    this.blocks = blocks;
+    this.functions = new Hash;
+    this.blocks.each(function(k, v) {
+      var func;
+      func = new Function('$', 'QUERY', 'FAIL', 'RETURN', v);
+      return _this.functions.set(k, func);
+    });
+  }
+
+  CompiledCode.prototype.functionFor = function(key) {
+    return this.functions.get(key);
+  };
+
+  CompiledCode.prototype.run = function(rootKey, input, client, cb) {
+    var FAIL, RETURN, dependencies, failures, mkQuery, results, runKey, thunk,
+      _this = this;
+    results = new Hash;
+    dependencies = new Hash;
+    failures = new Hash;
+    runKey = function(key, fail, succeed) {
+      var deps, onFailure, onSuccess, query;
+      DEBUG.log('evaluating key', key);
+      if (results.has(key)) {
+        return succeed(results.get(key));
+      }
+      if (failures.has(key)) {
+        return fail(failures.get(key));
+      }
+      deps = dependencies.set(key, []);
+      query = mkQuery(function(d) {
+        return deps.push(d);
+      });
+      onSuccess = function(data) {
+        results.set(key, data);
+        return succeed(data);
+      };
+      onFailure = function(err) {
+        failures.set(key, err);
+        return fail(err);
+      };
+      return _this.functionFor(key)(input, query, onFailure, onSuccess);
+    };
+    mkQuery = function(pushDep) {
+      return function(id, annotations, onFailure, onSuccess) {
+        var isSynchronous, out;
+        if (id == null) {
+          pushDep(Dependency.lexical(annotations));
+          return runKey(annotations, onFailure, onSuccess);
+        }
+        isSynchronous = true;
+        out = client.performQuery(id, annotations, function(err, data) {
+          if (err) {
+            pushDep(Dependency.failure(err));
+            if (isSynchronous) {
+              return function() {
+                return onFailure(err);
+              };
+            } else {
+              return trampoline(onFailure(err));
+            }
+          } else {
+            pushDep(Dependency.query(id, annotations));
+            if (isSynchronous) {
+              return function() {
+                return onSuccess(data);
+              };
+            } else {
+              return trampoline(onSuccess(data));
+            }
+          }
+        });
+        isSynchronous = false;
+        return out;
+      };
+    };
+    FAIL = function(f) {
+      return cb(f);
+    };
+    RETURN = function(d) {
+      return cb(null, d);
+    };
+    thunk = runKey(rootKey, cb, function() {
+      var out;
+      out = new Hash;
+      results.each(function(k, v) {
+        var deps, value;
+        value = Value.interpret(v, _this.outputType(k));
+        deps = dependencies.get(k);
+        deps = uniq(deps, function(x, y) {
+          return x.equals(y);
+        });
+        return out.set(k, [value, deps]);
+      });
+      return cb(null, out);
+    });
+    return trampoline(thunk);
+  };
+
+  CompiledCode.prototype.outputType = function(key) {
+    if (key == null) {
+      key = '/';
+    }
+    return this.semantics.get(key).flow.type;
+  };
+
+  return CompiledCode;
+
+})();
+
+Gibbon.compile = function(semantics) {
+  var codegen, compiled, optimize, reduce, sequence, translate;
+  codegen = Gibbon.codegen, reduce = Gibbon.reduce, sequence = Gibbon.sequence, optimize = Gibbon.optimize, translate = Gibbon.translate;
+  compiled = new Hash;
+  semantics.each(function(k, v) {
+    return compiled.set(k, codegen(reduce(sequence(optimize(translate(v))))).block.toJS());
+  });
+  return new CompiledCode(semantics, compiled);
+};
+
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
     var analyzeList, getType, getValue, listLookup, lists;
@@ -4252,7 +6844,7 @@ Gibbon.jsonConsumer = (function() {
         }
       });
     };
-    getValue = function(id, annotations, v, callback) {
+    getValue = function(id, annotations, callback) {
       var entity, values;
       if (!tables.hasOwnProperty(annotations.table)) {
         throw new Error("no such type " + annotations.table);
@@ -4265,7 +6857,7 @@ Gibbon.jsonConsumer = (function() {
       if (!(entity.hasOwnProperty(annotations.name) && (entity[annotations.name] != null))) {
         return callback(Failure.query(id, annotations));
       }
-      return callback(null, v.fromJSON(entity[annotations.name]));
+      return callback(null, entity[annotations.name]);
     };
     lists = tables._lists || {};
     analyzeList = function(id, listName, t, callback) {
@@ -4284,13 +6876,13 @@ Gibbon.jsonConsumer = (function() {
         }
       });
     };
-    listLookup = function(id, listName, v, callback) {
+    listLookup = function(id, listName, callback) {
       var list;
       list = lists[listName].values;
       if (list.indexOf(id) >= 0) {
-        return callback(null, v.boolean(true));
+        return callback(null, true);
       } else {
-        return callback(null, v.boolean(false));
+        return callback(null, false);
       }
     };
     return {
@@ -4304,11 +6896,11 @@ Gibbon.jsonConsumer = (function() {
             return callback(new Error("unknown query `" + query.type + "'"));
         }
       },
-      performQuery: function(id, annotations, v, callback) {
+      performQuery: function(id, annotations, callback) {
         if ('list' in annotations) {
-          return listLookup(id, annotations.list, v, callback);
+          return listLookup(id, annotations.list, callback);
         } else {
-          return getValue(id, annotations, v, callback);
+          return getValue(id, annotations, callback);
         }
       }
     };