goodguide-gibbon 0.4.0 → 0.4.1

data/lib/goodguide/gibbon.rb

@@ -71,12 +71,16 @@ module GoodGuide
       end
 
     private
-      def inspect_expr(expr)
-        obj = JS.default.gibbon[:TypeExpr].fromJSON(expr)
+      def inspect_js(type, js)
+        obj = JS.default.gibbon[type].fromJSON(js)
         inspect = obj[:inspect]
         inspect.methodcall(obj)
       end
 
+      def inspect_expr(expr)
+        inspect_js :TypeExpr, expr
+      end
+
       def semantic_error_message(e)
         case e['_tag']
         when 'match'
@@ -87,15 +91,17 @@ module GoodGuide
           type = inspect_expr e['type']
           "could not destructure #{type}"
         when 'lookup'
-          query_name = e['query']['name']
-          query_type = e['query']['type']
-          query = "@#{query_type}(#{query_name})"
+          query = inspect_js :AST, e['query']
           id = e['id']
           error = e['error']
           "error analyzing #{query} on #{id}: #{error}"
         when 'circular'
           chain = e['crumbs'].join(' -> ')
           "circular dependency: #{chain}"
+        when 'func'
+          funcname = e['node']['name']
+          expr = inspect_expr e['node']
+          "no such function: #{funcname} (in #{expr})"
         else
           raise "unknown error type #{e['_tag']}"
         end
@@ -163,8 +169,8 @@ module GoodGuide
         @queries ||= {}
       end
 
-      def self.query(name, &impl)
-        queries[name.to_s] = impl
+      def self.query(type, &impl)
+        queries[type.to_s] = impl
       end
 
       def to_js
@@ -201,7 +207,7 @@ module GoodGuide
 
       def analyze_query(input_id, query, t)
         query_impl = get_query(query.type)
-        analysis = instance_exec(input_id, query.name, t, &query_impl)
+        analysis = instance_exec(input_id, obj_to_ruby(query.args), t, &query_impl)
         analysis[:annotations]['_query_type'] = query.type
         analysis
       end

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.4.0'
+      '0.4.1'
     end
   end
 end

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

@@ -121,6 +121,22 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     function success(stream, i, result) { return result; }
   };
 
+  function furthestFailure(onFailure, myI, myExpected) {
+    return function(stream, yourI, yourExpected) {
+      if (myI > yourI) return onFailure(stream, myI, myExpected);
+      else return onFailure.apply(this, arguments);
+    };
+  }
+
+  function furthestFailureSuccess(onSuccess, myFurthestFailureI, myFurthestExpected) {
+    return function(stream, i, result, yourFurthestFailureI, yourFurthestExpected) {
+      if (myFurthestFailureI > yourFurthestFailureI) {
+        return onSuccess(stream, i, result, myFurthestFailureI, myFurthestExpected);
+      }
+      else return onSuccess.apply(this, arguments);
+    };
+  }
+
   // -*- primitive combinators -*- //
   _.or = function(alternative) {
     var self = this;
@@ -128,8 +144,10 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i, onSuccess, onFailure) {
       return self._(stream, i, onSuccess, failure);
 
-      function failure(stream, newI) {
-        return alternative._(stream, i, onSuccess, onFailure);
+      function failure(stream, newI, expected) {
+        var altSuccess = furthestFailureSuccess(onSuccess, newI, expected);
+        var altFailure = furthestFailure(onFailure, newI, expected);
+        return alternative._(stream, i, altSuccess, altFailure);
       }
     });
   };
@@ -140,9 +158,11 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i, onSuccess, onFailure) {
       return self._(stream, i, success, onFailure);
 
-      function success(stream, newI, result) {
+      function success(stream, newI, result, furthestFailureI, furthestExpected) {
         var nextParser = (next instanceof Parser ? next : next(result));
-        return nextParser._(stream, newI, onSuccess, onFailure);
+        var nextSuccess = furthestFailureSuccess(onSuccess, furthestFailureI, furthestExpected);
+        var nextFailure = furthestFailure(onFailure, furthestFailureI, furthestExpected);
+        return nextParser._(stream, newI, nextSuccess, nextFailure);
       }
     });
   };
@@ -167,15 +187,22 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i, onSuccess, onFailure) {
       var xs = [];
       while (self._(stream, i, success, failure));
-      return onSuccess(stream, i, xs);
+      var furthestFailureI, furthestExpected;
+      return onSuccess(stream, i, xs, furthestFailureI, furthestExpected);
 
-      function success(stream, newI, x) {
+      function success(stream, newI, x, successFurthestFailureI, successFurthestExpected) {
         i = newI;
         xs.push(x);
+        furthestFailureI = successFurthestFailureI;
+        furthestExpected = successFurthestExpected;
         return true;
       }
 
-      function failure() {
+      function failure(stream, newI, expected) {
+        if (!(furthestFailureI > newI)) {
+          furthestFailureI = newI;
+          furthestExpected = expected;
+        }
         return false;
       }
     });
@@ -208,32 +235,32 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i, onSuccess, onFailure) {
       var xs = [];
       var result = true;
-      var failure;
+      var furthestFailureI, furthestExpected;
 
       for (var times = 0; times < min; times += 1) {
-        result = self._(stream, i, success, firstFailure);
-        if (!result) return onFailure(stream, i, failure);
+        result = self._(stream, i, success, failure);
+        if (!result) return onFailure(stream, furthestFailureI, furthestExpected);
       }
 
       for (; times < max && result; times += 1) {
-        result = self._(stream, i, success, secondFailure);
+        result = self._(stream, i, success, failure);
       }
 
-      return onSuccess(stream, i, xs);
+      return onSuccess(stream, i, xs, furthestFailureI, furthestExpected);
 
-      function success(stream, newI, x) {
-        xs.push(x);
+      function success(stream, newI, x, successFurthestFailureI, successFurthestExpected) {
         i = newI;
+        xs.push(x);
+        furthestFailureI = successFurthestFailureI;
+        furthestExpected = successFurthestExpected;
         return true;
       }
 
-      function firstFailure(stream, newI, msg) {
-        failure = msg;
-        i = newI;
-        return false;
-      }
-
-      function secondFailure(stream, newI, msg) {
+      function failure(stream, newI, expected) {
+        if (!(furthestFailureI > newI)) {
+          furthestFailureI = newI;
+          furthestExpected = expected;
+        }
         return false;
       }
     });
@@ -268,7 +295,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       var head = stream.slice(i, i+len);
 
       if (head === str) {
-        return onSuccess(stream, i+len, head);
+        return onSuccess(stream, i+len, head, -1);
       }
       else {
         return onFailure(stream, i, expected);
@@ -286,7 +313,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
 
       if (match) {
         var result = match[0];
-        return onSuccess(stream, i+result.length, result);
+        return onSuccess(stream, i+result.length, result, -1);
       }
       else {
         return onFailure(stream, i, expected);
@@ -316,17 +343,17 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   var any = Parsimmon.any = Parser(function(stream, i, onSuccess, onFailure) {
     if (i >= stream.length) return onFailure(stream, i, 'any character');
 
-    return onSuccess(stream, i+1, stream.charAt(i));
+    return onSuccess(stream, i+1, stream.charAt(i), -1);
   });
 
   var all = Parsimmon.all = Parser(function(stream, i, onSuccess, onFailure) {
-    return onSuccess(stream, stream.length, stream.slice(i));
+    return onSuccess(stream, stream.length, stream.slice(i), -1);
   });
 
   var eof = Parsimmon.eof = Parser(function(stream, i, onSuccess, onFailure) {
     if (i < stream.length) return onFailure(stream, i, 'EOF');
 
-    return onSuccess(stream, i, '');
+    return onSuccess(stream, i, '', -1);
   });
 });
   return Parsimmon;
@@ -862,7 +889,7 @@ Gibbon.AST = AST = (function(_super) {
     block: ['flow'],
     list: ['elements', 'squish'],
     defaulted: ['body', 'alternative'],
-    query: ['type', 'name'],
+    query: ['type', 'args'],
     func: ['name', 'args'],
     pair: ['first', 'second'],
     flow: ['head', 'tail'],
@@ -897,11 +924,12 @@ Gibbon.AST = AST = (function(_super) {
       string: function(s) {
         return "'" + s + "'";
       },
-      query: function(query, name) {
+      query: function(query, args) {
         if (query === 'access') {
-          query = '';
+          return "@" + args[0];
+        } else {
+          return "." + query + " " + (args.join(' '));
         }
-        return "@" + query + "(" + name + ")";
       },
       subst: function(flow) {
         return "(" + (flow.inspect()) + ")";
@@ -1082,11 +1110,12 @@ parse = Gibbon.parse = (function() {
     return AST.string(s);
   });
   accessorExpr = accessor.map(function(name) {
-    return AST.query('access', name);
+    debugger;
+    return AST.query('access', [name]);
   });
   queryExpr = query.then(function(q) {
-    return name.map(function(n) {
-      return AST.query(q, n);
+    return name.many().map(function(args) {
+      return AST.query(q, args);
     });
   });
   numericExpr = percentExpr.or(decimalExpr.or(fractionExpr.or(integerExpr)));
@@ -1381,7 +1410,7 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
         return "%" + name;
       },
       query: function(input, _, query) {
-        return "@" + query.type + "(" + query.name + ")[" + (input.inspect()) + "]";
+        return "" + (input.inspect()) + "[" + (query.inspect()) + "]";
       },
       destructure: function(constraint, name, argnum) {
         return "" + (constraint.inspect()) + "/" + name + "[" + argnum + "]";
@@ -1611,7 +1640,7 @@ analyze = Gibbon.analyze = (function() {
       Scope.prototype.lookup = function(nativeId, query, cb) {
         var lexical;
         if (query.type === 'access' && nativeId === this.context.globalID) {
-          lexical = this.lexicalLookup(query.name);
+          lexical = this.lexicalLookup(query.args[0]);
           if (lexical) {
             return cb(lexical);
           } else {
@@ -1720,7 +1749,7 @@ analyze = Gibbon.analyze = (function() {
           },
           subst: function(subFlow) {
             push(TypeExpr.expr(flow), TypeExpr.expr(subFlow));
-            return _this.analyzeFlow(flow, global, push);
+            return _this.analyzeFlow(subFlow, global, push);
           },
           list: function(elements) {
             var el, expected, rest, _i, _len, _results;
@@ -1950,8 +1979,9 @@ analyze = Gibbon.analyze = (function() {
                 return Semantic.flow(flowType(this), toSemanticTree(head), tail && toSemanticTree(tail));
               },
               query: function(type, name) {
+                var _this = this;
                 DEBUG(function() {
-                  if (!semanticAccessors.has(this)) {
+                  if (!semanticAccessors.has(_this)) {
                     debugger;
                   }
                 });
@@ -1975,6 +2005,9 @@ analyze = Gibbon.analyze = (function() {
               block: function(flow) {
                 return Semantic.block(toSemanticTree(flow));
               },
+              subst: function(subFlow) {
+                return toSemanticTree(subFlow);
+              },
               list: function(elements, squish) {
                 var e;
                 return Semantic.list((function() {
@@ -2132,9 +2165,10 @@ analyze = Gibbon.analyze = (function() {
       DEBUG.log('initial crumbs', initialCrumbs);
       return contMap(initialCrumbs, solveEntry, function() {
         if (errors.length === 0) {
-          errors = null;
+          return finish(null, semantics);
+        } else {
+          return finish(errors);
         }
-        return finish(errors, semantics);
       });
     };
   })();
@@ -2357,33 +2391,10 @@ Value = Gibbon.Value = Value = (function(_super) {
 })(Union);
 
 Promise = (function() {
-  function Promise(fn) {
-    this.fn = fn;
+  function Promise(force) {
+    this.force = force;
   }
 
-  Promise.prototype.force = function(failure, success) {
-    var onFailure, onSuccess,
-      _this = this;
-    if (this.result === true) {
-      return success(this.value, this.dependencies);
-    }
-    if (this.result === false) {
-      return failure(this.value);
-    }
-    onSuccess = function(val, deps) {
-      _this.result = true;
-      _this.value = val;
-      _this.dependencies = deps;
-      return success(val, deps);
-    };
-    onFailure = function(fail) {
-      _this.result = false;
-      _this.value = fail;
-      return failure(fail);
-    };
-    return this.fn.call(null, onFailure, onSuccess);
-  };
-
   Promise.prototype.then = function(fn) {
     var _this = this;
     return new Promise(function(fail, cb) {
@@ -2744,15 +2755,486 @@ eval_ = Gibbon["eval"] = (function() {
   };
 })();
 // 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) {
+  var nameGen;
+
+  __extends(IR, _super);
+
+  function IR() {
+    _ref = IR.__super__.constructor.apply(this, arguments);
+    return _ref;
+  }
+
+  IR.types({
+    global: [],
+    constant: ['value'],
+    variable: ['name'],
+    branch: ['cond', 'ifTrue', 'ifFalse'],
+    bind: ['name', 'value', 'expr'],
+    delist: ['expr', 'index'],
+    depair: ['expr', 'key'],
+    list: ['elements'],
+    foldList: ['list', 'out', 'arg', 'accumArg', 'idxArg', 'body'],
+    mapList: ['list', 'arg', 'idxArg', 'body'],
+    zipLists: ['first', 'second'],
+    filterList: ['list', 'arg', 'body'],
+    squishList: ['list'],
+    len: ['list'],
+    pair: ['first', 'second'],
+    block: ['name', 'body'],
+    app: ['block', 'arg'],
+    query: ['expr', 'annotations'],
+    localQuery: ['expr', 'key'],
+    fail: ['message'],
+    binop: ['op', 'lhs', 'rhs'],
+    extern: ['name', 'value'],
+    rescue: ['expr', 'default']
+  });
+
+  IR.makeVariable = function(name) {
+    return IR.variable(nameGen(name));
+  };
+
+  IR.prototype.branch = function(ifTrue, ifFalse) {
+    return IR.branch(this, ifTrue, ifFalse);
+  };
+
+  IR.prototype.delist = function(index) {
+    return IR.delist(this, index);
+  };
+
+  IR.prototype.depair = function(key) {
+    return IR.depair(this, key);
+  };
+
+  IR.prototype.query = function(annotations) {
+    return IR.query(this, annotations);
+  };
+
+  IR.prototype.localQuery = function(key) {
+    return IR.localQuery(this, key);
+  };
+
+  IR.prototype.binop = function(op, other) {
+    return IR.binop(op, this, other);
+  };
+
+  IR.prototype.extern = function(name) {
+    return IR.extern(name, this);
+  };
+
+  IR.prototype.app = function(arg) {
+    return IR.app(this, arg);
+  };
+
+  IR.prototype.squish = function() {
+    return IR.squishList(this);
+  };
+
+  IR.prototype.len = function() {
+    return IR.len(this);
+  };
+
+  IR.prototype.seq = function(name, f) {
+    name = nameGen(name);
+    return IR.bind(name, this, f(IR.variable(name)));
+  };
+
+  IR.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)));
+  };
+
+  IR.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);
+  };
+
+  IR.prototype.zipList = function(other) {
+    return IR.zipLists(this, other);
+  };
+
+  IR.prototype.filterList = function(f) {
+    var name;
+    name = nameGen('el');
+    return IR.filterList(this, name, f(IR.variable(name)));
+  };
+
+  IR.prototype.subtrees = function() {
+    var double, single;
+    single = function(x) {
+      return [x];
+    };
+    double = function(x, y) {
+      return [x, y];
+    };
+    return this.cases({
+      branch: function(c, t, f) {
+        return [c, t, f];
+      },
+      bind: function(n, v, e) {
+        return [v, e];
+      },
+      delist: single,
+      depair: single,
+      list: function(e) {
+        return e;
+      },
+      foldList: function(l, o, a, aa, ia, b) {
+        return [l, o, b];
+      },
+      mapList: function(l, a, ia, b) {
+        return [l, b];
+      },
+      zipLists: double,
+      len: single,
+      pair: double,
+      block: function(n, b) {
+        return [b];
+      },
+      app: double,
+      query: single,
+      localQuery: single,
+      binop: function(op, l, r) {
+        return [l, r];
+      },
+      extern: function(n, v) {
+        return [v];
+      },
+      rescue: double,
+      other: function() {
+        return [];
+      }
+    });
+  };
+
+  IR.prototype.map = function(f) {
+    return this.cases({
+      branch: function(c, tr, fa) {
+        return IR.branch(f(c), f(tr), f(fa));
+      },
+      bind: function(n, v, e) {
+        return IR.bind(n, f(v), f(e));
+      },
+      delist: function(e, i) {
+        return IR.delist(f(e), i);
+      },
+      depair: function(e, k) {
+        return IR.depair(f(e), k);
+      },
+      list: function(els) {
+        var e;
+        return IR.list((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            e = els[_i];
+            _results.push(f(e));
+          }
+          return _results;
+        })());
+      },
+      foldList: function(l, o, a, i, aa, b) {
+        return IR.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));
+      },
+      zipLists: function(l, r) {
+        return IR.zipLists(f(l), f(r));
+      },
+      len: function(l) {
+        return IR.len(f(l));
+      },
+      pair: function(x, y) {
+        return IR.pair(f(x), f(y));
+      },
+      block: function(n, b) {
+        return IR.block(n, f(b));
+      },
+      app: function(b, a) {
+        return IR.app(f(b), f(a));
+      },
+      query: function(e, a) {
+        return IR.query(f(e), a);
+      },
+      localQuery: function(e, k) {
+        return IR.localQuery(f(e), k);
+      },
+      binop: function(o, l, r) {
+        return IR.binop(o, f(l), f(r));
+      },
+      extern: function(n, v) {
+        return IR.extern(n, f(v));
+      },
+      other: function() {
+        return this;
+      }
+    });
+  };
+
+  IR.prototype.replace = function(expr, other) {
+    if (this.equals(expr)) {
+      return other;
+    }
+    return this.map(function(x) {
+      return x.replace(expr, other);
+    });
+  };
+
+  IR.prototype.subst = function(varName, expr) {
+    if (this._tag === 'variable' && this.name === varName) {
+      return expr;
+    }
+    return this.map(function(x) {
+      return x.subst(varName, expr);
+    });
+  };
+
+  IR.prototype.equals = function(other) {
+    if (this._tag !== other._tag) {
+      return false;
+    }
+    return this.cases({
+      branch: function(cond, ifTrue, ifFalse) {
+        return cond.equals(other.cond) && ifTrue.equals(other.ifTrue) && ifFalse.equals(other.ifFalse);
+      },
+      bind: function(name, val, expr) {
+        if (!val.equals(other.value)) {
+          return false;
+        }
+        return expr.equals(other.replace(IR.variable(other.name), IR.variable(name)));
+      },
+      variable: function(name) {
+        return name === other.name;
+      },
+      delist: function(expr, index) {
+        return expr.equals(other.expr) && index.equals(other.index);
+      },
+      depair: function(expr, key) {
+        return expr.equals(other.expr) && key.equals(other.key);
+      },
+      list: function(els) {
+        var el, i, _i, _len;
+        for (i = _i = 0, _len = els.length; _i < _len; i = ++_i) {
+          el = els[i];
+          if (!el.equals(other.elements[i])) {
+            return false;
+          }
+        }
+        return true;
+      },
+      pair: function(x, y) {
+        return x.equals(other.first) && y.equals(other.second);
+      },
+      query: function(expr, annotations) {
+        return JSON.stringify(annotations) === JSON.stringify(other.annotations) && expr.equals(other.expr);
+      },
+      localQuery: function(expr, key) {
+        return key === other.key && expr.equals(other.expr);
+      }
+    });
+  };
+
+  nameGen = (function() {
+    var count;
+    count = 0;
+    return function(name) {
+      return "" + name + (count += 1);
+    };
+  })();
+
+  IR.prototype.inspect = function(indent) {
+    if (indent == null) {
+      indent = 0;
+    }
+    return this.cases({
+      global: function() {
+        return '$';
+      },
+      branch: function(cond, ifTrue, ifFalse) {
+        return "(IF " + (cond.inspect()) + " " + (ifTrue.inspect()) + " " + (ifFalse.inspect()) + ")";
+      },
+      bind: function(name, val, expr) {
+        return "(" + name + "=" + (val.inspect()) + " " + (expr.inspect()) + ")";
+      },
+      variable: function(name) {
+        return name;
+      },
+      delist: function(e, i) {
+        return "([" + i + "] " + (e.inspect()) + ")";
+      },
+      depair: function(e, k) {
+        return "([" + k + "] " + (e.inspect()) + ")";
+      },
+      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(' ')) + ")";
+      },
+      len: function(e) {
+        return "(LEN " + (e.inspect()) + ")";
+      },
+      mapList: function(list, arg, i, body) {
+        return "(MAP " + (list.inspect()) + " " + arg + " " + i + " " + (body.inspect()) + ")";
+      },
+      foldList: function(list, out, arg, next, i, body) {
+        return "(FOLDR " + (list.inspect()) + " " + (out.inspect()) + " " + arg + " " + next + " " + i + " " + (body.inspect()) + ")";
+      },
+      zipLists: function(x, y) {
+        return "(ZIP " + (x.inspect()) + " " + (y.inspect()) + ")";
+      },
+      pair: function(x, y) {
+        return "(PAIR " + (x.inspect()) + " " + (y.inspect()) + ")";
+      },
+      query: function(e, a) {
+        return "(QUERY " + (JSON.stringify(a)) + " " + (e.inspect()) + ")";
+      },
+      block: function(a, e) {
+        return "(LAMBDA " + a + " " + (e.inspect()) + ")";
+      },
+      app: function(b, a) {
+        return "(APPLY " + (b.inspect()) + " " + (a.inspect()) + ")";
+      },
+      localQuery: function(k) {
+        return "(@" + k + " " + (e.inspect()) + ")";
+      },
+      fail: function(m) {
+        return "(FAIL " + m + ")";
+      },
+      binop: function(op, l, r) {
+        return "(`" + op + "` " + (l.inspect()) + " " + (r.inspect()) + ")";
+      },
+      extern: function(name, val) {
+        return "(`" + name + "` " + (val.inspect()) + ")";
+      },
+      rescue: function(e, d) {
+        return "(RESCUE " + (e.inspect()) + " " + (d.inspect()) + ")";
+      },
+      constant: function(v) {
+        return '' + v;
+      }
+    });
+  };
+
+  return IR;
+
+})(Union);
+
+Gibbon.compile = (function() {
+  var compile;
+  compile = function(semantic, input, context) {
+    if (input == null) {
+      input = IR.global();
+    }
+    if (context == null) {
+      context = input;
+    }
+    return semantic.cases({
+      definition: function(_, flow) {
+        return compile(flow, input, context);
+      },
+      flow: function(_, head, tail) {
+        if (tail) {
+          return compile(head, compile(tail, input, context), context);
+        } else {
+          return compile(head, input, context);
+        }
+      },
+      query: function(annotations) {
+        return input.query(annotations);
+      },
+      localAccessor: function(key) {
+        return input.localQuery(key);
+      },
+      func: function(name, args) {
+        var arg, argTypes, compArgs;
+        compArgs = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            _results.push(compile(arg, context));
+          }
+          return _results;
+        })();
+        argTypes = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            _results.push(arg.type);
+          }
+          return _results;
+        })();
+        return stdlib[name].compile(input, compArgs, this.type, argTypes);
+      },
+      literal: function(syntax) {
+        return IR.constant(syntax.value);
+      },
+      list: function(elements) {
+        var e;
+        return IR.list((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(compile(e, context));
+          }
+          return _results;
+        })());
+      },
+      pair: function(x, y) {
+        return IR.pair(compile(x, context), compile(y, context));
+      },
+      block: function(body) {
+        var arg;
+        arg = IR.makeVariable('arg');
+        return IR.block(arg.name, compile(body, arg, arg));
+      },
+      defaulted: function(body, alternative) {
+        return IR.rescue(compile(body, context), compile(alternative, context));
+      }
+    });
+  };
+  return function(semantics) {
+    var out;
+    out = new Hash;
+    semantics.each(function(k, v) {
+      return out.set(k, compile(v));
+    });
+    return out;
+  };
+})();
+// Generated by CoffeeScript 1.6.3
 var stdlib;
 
 stdlib = Gibbon.stdlib = (function() {
-  var allBooleans, anyBooleans, combine, iter, unit, vFalse, vTrue;
+  var allBooleans, anyBooleans, combine, compEquals, iFalse, iTrue, iter, unit, vFalse, vTrue;
   unit = Promise.unit;
   iter = Promise.iter;
   combine = Promise.combine;
   vTrue = Value.boolean(true);
   vFalse = Value.boolean(false);
+  iTrue = IR.constant(true);
+  iFalse = IR.constant(false);
   anyBooleans = function(promises) {
     var out, step;
     step = function(cond, next) {
@@ -2781,6 +3263,35 @@ stdlib = Gibbon.stdlib = (function() {
     };
     return iter(promises, step, out);
   };
+  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;
+      },
+      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);
+      },
+      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);
+      }
+    });
+  };
   return {
     "case": {
       type: parse.type('case [bool : %b] = % -> %b'),
@@ -2801,6 +3312,13 @@ stdlib = Gibbon.stdlib = (function() {
           };
           return iter(list.elements, step, out);
         });
+      },
+      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": {
@@ -2826,12 +3344,36 @@ stdlib = Gibbon.stdlib = (function() {
           };
           return iter(list.elements, step, out);
         });
+      },
+      compile: function(input, _arg, _, _arg1) {
+        var alts, argType, eqType;
+        alts = _arg[0];
+        argType = _arg1[0];
+        eqType = argType.of.first;
+        return alts.foldList(IR.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);
+        });
       }
     },
     "case-eq-default": {
       type: parse.type('case-eq-default %b [%a : %b] = %a -> %b'),
       impl: function(evalInput, evalDefault, evalList) {
         return stdlib['case-eq'].impl(evalInput, evalList).or(evalDefault);
+      },
+      compile: function(input, _arg, _, _arg1) {
+        var alts, argType, default_, eqType;
+        default_ = _arg[0], alts = _arg[1];
+        argType = _arg1[0];
+        eqType = argType.of.first;
+        return alts.foldList(default_, function(el, next) {
+          var first, second;
+          first = el.depair('first');
+          second = el.depair('second');
+          return compEquals(input, first, eqType).branch(second, next);
+        });
       }
     },
     "any-true?": {
@@ -2840,6 +3382,11 @@ stdlib = Gibbon.stdlib = (function() {
         return evalList.then(function(list) {
           return anyBooleans(list.elements);
         });
+      },
+      compile: function(list) {
+        return list.foldList(iFalse, function(el, next) {
+          return el.branch(iTrue, next);
+        });
       }
     },
     "all-true?": {
@@ -2848,6 +3395,11 @@ stdlib = Gibbon.stdlib = (function() {
         return evalList.then(function(list) {
           return allBooleans(list.elements);
         });
+      },
+      compile: function(list) {
+        return list.foldList(iTrue, function(el, next) {
+          return el.branch(next, iFalse);
+        });
       }
     },
     "any?": {
@@ -2868,6 +3420,11 @@ stdlib = Gibbon.stdlib = (function() {
             return _results;
           })());
         });
+      },
+      compile: function(list, block) {
+        return list.foldList(iFalse, function(el, next) {
+          return block.app(el).branch(iTrue, next);
+        });
       }
     },
     "all?": {
@@ -2888,6 +3445,11 @@ stdlib = Gibbon.stdlib = (function() {
             return _results;
           })());
         });
+      },
+      compile: function(list, block) {
+        return list.foldList(iTrue, function(el, next) {
+          return block.app(el).branch(next, iFalse);
+        });
       }
     },
     "include?": {
@@ -2911,6 +3473,13 @@ stdlib = Gibbon.stdlib = (function() {
           })();
           return anyBooleans(booleans);
         });
+      },
+      compile: function(list, needle, _, _arg) {
+        var listType;
+        listType = _arg[0];
+        return list.foldList(iFalse, function(el, next) {
+          return compEquals(el, needle, listType.of).branch(iTrue, next);
+        });
       }
     },
     "empty?": {
@@ -2919,6 +3488,11 @@ stdlib = Gibbon.stdlib = (function() {
         return evalList.map(function(list) {
           return Value.boolean(list.length === 0);
         });
+      },
+      compile: function(list) {
+        return list.foldList(iTrue, function() {
+          return iFalse;
+        });
       }
     },
     weight: {
@@ -2953,6 +3527,18 @@ stdlib = Gibbon.stdlib = (function() {
             });
           });
         });
+      },
+      compile: function(_, weights) {
+        var ratio;
+        return ratio = weights.foldList(IR.pair(IR.constant(0), IR.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));
+        });
       }
     },
     filter: {
@@ -2985,6 +3571,11 @@ stdlib = Gibbon.stdlib = (function() {
             });
           });
         });
+      },
+      compile: function(input, block) {
+        return input.filterList(function(el) {
+          return block.app(el);
+        });
       }
     },
     scale: {
@@ -3031,6 +3622,13 @@ stdlib = Gibbon.stdlib = (function() {
             })());
           });
         });
+      },
+      compile: function(list, _arg) {
+        var block;
+        block = _arg[0];
+        return list.mapList(function(el) {
+          return block.app(el);
+        });
       }
     },
     count: {
@@ -3055,6 +3653,11 @@ stdlib = Gibbon.stdlib = (function() {
             return unit(Value.number(out));
           });
         });
+      },
+      compile: function(list) {
+        return list.foldList(IR.constant(0), function(el, next) {
+          return el.binop('+', next);
+        });
       }
     },
     "case-sum": {
@@ -3062,20 +3665,22 @@ stdlib = Gibbon.stdlib = (function() {
       impl: function(_, evalList) {
         return evalList.then(function(list) {
           return combine(list.elements).then(function(elements) {
-            var el, numbers;
+            var first, numbers, second;
             numbers = (function() {
-              var _i, _len, _results;
+              var _i, _len, _ref, _results;
               _results = [];
               for (_i = 0, _len = elements.length; _i < _len; _i++) {
-                el = elements[_i];
-                _results.push(el.first.then(function(cond) {
-                  if (!cond.value) {
-                    return unit(0);
-                  }
-                  return el.second.map(function(v) {
-                    return v.value;
+                _ref = elements[_i], first = _ref.first, second = _ref.second;
+                _results.push((function(first, second) {
+                  return first.then(function(cond) {
+                    if (!cond.value) {
+                      return unit(0);
+                    }
+                    return second.map(function(v) {
+                      return v.value;
+                    });
                   });
-                }));
+                })(first, second));
               }
               return _results;
             })();
@@ -3090,6 +3695,16 @@ stdlib = Gibbon.stdlib = (function() {
             });
           });
         });
+      },
+      compile: function(_, _arg) {
+        var list;
+        list = _arg[0];
+        return list.foldList(IR.constant(0), function(el, next) {
+          var cond, val;
+          cond = el.depair('first');
+          val = el.depair('second');
+          return cond.branch(val.binop('+', next), next);
+        });
       }
     },
     first: {
@@ -3098,6 +3713,9 @@ stdlib = Gibbon.stdlib = (function() {
         return list.then(function(val) {
           return val.elements[0];
         });
+      },
+      compile: function(list) {
+        return list.delist(0);
       }
     },
     squish: {
@@ -3131,6 +3749,13 @@ stdlib = Gibbon.stdlib = (function() {
             })());
           });
         });
+      },
+      compile: function(list) {
+        return list.filterList(function(el) {
+          return IR.rescue(el.seq('v', function(_) {
+            return iTrue;
+          }), iFalse);
+        });
       }
     },
     add: {
@@ -3141,6 +3766,11 @@ stdlib = Gibbon.stdlib = (function() {
           lhs = _arg[0], rhs = _arg[1];
           return Value.number(lhs.value + rhs.value);
         });
+      },
+      compile: function(input, _arg) {
+        var num;
+        num = _arg[0];
+        return input.binop('+', num);
       }
     },
     sub: {
@@ -3151,18 +3781,29 @@ stdlib = Gibbon.stdlib = (function() {
           lhs = _arg[0], rhs = _arg[1];
           return Value.number(lhs.value - rhs.value);
         });
+      },
+      compile: function(input, _arg) {
+        var num;
+        num = _arg[0];
+        return input.binop('+', num.extern('-'));
       }
     },
     id: {
       type: parse.type('id = %a -> %a'),
       impl: function(x) {
         return x;
+      },
+      compile: function(input) {
+        return input;
       }
     },
     "else": {
       type: parse.type('else = % -> bool'),
       impl: function(_) {
         return unit(vTrue);
+      },
+      compile: function(_) {
+        return iTrue;
       }
     },
     not: {
@@ -3171,6 +3812,9 @@ stdlib = Gibbon.stdlib = (function() {
         return evalBool.map(function(bool) {
           return Value.boolean(!bool.value);
         });
+      },
+      compile: function(input) {
+        return input.extern('!');
       }
     },
     gt: {
@@ -3181,6 +3825,11 @@ stdlib = Gibbon.stdlib = (function() {
           lhs = _arg[0], rhs = _arg[1];
           return Value.boolean(lhs.value > rhs.value);
         });
+      },
+      compile: function(input, _arg) {
+        var num;
+        num = _arg[0];
+        return input.binop('>', num);
       }
     },
     lt: {
@@ -3191,6 +3840,11 @@ stdlib = Gibbon.stdlib = (function() {
           lhs = _arg[0], rhs = _arg[1];
           return Value.boolean(lhs.value < rhs.value);
         });
+      },
+      compile: function(input, _arg) {
+        var num;
+        num = _arg[0];
+        return input.binop('<', num);
       }
     },
     eq: {
@@ -3201,6 +3855,12 @@ stdlib = Gibbon.stdlib = (function() {
           lhs = _arg[0], rhs = _arg[1];
           return lhs.equals(rhs);
         });
+      },
+      compile: function(input, _arg, _, _arg1) {
+        var obj, objType;
+        obj = _arg[0];
+        objType = _arg1[0];
+        return compEquals(input, obj, objType);
       }
     }
   };
@@ -3260,11 +3920,12 @@ Gibbon.jsonConsumer = (function() {
     };
     return {
       analyzeQuery: function(id, query, t, callback) {
+        debugger;
         switch (query.type) {
           case 'access':
-            return getType(id, query.name, t, callback);
+            return getType(id, query.args[0], t, callback);
           case 'on':
-            return analyzeList(id, query.name, t, callback);
+            return analyzeList(id, query.args[0], t, callback);
           default:
             return callback(new Error("unknown query `" + query.type + "'"));
         }