goodguide-gibbon 0.2.1 → 0.3.0

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

@@ -339,7 +339,7 @@ var Gibbon;
 
 Gibbon = {};
 // Generated by CoffeeScript 1.6.3
-var CompMap, Hash, Map, Union, allocate, asyncMap, catLists, contIter, contMap, genId, isArray, uniq, _ref,
+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; };
@@ -352,6 +352,12 @@ genId = (function() {
   };
 })();
 
+
+
+
+
+
+
 isArray = Array.isArray || function(arg) {
   return Object.prototype.toString.call(arg) === '[object Array]';
 };
@@ -849,10 +855,10 @@ Gibbon.AST = AST = (function(_super) {
     percent: ['value'],
     fraction: ['numerator', 'denominator'],
     string: ['value'],
-    accessor: ['name'],
     subst: ['flow'],
     block: ['flow'],
     list: ['elements'],
+    query: ['type', 'name'],
     func: ['name', 'args'],
     pair: ['first', 'second'],
     flow: ['head', 'tail'],
@@ -887,8 +893,11 @@ Gibbon.AST = AST = (function(_super) {
       string: function(s) {
         return "'" + s + "'";
       },
-      accessor: function(name) {
-        return "@" + name;
+      query: function(query, name) {
+        if (query === 'access') {
+          query = '';
+        }
+        return "@" + query + "(" + name + ")";
       },
       subst: function(flow) {
         return "(" + (flow.inspect()) + ")";
@@ -983,12 +992,20 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
     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 accessor, accessorExpr, 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, rbrace, rbrack, regex, rparen, signature, simpleType, singletonFlow, str, string, stringExpr, substExpr, succeed, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
+  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;
@@ -1025,9 +1042,9 @@ parse = Gibbon.parse = (function() {
   lparen = lexeme(string('('));
   rparen = lexeme(string(')'));
   comma = lexeme(string(','));
+  question = lexeme(string('?'));
   name = lexeme(identifier);
   str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'").expected()));
-  accessor = lexeme(string('@').then(identifier.expected()));
   fraction = lexeme(regex(/^\d+\/\d+/));
   decimal = lexeme(regex(/^\d+\.\d+/));
   percent = lexeme(regex(/^\d+%/));
@@ -1054,10 +1071,20 @@ parse = Gibbon.parse = (function() {
   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)));
-  accessorExpr = accessor.map(function(name) {
-    return AST.accessor(name);
-  });
   parenFlow = lparen.then(function() {
     return flow.expected().skip(rparen.expected());
   });
@@ -1077,7 +1104,7 @@ parse = Gibbon.parse = (function() {
   blockExpr = lbrace.then(function() {
     return flow.skip(rbrace.expected());
   }).map(AST.block);
-  expr = accessorExpr.or(substExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr)))));
+  expr = query.or(substExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr)))));
   singletonFlow = expr.map(function(e) {
     return AST.flow(e, null);
   });
@@ -1443,7 +1470,7 @@ Gibbon.Semantic = Semantic = (function(_super) {
   Semantic.types({
     definition: ['dependencies', 'flow'],
     literal: ['syntax'],
-    accessor: ['annotations'],
+    query: ['annotations'],
     localAccessor: ['name'],
     pair: ['first', 'second'],
     block: ['body'],
@@ -1466,7 +1493,7 @@ Gibbon.TypeLookup = TypeLookup = (function(_super) {
   }
 
   TypeLookup.types({
-    response: ['id', 'name', 'annotations'],
+    response: ['analysis'],
     local: ['name']
   });
 
@@ -1531,7 +1558,7 @@ analyze = Gibbon.analyze = (function() {
     TypeExpr.types({
       expr: ['expr'],
       variable: ['name'],
-      access: ['input', 'scope', 'accessor'],
+      query: ['input', 'scope', 'query'],
       destructure: ['constraint', 'name', 'argnum'],
       "native": ['id'],
       param: ['name', 'constraints'],
@@ -1569,8 +1596,8 @@ analyze = Gibbon.analyze = (function() {
         variable: function(name) {
           return "%" + name;
         },
-        access: function(input, _, accessor) {
-          return "@" + accessor.name + "[" + (input.inspect()) + "]";
+        query: function(input, _, query) {
+          return "@" + query.type + "(" + query.name + ")[" + (input.inspect()) + "]";
         },
         destructure: function(constraint, name, argnum) {
           return "" + (constraint.inspect()) + "/" + name + "[" + argnum + "]";
@@ -1609,11 +1636,11 @@ analyze = Gibbon.analyze = (function() {
         expr: function(e) {
           return e === other.expr;
         },
-        access: function(input, scope, accessor) {
+        query: function(input, scope, query) {
           if (scope !== other.scope) {
             return false;
           }
-          if (accessor !== other.accessor) {
+          if (query !== other.query) {
             return false;
           }
           return input.equals(other.input);
@@ -1623,7 +1650,7 @@ analyze = Gibbon.analyze = (function() {
         },
         param: function(name, constraints) {
           var constraint, i, _i, _len;
-          if (name !== other.name) {
+          if (name !== other.type) {
             return false;
           }
           for (i = _i = 0, _len = constraints.length; _i < _len; i = ++_i) {
@@ -1635,7 +1662,7 @@ analyze = Gibbon.analyze = (function() {
           return true;
         },
         destructure: function(constraint, name, argnum) {
-          if (name !== other.name) {
+          if (name !== other.type) {
             return false;
           }
           if (argnum !== other.argnum) {
@@ -1699,8 +1726,8 @@ analyze = Gibbon.analyze = (function() {
             return _results;
           })());
         },
-        access: function(input, scope, accessor) {
-          return TypeExpr.access(f(input), scope, accessor);
+        query: function(input, scope, query) {
+          return TypeExpr.query(f(input), scope, query);
         },
         destructure: function(constraint, name, argnum) {
           return TypeExpr.destructure(f(constraint), name, argnum);
@@ -1718,9 +1745,9 @@ analyze = Gibbon.analyze = (function() {
             return cb(TypeExpr.param(name, ps));
           });
         },
-        access: function(input, scope, accessor) {
+        query: function(input, scope, query) {
           return f(input, function(i) {
-            return cb(TypeExpr.access(i, scope, accessor));
+            return cb(TypeExpr.query(i, scope, query));
           });
         },
         destructure: function(param, name, argnum) {
@@ -1745,12 +1772,12 @@ analyze = Gibbon.analyze = (function() {
         this.externalLookup = externalLookup;
       }
 
-      NativeContext.prototype.lookup = function(id, name, cb) {
-        return this.externalLookup.call(null, id, name, function(err, response) {
+      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(id, name, response));
+          return cb(TypeLookup.response(analysis));
         });
       };
 
@@ -1776,17 +1803,17 @@ analyze = Gibbon.analyze = (function() {
         return new Scope(this, this.breadcrumbs.concat([name]), frame, this.context);
       };
 
-      Scope.prototype.lookup = function(nativeId, name, cb) {
+      Scope.prototype.lookup = function(nativeId, query, cb) {
         var lexical;
-        if (nativeId === this.context.globalID) {
-          lexical = this.lexicalLookup(name);
+        if (query.type === 'access' && nativeId === this.context.globalID) {
+          lexical = this.lexicalLookup(query.name);
           if (lexical) {
             return cb(lexical);
           } else {
-            return this.context.lookup(nativeId, name, cb);
+            return this.context.query(nativeId, query, cb);
           }
         } else {
-          return this.context.lookup(nativeId, name, cb);
+          return this.context.query(nativeId, query, cb);
         }
       };
 
@@ -1843,10 +1870,10 @@ analyze = Gibbon.analyze = (function() {
           this.analyzeFlow(flow.tail, global, push);
         }
         return flow.head.cases({
-          accessor: function(name) {
+          query: function() {
             var input;
             input = flow.tail ? TypeExpr.expr(flow.tail) : global;
-            return push(TypeExpr.expr(flow), TypeExpr.access(input, _this, flow.head));
+            return push(TypeExpr.expr(flow), TypeExpr.query(input, _this, flow.head));
           },
           pair: function(first, second) {
             _this.analyzeFlow(first, global, push);
@@ -1934,7 +1961,7 @@ analyze = Gibbon.analyze = (function() {
     };
   })();
   solve = (function() {
-    var TypeError, consume, logConstraint, _ref4;
+    var TypeError, consume, _ref4;
     TypeError = (function(_super) {
       __extends(TypeError, _super);
 
@@ -1954,9 +1981,7 @@ analyze = Gibbon.analyze = (function() {
       return TypeError;
 
     })(Union);
-    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) {
@@ -1982,21 +2007,18 @@ analyze = Gibbon.analyze = (function() {
       frameTypes = new Hash;
       locks = new Hash;
       solveEntry = function(crumbs, solved) {
-        var constraints, dependencies, done, error, frame, fullSubstitute, key, lhs, nextCrumbs, rhs, semanticAccessors, simplify, substitute, _i, _len, _ref5, _ref6;
+        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;
-        console.log('locking', key);
+        
         locks.set(key, true);
         semanticAccessors = new CompMap;
         dependencies = [];
-        for (_i = 0, _len = constraints.length; _i < _len; _i++) {
-          _ref6 = constraints[_i], lhs = _ref6[0], rhs = _ref6[1];
-          logConstraint('-> ', lhs, rhs);
-        }
+        
         substitute = function(texpr, cb) {
           return solutions.fetchAsync(texpr, (function() {
             return texpr.mapAsync(substitute, cb);
@@ -2005,9 +2027,7 @@ analyze = Gibbon.analyze = (function() {
         fullSubstitute = function(texpr, cb) {
           return substitute(texpr, function(substituted) {
             return simplify(substituted, function(result) {
-              if (!texpr.equals(result)) {
-                logConstraint('%> ', texpr, result);
-              }
+              
               return cb(result);
             });
           });
@@ -2038,22 +2058,21 @@ analyze = Gibbon.analyze = (function() {
                 }));
               });
             },
-            access: function(input, scope, accessor) {
+            query: function(input, scope, query) {
               return simplify(input, function(x) {
                 return x.cases({
                   "native": function(id) {
-                    accessor.source = id;
-                    return scope.lookup(id, accessor.name, function(lookup) {
+                    return scope.lookup(id, query, function(lookup) {
                       dependencies.push(lookup);
                       return lookup.cases({
-                        response: function(_, __, response) {
-                          semanticAccessors.set(accessor, Semantic.accessor(response.annotations));
-                          return cb(TypeExpr.fromAST(Gibbon.parse.unitType(response.type)));
+                        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(accessor, Semantic.localAccessor(key));
+                          semanticAccessors.set(query, Semantic.localAccessor(key));
                           if (locks.get(key)) {
                             return cb(error('circular', nextCrumbs));
                           }
@@ -2092,19 +2111,17 @@ analyze = Gibbon.analyze = (function() {
               flow: function(head, tail) {
                 return Semantic.flow(flowType(this), toSemanticTree(head), tail && toSemanticTree(tail));
               },
-              accessor: function(name) {
-                if (!semanticAccessors.has(this)) {
-                  debugger;
-                }
+              query: function(type, name) {
+                
                 return semanticAccessors.get(this);
               },
               func: function(name, args) {
                 var a;
                 return Semantic.func(name, (function() {
-                  var _j, _len1, _results;
+                  var _i, _len, _results;
                   _results = [];
-                  for (_j = 0, _len1 = args.length; _j < _len1; _j++) {
-                    a = args[_j];
+                  for (_i = 0, _len = args.length; _i < _len; _i++) {
+                    a = args[_i];
                     _results.push(toSemanticTree(a));
                   }
                   return _results;
@@ -2119,10 +2136,10 @@ analyze = Gibbon.analyze = (function() {
               list: function(elements) {
                 var e;
                 return Semantic.list((function() {
-                  var _j, _len1, _results;
+                  var _i, _len, _results;
                   _results = [];
-                  for (_j = 0, _len1 = elements.length; _j < _len1; _j++) {
-                    e = elements[_j];
+                  for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                    e = elements[_i];
                     _results.push(toSemanticTree(e));
                   }
                   return _results;
@@ -2145,19 +2162,17 @@ analyze = Gibbon.analyze = (function() {
               }
             });
           };
-          solutions.each(function(k, v) {
-            return logConstraint('=> ', k, v);
-          });
-          console.log('setting key: ' + key);
+          
+          
           semantics.set(key, toSemanticTree(frame));
           frameTypes.set(key, solutions.get(TypeExpr.expr(frame.flow)));
-          console.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;
-          logConstraint(':> ', lhs, rhs);
+          
           if (lhs.equals(rhs)) {
             return next();
           }
@@ -2168,7 +2183,7 @@ analyze = Gibbon.analyze = (function() {
                 push(solutions.get(lhs), rhs);
                 return next();
               } else {
-                logConstraint('>> ', lhs, rhs);
+                
                 solutions.set(lhs, rhs);
                 mapper = function(k, texpr, cb) {
                   return fullSubstitute(texpr, (function(s) {
@@ -2181,7 +2196,7 @@ analyze = Gibbon.analyze = (function() {
             });
           };
           log = function() {
-            logConstraint('?> ', lhs, rhs);
+            
             return next();
           };
           skip = function() {
@@ -2199,7 +2214,7 @@ analyze = Gibbon.analyze = (function() {
             expr: solveFor,
             variable: solveFor,
             any: skip,
-            access: function() {
+            query: function() {
               return rhs.cases({
                 expr: swap,
                 variable: swap,
@@ -2224,23 +2239,23 @@ analyze = Gibbon.analyze = (function() {
             param: function() {
               return rhs.cases({
                 param: function() {
-                  var constraint, i, _j, _len1, _ref7;
+                  var constraint, i, _i, _len, _ref6;
                   if (lhs.name !== rhs.name) {
                     return matchError();
                   }
-                  _ref7 = lhs.constraints;
-                  for (i = _j = 0, _len1 = _ref7.length; _j < _len1; i = ++_j) {
-                    constraint = _ref7[i];
+                  _ref6 = lhs.constraints;
+                  for (i = _i = 0, _len = _ref6.length; _i < _len; i = ++_i) {
+                    constraint = _ref6[i];
                     push(constraint, rhs.constraints[i]);
                   }
                   return next();
                 },
-                access: function() {
-                  var c, i, _j, _len1, _ref7;
-                  _ref7 = lhs.constraints;
-                  for (i = _j = 0, _len1 = _ref7.length; _j < _len1; i = ++_j) {
-                    c = _ref7[i];
-                    push(c, TypeExpr.destructure(rhs, lhs.name, i));
+                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();
                 },
@@ -2263,7 +2278,7 @@ analyze = Gibbon.analyze = (function() {
         }
         return _results;
       })();
-      console.log('initial crumbs', initialCrumbs);
+      
       return contMap(initialCrumbs, solveEntry, function() {
         if (errors.length === 0) {
           errors = null;
@@ -2277,9 +2292,9 @@ analyze = Gibbon.analyze = (function() {
     if (!(program instanceof AST)) {
       program = AST.fromJSON(program);
     }
-    console.log();
-    console.log(program.inspect());
-    constraints = generate(globalID, external.getType, program);
+    
+    
+    constraints = generate(globalID, external.analyzeQuery, program);
     return solve(constraints, cb);
   };
 })();
@@ -2447,6 +2462,45 @@ Value = Gibbon.Value = Value = (function(_super) {
     });
   };
 
+  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);
@@ -2604,7 +2658,7 @@ Dependency = (function(_super) {
   }
 
   Dependency.types({
-    lookup: ['entity', 'accessor'],
+    query: ['entity', 'query'],
     lexical: ['key']
   });
 
@@ -2613,11 +2667,11 @@ Dependency = (function(_super) {
       return false;
     }
     return this.cases({
-      lookup: function(entity, accessor) {
+      query: function(entity, query) {
         if (entity.id !== other.entity.id) {
           return false;
         }
-        if (accessor.name !== other.accessor.name) {
+        if (query.annotations !== other.query.annotations) {
           return false;
         }
         return true;
@@ -2630,8 +2684,8 @@ Dependency = (function(_super) {
 
   Dependency.prototype.inspect = function() {
     return this.cases({
-      lookup: function(entity, accessor) {
-        return "" + (accessor.inspect()) + "<" + entity.id + ">";
+      lookup: function(entity, query) {
+        return "" + (query.inspect()) + "<" + entity.id + ">";
       },
       lexical: function(definition) {
         return "@" + definition.name;
@@ -2644,85 +2698,38 @@ Dependency = (function(_super) {
 })(Union);
 
 eval_ = Gibbon["eval"] = (function() {
-  var Context, Scope, evalAll;
-  Context = (function() {
-    var CACHE;
-
-    CACHE = new Hash;
-
-    function Context(global, client) {
-      this.global = global;
-      this.client = client;
-      this.globalPromise = Promise.unit(this.global);
-    }
-
-    Context.prototype.lookup = function(entity, accessor) {
-      var annotations, id,
-        _this = this;
-      annotations = accessor.annotations;
-      id = entity.id;
-      return CACHE.cache("" + id + "/" + (JSON.stringify(annotations)), function() {
-        return new Promise(function(fail, cc) {
-          return _this.client.getValue(id, annotations, function(err, val) {
-            var dependency;
-            if (err) {
-              return fail(err);
-            }
-            dependency = Dependency.lookup(entity, accessor);
-            return Value.fromJSON(val).promise().depends([dependency]);
-          });
-        });
-      });
-    };
-
-    return Context;
-
-  })();
-  Scope = (function() {
-    Scope.global = function(context) {
-      return new Scope(null, [], context);
-    };
-
-    function Scope(parent, definitions, context) {
-      var def, _i, _len, _ref2;
-      this.parent = parent;
-      this.definitions = definitions;
-      this.context = context;
-      this.bindings = new Hash;
-      _ref2 = this.definitions;
-      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-        def = _ref2[_i];
-        this.setupBinding(def);
-      }
-    }
-
-    Scope.prototype.setupBinding = function(def) {};
-
-    Scope.prototype.extend = function(definitions) {
-      return new Scope(this, definitions, this.context);
-    };
-
-    Scope.prototype.allResults = function() {};
-
-    return Scope;
-
-  })();
+  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({
-        accessor: function(annotations) {
+        query: function(annotations) {
           return input.then(function(entity) {
             var _this = this;
             return new Promise(function(fail, cc) {
-              return client.getValue(entity.id, annotations, function(err, val) {
+              return client.performQuery(entity.id, annotations, function(err, val) {
                 var dependency;
                 if (err) {
                   return fail(err);
                 }
-                dependency = Dependency.lookup(entity, flow.head);
+                dependency = Dependency.query(entity, flow.head);
                 return Value.fromJSON(val).promise().depends([dependency]).force(fail, cc);
               });
             });
@@ -2788,19 +2795,6 @@ eval_ = Gibbon["eval"] = (function() {
         }
       });
     };
-    resultThunks = new Hash;
-    results = new Hash;
-    globalPromise = Promise.unit(entity);
-    semantics.each(function(key, definition) {
-      return resultThunks.set(key, Promise.lazy(function() {
-        return evalFlow(definition.flow, globalPromise).after(function(val, deps) {
-          deps = uniq(deps, function(x, y) {
-            return x.equals(y);
-          });
-          return results.set(key, [val, deps]);
-        });
-      }));
-    });
     return new Promise(function(fail, cc) {
       return Promise.combine(resultThunks.values()).force(fail, function(_, deps) {
         return cc(results, deps);
@@ -2832,41 +2826,54 @@ eval_ = Gibbon["eval"] = (function() {
 // Generated by CoffeeScript 1.6.3
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
-    return {
-      getType: function(id, accessorName, callback) {
-        var fields;
-        if (!tables.hasOwnProperty(id)) {
-          return callback(new Error("no such type " + type));
+    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
         }
-        fields = tables[id].fields;
-        if (!fields.hasOwnProperty(accessorName)) {
-          return callback(new Error("" + type + " has no field " + accessorName));
+      });
+    };
+    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 + "'"));
         }
-        return callback(null, {
-          type: 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]);
+      performQuery: function(id, annotations, callback) {
+        return getValue(id, annotations, callback);
       }
     };
   };
 })();
   return Gibbon;
 })();
+