goodguide-gibbon 0.2.1 → 0.3.0

data/goodguide-gibbon.gemspec

@@ -17,7 +17,8 @@ Gem::Specification.new do |s|
     'goodguide-gibbon.gemspec',
     'lib/**/*.rb',
     'vendor/gibbon/package.json',
-    'vendor/gibbon/lib/gibbon.browser.js'
+    'vendor/gibbon/lib/gibbon.browser.js',
+    'vendor/gibbon/lib/gibbon.browser.dev.js',
   ]
 
   s.add_dependency 'therubyracer'

data/lib/goodguide/gibbon.rb

@@ -12,6 +12,10 @@ module GoodGuide
       root.join('vendor/gibbon/lib/gibbon.browser.js')
     end
 
+    def self.dev_js_lib
+      root.join('vendor/gibbon/lib/gibbon.browser.dev.js')
+    end
+
     def self.js_source
       @js_source ||= File.read(js_lib)
     end
@@ -25,37 +29,44 @@ module GoodGuide
     class RuntimeError < StandardError; end
 
     class Program
-      def self.parse(context, global, source)
+      def self.compile(source, info={})
+        client = info[:client] || raise('please pass a static client')
+        global = info[:global] || raise('please pass a global table id')
+
+        context = info[:context] || Context.new
+
         syntax = context.parse(source)
-        semantics, errors = context.analyze(syntax, global)
+        semantics, errors = context.analyze(syntax, global, client.to_js)
+
         raise SemanticError.new(errors) if errors
 
-        Program.new(context,
-          :global => global,
+        Program.new(
           :syntax => syntax,
           :semantics => semantics,
+          :context => context,
         )
       end
 
       attr_reader :syntax, :semantics
-      def initialize(context, info={})
-        @context = context
-        @global = info[:global]
+      def initialize(info={})
         @syntax = info[:syntax]
         @semantics = info[:semantics]
+        @context = info[:context] || Context.new
       end
 
       def as_json
         {
-          global: @global,
           syntax: @syntax,
           semantics: @semantics,
         }
       end
 
-      def call(entity_id)
-        values, error = @context.eval_gibbon(
-          self.semantics, @global, entity_id
+      def call(runtime_client, entity_id)
+        # TODO
+        context = Context.new
+
+        values, error = context.eval_gibbon(
+          self.semantics, entity_id, runtime_client.to_js
         )
 
         raise RuntimeError.new(error) if error
@@ -63,21 +74,24 @@ module GoodGuide
       end
     end
 
-    class Client
-      def self.make_context
-        new.make_context
+    class AbstractClient
+      def self.queries
+        @queries ||= {}
       end
 
-      def make_context
-        Context.new(self)
+      def self.query(name, &impl)
+        queries[name.to_s] = impl
       end
 
-      def lookup_type(id, name)
+      def to_js
         raise 'abstract'
       end
 
-      def lookup_value(id, annotations)
-        raise 'abstract'
+    private
+      def get_query(type)
+        query = self.class.queries[type]
+        raise "no such query #{type}" if query.nil?
+        query
       end
 
       def proc_for(method)
@@ -85,57 +99,65 @@ module GoodGuide
           cb = args.pop
           err, val = begin
             [nil, send(method, *args)]
-          rescue => e
-            [e.to_s, nil]
+          # rescue => e
+          #   [e.to_s, nil]
           end
 
           cb.call(err, val)
         end
       end
+    end
+
+    class StaticClient < AbstractClient
+      def analyze_query(input_id, query, t)
+        query_impl = get_query(query.type)
+        analysis = instance_exec(input_id, query.name, t, &query_impl)
+        analysis[:annotations][:_query_type] = query.type
+        analysis
+      end
 
       def to_js
-        {
-          getType: proc_for(:lookup_type),
-          getValue: proc_for(:lookup_value),
-        }
+        { :analyzeQuery => proc_for(:analyze_query) }
       end
     end
 
-    class Context < V8::Context
-      class Console
-        def log(*a)
-          puts a.map(&:to_s).join(' ')
-        end
+    class RuntimeClient < AbstractClient
+      def perform_query(id, annotations)
+        query = get_query(annotations[:_query_type])
+        instance_exec(id, annotations, &query)
       end
 
-      attr_reader :client
-      def initialize(client)
-        super()
-        @client = client.to_js
-        self[:console] = Console.new
-        load GoodGuide::Gibbon.js_lib
+      def to_js
+        { :performQuery => proc_for(:perform_query) }
       end
+    end
 
-      def gibbon
-        self[:Gibbon]
+    class Context
+      attr_reader :gibbon
+      def initialize(js={})
+        if js.is_a? Hash
+          js = JS.new(js)
+        end
+
+        @gibbon = js.gibbon
       end
 
       def parse(str)
-        obj_to_ruby gibbon.parse(str).asJSON
+        obj_to_ruby self.gibbon.parse(str).asJSON
       end
 
-      def analyze(syntax, global_table)
+      def analyze(syntax, global_table, static_client)
         semantics, error = capture do |&callback|
-          gibbon.analyze(syntax, global_table, self.client, callback)
+          gibbon.analyze(syntax, global_table, static_client, callback)
         end
 
         [hash_to_ruby(semantics), obj_to_ruby(error)]
       end
 
-      def eval_gibbon(semantics, global_table, id)
+      def eval_gibbon(semantics, id, runtime_client)
         semantics = hash_to_js(semantics)
         values, error = capture do |&callback|
-          gibbon.eval(semantics, global_table, id, self.client, callback)
+          gibbon.eval(semantics, 0, id, runtime_client, callback)
         end
 
         [hash_to_ruby(values), obj_to_ruby(error)]
@@ -190,5 +212,35 @@ module GoodGuide
         end
       end
     end
+
+    class JS < V8::Context
+      def self.default
+        @default ||= new
+      end
+
+      class Console
+        def log
+          @log ||= proc { |_, *a| puts a.map(&:to_s).join(' ') }
+        end
+      end
+
+      attr_reader :client
+      def initialize(opts={})
+        super()
+        @debug = opts[:debug]
+
+        self[:console] = Console.new
+
+        if @debug
+          load GoodGuide::Gibbon.dev_js_lib
+        else
+          load GoodGuide::Gibbon.js_lib
+        end
+      end
+
+      def gibbon
+        self[:Gibbon]
+      end
+    end
   end
 end

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.2.1'
+      '0.3.0'
     end
   end
 end

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

@@ -0,0 +1,2906 @@
+var Gibbon = (function(undefined) {
+var Parsimmon = (function(undefined) {
+var P = (function(prototype, ownProperty, undefined) {
+  // helper functions that also help minification
+  function isObject(o) { return typeof o === 'object'; }
+  function isFunction(f) { return typeof f === 'function'; }
+
+  // used to extend the prototypes of superclasses (which might not
+  // have `.Bare`s)
+  function SuperclassBare() {}
+
+  function P(_superclass /* = Object */, definition) {
+    // handle the case where no superclass is given
+    if (definition === undefined) {
+      definition = _superclass;
+      _superclass = Object;
+    }
+
+    // C is the class to be returned.
+    //
+    // It delegates to instantiating an instance of `Bare`, so that it
+    // will always return a new instance regardless of the calling
+    // context.
+    //
+    //  TODO: the Chrome inspector shows all created objects as `C`
+    //        rather than `Object`.  Setting the .name property seems to
+    //        have no effect.  Is there a way to override this behavior?
+    function C() {
+      var self = new Bare;
+      if (isFunction(self.init)) self.init.apply(self, arguments);
+      return self;
+    }
+
+    // C.Bare is a class with a noop constructor.  Its prototype is the
+    // same as C, so that instances of C.Bare are also instances of C.
+    // New objects can be allocated without initialization by calling
+    // `new MyClass.Bare`.
+    function Bare() {}
+    C.Bare = Bare;
+
+    // Set up the prototype of the new class.
+    var _super = SuperclassBare[prototype] = _superclass[prototype];
+    var proto = Bare[prototype] = C[prototype] = new SuperclassBare;
+
+    // other variables, as a minifier optimization
+    var extensions;
+
+
+    // set the constructor property on the prototype, for convenience
+    proto.constructor = C;
+
+    C.mixin = function(def) {
+      Bare[prototype] = C[prototype] = P(C, def)[prototype];
+      return C;
+    }
+
+    return (C.open = function(def) {
+      extensions = {};
+
+      if (isFunction(def)) {
+        // call the defining function with all the arguments you need
+        // extensions captures the return value.
+        extensions = def.call(C, proto, _super, C, _superclass);
+      }
+      else if (isObject(def)) {
+        // if you passed an object instead, we'll take it
+        extensions = def;
+      }
+
+      // ...and extend it
+      if (isObject(extensions)) {
+        for (var ext in extensions) {
+          if (ownProperty.call(extensions, ext)) {
+            proto[ext] = extensions[ext];
+          }
+        }
+      }
+
+      // if there's no init, we assume we're inheriting a non-pjs class, so
+      // we default to applying the superclass's constructor.
+      if (!isFunction(proto.init)) {
+        proto.init = _superclass;
+      }
+
+      return C;
+    })(definition);
+  }
+
+  // ship it
+  return P;
+
+  // as a minifier optimization, we've closured in a few helper functions
+  // and the string 'prototype' (C[p] is much shorter than C.prototype)
+})('prototype', ({}).hasOwnProperty);
+var Parsimmon = {};
+
+Parsimmon.Parser = P(function(_, _super, Parser) {
+  "use strict";
+  // The Parser object is a wrapper for a parser function.
+  // Externally, you use one to parse a string by calling
+  //   var result = SomeParser.parse('Me Me Me! Parse Me!');
+  // You should never call the constructor, rather you should
+  // construct your Parser from the base parsers and the
+  // parser combinator methods.
+
+  function parseError(stream, i, expected) {
+    if (i === stream.length) {
+      var message = 'expected ' + expected + ', got the end of the string';
+    }
+    else {
+      var prefix = (i > 0 ? "'..." : "'");
+      var suffix = (stream.length - i > 12 ? "...'" : "'");
+      var message = 'expected ' + expected + ' at character ' + i + ', got '
+        + prefix + stream.slice(i, i+12) + suffix;
+    }
+    throw 'Parse Error: ' + message + "\n    parsing: '" + stream + "'";
+  }
+
+  _.init = function(body) { this._ = body; };
+
+  _.parse = function(stream) {
+    return this.skip(eof)._(stream, 0, success, parseError);
+
+    function success(stream, i, result) { return result; }
+  };
+
+  // -*- primitive combinators -*- //
+  _.or = function(alternative) {
+    var self = this;
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      return self._(stream, i, onSuccess, failure);
+
+      function failure(stream, newI) {
+        return alternative._(stream, i, onSuccess, onFailure);
+      }
+    });
+  };
+
+  _.then = function(next) {
+    var self = this;
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      return self._(stream, i, success, onFailure);
+
+      function success(stream, newI, result) {
+        var nextParser = (next instanceof Parser ? next : next(result));
+        return nextParser._(stream, newI, onSuccess, onFailure);
+      }
+    });
+  };
+
+  // -*- optimized iterative combinators -*- //
+  // equivalent to:
+  // _.many = function() {
+  //   return this.times(0, Infinity);
+  // };
+  // or, more explicitly:
+  // _.many = function() {
+  //   var self = this;
+  //   return self.then(function(x) {
+  //     return self.many().then(function(xs) {
+  //       return [x].concat(xs);
+  //     });
+  //   }).or(succeed([]));
+  // };
+  _.many = function() {
+    var self = this;
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      var xs = [];
+      while (self._(stream, i, success, failure));
+      return onSuccess(stream, i, xs);
+
+      function success(stream, newI, x) {
+        i = newI;
+        xs.push(x);
+        return true;
+      }
+
+      function failure() {
+        return false;
+      }
+    });
+  };
+
+  // equivalent to:
+  // _.times = function(min, max) {
+  //   if (arguments.length < 2) max = min;
+  //   var self = this;
+  //   if (min > 0) {
+  //     return self.then(function(x) {
+  //       return self.times(min - 1, max - 1).then(function(xs) {
+  //         return [x].concat(xs);
+  //       });
+  //     });
+  //   }
+  //   else if (max > 0) {
+  //     return self.then(function(x) {
+  //       return self.times(0, max - 1).then(function(xs) {
+  //         return [x].concat(xs);
+  //       });
+  //     }).or(succeed([]));
+  //   }
+  //   else return succeed([]);
+  // };
+  _.times = function(min, max) {
+    if (arguments.length < 2) max = min;
+    var self = this;
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      var xs = [];
+      var result = true;
+      var failure;
+
+      for (var times = 0; times < min; times += 1) {
+        result = self._(stream, i, success, firstFailure);
+        if (!result) return onFailure(stream, i, failure);
+      }
+
+      for (; times < max && result; times += 1) {
+        result = self._(stream, i, success, secondFailure);
+      }
+
+      return onSuccess(stream, i, xs);
+
+      function success(stream, newI, x) {
+        xs.push(x);
+        i = newI;
+        return true;
+      }
+
+      function firstFailure(stream, newI, msg) {
+        failure = msg;
+        i = newI;
+        return false;
+      }
+
+      function secondFailure(stream, newI, msg) {
+        return false;
+      }
+    });
+  };
+
+  // -*- higher-level combinators -*- //
+  _.result = function(res) { return this.then(succeed(res)); };
+  _.atMost = function(n) { return this.times(0, n); };
+  _.atLeast = function(n) {
+    var self = this;
+    return self.times(n).then(function(start) {
+      return self.many().map(function(end) {
+        return start.concat(end);
+      });
+    });
+  };
+
+  _.map = function(fn) {
+    return this.then(function(result) { return succeed(fn(result)); });
+  };
+
+  _.skip = function(two) {
+    return this.then(function(result) { return two.result(result); });
+  };
+
+  // -*- primitive parsers -*- //
+  var string = Parsimmon.string = function(str) {
+    var len = str.length;
+    var expected = "'"+str+"'";
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      var head = stream.slice(i, i+len);
+
+      if (head === str) {
+        return onSuccess(stream, i+len, head);
+      }
+      else {
+        return onFailure(stream, i, expected);
+      }
+    });
+  };
+
+  var regex = Parsimmon.regex = function(re) {
+    if (re.source[0] !== '^') throw 'regex '+re+' must be anchored';
+
+    var expected = ''+re;
+
+    return Parser(function(stream, i, onSuccess, onFailure) {
+      var match = re.exec(stream.slice(i));
+
+      if (match) {
+        var result = match[0];
+        return onSuccess(stream, i+result.length, result);
+      }
+      else {
+        return onFailure(stream, i, expected);
+      }
+    });
+  };
+
+  var succeed = Parsimmon.succeed = function(result) {
+    return Parser(function(stream, i, onSuccess) {
+      return onSuccess(stream, i, result);
+    });
+  };
+
+  var fail = Parsimmon.fail = function(expected) {
+    return Parser(function(stream, i, _, onFailure) {
+      return onFailure(stream, i, expected);
+    });
+  };
+
+  var letter = Parsimmon.letter = regex(/^[a-z]/i);
+  var letters = Parsimmon.letters = regex(/^[a-z]*/i);
+  var digit = Parsimmon.digit = regex(/^[0-9]/);
+  var digits = Parsimmon.digits = regex(/^[0-9]*/);
+  var whitespace = Parsimmon.whitespace = regex(/^\s+/);
+  var optWhitespace = Parsimmon.optWhitespace = regex(/^\s*/);
+
+  var 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));
+  });
+
+  var all = Parsimmon.all = Parser(function(stream, i, onSuccess, onFailure) {
+    return onSuccess(stream, stream.length, stream.slice(i));
+  });
+
+  var eof = Parsimmon.eof = Parser(function(stream, i, onSuccess, onFailure) {
+    if (i < stream.length) return onFailure(stream, i, 'EOF');
+
+    return onSuccess(stream, i, '');
+  });
+});
+  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,
+  __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; };
+
+genId = (function() {
+  var id;
+  id = 0;
+  return function() {
+    return id += 1;
+  };
+})();
+
+DEBUG = function(f) {
+  return f();
+};
+
+DEBUG.log = console.log;
+
+DEBUG.assert = function(msg, cond) {
+  if (!cond) {
+    throw msg;
+  }
+};
+
+isArray = Array.isArray || function(arg) {
+  return Object.prototype.toString.call(arg) === '[object Array]';
+};
+
+catLists = function(lists) {
+  var l, out, _i, _len;
+  out = [];
+  for (_i = 0, _len = lists.length; _i < _len; _i++) {
+    l = lists[_i];
+    out = out.concat(l);
+  }
+  return out;
+};
+
+uniq = function(list, eq) {
+  var el, out, u, _i, _j, _len, _len1;
+  if (eq == null) {
+    eq = (function(x, y) {
+      return x === y;
+    });
+  }
+  if (list.length === 0) {
+    return list;
+  }
+  out = [];
+  for (_i = 0, _len = list.length; _i < _len; _i++) {
+    el = list[_i];
+    for (_j = 0, _len1 = out.length; _j < _len1; _j++) {
+      u = out[_j];
+      if (!eq(el, u)) {
+        out.push(el);
+        break;
+      }
+    }
+    if (out.length === 0) {
+      out.push(el);
+    }
+  }
+  return out;
+};
+
+allocate = Object.create || function(proto) {
+  var dummy;
+  dummy = function() {};
+  dummy.prototype = proto;
+  return new dummy;
+};
+
+asyncMap = function(list, mapper, cb) {
+  var el, i, output, response, seen, _i, _len, _results;
+  if (list.length === 0) {
+    return cb(list);
+  }
+  seen = 0;
+  output = [];
+  response = function(i) {
+    return function(el) {
+      seen += 1;
+      output[i] = el;
+      if (seen >= list.length) {
+        return cb(output);
+      }
+    };
+  };
+  _results = [];
+  for (i = _i = 0, _len = list.length; _i < _len; i = ++_i) {
+    el = list[i];
+    _results.push(mapper(el, response(i), i));
+  }
+  return _results;
+};
+
+contMap = function(list, mapper, cb) {
+  var accum, step;
+  accum = [];
+  step = function(el, i, next) {
+    return mapper(el, function(result) {
+      accum[i] = result;
+      return next();
+    });
+  };
+  return contIter(list, step, function() {
+    return cb(accum);
+  });
+};
+
+contIter = function(list, f, cb) {
+  var loop_;
+  loop_ = function(i) {
+    if (i >= list.length) {
+      return cb();
+    }
+    return f(list[i], i, function() {
+      return loop_(i + 1);
+    });
+  };
+  return loop_(0);
+};
+
+Union = (function() {
+  var castJSON;
+
+  Union.specialize = function(tag, names) {
+    var klass, name, subclass, _i, _len;
+    klass = this;
+    subclass = function(values) {
+      if (values.length !== names.length) {
+        throw new TypeError("wrong number of arguments: " + values.length + " for " + names.length);
+      }
+      return klass.call(this, names, values);
+    };
+    subclass.prototype = allocate(klass.prototype);
+    subclass.prototype._tag = tag;
+    for (_i = 0, _len = names.length; _i < _len; _i++) {
+      name = names[_i];
+      subclass.prototype[name] = null;
+    }
+    return function() {
+      var values;
+      values = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      return new subclass(values);
+    };
+  };
+
+  Union.types = function(tags) {
+    var names, tag, _results;
+    this.tags = tags;
+    _results = [];
+    for (tag in tags) {
+      if (!__hasProp.call(tags, tag)) continue;
+      names = tags[tag];
+      _results.push(this[tag] = this.specialize(tag, names));
+    }
+    return _results;
+  };
+
+  function Union(_names, _values) {
+    var i, name, _i, _len, _ref;
+    this._names = _names;
+    this._values = _values;
+    _ref = this._names;
+    for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
+      name = _ref[i];
+      this[name] = this._values[i];
+    }
+  }
+
+  Union.prototype.cases = function(cases) {
+    var fn;
+    fn = cases[this._tag] || cases.other;
+    if (!fn) {
+      throw new Error("non-exhaustive cases: missing " + this._tag);
+    }
+    return fn.apply(this, this._values);
+  };
+
+  castJSON = function(val) {
+    var v, _i, _len, _results;
+    if (typeof (val != null ? val.asJSON : void 0) === 'function') {
+      return val.asJSON();
+    } else if (isArray(val)) {
+      _results = [];
+      for (_i = 0, _len = val.length; _i < _len; _i++) {
+        v = val[_i];
+        _results.push(castJSON(v));
+      }
+      return _results;
+    } else {
+      return val;
+    }
+  };
+
+  Union.prototype.asJSON = function() {
+    var name, out, _i, _len, _ref;
+    out = {
+      _tag: this._tag,
+      _union: this.constructor.name
+    };
+    _ref = this._names;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      name = _ref[_i];
+      out[name] = castJSON(this[name]);
+    }
+    return out;
+  };
+
+  Union.fromJSON = function(o) {
+    var constructor, e, name, names, vals;
+    if (isArray(o)) {
+      return (function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = o.length; _i < _len; _i++) {
+          e = o[_i];
+          _results.push(this.fromJSON(e));
+        }
+        return _results;
+      }).call(this);
+    }
+    if (!(typeof o === 'object' && (o != null) && '_tag' in o)) {
+      return o;
+    }
+    constructor = Gibbon[o._union];
+    names = constructor.tags[o._tag];
+    vals = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = names.length; _i < _len; _i++) {
+        name = names[_i];
+        _results.push(constructor.fromJSON(o[name]));
+      }
+      return _results;
+    })();
+    return constructor[o._tag].apply(constructor, vals);
+  };
+
+  Union.wrap = function(o) {
+    if (o instanceof this) {
+      return o;
+    }
+    return this.fromJSON(o);
+  };
+
+  return Union;
+
+})();
+
+Map = (function() {
+  function Map() {}
+
+  Map.prototype.has = function() {
+    throw 'abstract';
+  };
+
+  Map.prototype.get = function() {
+    throw 'abstract';
+  };
+
+  Map.prototype.set = function() {
+    throw 'abstract';
+  };
+
+  Map.prototype.each = function() {
+    throw 'abstract';
+  };
+
+  Map.prototype.fetch = function(k, f) {
+    if (this.has(k)) {
+      return this.get(k);
+    } else {
+      return f();
+    }
+  };
+
+  Map.prototype.merge = function() {
+    var k, obj, objs, v, _i, _len, _results;
+    objs = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    _results = [];
+    for (_i = 0, _len = objs.length; _i < _len; _i++) {
+      obj = objs[_i];
+      _results.push((function() {
+        var _results1;
+        _results1 = [];
+        for (k in obj) {
+          if (!__hasProp.call(obj, k)) continue;
+          v = obj[k];
+          _results1.push(this.set(k, v));
+        }
+        return _results1;
+      }).call(this));
+    }
+    return _results;
+  };
+
+  Map.prototype.modify = function(k, f) {
+    return this.set(k, f(this.get(k)));
+  };
+
+  Map.prototype.cache = function(k, f) {
+    var _this = this;
+    return this.fetch(k, function() {
+      return _this.modify(k, f);
+    });
+  };
+
+  Map.prototype.keys = function() {
+    var out;
+    out = [];
+    this.each(function(k, v) {
+      return out.push(k);
+    });
+    return out;
+  };
+
+  Map.prototype.values = function() {
+    var out;
+    out = [];
+    this.each(function(k, v) {
+      return out.push(v);
+    });
+    return out;
+  };
+
+  return Map;
+
+})();
+
+Gibbon.Hash = Hash = (function(_super) {
+  var salt;
+
+  __extends(Hash, _super);
+
+  function Hash() {
+    _ref = Hash.__super__.constructor.apply(this, arguments);
+    return _ref;
+  }
+
+  salt = '<key>';
+
+  Hash.prototype.loadKey = function(k) {
+    return salt + k;
+  };
+
+  Hash.prototype.dumpKey = function(k) {
+    if (k.indexOf(salt) === 0) {
+      return k.slice(salt.length);
+    }
+  };
+
+  Hash.prototype.get = function(k) {
+    return this[salt + k];
+  };
+
+  Hash.prototype.set = function(k, v) {
+    return this[salt + k] = v;
+  };
+
+  Hash.prototype.has = function(k) {
+    return this.hasOwnProperty(salt + k);
+  };
+
+  Hash.prototype.each = function(f) {
+    var k, v, _results;
+    _results = [];
+    for (k in this) {
+      if (!__hasProp.call(this, k)) continue;
+      v = this[k];
+      if (k.indexOf(salt) !== 0) {
+        continue;
+      }
+      _results.push(f(k.slice(salt.length), v));
+    }
+    return _results;
+  };
+
+  return Hash;
+
+})(Map);
+
+CompMap = (function(_super) {
+  __extends(CompMap, _super);
+
+  function CompMap(fn) {
+    if (fn == null) {
+      fn = (function(x, y) {
+        return x === y;
+      });
+    }
+    CompMap.__super__.constructor.apply(this, arguments);
+    this.compare = fn;
+    this.keys = [];
+    this.values = [];
+  }
+
+  CompMap.prototype.addBinding = function(k, v) {
+    this.keys.push(k);
+    this.values.push(v);
+    return v;
+  };
+
+  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];
+      if (this.compare(key, k)) {
+        return i;
+      }
+    }
+    return null;
+  };
+
+  CompMap.prototype.has = function(k) {
+    return this.keyIndex(k) != null;
+  };
+
+  CompMap.prototype.get = function(k) {
+    var index;
+    index = this.keyIndex(k);
+    return (index != null) && this.values[index];
+  };
+
+  CompMap.prototype.set = function(k, v) {
+    var index;
+    index = this.keyIndex(k);
+    if (index != null) {
+      return this.values[index] = v;
+    } else {
+      return this.addBinding(k, v);
+    }
+  };
+
+  CompMap.prototype.each = function(f) {
+    var i, k, _i, _len, _ref1, _results;
+    _ref1 = this.keys;
+    _results = [];
+    for (i = _i = 0, _len = _ref1.length; _i < _len; i = ++_i) {
+      k = _ref1[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;
+    keys = this.keys;
+    if (keys.length === 0) {
+      return;
+    }
+    seen = 0;
+    responder = function(i) {
+      return function() {
+        seen += 1;
+        if (seen >= keys.length) {
+          return 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)));
+    }
+    return _results;
+  };
+
+  CompMap.prototype.fetch = function(k, f) {
+    var index;
+    index = this.keyIndex(k);
+    if (index != null) {
+      return this.values[index];
+    } else {
+      return f();
+    }
+  };
+
+  CompMap.prototype.fetchAsync = function(k, f, cb) {
+    var index;
+    index = this.keyIndex(k);
+    if (index != null) {
+      return cb(this.values[index]);
+    } else {
+      return f(cb);
+    }
+  };
+
+  CompMap.prototype.cache = function(k, f) {
+    var _this = this;
+    return this.fetch(k, function() {
+      return _this.addBinding(k, f());
+    });
+  };
+
+  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; };
+
+Gibbon.AST = AST = (function(_super) {
+  var inspectDefinitions;
+
+  __extends(AST, _super);
+
+  function AST() {
+    _ref = AST.__super__.constructor.apply(this, arguments);
+    return _ref;
+  }
+
+  AST.types({
+    integer: ['value'],
+    decimal: ['value'],
+    percent: ['value'],
+    fraction: ['numerator', 'denominator'],
+    string: ['value'],
+    subst: ['flow'],
+    block: ['flow'],
+    list: ['elements'],
+    query: ['type', 'name'],
+    func: ['name', 'args'],
+    pair: ['first', 'second'],
+    flow: ['head', 'tail'],
+    metadata: ['key', 'text'],
+    definition: ['metadata', 'name', 'frame'],
+    frame: ['definitions', 'flow']
+  });
+
+  inspectDefinitions = function(defs) {
+    var def, out, _i, _len;
+    out = [];
+    for (_i = 0, _len = defs.length; _i < _len; _i++) {
+      def = defs[_i];
+      out.push(def.inspect());
+      out.push("\n");
+    }
+    return out.join('');
+  };
+
+  AST.prototype.inspect = function() {
+    var id;
+    id = function(x) {
+      return x;
+    };
+    return this.cases({
+      integer: id,
+      decimal: id,
+      percent: id,
+      fraction: function(num, denom) {
+        return "" + num + "/" + denom;
+      },
+      string: function(s) {
+        return "'" + s + "'";
+      },
+      query: function(query, name) {
+        if (query === 'access') {
+          query = '';
+        }
+        return "@" + query + "(" + name + ")";
+      },
+      subst: function(flow) {
+        return "(" + (flow.inspect()) + ")";
+      },
+      block: function(flow) {
+        return "{ " + (flow.inspect()) + " }";
+      },
+      list: function(els) {
+        var el;
+        return "[ " + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            el = els[_i];
+            _results.push(el.inspect());
+          }
+          return _results;
+        })()).join(', ')) + " ]";
+      },
+      func: function(name, args) {
+        var arg;
+        args = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = args.length; _i < _len; _i++) {
+            arg = args[_i];
+            _results.push(arg.inspect());
+          }
+          return _results;
+        })();
+        return "" + name + " " + (args.join(' '));
+      },
+      pair: function(first, second) {
+        return "" + (first.inspect()) + " : " + (second.inspect());
+      },
+      flow: function(head, tail) {
+        if (tail) {
+          tail = "" + (tail.inspect()) + " -> ";
+        } else {
+          tail = '';
+        }
+        return "" + tail + (head.inspect());
+      },
+      metadata: function(key, text) {
+        return "" + key + ": " + text;
+      },
+      definition: function(metadata, name, frame) {
+        var m, out, _i, _len;
+        out = [];
+        for (_i = 0, _len = metadata.length; _i < _len; _i++) {
+          m = metadata[_i];
+          out.push(m.inspect());
+          out.push("\n");
+        }
+        out.push("" + name + " := ");
+        out.push(frame.inspect());
+        return out.join('');
+      },
+      frame: function(definitions, flow) {
+        var out;
+        out = [];
+        out.push("(");
+        out.push(inspectDefinitions(definitions));
+        out.push(flow.inspect());
+        out.push(")");
+        return out.join('');
+      }
+    });
+  };
+
+  return AST;
+
+})(Union);
+
+Gibbon.TypeAST = TypeAST = (function(_super) {
+  __extends(TypeAST, _super);
+
+  function TypeAST() {
+    _ref1 = TypeAST.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  TypeAST.types({
+    concrete: ['name'],
+    variable: ['name'],
+    "native": ['id'],
+    wildcard: [],
+    list: ['of'],
+    func: ['input', 'args', 'output'],
+    block: ['of'],
+    pair: ['first', 'second'],
+    arrow: ['from', 'to']
+  });
+
+  TypeAST.parse = function(str) {
+    return parse.type(str);
+  };
+
+  TypeAST.parseUnit = function(str) {
+    return parse.unitType(str);
+  };
+
+  return TypeAST;
+
+})(Union);
+
+parse = Gibbon.parse = (function() {
+  var arrow, arrowType, assertString, bang, blockExpr, blockType, comma, comment, component, concrete, decimal, decimalExpr, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, ignore, innerFrame, integer, integerExpr, isString, label, labelVal, lbrace, lbrack, lexeme, listExpr, listType, lparen, metadata, name, nativeId, nativeType, nonPairedFlow, numericExpr, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, question, rbrace, rbrack, regex, rparen, signature, simpleType, singletonFlow, str, string, stringExpr, substExpr, succeed, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
+  string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
+  Parsimmon.Parser.prototype.expected = function(message) {
+    var _this = this;
+    return Parsimmon.Parser(function(stream, i, onSuccess) {
+      return _this._(stream, i, onSuccess, function(newStream, _, defMessage) {
+        var at;
+        at = stream.slice(0, 10) || 'EOF';
+        throw new Error("Parse Error: expected " + (message || defMessage) + " (at '" + at + "')");
+      });
+    });
+  };
+  Parsimmon.Parser.prototype.named = function(name) {
+    var _this = this;
+    return Parsimmon.Parser(function(stream, i, onSuccess, onFailure) {
+      return _this._(stream, i, onSuccess, function() {
+        return onFailure(stream, i, name);
+      });
+    });
+  };
+  whitespace = regex(/^[\n\s]+/);
+  comment = regex(/^#.*?(\n|$)/);
+  ignore = (whitespace.or(comment)).many();
+  lexeme = function(p) {
+    return p.skip(ignore);
+  };
+  identifier = regex(/^[a-z][\w-]*/i);
+  arrow = lexeme(string('->'));
+  define = lexeme(string(':='));
+  pair = lexeme(string(':'));
+  lbrace = lexeme(string('{'));
+  rbrace = lexeme(string('}'));
+  lbrack = lexeme(string('['));
+  rbrack = lexeme(string(']'));
+  lparen = lexeme(string('('));
+  rparen = lexeme(string(')'));
+  comma = lexeme(string(','));
+  question = lexeme(string('?'));
+  name = lexeme(identifier);
+  str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'").expected()));
+  fraction = lexeme(regex(/^\d+\/\d+/));
+  decimal = lexeme(regex(/^\d+\.\d+/));
+  percent = lexeme(regex(/^\d+%/));
+  integer = lexeme(regex(/^\d+/));
+  label = lexeme(identifier.skip(string(':')));
+  labelVal = lexeme(regex(/^[^\n]*/));
+  variable = lexeme(string('%').then(identifier));
+  wildcard = lexeme(string('%'));
+  funcPlaceholder = lexeme(string('&'));
+  integerExpr = integer.map(function(i) {
+    return AST.integer(parseInt(i));
+  });
+  decimalExpr = decimal.map(function(d) {
+    return AST.decimal(parseFloat(d));
+  });
+  percentExpr = percent.map(function(p) {
+    return AST.percent(parseInt(p));
+  });
+  fractionExpr = fraction.map(function(f) {
+    var denom, num, _ref2;
+    _ref2 = f.split('/'), num = _ref2[0], denom = _ref2[1];
+    return AST.fraction(num, denom);
+  });
+  stringExpr = str.map(function(s) {
+    return AST.string(s);
+  });
+  query = string('@').then((function() {
+    var accessor, fullQuery, parenName;
+    parenName = lparen.then(lexeme(identifier).expected()).skip(rparen.expected());
+    accessor = parenName.map(function(name) {
+      return AST.query('access', name);
+    });
+    fullQuery = identifier.then(function(q) {
+      return parenName.map(function(name) {
+        return AST.query(q, name);
+      });
+    });
+    return accessor.or(fullQuery);
+  })());
+  numericExpr = percentExpr.or(decimalExpr.or(fractionExpr.or(integerExpr)));
+  parenFlow = lparen.then(function() {
+    return flow.expected().skip(rparen.expected());
+  });
+  substExpr = parenFlow.map(function(fl) {
+    return AST.subst(fl);
+  });
+  listExpr = lbrack.then(function() {
+    return flow.skip(comma).many().then(function(els) {
+      return flow.or(succeed(null)).then(function(final) {
+        if (final) {
+          els.push(final);
+        }
+        return rbrack.expected().result(AST.list(els));
+      });
+    });
+  });
+  blockExpr = lbrace.then(function() {
+    return flow.skip(rbrace.expected());
+  }).map(AST.block);
+  expr = query.or(substExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr)))));
+  singletonFlow = expr.map(function(e) {
+    return AST.flow(e, null);
+  });
+  func = name.then(function(funcName) {
+    return parenFlow.or(singletonFlow).many().map(function(args) {
+      return AST.func(funcName, args);
+    });
+  });
+  component = expr.or(func);
+  nonPairedFlow = component.then(function(first) {
+    return arrow.then(component).many().map(function(rest) {
+      var comp, cursor, _i, _len;
+      cursor = AST.flow(first, null);
+      for (_i = 0, _len = rest.length; _i < _len; _i++) {
+        comp = rest[_i];
+        cursor = AST.flow(comp, cursor);
+      }
+      return cursor;
+    });
+  });
+  flow = nonPairedFlow.then(function(first) {
+    return pair.then(flow).map(function(second) {
+      return AST.flow(AST.pair(first, second), null);
+    }).or(succeed(first));
+  });
+  metadata = label.then(function(key) {
+    return labelVal.map(function(text) {
+      return AST.metadata(key, text);
+    });
+  });
+  definition = metadata.many().then(function(md) {
+    return name.then(function(n) {
+      return define.then(innerFrame.expected()).map(function(fl) {
+        return AST.definition(md, n, fl);
+      });
+    });
+  });
+  frame = definition.many().then(function(defs) {
+    return flow.expected().map(function(fl) {
+      return AST.frame(defs, fl);
+    });
+  });
+  parenFrame = lparen.then(frame).skip(rparen.expected());
+  freeFrame = flow.map(function(fl) {
+    return AST.frame([], fl);
+  });
+  innerFrame = parenFrame.or(freeFrame);
+  program = ignore.then(frame);
+  tassign = lexeme(string('='));
+  bang = lexeme(string('!'));
+  nativeId = lexeme(regex(/^\w+/));
+  concrete = name.map(function(n) {
+    return TypeAST.concrete(n);
+  });
+  typeVar = variable.map(function(v) {
+    return TypeAST.variable(v);
+  });
+  wildType = wildcard.result(TypeAST.wildcard());
+  listType = lbrack.then(function() {
+    return type.skip(rbrack.expected()).map(function(t) {
+      return TypeAST.list(t);
+    });
+  });
+  parenType = lparen.then(function() {
+    return type.skip(rparen.expected());
+  });
+  blockType = lbrace.then(function() {
+    return arrowType.skip(rbrace.expected()).map(function(t) {
+      return TypeAST.block(t);
+    });
+  });
+  nativeType = bang.then(nativeId).map(TypeAST["native"]);
+  simpleType = (typeVar.or(wildType.or(listType.or(parenType.or(blockType.or(concrete.or(nativeType))))))).named('a simple type');
+  type = simpleType.then(function(first) {
+    return pair.then(type.expected()).map(function(second) {
+      return TypeAST.pair(first, second);
+    }).or(succeed(first));
+  });
+  arrowType = type.then(function(first) {
+    return arrow.then(type.expected()).map(function(second) {
+      return TypeAST.arrow(first, second);
+    });
+  });
+  signature = name.then(function(n) {
+    return type.many().then(function(argTypes) {
+      return tassign.then(arrowType).map(function(ftype) {
+        return TypeAST.func(ftype.from, argTypes, ftype.to);
+      });
+    });
+  });
+  fullSignature = ignore.then(signature);
+  isString = function(s) {
+    return typeof s === 'string' || s instanceof String;
+  };
+  assertString = function(s) {
+    if (!isString(s)) {
+      throw 'can only parse strings';
+    }
+  };
+  parse = function(str) {
+    assertString(str);
+    return program.parse(str);
+  };
+  parse.type = function(str) {
+    assertString(str);
+    return fullSignature.parse(str);
+  };
+  parse.unitType = function(str) {
+    assertString(str);
+    return type.parse(str);
+  };
+  return parse;
+})();
+// Generated by CoffeeScript 1.6.3
+var stdlib;
+
+stdlib = Gibbon.stdlib = (function() {
+  return {
+    "case": {
+      type: parse.type('case [bool : %b] = % -> %b'),
+      impl: function(_, evalList) {
+        return evalList.then(function(list) {
+          var out, step;
+          step = function(pair, next) {
+            return pair.first.then(function(cond) {
+              if (cond.value) {
+                return pair.second;
+              } else {
+                return next();
+              }
+            });
+          };
+          out = function() {
+            throw new Error('Runtime Error: non-exhaustive cases');
+          };
+          return Promise.iter(list.elements, step, out);
+        });
+      }
+    },
+    weight: {
+      type: parse.type('weight [numeric : numeric] = % -> numeric'),
+      impl: function(_, eWeights) {
+        return eWeights.then(function(weights) {
+          return Promise.combine(weights.elements).then(function(pairs) {
+            var denominator, numerator, p, process;
+            numerator = 0;
+            denominator = 0;
+            process = function(pair) {
+              return Promise.combine([pair.first, pair.second]).after(function(_arg) {
+                var first, second;
+                first = _arg[0], second = _arg[1];
+                numerator += first.value * second.value;
+                return denominator += second.value;
+              });
+            };
+            return Promise.combine((function() {
+              var _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = pairs.length; _i < _len; _i++) {
+                p = pairs[_i];
+                _results.push(process(p));
+              }
+              return _results;
+            })()).then(function() {
+              if (denominator === 0) {
+                return Promise.fail('cannot divide by zero');
+              }
+              debugger;
+              return Promise.unit(Value.number(numerator / denominator));
+            });
+          });
+        });
+      }
+    },
+    filter: {
+      type: parse.type('filter { %a -> bool } = [%a] -> [%a]'),
+      impl: function(evalInput, evalBlock) {
+        return evalBlock.then(function(block) {
+          var fn;
+          fn = block.fn;
+          return evalInput.then(function(list) {
+            var check, e, out;
+            out = [];
+            check = function(thunk) {
+              return fn(thunk).after(function(bool) {
+                if (bool.value) {
+                  return out.push(thunk);
+                }
+              });
+            };
+            return Promise.combine((function() {
+              var _i, _len, _ref, _results;
+              _ref = list.elements;
+              _results = [];
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                e = _ref[_i];
+                _results.push(check(e));
+              }
+              return _results;
+            })()).map(function() {
+              return Value.list(out);
+            });
+          });
+        });
+      }
+    },
+    scale: {
+      type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
+      impl: function(eInput, eDomain, eRange) {
+        return Promise.combine([eInput, eDomain, eRange]).then(function(_arg) {
+          var bounds, dom, input, range;
+          input = _arg[0], dom = _arg[1], range = _arg[2];
+          bounds = Promise.combine([dom.first, dom.second, range.first, range.second]);
+          return bounds.map(function(_arg1) {
+            var domHigh, domLow, domSize, rangeHigh, rangeLow, rangeSize, retranslated, scaled, translated;
+            domLow = _arg1[0], domHigh = _arg1[1], rangeLow = _arg1[2], rangeHigh = _arg1[3];
+            if (input.value < domLow.value) {
+              input = domLow;
+            } else if (input.value > domHigh.value) {
+              input = domHigh;
+            }
+            domSize = domHigh.value - domLow.value;
+            rangeSize = rangeHigh.value - rangeLow.value;
+            translated = input.value - domLow.value;
+            scaled = translated * rangeSize / domSize;
+            retranslated = scaled + rangeLow.value;
+            return Value.number(retranslated);
+          });
+        });
+      }
+    },
+    map: {
+      type: parse.type('map { %a -> %b } = [%a] -> [%b]'),
+      impl: function(evalList, evalBlock) {
+        return evalList.then(function(list) {
+          return evalBlock.map(function(block) {
+            var e, fn;
+            fn = block.fn;
+            return Value.list(Promise.combine((function() {
+              var _i, _len, _ref, _results;
+              _ref = list.elements;
+              _results = [];
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                e = _ref[_i];
+                _results.push(fn(e));
+              }
+              return _results;
+            })()));
+          });
+        });
+      }
+    },
+    count: {
+      type: parse.type('count = [%a] -> numeric'),
+      impl: function(evalList) {
+        return evalList.map(function(list) {
+          return Value.number(list.elements.length);
+        });
+      }
+    },
+    sum: {
+      type: parse.type('sum = [numeric] -> numeric'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return Promise.combine(val.elements).then(function(vals) {
+            var e, out, _i, _len;
+            out = 0;
+            for (_i = 0, _len = vals.length; _i < _len; _i++) {
+              e = vals[_i];
+              out += e.value;
+            }
+            return Promise.unit(Value.number(out));
+          });
+        });
+      }
+    },
+    first: {
+      type: parse.type('first = [%a] -> %a'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return val.elements[0];
+        });
+      }
+    },
+    add: {
+      type: parse.type('add numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return Promise.combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value + rhs.value);
+        });
+      }
+    },
+    sub: {
+      type: parse.type('sub numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return Promise.combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value - rhs.value);
+        });
+      }
+    },
+    id: {
+      type: parse.type('id = %a -> %a'),
+      impl: function(x) {
+        return x;
+      }
+    },
+    "else": {
+      type: parse.type('else = % -> bool'),
+      impl: function(_) {
+        return Promise.unit(Value.boolean(true));
+      }
+    },
+    gt: {
+      type: parse.type('gt numeric = numeric -> bool'),
+      impl: function(input, num) {
+        return Promise.combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.boolean(lhs.value > rhs.value);
+        });
+      }
+    },
+    lt: {
+      type: parse.type('lt numeric = numeric -> bool'),
+      impl: function(input, num) {
+        return Promise.combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.boolean(lhs.value < rhs.value);
+        });
+      }
+    },
+    eq: {
+      type: parse.type('eq %a = %a -> bool'),
+      impl: function(input, obj) {
+        return Promise.combine([input, obj]).then(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return lhs.equals(rhs);
+        });
+      }
+    }
+  };
+})();
+// Generated by CoffeeScript 1.6.3
+var Semantic, Type, TypeLookup, analyze, _ref, _ref1, _ref2,
+  __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;
+  }
+
+  Semantic.types({
+    definition: ['dependencies', 'flow'],
+    literal: ['syntax'],
+    query: ['annotations'],
+    localAccessor: ['name'],
+    pair: ['first', 'second'],
+    block: ['body'],
+    list: ['elements'],
+    flow: ['type', 'head', 'tail'],
+    func: ['name', 'args'],
+    subst: ['flow']
+  });
+
+  return Semantic;
+
+})(Union);
+
+Gibbon.TypeLookup = TypeLookup = (function(_super) {
+  __extends(TypeLookup, _super);
+
+  function TypeLookup() {
+    _ref1 = TypeLookup.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  TypeLookup.types({
+    response: ['analysis'],
+    local: ['name']
+  });
+
+  return TypeLookup;
+
+})(Union);
+
+Gibbon.Type = Type = (function(_super) {
+  __extends(Type, _super);
+
+  function Type() {
+    _ref2 = Type.__super__.constructor.apply(this, arguments);
+    return _ref2;
+  }
+
+  Type.types({
+    block: ['from', 'to'],
+    pair: ['first', 'second'],
+    list: ['of'],
+    entity: ['id'],
+    numeric: [],
+    string: [],
+    bool: [],
+    abstract: ['expr']
+  });
+
+  Type.prototype.inspect = function() {
+    var v, vals;
+    if (this._tag === 'entity') {
+      return "(entity " + this.id + ")";
+    }
+    vals = this._values;
+    if (!vals.length) {
+      return this._tag;
+    }
+    vals = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = vals.length; _i < _len; _i++) {
+        v = vals[_i];
+        _results.push(v.inspect());
+      }
+      return _results;
+    })();
+    return "(" + this._tag + " " + (vals.join(' ')) + ")";
+  };
+
+  return Type;
+
+})(Union);
+
+analyze = Gibbon.analyze = (function() {
+  var TypeExpr, generate, solve, _ref3;
+  TypeExpr = (function(_super) {
+    __extends(TypeExpr, _super);
+
+    function TypeExpr() {
+      _ref3 = TypeExpr.__super__.constructor.apply(this, arguments);
+      return _ref3;
+    }
+
+    TypeExpr.types({
+      expr: ['expr'],
+      variable: ['name'],
+      query: ['input', 'scope', 'query'],
+      destructure: ['constraint', 'name', 'argnum'],
+      "native": ['id'],
+      param: ['name', 'constraints'],
+      any: []
+    });
+
+    TypeExpr.prototype.realize = function() {
+      return this.cases({
+        "native": function(id) {
+          return Type.entity(id);
+        },
+        param: function(name, args) {
+          var arg;
+          return Type[name].apply(Type, (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = args.length; _i < _len; _i++) {
+              arg = args[_i];
+              _results.push(arg.realize());
+            }
+            return _results;
+          })());
+        },
+        other: function() {
+          return Type.abstract(this);
+        }
+      });
+    };
+
+    TypeExpr.prototype.inspect = function() {
+      return this.cases({
+        expr: function(e) {
+          return "<" + (e.inspect()) + ">";
+        },
+        variable: function(name) {
+          return "%" + name;
+        },
+        query: function(input, _, query) {
+          return "@" + query.type + "(" + query.name + ")[" + (input.inspect()) + "]";
+        },
+        destructure: function(constraint, name, argnum) {
+          return "" + (constraint.inspect()) + "/" + name + "[" + argnum + "]";
+        },
+        "native": function(id) {
+          return "!" + id;
+        },
+        param: function(name, exprs) {
+          var expr;
+          if (!exprs.length) {
+            return "(" + name + ")";
+          }
+          exprs = (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = exprs.length; _i < _len; _i++) {
+              expr = exprs[_i];
+              _results.push(expr.inspect());
+            }
+            return _results;
+          })();
+          return "(" + name + " " + (exprs.join(' ')) + ")";
+        },
+        any: function() {
+          return '*';
+        }
+      });
+    };
+
+    TypeExpr.prototype.equals = function(other) {
+      var _this = this;
+      if (this._tag !== other._tag) {
+        return false;
+      }
+      return this.cases({
+        expr: function(e) {
+          return e === other.expr;
+        },
+        query: function(input, scope, query) {
+          if (scope !== other.scope) {
+            return false;
+          }
+          if (query !== other.query) {
+            return false;
+          }
+          return input.equals(other.input);
+        },
+        "native": function(id) {
+          return id === other.id;
+        },
+        param: function(name, constraints) {
+          var constraint, i, _i, _len;
+          if (name !== other.type) {
+            return false;
+          }
+          for (i = _i = 0, _len = constraints.length; _i < _len; i = ++_i) {
+            constraint = constraints[i];
+            if (!constraint.equals(other.constraints[i])) {
+              return false;
+            }
+          }
+          return true;
+        },
+        destructure: function(constraint, name, argnum) {
+          if (name !== other.type) {
+            return false;
+          }
+          if (argnum !== other.argnum) {
+            return false;
+          }
+          return constraint.equals(other.constraint);
+        },
+        other: function() {
+          return _this === other;
+        }
+      });
+    };
+
+    TypeExpr.fromAST = function(typeAST, scope) {
+      var e, r;
+      r = function(ast) {
+        return TypeExpr.fromAST(ast, scope);
+      };
+      e = TypeExpr;
+      return typeAST.cases({
+        concrete: function(name) {
+          if (typeof Type[name] !== 'function') {
+            throw new Error("unknown type " + name);
+          }
+          return e.param(name, []);
+        },
+        variable: function(name) {
+          return scope.cache(name, function() {
+            return e.variable(name);
+          });
+        },
+        "native": function(id) {
+          return e["native"](id);
+        },
+        wildcard: function() {
+          return e.any();
+        },
+        list: function(el) {
+          return e.param('list', [r(el)]);
+        },
+        block: function(el) {
+          return e.param('block', [r(el.from), r(el.to)]);
+        },
+        pair: function(first, second) {
+          return e.param('pair', [r(first), r(second)]);
+        }
+      });
+    };
+
+    TypeExpr.prototype.map = function(f) {
+      return this.cases({
+        param: function(name, params) {
+          var p;
+          return TypeExpr.param(name, (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = params.length; _i < _len; _i++) {
+              p = params[_i];
+              _results.push(f(p));
+            }
+            return _results;
+          })());
+        },
+        query: function(input, scope, query) {
+          return TypeExpr.query(f(input), scope, query);
+        },
+        destructure: function(constraint, name, argnum) {
+          return TypeExpr.destructure(f(constraint), name, argnum);
+        },
+        other: function() {
+          return this;
+        }
+      });
+    };
+
+    TypeExpr.prototype.mapAsync = function(f, cb) {
+      return this.cases({
+        param: function(name, params) {
+          return asyncMap(params, f, function(ps) {
+            return cb(TypeExpr.param(name, ps));
+          });
+        },
+        query: function(input, scope, query) {
+          return f(input, function(i) {
+            return cb(TypeExpr.query(i, scope, query));
+          });
+        },
+        destructure: function(param, name, argnum) {
+          return f(param, function(p) {
+            return cb(TypeExpr.destructure(p, name, argnum));
+          });
+        },
+        other: function() {
+          return cb(this);
+        }
+      });
+    };
+
+    return TypeExpr;
+
+  })(Union);
+  generate = (function() {
+    var NativeContext, Scope;
+    NativeContext = (function() {
+      function NativeContext(globalID, externalLookup) {
+        this.globalID = globalID;
+        this.externalLookup = externalLookup;
+      }
+
+      NativeContext.prototype.query = function(id, query, cb) {
+        return this.externalLookup.call(null, id, query, TypeAST, function(err, analysis) {
+          if (err) {
+            throw err;
+          }
+          return cb(TypeLookup.response(analysis));
+        });
+      };
+
+      return NativeContext;
+
+    })();
+    Scope = (function() {
+      var makeKey;
+
+      Scope.global = function(context, frame) {
+        return new Scope(null, [], frame, context);
+      };
+
+      function Scope(parent, breadcrumbs, frame, context) {
+        this.parent = parent;
+        this.breadcrumbs = breadcrumbs;
+        this.frame = frame;
+        this.context = context;
+        this.bindings = new Hash;
+      }
+
+      Scope.prototype.extend = function(name, frame) {
+        return new Scope(this, this.breadcrumbs.concat([name]), frame, this.context);
+      };
+
+      Scope.prototype.lookup = function(nativeId, query, cb) {
+        var lexical;
+        if (query.type === 'access' && nativeId === this.context.globalID) {
+          lexical = this.lexicalLookup(query.name);
+          if (lexical) {
+            return cb(lexical);
+          } else {
+            return this.context.query(nativeId, query, cb);
+          }
+        } else {
+          return this.context.query(nativeId, query, cb);
+        }
+      };
+
+      Scope.prototype.lexicalLookup = function(name) {
+        var local;
+        local = this.lookupLocal(name);
+        if (local) {
+          return local;
+        }
+        if (this.parent) {
+          return this.parent.lexicalLookup(name);
+        }
+      };
+
+      Scope.prototype.lookupLocal = function(name) {
+        if (!this.bindings.has(name)) {
+          return null;
+        }
+        return TypeLookup.local(this.keyFor(name));
+      };
+
+      makeKey = function(crumbs) {
+        return '/' + crumbs.join('/');
+      };
+
+      Scope.prototype.key = function() {
+        return makeKey(this.breadcrumbs);
+      };
+
+      Scope.prototype.keyFor = function(name) {
+        return makeKey(this.breadcrumbs.concat([name]));
+      };
+
+      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];
+          frameScope = this.extend(def.name, def.frame);
+          frameScope.analyze(push);
+          this.bindings.set(def.name, frameScope);
+        }
+        key = this.key();
+        global = TypeExpr["native"](this.context.globalID);
+        frame = this.frame;
+        return this.analyzeFlow(this.frame.flow, global, function(lhs, rhs) {
+          return push(key, frame, [lhs, rhs]);
+        });
+      };
+
+      Scope.prototype.analyzeFlow = function(flow, global, push) {
+        var _this = this;
+        if (flow.tail) {
+          this.analyzeFlow(flow.tail, global, push);
+        }
+        return flow.head.cases({
+          query: function() {
+            var input;
+            input = flow.tail ? TypeExpr.expr(flow.tail) : global;
+            return push(TypeExpr.expr(flow), TypeExpr.query(input, _this, flow.head));
+          },
+          pair: function(first, second) {
+            _this.analyzeFlow(first, global, push);
+            _this.analyzeFlow(second, global, push);
+            return push(TypeExpr.expr(flow), TypeExpr.param('pair', [TypeExpr.expr(first), TypeExpr.expr(second)]));
+          },
+          func: function(name, args) {
+            var arg, ast, func, i, input, scope, _i, _len, _results;
+            func = stdlib[name];
+            ast = func.type;
+            scope = new Hash;
+            input = TypeExpr.fromAST(ast.input, scope);
+            if (flow.tail) {
+              push(TypeExpr.expr(flow.tail), input);
+            } else {
+              push(input, global);
+            }
+            push(TypeExpr.expr(flow), TypeExpr.fromAST(ast.output, scope));
+            _results = [];
+            for (i = _i = 0, _len = args.length; _i < _len; i = ++_i) {
+              arg = args[i];
+              push(TypeExpr.expr(arg), TypeExpr.fromAST(ast.args[i], scope));
+              _results.push(_this.analyzeFlow(arg, global, push));
+            }
+            return _results;
+          },
+          integer: function() {
+            return push(TypeExpr.expr(flow), TypeExpr.param('numeric', []));
+          },
+          decimal: function() {
+            return push(TypeExpr.expr(flow), TypeExpr.param('numeric', []));
+          },
+          string: function() {
+            return push(TypeExpr.expr(flow), TypeExpr.param('string', []));
+          },
+          subst: function(subFlow) {
+            push(TypeExpr.expr(flow), TypeExpr.expr(subFlow));
+            return _this.analyzeFlow(flow, 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);
+            _results = [];
+            for (_i = 0, _len = rest.length; _i < _len; _i++) {
+              el = rest[_i];
+              _this.analyzeFlow(el, global, push);
+              _results.push(push(TypeExpr.expr(el), TypeExpr.expr(expected)));
+            }
+            return _results;
+          },
+          block: function(subFlow) {
+            var input;
+            input = TypeExpr.variable('.input');
+            push(TypeExpr.expr(flow), TypeExpr.param('block', [input, TypeExpr.expr(subFlow)]));
+            return _this.analyzeFlow(subFlow, input, push);
+          }
+        });
+      };
+
+      return Scope;
+
+    })();
+    return function(globalID, externalLookup, program) {
+      var constraintMap, context, scope;
+      context = new NativeContext(globalID, externalLookup);
+      scope = Scope.global(context, program);
+      constraintMap = new Hash;
+      scope.analyze(function(key, frame, constraint) {
+        var entry;
+        entry = constraintMap.cache(key, function() {
+          return {
+            frame: frame,
+            constraints: []
+          };
+        });
+        return entry.constraints.push(constraint);
+      });
+      return constraintMap;
+    };
+  })();
+  solve = (function() {
+    var TypeError, consume, _ref4;
+    TypeError = (function(_super) {
+      __extends(TypeError, _super);
+
+      function TypeError() {
+        _ref4 = TypeError.__super__.constructor.apply(this, arguments);
+        return _ref4;
+      }
+
+      TypeError.types({
+        match: ['lhs', 'rhs'],
+        infinite: ['type'],
+        destructure: ['type'],
+        access: ['type'],
+        circular: ['crumbs']
+      });
+
+      return TypeError;
+
+    })(Union);
+    DEBUG.logConstraint = function(prefix, lhs, rhs) {
+      return console.log(prefix, lhs.inspect(), '=', rhs.inspect());
+    };
+    consume = function(array, next, body) {
+      var loop_, push;
+      push = function(x, y) {
+        return array.push([x, y]);
+      };
+      loop_ = function() {
+        var lhs, rhs, _ref5;
+        if (!(array.length > 0)) {
+          return next();
+        }
+        _ref5 = array.pop(), lhs = _ref5[0], rhs = _ref5[1];
+        return body(lhs, rhs, push, loop_);
+      };
+      return loop_();
+    };
+    return function(constraintMap, finish) {
+      var errors, frameTypes, initialCrumbs, k, locks, semantics, solutions, solveEntry;
+      errors = [];
+      solutions = new CompMap(function(x, y) {
+        return x.equals(y);
+      });
+      semantics = new Hash;
+      frameTypes = new Hash;
+      locks = new Hash;
+      solveEntry = function(crumbs, solved) {
+        var constraints, dependencies, done, error, frame, fullSubstitute, key, nextCrumbs, semanticAccessors, simplify, substitute, _ref5;
+        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;
+        DEBUG.log('locking', key);
+        locks.set(key, true);
+        semanticAccessors = new CompMap;
+        dependencies = [];
+        DEBUG(function() {
+          var lhs, rhs, _i, _len, _ref6, _results;
+          _results = [];
+          for (_i = 0, _len = constraints.length; _i < _len; _i++) {
+            _ref6 = constraints[_i], lhs = _ref6[0], rhs = _ref6[1];
+            _results.push(DEBUG.logConstraint('-> ', lhs, rhs));
+          }
+          return _results;
+        });
+        substitute = function(texpr, cb) {
+          return solutions.fetchAsync(texpr, (function() {
+            return texpr.mapAsync(substitute, cb);
+          }), cb);
+        };
+        fullSubstitute = function(texpr, cb) {
+          return substitute(texpr, function(substituted) {
+            return simplify(substituted, function(result) {
+              DEBUG(function() {
+                if (!texpr.equals(result)) {
+                  return DEBUG.logConstraint('%> ', texpr, result);
+                }
+              });
+              return cb(result);
+            });
+          });
+        };
+        error = function() {
+          var args, type;
+          type = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+          errors.push(TypeError[type].apply(TypeError, args));
+          return TypeExpr.any();
+        };
+        simplify = function(expr, cb) {
+          return expr.cases({
+            destructure: function(constraint, name, argnum) {
+              var destructured;
+              destructured = this;
+              return simplify(constraint, function(x) {
+                return cb(x.cases({
+                  param: function(paramName, paramArgs) {
+                    if (paramName === name) {
+                      return paramArgs[argnum];
+                    } else {
+                      return error('destructure', this);
+                    }
+                  },
+                  other: function() {
+                    return error('destructure', this);
+                  }
+                }));
+              });
+            },
+            query: function(input, scope, query) {
+              return simplify(input, function(x) {
+                return x.cases({
+                  "native": function(id) {
+                    return scope.lookup(id, query, function(lookup) {
+                      dependencies.push(lookup);
+                      return lookup.cases({
+                        response: function(analysis) {
+                          semanticAccessors.set(query, Semantic.query(analysis.annotations));
+                          return cb(TypeExpr.fromAST(analysis.type));
+                        },
+                        local: function(key) {
+                          var localFrame;
+                          nextCrumbs = crumbs.concat([key]);
+                          semanticAccessors.set(query, Semantic.localAccessor(key));
+                          if (locks.get(key)) {
+                            return cb(error('circular', nextCrumbs));
+                          }
+                          localFrame = constraintMap.get(key).frame;
+                          return solveEntry(nextCrumbs, function() {
+                            return cb(frameTypes.get(key));
+                          });
+                        }
+                      });
+                    });
+                  },
+                  other: function() {
+                    return cb(expr);
+                  }
+                });
+              });
+            },
+            other: function() {
+              return this.mapAsync(simplify, cb);
+            }
+          });
+        };
+        done = function() {
+          var flowType, toSemanticTree;
+          flowType = function(expr) {
+            if (!solutions.has(TypeExpr.expr(expr))) {
+              throw 'unsolved!';
+            }
+            return solutions.get(TypeExpr.expr(expr)).realize();
+          };
+          toSemanticTree = function(expr) {
+            return expr.cases({
+              frame: function(_, flow) {
+                return Semantic.definition(dependencies, toSemanticTree(flow));
+              },
+              flow: function(head, tail) {
+                return Semantic.flow(flowType(this), toSemanticTree(head), tail && toSemanticTree(tail));
+              },
+              query: function(type, name) {
+                DEBUG(function() {
+                  if (!semanticAccessors.has(this)) {
+                    debugger;
+                  }
+                });
+                return semanticAccessors.get(this);
+              },
+              func: function(name, args) {
+                var a;
+                return Semantic.func(name, (function() {
+                  var _i, _len, _results;
+                  _results = [];
+                  for (_i = 0, _len = args.length; _i < _len; _i++) {
+                    a = args[_i];
+                    _results.push(toSemanticTree(a));
+                  }
+                  return _results;
+                })());
+              },
+              pair: function(first, second) {
+                return Semantic.pair(toSemanticTree(first), toSemanticTree(second));
+              },
+              block: function(flow) {
+                return Semantic.block(toSemanticTree(flow));
+              },
+              list: function(elements) {
+                var e;
+                return Semantic.list((function() {
+                  var _i, _len, _results;
+                  _results = [];
+                  for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                    e = elements[_i];
+                    _results.push(toSemanticTree(e));
+                  }
+                  return _results;
+                })());
+              },
+              integer: function() {
+                return Semantic.literal(this);
+              },
+              decimal: function() {
+                return Semantic.literal(this);
+              },
+              percent: function() {
+                return Semantic.literal(this);
+              },
+              fraction: function() {
+                return Semantic.literal(this);
+              },
+              string: function() {
+                return Semantic.literal(this);
+              }
+            });
+          };
+          DEBUG(function() {
+            return solutions.each(function(k, v) {
+              return DEBUG.logConstraint('=> ', k, v);
+            });
+          });
+          DEBUG.log('setting key: ' + key);
+          semantics.set(key, toSemanticTree(frame));
+          frameTypes.set(key, solutions.get(TypeExpr.expr(frame.flow)));
+          DEBUG.log('unlocking', key);
+          locks.set(key, false);
+          return solved();
+        };
+        return consume(constraints.reverse(), done, function(lhs, rhs, push, next) {
+          var log, matchError, skip, solveFor, swap;
+          DEBUG.logConstraint(':> ', lhs, rhs);
+          if (lhs.equals(rhs)) {
+            return next();
+          }
+          solveFor = function() {
+            return fullSubstitute(rhs, function(rhs) {
+              var mapper;
+              if (solutions.has(lhs)) {
+                push(solutions.get(lhs), rhs);
+                return next();
+              } else {
+                DEBUG.logConstraint('>> ', lhs, rhs);
+                solutions.set(lhs, rhs);
+                mapper = function(k, texpr, cb) {
+                  return fullSubstitute(texpr, (function(s) {
+                    solutions.set(k, s);
+                    return cb();
+                  }));
+                };
+                return solutions.eachAsync(mapper, next);
+              }
+            });
+          };
+          log = function() {
+            DEBUG.logConstraint('?> ', lhs, rhs);
+            return next();
+          };
+          skip = function() {
+            return next();
+          };
+          swap = function() {
+            push(rhs, lhs);
+            return next();
+          };
+          matchError = function() {
+            error('match', lhs, rhs);
+            return next();
+          };
+          return lhs.cases({
+            expr: solveFor,
+            variable: solveFor,
+            any: skip,
+            query: function() {
+              return rhs.cases({
+                expr: swap,
+                variable: swap,
+                param: swap,
+                other: log
+              });
+            },
+            "native": function(id) {
+              return rhs.cases({
+                variable: swap,
+                expr: swap,
+                "native": function(otherId) {
+                  if (id === otherId) {
+                    return skip();
+                  } else {
+                    return matchError();
+                  }
+                },
+                other: matchError
+              });
+            },
+            param: function() {
+              return rhs.cases({
+                param: function() {
+                  var constraint, i, _i, _len, _ref6;
+                  if (lhs.name !== rhs.name) {
+                    return matchError();
+                  }
+                  _ref6 = lhs.constraints;
+                  for (i = _i = 0, _len = _ref6.length; _i < _len; i = ++_i) {
+                    constraint = _ref6[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];
+                    push(c, TypeExpr.destructure(rhs, lhs.type(i)));
+                  }
+                  return next();
+                },
+                expr: swap,
+                variable: swap,
+                other: matchError
+              });
+            },
+            other: log
+          });
+        });
+      };
+      initialCrumbs = (function() {
+        var _i, _len, _ref5, _results;
+        _ref5 = constraintMap.keys();
+        _results = [];
+        for (_i = 0, _len = _ref5.length; _i < _len; _i++) {
+          k = _ref5[_i];
+          _results.push([k]);
+        }
+        return _results;
+      })();
+      DEBUG.log('initial crumbs', initialCrumbs);
+      return contMap(initialCrumbs, solveEntry, function() {
+        if (errors.length === 0) {
+          errors = null;
+        }
+        return finish(errors, semantics);
+      });
+    };
+  })();
+  return function(program, globalID, external, cb) {
+    var constraints;
+    if (!(program instanceof AST)) {
+      program = AST.fromJSON(program);
+    }
+    DEBUG.log();
+    DEBUG.log(program.inspect());
+    constraints = generate(globalID, external.analyzeQuery, program);
+    return solve(constraints, cb);
+  };
+})();
+// Generated by CoffeeScript 1.6.3
+var Dependency, Promise, Value, eval_, _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; },
+  __slice = [].slice;
+
+Value = Gibbon.Value = Value = (function(_super) {
+  var thunksAreEqual;
+
+  __extends(Value, _super);
+
+  function Value() {
+    _ref = Value.__super__.constructor.apply(this, arguments);
+    return _ref;
+  }
+
+  Value.types({
+    string: ['value'],
+    number: ['value'],
+    boolean: ['value'],
+    block: ['fn'],
+    list: ['elements'],
+    pair: ['first', 'second'],
+    entity: ['type', 'id']
+  });
+
+  Value.fromJSON = function(o) {
+    var e;
+    if (typeof o === 'boolean') {
+      return Value.boolean(o);
+    }
+    if (typeof o === 'number') {
+      return Value.number(o);
+    }
+    if (typeof o === 'string') {
+      return Value.string(o);
+    }
+    if (isArray(o)) {
+      return Value.list((function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = o.length; _i < _len; _i++) {
+          e = o[_i];
+          _results.push(Value.fromJSON(e));
+        }
+        return _results;
+      })());
+    }
+    switch (o._tag) {
+      case 'entity':
+        return Value.entity(o.type, o.id);
+      case 'pair':
+        return Value.pair(o.first, o.second);
+    }
+    throw new Error('invalid value: ' + o);
+  };
+
+  Value.prototype.promise = function() {
+    return Promise.unit(this.map(function(x) {
+      return x.promise();
+    }));
+  };
+
+  thunksAreEqual = function(list1, list2) {
+    var i, out, step, x, zipped;
+    if (list1.length !== list2.length) {
+      return Promise.unit(Value.boolean(false));
+    }
+    zipped = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (i = _i = 0, _len = list1.length; _i < _len; i = ++_i) {
+        x = list1[i];
+        _results.push(Promise.combine(x, list2[i]));
+      }
+      return _results;
+    })();
+    step = function(_arg, next) {
+      var x, y;
+      x = _arg[0], y = _arg[1];
+      return x.equals(y).then(function(isEqual) {
+        if (isEqual.value) {
+          return next();
+        } else {
+          return Promise.unit(Value.boolean(false));
+        }
+      });
+    };
+    out = function() {
+      return Promise.unit(Value.boolean(true));
+    };
+    return Promise.iter(zipped, step, out);
+  };
+
+  Value.prototype.equals = function(other) {
+    var wrap;
+    wrap = function(b) {
+      return Promise.unit(Value.boolean(b));
+    };
+    return this.cases({
+      string: function(val) {
+        return wrap(val === other.value);
+      },
+      number: function(val) {
+        return wrap(val === other.value);
+      },
+      boolean: function(val) {
+        return wrap(val === other.value);
+      },
+      block: function() {
+        return wrap(false);
+      },
+      list: function(els) {
+        return thunksAreEqual(els, other.elements);
+      },
+      pair: function(evalFirst, evalSecond) {
+        return thunksAreEqual([evalFirst, evalSecond], [other.first, other.second]);
+      }
+    });
+  };
+
+  Value.prototype.map = function(f) {
+    return this.cases({
+      list: function(els) {
+        var x;
+        return Value.list((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = els.length; _i < _len; _i++) {
+            x = els[_i];
+            _results.push(f(x));
+          }
+          return _results;
+        })());
+      },
+      pair: function(first, second) {
+        return Value.pair(f(first), f(second));
+      },
+      other: function() {
+        return this;
+      }
+    });
+  };
+
+  Value.prototype.mapAsync = function(f, cb) {
+    return this.cases({
+      list: function(els) {
+        return asyncMap(els, f, function(mapped) {
+          return Value.list(mapped);
+        });
+      },
+      pair: function(first, second) {
+        return asyncMap([first, second], f, function(_arg) {
+          var first, second;
+          first = _arg[0], second = _arg[1];
+          return Value.pair(first, second);
+        });
+      },
+      other: function() {
+        return cb(this);
+      }
+    });
+  };
+
+  Value.prototype.mapPromise = function(f) {
+    return this.cases({
+      list: function(promises) {
+        return Promise.combine(promises).then(function(els) {
+          var el;
+          return Promise.combine((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = els.length; _i < _len; _i++) {
+              el = els[_i];
+              _results.push(f(el));
+            }
+            return _results;
+          })()).map(function(els) {
+            return Value.list(els);
+          });
+        });
+      },
+      pair: function(eFirst, eSecond) {
+        return Promise.combine([eFirst, eSecond]).then(function(first, second) {
+          return Promise.combine([f(first), f(second)]).map(function(_arg) {
+            var mFirst, mSecond;
+            mFirst = _arg[0], mSecond = _arg[1];
+            return Value.pair(mFirst, mSecond);
+          });
+        });
+      },
+      other: function() {
+        return Promise.unit(this);
+      }
+    });
+  };
+
+  Value.prototype.resolve = function() {
+    return this.mapPromise(function(x) {
+      return x.resolve();
+    });
+  };
+
+  return Value;
+
+})(Union);
+
+Promise = (function() {
+  function Promise(fn) {
+    this.fn = fn;
+  }
+
+  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) {
+      return _this.force(fail, function(val, deps) {
+        return fn(val, deps).depends(deps).force(fail, cb);
+      });
+    });
+  };
+
+  Promise.prototype.depends = function(deps) {
+    var _this = this;
+    return new Promise(function(fail, cc) {
+      return _this.force(fail, function(val, prevDeps) {
+        return cc(val, prevDeps.concat(deps));
+      });
+    });
+  };
+
+  Promise.prototype.map = function(f) {
+    return this.then(function(v, d) {
+      return Promise.unit(f(v, d));
+    });
+  };
+
+  Promise.prototype.mapDependencies = function(f) {
+    var _this = this;
+    return new Promise(function(fail, cc) {
+      return _this.force(fail, function(val, deps) {
+        return cc(val, f(deps));
+      });
+    });
+  };
+
+  Promise.prototype.after = function(f) {
+    var _this = this;
+    return new Promise(function(fail, cc) {
+      return _this.force(fail, function(val, deps) {
+        f(val, deps);
+        return cc(val, deps);
+      });
+    });
+  };
+
+  Promise.unit = function(e) {
+    if (!(e instanceof Gibbon.Value)) {
+      throw new Error('only make thunks of Value for now');
+    }
+    return new Promise(function(_, f) {
+      return f(e, []);
+    });
+  };
+
+  Promise.fail = function(fail) {
+    return new Promise(function(f, _) {
+      return f(fail);
+    });
+  };
+
+  Promise.lazy = function(f) {
+    return new Promise(function(fail, cc) {
+      return f().force(fail, cc);
+    });
+  };
+
+  Promise.combine = function(thunks) {
+    return new Promise(function(fail, cb) {
+      var mapper;
+      mapper = function(thunk, push) {
+        return thunk.force(fail, function(val, deps) {
+          return push([val, deps]);
+        });
+      };
+      return asyncMap(thunks, mapper, function(vals) {
+        var outDeps, outVal, v;
+        outVal = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = vals.length; _i < _len; _i++) {
+            v = vals[_i];
+            _results.push(v[0]);
+          }
+          return _results;
+        })();
+        outDeps = catLists((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = vals.length; _i < _len; _i++) {
+            v = vals[_i];
+            _results.push(v[1]);
+          }
+          return _results;
+        })());
+        return cb(outVal, outDeps);
+      });
+    });
+  };
+
+  Promise.iter = function(list, step, out) {
+    var _loop;
+    _loop = function(i) {
+      if (i >= list.length) {
+        return out();
+      }
+      return list[i].then(function(val) {
+        return step(val, function() {
+          return _loop(i + 1);
+        });
+      });
+    };
+    return _loop(0);
+  };
+
+  return Promise;
+
+})();
+
+Dependency = (function(_super) {
+  __extends(Dependency, _super);
+
+  function Dependency() {
+    _ref1 = Dependency.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  Dependency.types({
+    query: ['entity', 'query'],
+    lexical: ['key']
+  });
+
+  Dependency.prototype.equals = function(other) {
+    if (this.tag !== other.tag) {
+      return false;
+    }
+    return this.cases({
+      query: function(entity, query) {
+        if (entity.id !== other.entity.id) {
+          return false;
+        }
+        if (query.annotations !== other.query.annotations) {
+          return false;
+        }
+        return true;
+      },
+      lexical: function(key) {
+        return key === other.key;
+      }
+    });
+  };
+
+  Dependency.prototype.inspect = function() {
+    return this.cases({
+      lookup: function(entity, query) {
+        return "" + (query.inspect()) + "<" + entity.id + ">";
+      },
+      lexical: function(definition) {
+        return "@" + definition.name;
+      }
+    });
+  };
+
+  return Dependency;
+
+})(Union);
+
+eval_ = Gibbon["eval"] = (function() {
+  var evalAll;
+  evalAll = function(semantics, entity, client) {
+    var evalFlow, globalPromise, resultThunks, results;
+    results = new Hash;
+    globalPromise = Promise.unit(entity);
+    resultThunks = new Hash;
+    semantics.each(function(key, definition) {
+      return resultThunks.set(key, Promise.lazy(function() {
+        return evalFlow(definition.flow, globalPromise).then(function(val) {
+          return val.resolve();
+        }).after(function(val, deps) {
+          deps = uniq(deps, function(x, y) {
+            return x.equals(y);
+          });
+          return results.set(key, [val, deps]);
+        });
+      }));
+    });
+    evalFlow = function(flow, global) {
+      var input;
+      input = flow.tail ? evalFlow(flow.tail, global) : global;
+      return flow.head.cases({
+        query: function(annotations) {
+          return input.then(function(entity) {
+            var _this = this;
+            return new Promise(function(fail, cc) {
+              return client.performQuery(entity.id, annotations, function(err, val) {
+                var dependency;
+                if (err) {
+                  return fail(err);
+                }
+                dependency = Dependency.query(entity, flow.head);
+                return Value.fromJSON(val).promise().depends([dependency]).force(fail, cc);
+              });
+            });
+          });
+        },
+        localAccessor: function(key) {
+          return new Promise(function(fail, cc) {
+            return resultThunks.get(key).force(fail, function(val, otherDeps) {
+              return cc(val, [Dependency.lexical(key)]);
+            });
+          });
+        },
+        func: function(name, args) {
+          var a, func;
+          func = stdlib[name].impl;
+          args = (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = args.length; _i < _len; _i++) {
+              a = args[_i];
+              _results.push(evalFlow(a, global));
+            }
+            return _results;
+          })();
+          return func.apply(null, [input].concat(__slice.call(args)));
+        },
+        literal: function(syntax) {
+          return syntax.cases({
+            integer: function(value) {
+              return Promise.unit(Value.number(value));
+            },
+            decimal: function(value) {
+              return Promise.unit(Value.number(value));
+            },
+            string: function(value) {
+              return Promise.unit(Value.string(value));
+            }
+          });
+        },
+        pair: function(first, second) {
+          var eFirst, eSecond;
+          eFirst = evalFlow(first, global);
+          eSecond = evalFlow(second, global);
+          return Promise.unit(Value.pair(eFirst, eSecond));
+        },
+        list: function(elements) {
+          var e;
+          elements = (function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = elements.length; _i < _len; _i++) {
+              e = elements[_i];
+              _results.push(evalFlow(e, global));
+            }
+            return _results;
+          })();
+          return Promise.unit(Value.list(elements));
+        },
+        block: function(body) {
+          return Promise.unit(Value.block(function(inputPromise) {
+            return evalFlow(body, inputPromise);
+          }));
+        }
+      });
+    };
+    return new Promise(function(fail, cc) {
+      return Promise.combine(resultThunks.values()).force(fail, function(_, deps) {
+        return cc(results, deps);
+      });
+    });
+  };
+  return function(semantics, table, id, client, finish) {
+    var entity, key, onFailure, onSuccess, _i, _len, _ref2;
+    _ref2 = semantics.keys();
+    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+      key = _ref2[_i];
+      semantics.modify(key, function(val) {
+        if (val instanceof Semantic) {
+          return val;
+        }
+        return Semantic.fromJSON(val);
+      });
+    }
+    entity = Value.entity(table, id);
+    onFailure = function(fail) {
+      return finish(fail);
+    };
+    onSuccess = function(vals) {
+      return finish(null, vals);
+    };
+    return evalAll(semantics, entity, client).force(onFailure, onSuccess);
+  };
+})();
+// Generated by CoffeeScript 1.6.3
+Gibbon.jsonConsumer = (function() {
+  return function(tables) {
+    var getType, getValue;
+    getType = function(id, accessorName, t, callback) {
+      var fields;
+      if (!tables.hasOwnProperty(id)) {
+        return callback(new Error("no such type " + id));
+      }
+      fields = tables[id].fields;
+      if (!fields.hasOwnProperty(accessorName)) {
+        return callback(new Error("" + id + " has no field " + accessorName));
+      }
+      return callback(null, {
+        type: t.parseUnit(fields[accessorName]),
+        annotations: {
+          name: accessorName,
+          table: id
+        }
+      });
+    };
+    getValue = function(id, annotations, callback) {
+      var entity, values;
+      if (!tables.hasOwnProperty(annotations.table)) {
+        return callback(new Error("no such type " + annotations.table));
+      }
+      values = tables[annotations.table].values;
+      if (!values[id]) {
+        return callback(new Error("no entity with id " + id));
+      }
+      entity = values[id];
+      if (!entity.hasOwnProperty(annotations.name)) {
+        return callback(null, null);
+      }
+      return callback(null, entity[annotations.name]);
+    };
+    return {
+      analyzeQuery: function(id, query, t, callback) {
+        switch (query.type) {
+          case 'access':
+            return getType(id, query.name, t, callback);
+          default:
+            return callback(new Error("unknown query `" + query.type + "'"));
+        }
+      },
+      performQuery: function(id, annotations, callback) {
+        return getValue(id, annotations, callback);
+      }
+    };
+  };
+})();
+  return Gibbon;
+})();