goodguide-gibbon 0.13.1 → 0.14.0

data/vendor/gibbon/gibbon.browser.js

@@ -1,87 +1,22 @@
 var Gibbon = (function(undefined) {
-var Parsimmon = (function(undefined) {
-var P = (function(prototype, ownProperty, undefined) {
-  return 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.
-    //
-    // When called, creates and initializes an instance of C, unless
-    // `this` is already an instance of C, then just initializes `this`;
-    // either way, returns the instance of C that was initialized.
-    //
-    //  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 = this instanceof C ? this : new Bare;
-      self.init.apply(self, arguments);
-      return self;
-    }
-
-    // C.Bare is a class with a noop constructor.  Its prototype will be
-    // the same as C, so that instances of C.Bare are instances of C.
-    // `new MyClass.Bare` then creates new instances of C without
-    // calling .init().
-    function Bare() {}
-    C.Bare = Bare;
-
-    // Extend the prototype chain: first use Bare to create an
-    // uninitialized instance of the superclass, then set up Bare
-    // to create instances of this class.
-    var _super = Bare[prototype] = _superclass[prototype];
-    var proto = Bare[prototype] = C[prototype] = C.p = new Bare;
-
-    // pre-declaring the iteration variable for the loop below to save
-    // a `var` keyword after minification
-    var key;
-
-    // set the constructor property on the prototype, for convenience
-    proto.constructor = C;
-
-    C.extend = function(def) { return P(C, def); }
-
-    return (C.open = function(def) {
-      if (typeof def === 'function') {
-        // call the defining function with all the arguments you need
-        // extensions captures the return value.
-        def = def.call(C, proto, _super, C, _superclass);
-      }
-
-      // ...and extend it
-      if (typeof def === 'object') {
-        for (key in def) {
-          if (ownProperty.call(def, key)) {
-            proto[key] = def[key];
-          }
-        }
-      }
-
-      // if no init, assume we're inheriting from a non-Pjs class, so
-      // default to using the superclass constructor.
-      if (!('init' in proto)) proto.init = _superclass;
-
-      return C;
-    })(definition);
-  }
-
-  // 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);
+// pass
 var Parsimmon = {};
 
-Parsimmon.Parser = P(function(_, _super, Parser) {
+Parsimmon.Parser = (function() {
   "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 Parser(action) {
+    if (!(this instanceof Parser)) return new Parser(action);
+    this._ = action;
+  };
+
+  var _ = Parser.prototype;
 
   function makeSuccess(index, value) {
     return {
@@ -89,7 +24,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       index: index,
       value: value,
       furthest: -1,
-      expected: ''
+      expected: []
     };
   }
 
@@ -99,20 +34,24 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       index: -1,
       value: null,
       furthest: index,
-      expected: expected
+      expected: [expected]
     };
   }
 
-  function furthestBacktrackFor(result, last) {
+  function mergeReplies(result, last) {
     if (!last) return result;
-    if (result.furthest >= last.furthest) return result;
+    if (result.furthest > last.furthest) return result;
+
+    var expected = (result.furthest === last.furthest)
+      ? result.expected.concat(last.expected)
+      : last.expected;
 
     return {
       status: result.status,
       index: result.index,
       value: result.value,
       furthest: last.furthest,
-      expected: last.expected
+      expected: expected
     }
   }
 
@@ -120,23 +59,28 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     if (!(p instanceof Parser)) throw new Error('not a parser: '+p);
   }
 
-  var formatError = Parsimmon.formatError = function(stream, error) {
-    var expected = error.expected;
+  function formatExpected(expected) {
+    if (expected.length === 1) return expected[0];
+
+    return 'one of ' + expected.join(', ')
+  }
+
+  function formatGot(stream, error) {
     var i = error.index;
 
-    if (i === stream.length) {
-      return 'expected ' + expected + ', got the end of the string';
-    }
+    if (i === stream.length) return ', got the end of the stream'
+
 
     var prefix = (i > 0 ? "'..." : "'");
     var suffix = (stream.length - i > 12 ? "...'" : "'");
-    return (
-      'expected ' + expected + ' at character ' + i + ', got ' +
-      prefix + stream.slice(i, i+12) + suffix
-    );
-  };
 
-  _.init = function(body) { this._ = body; };
+    return ' at character ' + i + ', got ' + prefix + stream.slice(i, i+12) + suffix
+  }
+
+  var formatError = Parsimmon.formatError = function(stream, error) {
+    console.log('formatError', stream, error);
+    return 'expected ' + formatExpected(error.expected) + formatGot(stream, error)
+  };
 
   _.parse = function(stream) {
     var result = this.skip(eof)._(stream, 0);
@@ -161,13 +105,22 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       var accum = new Array(numParsers);
 
       for (var j = 0; j < numParsers; j += 1) {
-        result = furthestBacktrackFor(parsers[j]._(stream, i), result);
+        result = mergeReplies(parsers[j]._(stream, i), result);
         if (!result.status) return result;
         accum[j] = result.value
         i = result.index;
       }
 
-      return furthestBacktrackFor(makeSuccess(i, accum), result);
+      return mergeReplies(makeSuccess(i, accum), result);
+    });
+  };
+
+
+  var seqMap = Parsimmon.seqMap = function() {
+    var args = [].slice.call(arguments);
+    var mapper = args.pop();
+    return seq.apply(null, args).map(function(results) {
+      return mapper.apply(null, results);
     });
   };
 
@@ -186,7 +139,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i) {
       var result;
       for (var j = 0; j < parsers.length; j += 1) {
-        result = furthestBacktrackFor(parsers[j]._(stream, i), result);
+        result = mergeReplies(parsers[j]._(stream, i), result);
         if (result.status) return result;
       }
       return result;
@@ -200,7 +153,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
 
   _.then = function(next) {
     if (typeof next === 'function') {
-      throw new Error('chaining features of .then are no longer supported');
+      throw new Error('chaining features of .then are no longer supported, use .chain instead');
     }
 
     assertParser(next);
@@ -230,14 +183,14 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       var prevResult;
 
       for (;;) {
-        result = furthestBacktrackFor(self._(stream, i), result);
+        result = mergeReplies(self._(stream, i), result);
 
         if (result.status) {
           i = result.index;
           accum.push(result.value);
         }
         else {
-          return furthestBacktrackFor(makeSuccess(i, accum), result);
+          return mergeReplies(makeSuccess(i, accum), result);
         }
       }
     });
@@ -275,39 +228,35 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
 
       for (var times = 0; times < min; times += 1) {
         result = self._(stream, i);
-        prevResult = furthestBacktrackFor(result, prevResult);
+        prevResult = mergeReplies(result, prevResult);
         if (result.status) {
           i = result.index;
           accum.push(result.value);
         }
-        else {
-          return prevResult;
-        }
+        else return prevResult;
       }
 
       for (; times < max; times += 1) {
         result = self._(stream, i);
-        prevResult = furthestBacktrackFor(result, prevResult);
+        prevResult = mergeReplies(result, prevResult);
         if (result.status) {
           i = result.index;
           accum.push(result.value);
         }
-        else {
-          break;
-        }
+        else break;
       }
 
-      return furthestBacktrackFor(makeSuccess(i, accum), prevResult);
+      return mergeReplies(makeSuccess(i, accum), prevResult);
     });
   };
 
   // -*- higher-level combinators -*- //
-  _.result = function(res) { return this.then(succeed(res)); };
+  _.result = function(res) { return this.map(function(_) { return res; }); };
   _.atMost = function(n) { return this.times(0, n); };
   _.atLeast = function(n) {
     var self = this;
-    return seq(this.times(n), this.many()).map(function(results) {
-      return results[0].concat(results[1]);
+    return seqMap(this.times(n), this.many(), function(init, rest) {
+      return init.concat(rest);
     });
   };
 
@@ -316,7 +265,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     return Parser(function(stream, i) {
       var result = self._(stream, i);
       if (!result.status) return result;
-      return furthestBacktrackFor(makeSuccess(result.index, fn(result.value)), result);
+      return mergeReplies(makeSuccess(result.index, fn(result.value)), result);
     });
   };
 
@@ -325,13 +274,18 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   };
 
   _.mark = function() {
-    return seq(index, this, index).map(function(results) {
-      return { start: results[0], value: results[1], end: results[2] };
+    return seqMap(index, this, index, function(start, value, end) {
+      return { start: start, value: value, end: end };
     });
   };
 
   _.desc = function(expected) {
-    return this.or(fail(expected))
+    var self = this;
+    return Parser(function(stream, i) {
+      var reply = self._(stream, i);
+      if (!reply.status) reply.expected = [expected];
+      return reply;
+    });
   };
 
   // -*- primitive parsers -*- //
@@ -351,19 +305,21 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     });
   };
 
-  var regex = Parsimmon.regex = function(re) {
+  var regex = Parsimmon.regex = function(re, group) {
     var anchored = RegExp('^(?:'+re.source+')', (''+re).slice((''+re).lastIndexOf('/')+1));
+    var expected = '' + re;
+    if (group == null) group = 0;
 
     return Parser(function(stream, i) {
       var match = anchored.exec(stream.slice(i));
 
       if (match) {
-        var result = match[0];
-        return makeSuccess(i+result.length, result);
-      }
-      else {
-        return makeFailure(i, re);
+        var fullMatch = match[0];
+        var groupMatch = match[group];
+        if (groupMatch != null) return makeSuccess(i+fullMatch.length, groupMatch);
       }
+
+      return makeFailure(i, expected);
     });
   };
 
@@ -412,6 +368,14 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
     });
   };
 
+  var oneOf = Parsimmon.oneOf = function(str) {
+    return test(function(ch) { return str.indexOf(ch) >= 0; });
+  };
+
+  var noneOf = Parsimmon.noneOf = function(str) {
+    return test(function(ch) { return str.indexOf(ch) < 0; });
+  };
+
   var takeWhile = Parsimmon.takeWhile = function(predicate) {
     return Parser(function(stream, i) {
       var j = i;
@@ -450,9 +414,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   _.of = Parser.of = Parsimmon.of = succeed
 
   _.ap = function(other) {
-    return seq(this, other).map(function(results) {
-      return results[0](results[1]);
-    });
+    return seqMap(this, other, function(f, x) { return f(x); })
   };
 
   //- Monad
@@ -462,12 +424,13 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
       var result = self._(stream, i);
       if (!result.status) return result;
       var nextParser = f(result.value);
-      return furthestBacktrackFor(nextParser._(stream, result.index), result);
+      return mergeReplies(nextParser._(stream, result.index), result);
     });
   };
-});
-  return Parsimmon;
-})()
+
+  return Parser;
+})();
+// pass
 // Generated by CoffeeScript 1.6.3
 var AST, CompiledCode, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, RVal, Result, Ruby, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, Value, VarTrace, Variant, analyze, applyOp1, applyOp2, asyncMap, contIter, contMap, equalArrays, eval_, inspectNative, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
   __slice = [].slice,
@@ -1050,7 +1013,8 @@ Gibbon.AST = AST = (function(_super) {
     flow: ['loc', 'head', 'tail'],
     metadata: ['loc', 'key', 'text'],
     definition: ['loc', 'metadata', 'name', 'frame'],
-    frame: ['loc', 'definitions', 'flow']
+    frame: ['loc', 'definitions', 'flow'],
+    program: ['definitions']
   });
 
   inspectDefinitions = function(defs) {
@@ -1169,6 +1133,9 @@ Gibbon.AST = AST = (function(_super) {
         out.push(flow.inspect());
         out.push(")");
         return out.join('');
+      },
+      program: function(definitions) {
+        return inspectDefinitions(definitions);
       }
     });
   };
@@ -1205,17 +1172,10 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
 })(Variant);
 
 parse = Gibbon.parse = (function() {
-  var accessor, accessorExpr, arrow, arrowType, assertString, blankLines, blockExpr, blockType, comma, commaSepFlows, comment, component, concrete, decimal, decimalExpr, defaulted, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, handleResult, identifier, innerFrame, integer, integerExpr, isString, label, labelVal, lazy, lbrace, lbrack, lexeme, lexical, lexicalExpr, lines, listExpr, listType, lparen, lsplat, metadata, multiline, name, nonDefaultedFlow, nonPairedFlow, numericExpr, opt, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, queryArg, queryExpr, rbrace, rbrack, regex, rparen, rsplat, seq, signature, simpleType, singletonFlow, spanLoc, squishListExpr, str, string, stringExpr, substExpr, succeed, tag, tassign, type, typeVar, variable, whitespace, wildType, wildcard, withLoc,
+  var accessor, accessorExpr, arrow, arrowType, assertString, blankLines, blockExpr, blockType, comma, commaSepFlows, comment, component, concrete, decimal, decimalExpr, defaulted, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullFrame, fullSignature, func, funcPlaceholder, handleResult, identifier, innerFrame, integer, integerExpr, isString, label, labelVal, lazy, lbrace, lbrack, lexeme, lexical, lexicalExpr, lines, listExpr, listType, lparen, lsplat, metadata, multiline, name, nonDefaultedFlow, nonPairedFlow, numericExpr, opt, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, queryArg, queryExpr, rbrace, rbrack, regex, rparen, rsplat, seq, signature, simpleType, singletonFlow, spanLoc, squishListExpr, str, string, stringExpr, substExpr, succeed, tag, tassign, type, typeVar, variable, whitespace, wildType, wildcard, withLoc,
     _this = this;
   tag = function(name, parser) {
-    return Parsimmon.Parser(function(stream, i) {
-      var result;
-      result = parser._(stream, i);
-      if (!result.status) {
-        result.expected = name;
-      }
-      return result;
-    });
+    return parser.desc(name);
   };
   Parsimmon.Parser.prototype.tryChain = function(f) {
     return this.chain(function(res) {
@@ -1224,10 +1184,10 @@ parse = Gibbon.parse = (function() {
   };
   string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
   seq = Parsimmon.seq, lazy = Parsimmon.lazy;
-  whitespace = regex(/^[ \t]*/);
-  blankLines = regex(/^[\n;\s]+/);
-  comment = regex(/^#.*?(\n|$)/);
-  lines = (blankLines.or(comment)).many();
+  whitespace = tag('inline whitespace', regex(/^[ \t]*/));
+  blankLines = regex(/[\n;\s]+/).desc('blank lines');
+  comment = regex(/#.*?(\n|$)/).desc('a comment');
+  lines = tag('whitespace', (blankLines.or(comment)).many());
   lexeme = function(p) {
     return p.mark().skip(whitespace);
   };
@@ -1267,9 +1227,9 @@ parse = Gibbon.parse = (function() {
   defaulted = multiline(string('|'));
   lsplat = multiline(string('[*'));
   rsplat = lexeme(string('*]'));
-  query = lexeme(string('@:').then(identifier));
+  query = lexeme(string('@:').then(identifier).desc('a query'));
   queryArg = lexeme(regex(/^\w[\w-]*/));
-  accessor = lexeme(string('@').then(identifier));
+  accessor = lexeme(string('@').then(identifier).desc('an accessor'));
   lexical = lexeme(string('.').then(identifier));
   name = lexeme(identifier);
   str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'")));
@@ -1404,7 +1364,7 @@ parse = Gibbon.parse = (function() {
     }
     return els;
   });
-  metadata = seq(label, labelVal).map(function(_arg) {
+  metadata = seq(label, labelVal).desc('metadata').map(function(_arg) {
     var key, text;
     key = _arg[0], text = _arg[1];
     return AST.metadata(spanLoc(key, text), key.value, text.value);
@@ -1417,10 +1377,11 @@ parse = Gibbon.parse = (function() {
       return AST.definition(loc, md, n.value, fl);
     });
   });
-  frame = seq(definition.many(), flow).map(function(_arg) {
-    var defs, flow, loc;
-    defs = _arg[0], flow = _arg[1];
-    loc = spanLoc((defs[0] || flow).loc, flow.loc);
+  frame = seq(definition, definition.many(), flow).map(function(_arg) {
+    var defs, first, flow, loc, rest;
+    first = _arg[0], rest = _arg[1], flow = _arg[2];
+    defs = [first].concat(rest);
+    loc = spanLoc(first.loc, flow.loc);
     return AST.frame(loc, defs, flow);
   });
   parenFrame = seq(lparen, frame, rparen, lines).map(function(_arg) {
@@ -1433,7 +1394,10 @@ parse = Gibbon.parse = (function() {
     return AST.frame(fl.loc, [], fl);
   });
   innerFrame = parenFrame.or(freeFrame);
-  program = lines.then(frame);
+  program = lines.then(definition.many()).map(function(ds) {
+    return AST.program(ds);
+  });
+  fullFrame = lines.then(frame.or(flow));
   tassign = lexeme(string('='));
   concrete = name.map(function(n) {
     return TypeAST.concrete(n.value);
@@ -1493,6 +1457,9 @@ parse = Gibbon.parse = (function() {
     assertString(str);
     return handleResult(str, program.parse(str));
   };
+  parse.frame = function(str) {
+    return handleResult(str, fullFrame.parse(str));
+  };
   parse.type = function(str) {
     assertString(str);
     return handleResult(str, fullSignature.parse(str));
@@ -1732,9 +1699,9 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
     variable: ['name', 'uniq'],
     query: ['input', 'scope', 'query'],
     lexical: ['syntax', 'scope'],
-    destructure: ['constraint', 'name', 'argnum'],
     "native": ['id'],
     param: ['name', 'constraints'],
+    destructure: ['constraint', 'name', 'argnum'],
     error: ['type', 'args'],
     any: []
   });
@@ -1958,29 +1925,6 @@ Gibbon.TypeExpr = TypeExpr = (function(_super) {
     });
   };
 
-  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;
 
 })(Variant);
@@ -2003,19 +1947,18 @@ analyze = Gibbon.analyze = (function() {
         })();
       }
 
-      NativeContext.prototype.query = function(id, query, cb) {
-        var cacheKey, lookupFn,
-          _this = this;
+      NativeContext.prototype.query = function(id, query) {
+        var cacheKey, lookupFn;
         cacheKey = "" + id + "/" + query.type + " " + (query.args.join(' '));
-        if (this.queryCache.has(cacheKey)) {
-          return Thunk.trampoline(cb(this.queryCache.get(cacheKey)));
-        }
         lookupFn = this.externalLookup;
-        return lookupFn(id, query, Type, function(err, analysis) {
+        return this.queryCache.cache(cacheKey, function() {
           var result;
-          result = err ? TypeLookup.error(err) : TypeLookup.response(query, analysis);
-          _this.queryCache.set(cacheKey, result);
-          return Thunk.trampoline(cb(result));
+          result = lookupFn(id, query, Type);
+          if (result.success) {
+            return TypeLookup.response(query, result.analysis);
+          } else {
+            return TypeLookup.error(result.error);
+          }
         });
       };
 
@@ -2025,14 +1968,14 @@ analyze = Gibbon.analyze = (function() {
     Scope = (function() {
       var makeKey;
 
-      Scope.global = function(context, frame) {
-        return new Scope(null, [], frame, context, new Hash);
+      Scope.global = function(context, defs) {
+        return new Scope(null, [], defs, context, new Hash);
       };
 
-      function Scope(parent, breadcrumbs, frame, context, metadata) {
+      function Scope(parent, breadcrumbs, definitions, context, metadata) {
         this.parent = parent;
         this.breadcrumbs = breadcrumbs;
-        this.frame = frame;
+        this.definitions = definitions;
         this.context = context;
         this.metadata = metadata;
         this.bindings = new Hash;
@@ -2040,20 +1983,20 @@ analyze = Gibbon.analyze = (function() {
       }
 
       Scope.prototype.extend = function(definition) {
-        var breadcrumbs, frame, key, metadata, text, _i, _len, _ref10, _ref9;
+        var breadcrumbs, definitions, key, metadata, text, _i, _len, _ref10, _ref9;
         breadcrumbs = this.breadcrumbs.concat(definition.name);
-        frame = definition.frame;
+        definitions = definition.frame.definitions;
         metadata = new Hash;
         _ref9 = definition.metadata;
         for (_i = 0, _len = _ref9.length; _i < _len; _i++) {
           _ref10 = _ref9[_i], key = _ref10.key, text = _ref10.text;
           metadata.set(key, text);
         }
-        return new Scope(this, breadcrumbs, frame, this.context, metadata);
+        return new Scope(this, breadcrumbs, definitions, this.context, metadata);
       };
 
-      Scope.prototype.lookup = function(nativeId, query, cb) {
-        return this.context.query(nativeId, query, cb);
+      Scope.prototype.lookup = function(nativeId, query) {
+        return this.context.query(nativeId, query);
       };
 
       Scope.prototype.lexicalLookup = function(name) {
@@ -2079,20 +2022,21 @@ analyze = Gibbon.analyze = (function() {
       };
 
       Scope.prototype.analyze = function(push) {
-        var def, frame, frameScope, global, _i, _len, _ref9,
+        var def, framePush, frameScope, global, _i, _len, _ref9, _results,
           _this = this;
-        _ref9 = this.frame.definitions;
+        global = TypeExpr["native"](this.context.globalID);
+        _ref9 = this.definitions;
+        _results = [];
         for (_i = 0, _len = _ref9.length; _i < _len; _i++) {
           def = _ref9[_i];
-          frameScope = this.extend(def);
+          frameScope = this.bindings.set(def.name, this.extend(def));
           frameScope.analyze(push);
-          this.bindings.set(def.name, frameScope);
+          framePush = function(lhs, rhs) {
+            return push(frameScope, def.frame, [lhs, rhs]);
+          };
+          _results.push(frameScope.analyzeFlow(def.frame.flow, global, framePush));
         }
-        global = TypeExpr["native"](this.context.globalID);
-        frame = this.frame;
-        return this.analyzeFlow(this.frame.flow, global, function(lhs, rhs) {
-          return push(_this, [lhs, rhs]);
-        });
+        return _results;
       };
 
       Scope.prototype.analyzeFlow = function(flow, global, push) {
@@ -2186,13 +2130,14 @@ analyze = Gibbon.analyze = (function() {
     return function(globalID, externalLookup, program) {
       var constraintMap, context, scope;
       context = new NativeContext(globalID, externalLookup);
-      scope = Scope.global(context, program);
+      scope = Scope.global(context, program.definitions);
       constraintMap = new Hash;
-      scope.analyze(function(scope, constraint) {
+      scope.analyze(function(scope, frame, constraint) {
         var entry;
         entry = constraintMap.cache(scope.key(), function() {
           return {
             scope: scope,
+            frame: frame,
             constraints: []
           };
         });
@@ -2202,7 +2147,8 @@ analyze = Gibbon.analyze = (function() {
     };
   })();
   solve = (function() {
-    var TypeError, consume, _ref9;
+    var SolveState, Solver, TypeError, _ref9;
+    
     TypeError = (function(_super) {
       __extends(TypeError, _super);
 
@@ -2246,364 +2192,429 @@ analyze = Gibbon.analyze = (function() {
       return TypeError;
 
     })(Variant);
-    
-    consume = function(array, next, body) {
-      var loop_, push;
-      push = function(x, y) {
-        return array.push([x, y]);
+    SolveState = (function() {
+      function SolveState(constraintMap) {
+        this.constraintMap = constraintMap;
+        this.locks = new Hash;
+        this.crumbs = [];
+        this.errors = [];
+        this.semantics = new Hash;
+      }
+
+      SolveState.prototype.solved = function(key, semantic) {
+        return this.semantics.set(key, semantic);
+      };
+
+      SolveState.prototype.solverFor = function(key) {
+        return new Solver(this, key);
+      };
+
+      SolveState.prototype.solveKey = function(key) {
+        if (this.semantics.has(key)) {
+          return TypeExpr.fromType(this.semantics.get(key).flow.type);
+        }
+        return this.solverFor(key).solve();
       };
-      loop_ = function() {
-        var lhs, rhs, _ref10;
-        if (!(array.length > 0)) {
-          return next();
+
+      SolveState.prototype.solveAll = function() {
+        var key, _i, _len, _ref10;
+        
+        _ref10 = this.constraintMap.keys();
+        for (_i = 0, _len = _ref10.length; _i < _len; _i++) {
+          key = _ref10[_i];
+          this.solveKey(key);
         }
-        _ref10 = array.pop(), lhs = _ref10[0], rhs = _ref10[1];
-        return body(lhs, rhs, push, function() {
-          return new Thunk(loop_);
+        if (this.errors.length === 0) {
+          return {
+            success: true,
+            semantics: this.semantics
+          };
+        } else {
+          return {
+            success: false,
+            errors: this.errors
+          };
+        }
+      };
+
+      return SolveState;
+
+    })();
+    Solver = (function() {
+      function Solver(state, key) {
+        var entry;
+        this.state = state;
+        this.key = key;
+        entry = this.state.constraintMap.get(this.key);
+        this.scope = entry.scope;
+        this.frame = entry.frame;
+        this.constraints = entry.constraints.reverse();
+        this.dependencies = [];
+        this.solutions = new ObjHash;
+        this.queryResults = new ObjHash;
+      }
+
+      Solver.prototype.error = function() {
+        var args, type;
+        type = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+        this.state.errors.push(TypeError[type].apply(TypeError, args));
+        return TypeExpr.any();
+      };
+
+      Solver.prototype.hasErrors = function() {
+        return this.state.errors.length > 0;
+      };
+
+      Solver.prototype.typeOf = function(expr) {
+        if (this.solutions.has(expr)) {
+          return this.solutions.get(expr).realize();
+        }
+        return expr.cases({
+          expr: function() {
+            throw new Error('unsolved!');
+          },
+          other: function() {
+            return Type.abstract(TypeExpr.expr(expr));
+          }
         });
       };
-      return Thunk.trampoline(loop_());
-    };
-    return function(constraintMap, finish) {
-      var errors, frameTypes, initialCrumbs, k, locks, semantics, solutions, solveEntry;
-      errors = [];
-      solutions = new ObjHash;
-      semantics = new Hash;
-      frameTypes = new Hash;
-      locks = new Hash;
-      solveEntry = function(crumbs, solved) {
-        var constraints, dependencies, done, error, frame, fullSubstitute, key, nextCrumbs, scope, semanticAccessors, simplify, substitute, _ref10;
-        key = crumbs[crumbs.length - 1];
-        if (semantics.has(key)) {
-          return solved();
+
+      Solver.prototype.makeSemantic = function(expr) {
+        var _this = this;
+        return expr.cases({
+          frame: function(_, __, flow) {
+            return Semantic.definition(_this.dependencies, _this.makeSemantic(flow), _this.scope.metadata);
+          },
+          flow: function(_, head, tail) {
+            return Semantic.flow(_this.typeOf(TypeExpr.expr(expr)), _this.makeSemantic(head), tail && _this.makeSemantic(tail));
+          },
+          query: function(_, type, name) {
+            if (!(_this.hasErrors() || _this.queryResults.has(expr))) {
+              throw "panic: unsolved query with no errors!";
+            }
+            return _this.queryResults.get(expr);
+          },
+          lexical: function(_, name) {
+            return _this.queryResults.get(expr);
+          },
+          func: function(_, name, args) {
+            var a, semArgs, solvedScope, typeScope;
+            typeScope = expr.__scope__;
+            solvedScope = new Hash;
+            typeScope && typeScope.each(function(name, texpr) {
+              return solvedScope.set(name, _this.typeOf(texpr));
+            });
+            semArgs = (function() {
+              var _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = args.length; _i < _len; _i++) {
+                a = args[_i];
+                _results.push(this.makeSemantic(a));
+              }
+              return _results;
+            }).call(_this);
+            return Semantic.func(name, semArgs, solvedScope);
+          },
+          pair: function(_, first, second) {
+            return Semantic.pair(_this.makeSemantic(first), _this.makeSemantic(second));
+          },
+          block: function(_, flow) {
+            return Semantic.block(_this.makeSemantic(flow));
+          },
+          subst: function(_, subFlow) {
+            return _this.makeSemantic(subFlow);
+          },
+          list: function(_, elements, squish) {
+            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(this.makeSemantic(e));
+              }
+              return _results;
+            }).call(_this), squish);
+          },
+          defaulted: function(_, body, alt) {
+            return Semantic.defaulted(_this.makeSemantic(body), _this.makeSemantic(alt));
+          },
+          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);
+          }
+        });
+      };
+
+      Solver.prototype.lookup = function(scope, id, query) {
+        var lookup,
+          _this = this;
+        lookup = scope.lookup(id, query);
+        this.dependencies.push(lookup);
+        return lookup.cases({
+          error: function(e) {
+            return _this.error('lookup', query, id, e);
+          },
+          response: function(_, analysis) {
+            _this.queryResults.set(query, Semantic.query({
+              annotations: analysis.annotations,
+              type: analysis.type.toSexpr()
+            }));
+            return TypeExpr.fromType(analysis.type);
+          }
+        });
+      };
+
+      Solver.prototype.lexicalLookup = function(syntax, scope) {
+        var lookupKey;
+        lookupKey = scope.lexicalLookup(syntax.name);
+        if (!lookupKey) {
+          return this.error('lexical', name, scope);
         }
-        nextCrumbs = crumbs.concat([key]);
-        _ref10 = constraintMap.get(key), scope = _ref10.scope, constraints = _ref10.constraints;
-        frame = scope.frame;
+        this.queryResults.set(syntax, Semantic.localAccessor(lookupKey));
+        this.dependencies.push(TypeLookup.local(lookupKey));
+        return this.state.solveKey(lookupKey);
+      };
+
+      Solver.prototype.resolve = function(expr) {
+        var _this = this;
+        return expr.cases({
+          error: function(type, args) {
+            return _this.error.apply(_this, [type].concat(__slice.call(args)));
+          },
+          destructure: function(constraint, name, argnum) {
+            return _this.resolve(constraint).cases({
+              param: function(paramName, paramArgs) {
+                if (paramName === name) {
+                  return paramArgs[argnum];
+                } else {
+                  return _this.error('destructure', expr);
+                }
+              },
+              other: function() {
+                return _this.error('destructure', expr);
+              }
+            });
+          },
+          lexical: function(syntax, scope) {
+            return _this.lexicalLookup(syntax, scope);
+          },
+          query: function(input, scope, query) {
+            return _this.resolve(input).cases({
+              "native": function(id) {
+                return _this.lookup(scope, id, query);
+              },
+              other: function() {
+                return expr;
+              }
+            });
+          },
+          other: function() {
+            return expr.map(function(e) {
+              return _this.resolve(e);
+            });
+          }
+        });
+      };
+
+      Solver.prototype.substitute = function(texpr) {
+        var _this = this;
+        return this.solutions.fetch(texpr, function() {
+          return texpr.map(function(e) {
+            return _this.substitute(e);
+          });
+        });
+      };
+
+      Solver.prototype.fullSubstitute = function(texpr) {
+        var resolved, substituted;
+        substituted = this.substitute(texpr);
+        resolved = this.resolve(substituted);
         
-        locks.set(key, true);
-        semanticAccessors = new ObjHash;
-        dependencies = [];
+        return resolved;
+      };
+
+      Solver.prototype.addSolution = function(lhs, rhs) {
+        var _this = this;
+        
+        this.solutions.set(lhs, rhs);
+        return this.solutions.each(function(k, texpr) {
+          return _this.solutions.set(k, _this.fullSubstitute(texpr));
+        });
+      };
+
+      Solver.prototype.processPair = function(lhs, rhs) {
+        var log, matchError, push, solveFor, swap,
+          _this = this;
         
-        substitute = function(texpr, cb) {
-          if (solutions.has(texpr)) {
-            return cb(solutions.get(texpr));
+        push = function(newLhs, newRhs) {
+          return _this.constraints.push([newLhs, newRhs]);
+        };
+        solveFor = function() {
+          rhs = _this.fullSubstitute(rhs);
+          if (_this.solutions.has(lhs)) {
+            return push(_this.solutions.get(lhs), rhs);
           } else {
-            return texpr.mapAsync(substitute, cb);
+            return _this.addSolution(lhs, rhs);
           }
         };
-        fullSubstitute = function(texpr, cb) {
-          return substitute(texpr, function(substituted) {
-            return simplify(substituted, function(result) {
-              
-              return cb(result);
-            });
-          });
+        log = function() {
+          return DEBUG.logConstraint('?> ', lhs, rhs);
         };
-        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();
+        swap = function() {
+          return push(rhs, lhs);
         };
-        simplify = function(expr, cb) {
-          return expr.cases({
-            error: function(type, args) {
-              return cb(error.apply(null, [type].concat(__slice.call(args))));
-            },
-            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);
-                  }
-                }));
-              });
-            },
-            lexical: function(syntax, scope) {
-              var lookupKey;
-              lookupKey = scope.lexicalLookup(syntax.name);
-              if (!lookupKey) {
-                return cb(error('lexical', name, scope));
-              }
-              semanticAccessors.set(syntax, Semantic.localAccessor(lookupKey));
-              dependencies.push(TypeLookup.local(lookupKey));
-              nextCrumbs = crumbs.concat([lookupKey]);
-              if (locks.get(lookupKey)) {
-                return cb(error('circular', nextCrumbs));
-              }
-              return new Thunk(function() {
-                return solveEntry(nextCrumbs, function() {
-                  return new Thunk(function() {
-                    return cb(frameTypes.get(lookupKey));
-                  });
-                });
-              });
-            },
-            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({
-                        error: function(e) {
-                          return cb(error('lookup', query, id, e));
-                        },
-                        response: function(_, analysis) {
-                          semanticAccessors.set(query, Semantic.query({
-                            annotations: analysis.annotations,
-                            type: analysis.type.toSexpr()
-                          }));
-                          return cb(TypeExpr.fromType(analysis.type));
-                        }
-                      });
-                    });
-                  },
-                  other: function() {
-                    return cb(expr);
-                  }
-                });
-              });
-            },
-            other: function() {
-              return this.mapAsync(simplify, cb);
-            }
-          });
+        matchError = function() {
+          
+          return _this.error('match', lhs, rhs);
         };
-        done = function() {
-          var flowType, toSemanticTree;
-          flowType = function(expr) {
-            if (!solutions.has(expr)) {
-              if (errors.length === 0 && expr._tag === 'expr') {
-                throw new Error('unsolved!');
-              }
-              return Type.abstract(TypeExpr.expr(expr));
-            }
-            return solutions.get(expr).realize();
-          };
-          toSemanticTree = function(expr) {
-            return expr.cases({
-              frame: function(_, __, flow) {
-                return Semantic.definition(dependencies, toSemanticTree(flow), scope.metadata);
-              },
-              flow: function(_, head, tail) {
-                return Semantic.flow(flowType(TypeExpr.expr(this)), toSemanticTree(head), tail && toSemanticTree(tail));
-              },
-              query: function(_, type, name) {
-                if (!(errors.length || semanticAccessors.has(this))) {
-                  throw "unsolved with no errors!";
+        if ('any' === rhs._tag || 'any' === lhs._tag) {
+          return;
+        }
+        if (lhs.equals(rhs)) {
+          return;
+        }
+        return lhs.cases({
+          expr: solveFor,
+          variable: solveFor,
+          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 matchError();
                 }
-                return semanticAccessors.get(this);
-              },
-              lexical: function(_, name) {
-                return semanticAccessors.get(this);
-              },
-              func: function(_, name, args) {
-                var a, semArgs, solvedScope, typeScope;
-                typeScope = this.__scope__;
-                solvedScope = new Hash;
-                typeScope && typeScope.each(function(name, texpr) {
-                  return solvedScope.set(name, flowType(texpr));
-                });
-                semArgs = (function() {
-                  var _i, _len, _results;
-                  _results = [];
-                  for (_i = 0, _len = args.length; _i < _len; _i++) {
-                    a = args[_i];
-                    _results.push(toSemanticTree(a));
-                  }
-                  return _results;
-                })();
-                return Semantic.func(name, semArgs, solvedScope);
               },
-              pair: function(_, first, second) {
-                return Semantic.pair(toSemanticTree(first), toSemanticTree(second));
-              },
-              block: function(_, flow) {
-                return Semantic.block(toSemanticTree(flow));
-              },
-              subst: function(_, subFlow) {
-                return toSemanticTree(subFlow);
-              },
-              list: function(_, elements, squish) {
-                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;
-                })(), squish);
-              },
-              defaulted: function(_, body, alt) {
-                return Semantic.defaulted(toSemanticTree(body), toSemanticTree(alt));
-              },
-              integer: function() {
-                return Semantic.literal(this);
-              },
-              decimal: function() {
-                return Semantic.literal(this);
-              },
-              percent: function() {
-                return Semantic.literal(this);
+              query: swap,
+              other: matchError
+            });
+          },
+          param: function() {
+            return rhs.cases({
+              param: function() {
+                var constraint, i, _i, _len, _ref10, _results;
+                if (lhs.name !== rhs.name) {
+                  return matchError();
+                }
+                _ref10 = lhs.constraints;
+                _results = [];
+                for (i = _i = 0, _len = _ref10.length; _i < _len; i = ++_i) {
+                  constraint = _ref10[i];
+                  _results.push(push(constraint, rhs.constraints[i]));
+                }
+                return _results;
               },
-              fraction: function() {
-                return Semantic.literal(this);
+              query: function() {
+                var c, i, _i, _len, _ref10, _results;
+                _ref10 = lhs.constraints;
+                _results = [];
+                for (i = _i = 0, _len = _ref10.length; _i < _len; i = ++_i) {
+                  c = _ref10[i];
+                  _results.push(push(c, TypeExpr.destructure(rhs, lhs.type, i)));
+                }
+                return _results;
               },
-              string: function() {
-                return Semantic.literal(this);
-              }
+              expr: swap,
+              variable: swap,
+              other: matchError
             });
-          };
-          
+          },
+          other: log
+        });
+      };
+
+      Solver.prototype.registeredType = function() {
+        if (!this.state.semantics.has(this.key)) {
+          return null;
+        }
+        return TypeExpr.fromType(this.state.semantics.get(this.key).flow.type);
+      };
+
+      Solver.prototype.register = function() {
+        
+        return this.state.semantics.set(this.key, this.makeSemantic(this.frame));
+      };
+
+      Solver.prototype.setLock = function() {
+        
+        return this.state.locks.set(this.key, true);
+      };
+
+      Solver.prototype.clearLock = function() {
+        
+        return this.state.locks.set(this.key, false);
+      };
+
+      Solver.prototype.isLocked = function() {
+        return this.state.locks.get(this.key);
+      };
+
+      Solver.prototype.withLock = function(fn) {
+        var result;
+        this.state.crumbs.push(this.key);
+        if (this.isLocked()) {
+          result = this.error('circular', this.state.crumbs.slice());
+        } else {
+          this.setLock();
+          result = fn(this);
+          this.clearLock();
+        }
+        this.state.crumbs.pop();
+        return result;
+      };
+
+      Solver.prototype.solve = function() {
+        var _this = this;
+        return this.withLock(function() {
+          var lhs, rhs, _ref10;
           
-          if (!errors.length) {
-            semantics.set(key, toSemanticTree(frame));
+          while (_this.constraints.length > 0) {
+            _ref10 = _this.constraints.pop(), lhs = _ref10[0], rhs = _ref10[1];
+            _this.processPair(lhs, rhs);
           }
-          frameTypes.set(key, solutions.get(TypeExpr.expr(frame.flow)));
-          
-          locks.set(key, false);
-          return solved();
-        };
-        return consume(constraints.reverse(), done, function(lhs, rhs, push, next) {
-          var log, matchError, skip, solveFor, swap;
           
-          if (lhs.equals(rhs)) {
-            return next();
+          if (!_this.hasErrors()) {
+            _this.register();
           }
-          solveFor = function() {
-            return fullSubstitute(rhs, function(rhs) {
-              var mapper;
-              if (solutions.has(lhs)) {
-                push(solutions.get(lhs), rhs);
-                return next();
-              } else {
-                
-                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() {
-            
-            return next();
-          };
-          skip = function() {
-            return next();
-          };
-          swap = function() {
-            push(rhs, lhs);
-            return next();
-          };
-          matchError = function() {
-            
-            error('match', lhs, rhs);
-            return next();
-          };
-          if ('any' === rhs._tag || 'any' === lhs._tag) {
-            return next();
-          }
-          return lhs.cases({
-            expr: solveFor,
-            variable: solveFor,
-            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, _ref11;
-                  if (lhs.name !== rhs.name) {
-                    return matchError();
-                  }
-                  _ref11 = lhs.constraints;
-                  for (i = _i = 0, _len = _ref11.length; _i < _len; i = ++_i) {
-                    constraint = _ref11[i];
-                    push(constraint, rhs.constraints[i]);
-                  }
-                  return next();
-                },
-                query: function() {
-                  var c, i, _i, _len, _ref11;
-                  _ref11 = lhs.constraints;
-                  for (i = _i = 0, _len = _ref11.length; _i < _len; i = ++_i) {
-                    c = _ref11[i];
-                    push(c, TypeExpr.destructure(rhs, lhs.type, i));
-                  }
-                  return next();
-                },
-                expr: swap,
-                variable: swap,
-                other: matchError
-              });
-            },
-            other: log
+          return _this.solutions.fetch(TypeExpr.expr(_this.frame.flow), function() {
+            return TypeExpr.any();
           });
         });
       };
-      initialCrumbs = (function() {
-        var _i, _len, _ref10, _results;
-        _ref10 = constraintMap.keys();
-        _results = [];
-        for (_i = 0, _len = _ref10.length; _i < _len; _i++) {
-          k = _ref10[_i];
-          _results.push([k]);
-        }
-        return _results;
-      })();
-      
-      return contMap(initialCrumbs, solveEntry, function() {
-        if (errors.length === 0) {
-          return finish(null, semantics);
-        } else {
-          return finish(errors);
-        }
-      });
+
+      return Solver;
+
+    })();
+    return function(constraintMap) {
+      return new SolveState(constraintMap).solveAll();
     };
   })();
-  return function(program, globalID, external, cb) {
+  return function(program, globalID, external) {
     var constraints;
     
     
     constraints = generate(globalID, external.analyzeQuery, program);
-    return solve(constraints, cb);
+    return solve(constraints);
   };
 })();
 
@@ -3265,8 +3276,8 @@ Gibbon.Core = Core = (function(_super) {
 
 })(Variant);
 
-Gibbon.translate = (function() {
-  var translate;
+Gibbon.translate = function(semantics) {
+  var translate, translated;
   translate = function(semantic, input, context) {
     if (input == null) {
       input = Core.global();
@@ -3289,7 +3300,15 @@ Gibbon.translate = (function() {
         return input.query(annotations);
       },
       localAccessor: function(key) {
-        return Core.localQuery(key);
+        var definition;
+        definition = semantics.get(key) || (function() {
+          throw "panic: invalid reference";
+        })();
+        if (definition.metadata.has('export')) {
+          return translate(definition, Core.global());
+        } else {
+          return Core.localQuery(key);
+        }
       },
       func: function(name, args, tvars) {
         var arg, compArgs;
@@ -3337,10 +3356,12 @@ Gibbon.translate = (function() {
       }
     });
   };
-  return function(semantic) {
-    return translate(semantic);
-  };
-})();
+  translated = new Hash;
+  semantics.each(function(key, semantic) {
+    return translated.set(key, translate(semantic));
+  });
+  return translated;
+};
 
 Gibbon.optimize = (function() {
   var insertBindings, partialEval, uncachedPartialEval;
@@ -3380,15 +3401,21 @@ Gibbon.optimize = (function() {
         });
       },
       branch: function(cond, ifTrue, ifFalse) {
-        var abort;
+        var abort,
+          _this = this;
         cond = recurse(cond);
         abort = function() {
+          var _ref10;
           ifTrue = recurse(ifTrue);
           ifFalse = recurse(ifFalse);
           if (ifTrue.equals(ifFalse)) {
             
             return ifTrue;
           }
+          if (ifTrue._tag === 'constant' && ifFalse._tag === 'constant' && ((_ref10 = ifTrue.value) === true || _ref10 === false)) {
+            
+            return (ifTrue.value ? cond : recurse(cond.op1('!')));
+          }
           return cond.branch(ifTrue, ifFalse);
         };
         return cond.cases({
@@ -6003,6 +6030,18 @@ stdlib = Gibbon.stdlib = (function() {
         obj = _arg[0];
         return equals(input, obj, tvars.get('a')).op1('!');
       }
+    },
+    t: {
+      type: parse.type('t = % -> bool'),
+      compile: function() {
+        return TRUE;
+      }
+    },
+    f: {
+      type: parse.type('f = % -> bool'),
+      compile: function() {
+        return FALSE;
+      }
     }
   };
 })();
@@ -6434,9 +6473,6 @@ Gibbon.CompiledCode = CompiledCode = (function() {
 
   CompiledCode.prototype.outputType = function(key) {
     var e, type;
-    if (key == null) {
-      key = '/';
-    }
     try {
       type = this.semantics.get(key).flow.type;
       if (type == null) {
@@ -6457,11 +6493,12 @@ Gibbon.CompiledCode = CompiledCode = (function() {
 })();
 
 Gibbon.compile = function(semantics) {
-  var codegen, compiled, optimize, reduce, sequence, translate;
+  var codegen, compiled, optimize, reduce, sequence, translate, translated;
   codegen = Gibbon.codegen, reduce = Gibbon.reduce, sequence = Gibbon.sequence, optimize = Gibbon.optimize, translate = Gibbon.translate;
   compiled = new Hash;
-  semantics.each(function(k, v) {
-    return compiled.set(k, codegen(reduce(sequence(optimize(translate(v))))).block.toJS());
+  translated = translate(semantics);
+  translated.each(function(k, v) {
+    return compiled.set(k, codegen(reduce(sequence(optimize(v)))).block.toJS());
   });
   return new CompiledCode(semantics, compiled);
 };
@@ -6893,11 +6930,12 @@ Gibbon.compileRuby = (function() {
     });
   };
   return function(semantics) {
-    var key, keys, optimize, out, processKey, seen, translate, _i, _len;
+    var key, keys, optimize, out, processKey, seen, translate, translated, _i, _len;
     optimize = Gibbon.optimize, translate = Gibbon.translate;
     keys = semantics.keys();
     seen = new Hash;
     out = [];
+    translated = translate(semantics);
     processKey = function(key) {
       var compiledRuby, dep, _i, _len, _ref20;
       if (seen.has(key)) {
@@ -6911,7 +6949,7 @@ Gibbon.compileRuby = (function() {
           processKey(dep.name);
         }
       }
-      compiledRuby = compileCore(optimize(translate(semantics.get(key))), null, key).toRuby();
+      compiledRuby = compileCore(optimize(translated.get(key)), null, key).toRuby();
       return out.push("" + (idForLocal(key)) + " = begin\n  {:status=>:success,:value=>(" + compiledRuby + ")}\nrescue E => e\n  {:status=>:failure,:error=>e}\nend");
     };
     for (_i = 0, _len = keys.length; _i < _len; _i++) {
@@ -6929,6 +6967,7 @@ Gibbon.compileRuby = (function() {
       return _results;
     })()).join(','));
     out.push('}');
+    
     return out.join("\n");
   };
 })();
@@ -6939,19 +6978,28 @@ Gibbon.jsonConsumer = (function() {
     getType = function(id, accessorName, t, callback) {
       var fields;
       if (!tables.hasOwnProperty(id)) {
-        return callback(new Error("no such type " + id));
+        return {
+          success: false,
+          error: new Error("no such type " + id)
+        };
       }
       fields = tables[id].fields;
       if (!fields.hasOwnProperty(accessorName)) {
-        return callback(new Error("" + id + " has no field " + accessorName));
+        return {
+          success: false,
+          error: new Error("" + id + " has no field " + accessorName)
+        };
       }
-      return callback(null, {
-        type: fields[accessorName],
-        annotations: {
-          name: accessorName,
-          table: id
+      return {
+        success: true,
+        analysis: {
+          type: fields[accessorName],
+          annotations: {
+            name: accessorName,
+            table: id
+          }
         }
-      });
+      };
     };
     getValue = function(id, annotations, callback) {
       var entity, values;
@@ -6972,18 +7020,27 @@ Gibbon.jsonConsumer = (function() {
     analyzeList = function(id, listName, t, callback) {
       var list;
       if (!lists.hasOwnProperty(listName)) {
-        callback(new Error("unkown list `" + listName + "'"));
+        ({
+          success: false,
+          error: new Error("unkown list `" + listName + "'")
+        });
       }
       list = lists[listName];
       if (id !== list.type) {
-        callback(new Error("wrong type " + id + " for list `" + listName + "'"));
+        ({
+          success: false,
+          error: new Error("wrong type " + id + " for list `" + listName + "'")
+        });
       }
-      return callback(null, {
-        type: t.bool(),
-        annotations: {
-          list: listName
+      return {
+        success: true,
+        analysis: {
+          type: t.bool(),
+          annotations: {
+            list: listName
+          }
         }
-      });
+      };
     };
     listLookup = function(id, listName, callback) {
       var list;
@@ -6998,11 +7055,14 @@ Gibbon.jsonConsumer = (function() {
       analyzeQuery: function(id, query, t, callback) {
         switch (query.type) {
           case 'access':
-            return getType(id, query.args[0], t, callback);
+            return getType(id, query.args[0], t);
           case 'on':
-            return analyzeList(id, query.args[0], t, callback);
+            return analyzeList(id, query.args[0], t);
           default:
-            return callback(new Error("unknown query `" + query.type + "'"));
+            return {
+              success: false,
+              error: new Error("unknown query `" + query.type + "'")
+            };
         }
       },
       performQuery: function(id, annotations, callback) {