goodguide-gibbon 0.4.2 → 0.5.0

data/lib/goodguide/gibbon.rb

@@ -9,22 +9,46 @@ module GoodGuide
       def hash_to_ruby(js_hash)
         return nil unless js_hash
 
-        ruby_hash = {}
-        iterator = lambda { |this, k, v|
-          ruby_hash[k] = obj_to_ruby(v)
-        }
+        ruby_hash = { '__isHash__' => true }
 
-        js_hash[:each].methodcall js_hash, iterator
+        js_hash[:each].methodcall(js_hash, lambda { |this, k, v|
+          ruby_hash[k] = obj_to_ruby(v)
+        })
 
         ruby_hash
       end
 
-      def hash_to_js(ruby_hash)
-        js_hash = gibbon[:Hash].new
-        ruby_hash.each do |k, v|
-          js_hash.set(k, v)
+      def obj_to_js(o)
+        case o
+        when Array
+          o.map { |x| obj_to_js(x) }
+        when Hash
+          if o['__isHash__'] or o[:__isHash__]
+            js_hash = gibbon[:Hash].new
+            o.each do |k, v|
+              next if k.to_s == '__isHash__'
+              js_hash.set(k, obj_to_js(v))
+            end
+            js_hash
+          elsif o['_union'] or o[:_union]
+            union = o['_union'] or o[:_union]
+            tag = o['_tag'] or o[:_tag]
+            constructor = gibbon[union]
+            raise "unknown union #{union}" unless constructor && constructor.tags
+            names = constructor.tags[tag]
+            raise "unknown tag #{tag}" unless names.is_a? V8::Array
+
+            vals = names.map do |name|
+              obj_to_js(o[name])
+            end
+
+            constructor[tag].methodcall(constructor, *vals)
+          else
+            o
+          end
+        else
+          o
         end
-        js_hash
       end
 
       def obj_to_ruby(o)
@@ -32,13 +56,17 @@ module GoodGuide
         when V8::Array
           o.map { |x| obj_to_ruby(x) }
         when V8::Object
-          o = o.asJSON if o.respond_to? :asJSON
-
-          out = {}
-          o.each do |k, v|
-            out[k] = obj_to_ruby(v)
+          if o[:__isHash__]
+            hash_to_ruby(o)
+          else
+            o = o.asJSON if o.respond_to? :asJSON
+
+            out = {}
+            o.each do |k, v|
+              out[k] = obj_to_ruby(v)
+            end
+            out
           end
-          out
         else
           o
         end
@@ -160,10 +188,7 @@ module GoodGuide
       end
 
       def call(runtime_client, entity_id)
-        # TODO
-        context = Context.new
-
-        values, error = context.eval_gibbon(
+        values, error = @context.eval_gibbon(
           self.semantics, entity_id, runtime_client.to_js
         )
 
@@ -273,6 +298,7 @@ module GoodGuide
           js = JS.new(js)
         end
 
+        @defer = js[:setTimeout]
         @gibbon = js.gibbon
       end
 
@@ -281,6 +307,8 @@ module GoodGuide
       end
 
       def analyze(syntax, global_table, static_client)
+        syntax = obj_to_js(syntax)
+
         semantics, error = capture do |&callback|
           gibbon.analyze(syntax, global_table, static_client, callback)
         end
@@ -289,7 +317,7 @@ module GoodGuide
       end
 
       def eval_gibbon(semantics, id, runtime_client)
-        semantics = hash_to_js(semantics)
+        semantics = obj_to_js(semantics)
         values, error = capture do |&callback|
           gibbon.eval(semantics, 0, id, runtime_client, callback)
         end
@@ -307,7 +335,6 @@ module GoodGuide
 
         [output, error]
       end
-
     end
 
     class JS < V8::Context

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.4.2'
+      '0.5.0'
     end
   end
 end

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

@@ -388,6 +388,10 @@ DEBUG.assert = function(msg, cond) {
   }
 };
 
+DEBUG.getStackSize = function() {
+  return (new Error).stack.match(/\n/g).length;
+};
+
 isArray = Array.isArray || function(arg) {
   return Object.prototype.toString.call(arg) === '[object Array]';
 };
@@ -448,8 +452,9 @@ asyncMap = function(list, mapper, cb) {
       seen += 1;
       output[i] = el;
       if (seen >= list.length) {
-        return cb(output);
+        cb(output);
       }
+      return null;
     };
   };
   _results = [];
@@ -705,6 +710,8 @@ Gibbon.Hash = Hash = (function(_super) {
     return _ref;
   }
 
+  Hash.prototype.__isHash__ = true;
+
   salt = '<key>';
 
   Hash.prototype.loadKey = function(k) {
@@ -1287,7 +1294,7 @@ Gibbon.Semantic = Semantic = (function(_super) {
     block: ['body'],
     list: ['elements', 'squish'],
     flow: ['type', 'head', 'tail'],
-    func: ['name', 'args'],
+    func: ['name', 'args', 'scope'],
     subst: ['flow'],
     defaulted: ['body', 'alternative']
   });
@@ -1722,6 +1729,7 @@ analyze = Gibbon.analyze = (function() {
             func = stdlib[name];
             ast = func.type;
             scope = new Hash;
+            flow.head.__scope__ = scope;
             input = TypeExpr.fromAST(ast.input, scope);
             if (flow.tail) {
               push(TypeExpr.expr(flow.tail), input);
@@ -1961,13 +1969,13 @@ analyze = Gibbon.analyze = (function() {
         done = function() {
           var flowType, toSemanticTree;
           flowType = function(expr) {
-            if (!solutions.has(TypeExpr.expr(expr))) {
+            if (!solutions.has(expr)) {
               if (errors.length === 0) {
                 throw new Error('unsolved!');
               }
               return Type.abstract(TypeExpr.expr(expr));
             }
-            return solutions.get(TypeExpr.expr(expr)).realize();
+            return solutions.get(expr).realize();
           };
           toSemanticTree = function(expr) {
             return expr.cases({
@@ -1975,7 +1983,7 @@ analyze = Gibbon.analyze = (function() {
                 return Semantic.definition(dependencies, toSemanticTree(flow));
               },
               flow: function(head, tail) {
-                return Semantic.flow(flowType(this), toSemanticTree(head), tail && toSemanticTree(tail));
+                return Semantic.flow(flowType(TypeExpr.expr(this)), toSemanticTree(head), tail && toSemanticTree(tail));
               },
               query: function(type, name) {
                 var _this = this;
@@ -1987,8 +1995,13 @@ analyze = Gibbon.analyze = (function() {
                 return semanticAccessors.get(this);
               },
               func: function(name, args) {
-                var a;
-                return Semantic.func(name, (function() {
+                var a, scope, semArgs, solvedScope;
+                scope = this.__scope__;
+                solvedScope = new Hash;
+                scope && scope.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++) {
@@ -1996,7 +2009,8 @@ analyze = Gibbon.analyze = (function() {
                     _results.push(toSemanticTree(a));
                   }
                   return _results;
-                })());
+                })();
+                return Semantic.func(name, semArgs, solvedScope);
               },
               pair: function(first, second) {
                 return Semantic.pair(toSemanticTree(first), toSemanticTree(second));
@@ -2173,9 +2187,6 @@ analyze = Gibbon.analyze = (function() {
   })();
   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);
@@ -2183,14 +2194,11 @@ analyze = Gibbon.analyze = (function() {
   };
 })();
 // Generated by CoffeeScript 1.6.3
-var Dependency, Failure, Promise, Value, eval_, _ref, _ref1, _ref2,
+var CachingPromise, Dependency, Failure, Promise, Thunk, UnitPromise, Value, eval_, _ref, _ref1, _ref2, _ref3,
   __hasProp = {}.hasOwnProperty,
-  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
-  __slice = [].slice;
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
 
 Value = Gibbon.Value = Value = (function(_super) {
-  var thunksAreEqual;
-
   __extends(Value, _super);
 
   function Value() {
@@ -2245,37 +2253,6 @@ Value = Gibbon.Value = Value = (function(_super) {
     }));
   };
 
-  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) {
@@ -2326,26 +2303,6 @@ Value = Gibbon.Value = Value = (function(_super) {
     });
   };
 
-  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) {
@@ -2391,16 +2348,47 @@ Value = Gibbon.Value = Value = (function(_super) {
 
 })(Union);
 
+Thunk = (function() {
+  Thunk.trampoline = function(t) {
+    while (t instanceof Thunk) {
+      t = t.run();
+    }
+    return t;
+  };
+
+  function Thunk(run) {
+    this.run = run;
+  }
+
+  return Thunk;
+
+})();
+
 Promise = (function() {
-  function Promise(force) {
-    this.force = force;
+  function Promise(forceRaw) {
+    this.forceRaw = forceRaw;
   }
 
+  Promise.prototype.force = function(fail, cc) {
+    return Thunk.trampoline(this.forceRaw(fail, cc));
+  };
+
+  Promise.prototype.step = function(fail, cc) {
+    var _this = this;
+    return new Thunk(function() {
+      return _this.forceRaw(fail, cc);
+    });
+  };
+
   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);
+      return _this.step(fail, function(val, deps) {
+        var next;
+        next = fn(val, deps).depends(deps);
+        return new Thunk(function() {
+          return next.forceRaw(fail, cb);
+        });
       });
     });
   };
@@ -2410,9 +2398,11 @@ Promise = (function() {
     return new Promise(function(fail, cb) {
       var rescue;
       rescue = function(failure) {
-        return fn(failure).depends([Dependency.failure(failure)]).force(fail, cb);
+        var rescuer;
+        rescuer = fn(failure).depends([Dependency.failure(failure)]);
+        return rescuer.step(fail, cb);
       };
-      return _this.force(rescue, cb);
+      return _this.step(rescue, cb);
     });
   };
 
@@ -2422,67 +2412,95 @@ Promise = (function() {
     });
   };
 
-  Promise.prototype.depends = function(deps) {
+  Promise.prototype.mapDeps = function(f) {
     var _this = this;
     return new Promise(function(fail, cc) {
-      return _this.force(fail, function(val, prevDeps) {
-        return cc(val, prevDeps.concat(deps));
+      return _this.step(fail, function(val, deps) {
+        return new Thunk(function() {
+          return cc(val, f(deps));
+        });
       });
     });
   };
 
-  Promise.prototype.map = function(f) {
-    return this.then(function(v, d) {
-      return Promise.unit(f(v, d));
+  Promise.prototype.depends = function(deps) {
+    if (deps.length === 0) {
+      return this;
+    }
+    return this.mapDeps(function(prevDeps) {
+      return prevDeps.concat(deps);
     });
   };
 
-  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.dependsOnly = function(deps) {
+    return this.mapDeps(function() {
+      return deps;
+    });
+  };
+
+  Promise.prototype.map = function(f) {
+    return this.then(function(v, d) {
+      return Promise.unit(f(v, d));
     });
   };
 
   Promise.prototype.after = function(f) {
     var _this = this;
     return new Promise(function(fail, cc) {
-      return _this.force(fail, function(val, deps) {
+      return _this.step(fail, function(val, deps) {
         f(val, deps);
-        return cc(val, deps);
+        return new Thunk(function() {
+          return cc(val, deps);
+        });
       });
     });
   };
 
   Promise.unit = function(e) {
-    return new Promise(function(_, f) {
-      return f(e, []);
+    return new UnitPromise(function(_, cc) {
+      return new Thunk(function() {
+        return cc(e, []);
+      });
     });
   };
 
   Promise.fail = function(fail) {
     return new Promise(function(f, _) {
-      return f(fail);
+      return new Thunk(function() {
+        return f(fail);
+      });
     });
   };
 
   Promise.lazy = function(f) {
     return new Promise(function(fail, cc) {
-      return f().force(fail, cc);
+      return f().step(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) {
+  Promise.prototype.cache = function() {
+    return new CachingPromise(this.forceRaw);
+  };
+
+  Promise.combine = function(promises) {
+    if (promises.length === 0) {
+      return Promise.unit([]);
+    }
+    if (promises.length === 1) {
+      return promises[0].map(function(t) {
+        return [t];
+      });
+    }
+    return new Promise(function(fail, cc) {
+      var isSynchronous, mapper, outThunk;
+      isSynchronous = true;
+      outThunk = null;
+      mapper = function(promise, push) {
+        return promise.force(fail, function(val, deps) {
           return push([val, deps]);
         });
       };
-      return asyncMap(thunks, mapper, function(vals) {
+      asyncMap(promises, mapper, function(vals) {
         var outDeps, outVal, v;
         outVal = (function() {
           var _i, _len, _results;
@@ -2502,41 +2520,86 @@ Promise = (function() {
           }
           return _results;
         })());
-        return cb(outVal, outDeps);
+        if (isSynchronous) {
+          return outThunk = new Thunk(function() {
+            return cc(outVal, outDeps);
+          });
+        } else {
+          return Thunk.trampoline(cc(outVal, outDeps));
+        }
       });
+      isSynchronous = false;
+      return outThunk;
     });
   };
 
-  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 Promise;
+
+})();
+
+UnitPromise = (function(_super) {
+  __extends(UnitPromise, _super);
+
+  function UnitPromise() {
+    _ref1 = UnitPromise.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  UnitPromise.prototype.cache = function() {
+    return this;
+  };
+
+  return UnitPromise;
+
+})(Promise);
+
+CachingPromise = (function(_super) {
+  __extends(CachingPromise, _super);
+
+  function CachingPromise(uncached) {
+    var _this = this;
+    this.forceRaw = function(fail, cc) {
+      var cacheCC, cacheFail;
+      cacheFail = function(failure) {
+        return (_this.forceRaw = function(f, _) {
+          return new Thunk(function() {
+            return f(failure);
+          });
+        })(fail, cc);
+      };
+      cacheCC = function(val, deps) {
+        return (_this.forceRaw = function(_, s) {
+          return new Thunk(function() {
+            return s(val, deps);
+          });
+        })(fail, cc);
+      };
+      return new Thunk(function() {
+        return uncached(cacheFail, cacheCC);
       });
     };
-    return _loop(0);
+  }
+
+  CachingPromise.prototype.cache = function() {
+    return this;
   };
 
-  return Promise;
+  return CachingPromise;
 
-})();
+})(Promise);
 
 Gibbon.Failure = Failure = (function(_super) {
   __extends(Failure, _super);
 
   function Failure() {
-    _ref1 = Failure.__super__.constructor.apply(this, arguments);
-    return _ref1;
+    _ref2 = Failure.__super__.constructor.apply(this, arguments);
+    return _ref2;
   }
 
   Failure.types({
     query: ['id', 'annotations'],
-    composite: ['failures']
+    composite: ['failures'],
+    message: ['message']
   });
 
   Failure.prototype.equals = function(other) {
@@ -2552,6 +2615,9 @@ Gibbon.Failure = Failure = (function(_super) {
           return false;
         }
       },
+      message: function(m) {
+        return m === other.message;
+      },
       composite: function(failures) {
         var failure, i, _i, _len;
         for (i = _i = 0, _len = failures.length; _i < _len; i = ++_i) {
@@ -2573,8 +2639,8 @@ Gibbon.Dependency = Dependency = (function(_super) {
   __extends(Dependency, _super);
 
   function Dependency() {
-    _ref2 = Dependency.__super__.constructor.apply(this, arguments);
-    return _ref2;
+    _ref3 = Dependency.__super__.constructor.apply(this, arguments);
+    return _ref3;
   }
 
   Dependency.types({
@@ -2625,148 +2691,386 @@ Gibbon.Dependency = Dependency = (function(_super) {
 })(Union);
 
 eval_ = Gibbon["eval"] = (function() {
-  var evalAll;
-  evalAll = function(semantics, entity, client) {
-    var evalFlow, globalPromise, resultThunks, results, toForce;
-    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();
+  var Context, Scope, combine, unit, vFalse, vTrue;
+  unit = Promise.unit, combine = Promise.combine;
+  vTrue = Value.boolean(true);
+  vFalse = Value.boolean(false);
+  Context = (function() {
+    function Context(client, entity, definitions) {
+      this.client = client;
+      this.entity = entity;
+      this.definitions = definitions;
+      this.rootScope = Scope.global(entity, this);
+      this.definitionBindings = new Hash;
+    }
+
+    Context.prototype.evalAll = function() {
+      var results, toForce,
+        _this = this;
+      this.definitions.each(function(key, ir) {
+        var lazy;
+        lazy = Promise.lazy(function() {
+          return _this.rootScope["eval"](ir).then(function(x) {
+            return x.resolve();
+          });
         });
-      }));
-    });
-    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, Gibbon.Value, function(err, val) {
-                var dependency;
-                if (err) {
-                  return fail(err);
-                }
-                dependency = Dependency.query(entity, flow.head);
-                return val.promise().depends([dependency]).force(fail, cc);
-              });
-            });
+        return _this.definitionBindings.set(key, lazy.cache());
+      });
+      toForce = [];
+      results = new Hash;
+      this.definitionBindings.each(function(key, promise) {
+        return toForce.push(promise.after(function(val, deps) {
+          deps = uniq(deps, function(x, y) {
+            return x.equals(y);
           });
+          return results.set(key, [val, deps]);
+        }).rescue(function(failure) {
+          results.set(key, [null, [Dependency.failure(failure)]]);
+          return Promise.unit(null);
+        }));
+      });
+      return combine(toForce).then(function() {
+        var deps, val, _ref4;
+        _ref4 = results.get('/'), val = _ref4[0], deps = _ref4[1];
+        if (val) {
+          return Promise.unit(results);
+        } else {
+          return Promise.fail(deps[0].failure);
+        }
+      });
+    };
+
+    Context.prototype.lookup = function(key) {
+      return this.definitionBindings.get(key).dependsOnly([Dependency.lexical(key)]);
+    };
+
+    Context.prototype.performQuery = function(id, annotations) {
+      var _this = this;
+      return new Promise(function(fail, cc) {
+        var isSynchronous, out;
+        isSynchronous = true;
+        out = null;
+        _this.client.performQuery(id, annotations, Value, function(err, data) {
+          var result;
+          if (err) {
+            return (out = fail(err));
+          }
+          result = data.promise().depends([Dependency.query(id, annotations)]);
+          if (isSynchronous) {
+            return out = result.step(fail, cc);
+          } else {
+            return result.force(fail, cc);
+          }
+        });
+        isSynchronous = false;
+        return out;
+      });
+    };
+
+    return Context;
+
+  })();
+  Scope = (function() {
+    var EXTERN, OPERATORS;
+
+    function Scope(bindings, context, parent) {
+      this.bindings = bindings;
+      this.context = context;
+      this.parent = parent;
+    }
+
+    Scope.global = function(entity, context) {
+      return new Scope(new Hash, context, null)["let"]([['@', unit(entity)]]);
+    };
+
+    Scope.prototype.extend = function(b) {
+      if (b == null) {
+        b = new Hash;
+      }
+      return new Scope(b, this.context, this);
+    };
+
+    Scope.prototype["let"] = function(bindings) {
+      var ext, k, v, _i, _len, _ref4;
+      ext = new Hash;
+      for (_i = 0, _len = bindings.length; _i < _len; _i++) {
+        _ref4 = bindings[_i], k = _ref4[0], v = _ref4[1];
+        ext.set(k, v.cache());
+      }
+      return this.extend(ext);
+    };
+
+    OPERATORS = {
+      '+': function(x, y) {
+        return Value.number(x + y);
+      },
+      '*': function(x, y) {
+        return Value.number(x * y);
+      },
+      '/': function(x, y) {
+        return Value.number(x / y);
+      },
+      '<': function(x, y) {
+        return Value.boolean(x < y);
+      },
+      '>': function(x, y) {
+        return Value.boolean(x > y);
+      },
+      '<=': function(x, y) {
+        return Value.boolean(x <= y);
+      },
+      '>=': function(x, y) {
+        return Value.boolean(x >= y);
+      },
+      '===': function(x, y) {
+        return Value.boolean(x === y);
+      }
+    };
+
+    EXTERN = {
+      '-': function(x) {
+        return Value.number(-x);
+      },
+      '!': function(x) {
+        return Value.boolean(!x);
+      }
+    };
+
+    Scope.prototype.get = function(v) {
+      if (this.bindings.has(v)) {
+        return this.bindings.get(v);
+      } else if (this.parent) {
+        return this.parent.get(v);
+      } else {
+        throw "no such variable: " + v;
+      }
+    };
+
+    Scope.prototype.force = function(varName) {
+      return this.get(varName);
+    };
+
+    Scope.prototype["eval"] = function(ir) {
+      var _this = this;
+      return ir.cases({
+        global: function() {
+          return _this.get('@');
         },
-        localAccessor: function(key) {
-          return new Promise(function(fail, cc) {
-            return resultThunks.get(key).force(fail, function(val, otherDeps) {
-              return cc(val, [Dependency.lexical(key)]);
-            });
-          });
+        constant: function(value) {
+          return unit(Value.fromJSON(value));
         },
-        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)));
+        variable: function(name) {
+          return _this.get(name);
         },
-        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));
+        branch: function(cond, ifTrue, ifFalse) {
+          return _this["eval"](cond).then(function(c) {
+            if (c.value) {
+              return _this["eval"](ifTrue);
+            } else {
+              return _this["eval"](ifFalse);
             }
           });
         },
-        pair: function(first, second) {
-          var eFirst, eSecond;
-          eFirst = evalFlow(first, global);
-          eSecond = evalFlow(second, global);
-          return Promise.unit(Value.pair(eFirst, eSecond));
+        bind: function(name, val, expr) {
+          return _this["eval"](val).then(function(v) {
+            return _this["let"]([[name, v]])["eval"](expr);
+          });
+        },
+        delist: function(expr, index) {
+          var evaled;
+          evaled = [_this["eval"](expr), _this["eval"](index)];
+          return combine(evaled).then(function(_arg) {
+            var elements, value, _ref4, _ref5;
+            (_ref4 = _arg[0], elements = _ref4.elements), (_ref5 = _arg[1], value = _ref5.value);
+            return elements[value];
+          });
+        },
+        depair: function(expr, key) {
+          return _this["eval"](expr).then(function(v) {
+            return v[key];
+          });
         },
-        list: function(elements, squished) {
-          var e, list;
-          list = Promise.unit(Value.list((function() {
+        list: function(elements) {
+          var e;
+          return unit(Value.list((function() {
             var _i, _len, _results;
             _results = [];
             for (_i = 0, _len = elements.length; _i < _len; _i++) {
               e = elements[_i];
-              _results.push(evalFlow(e, global));
+              _results.push(this["eval"](e));
             }
             return _results;
-          })()));
-          if (squished) {
-            return stdlib.squish.impl(list);
-          } else {
-            return list;
-          }
+          }).call(_this)));
+        },
+        foldList: function(list, out, arg, accumArg, idxArg, body) {
+          return _this["eval"](list).then(function(_arg) {
+            var elements, _loop;
+            elements = _arg.elements;
+            _loop = function(i) {
+              if (i >= elements.length) {
+                return _this["eval"](out);
+              }
+              return _this["let"]([[idxArg, unit(Value.number(i))], [arg, elements[i]], [accumArg, _loop(i + 1)]])["eval"](body);
+            };
+            return _loop(0);
+          });
+        },
+        mapList: function(list, arg, idxArg, body) {
+          return _this["eval"](list).then(function(_arg) {
+            var el, elements, i, mapped;
+            elements = _arg.elements;
+            mapped = (function() {
+              var _i, _len, _results;
+              _results = [];
+              for (i = _i = 0, _len = elements.length; _i < _len; i = ++_i) {
+                el = elements[i];
+                _results.push(this["let"]([[arg, el], [idxArg, unit(Value.number(i))]])["eval"](body));
+              }
+              return _results;
+            }).call(_this);
+            return unit(Value.list(mapped));
+          });
+        },
+        zipLists: function(firstExpr, secondExpr) {
+          var evaled;
+          evaled = [_this["eval"](firstExpr), _this["eval"](secondExpr)];
+          return combine(evaled).then(function(_arg) {
+            var el, first, i, pairs, second;
+            first = _arg[0], second = _arg[1];
+            pairs = (function() {
+              var _i, _len, _ref4, _results;
+              _ref4 = first.elements;
+              _results = [];
+              for (i = _i = 0, _len = _ref4.length; _i < _len; i = ++_i) {
+                el = _ref4[i];
+                _results.push(Value.pair(el, second.elements[i]));
+              }
+              return _results;
+            })();
+            return unit(Value.list(pairs));
+          });
+        },
+        filterList: function(listExpr, arg, body) {
+          return _this["eval"](listExpr).then(function(_arg) {
+            var el, elements, mapped;
+            elements = _arg.elements;
+            mapped = (function() {
+              var _i, _len, _results,
+                _this = this;
+              _results = [];
+              for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                el = elements[_i];
+                _results.push((function(el) {
+                  return _this["let"]([[arg, el]])["eval"](body).map(function(v) {
+                    if (v.value) {
+                      return [el];
+                    } else {
+                      return [];
+                    }
+                  });
+                })(el));
+              }
+              return _results;
+            }).call(_this);
+            return combine(mapped).map(function(mappedEls) {
+              return Value.list(catLists(mappedEls));
+            });
+          });
+        },
+        squishList: function(listExpr) {
+          return _this["eval"](listExpr).then(function(_arg) {
+            var elements, promise, wrapped;
+            elements = _arg.elements;
+            wrapped = (function() {
+              var _i, _len, _results,
+                _this = this;
+              _results = [];
+              for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                promise = elements[_i];
+                _results.push(promise.then(function(e) {
+                  return e.resolve().map(function(e) {
+                    return [e.promise()];
+                  });
+                }).or(unit([])));
+              }
+              return _results;
+            }).call(_this);
+            return combine(wrapped).map(function(lists) {
+              return Value.list(catLists(lists));
+            });
+          });
+        },
+        len: function(list) {
+          return _this["eval"](list).map(function(_arg) {
+            var elements;
+            elements = _arg.elements;
+            return Value.number(elements.length);
+          });
+        },
+        pair: function(first, second) {
+          return unit(Value.pair(_this["eval"](first), _this["eval"](second)));
         },
-        block: function(body) {
-          return Promise.unit(Value.block(function(inputPromise) {
-            return evalFlow(body, inputPromise);
+        block: function(name, body) {
+          return unit(Value.block(function(input) {
+            return _this["let"]([['@', input], [name, input]])["eval"](body);
           }));
         },
-        defaulted: function(body, alt) {
-          return evalFlow(body, global).or(evalFlow(alt, global));
+        app: function(block, arg) {
+          arg = _this["eval"](arg);
+          return _this["eval"](block).then(function(b) {
+            return b.fn(arg);
+          });
+        },
+        query: function(expr, annotations) {
+          return _this["eval"](expr).then(function(entity) {
+            return _this.context.performQuery(entity.id, annotations);
+          });
+        },
+        localQuery: function(key) {
+          return _this.context.lookup(key);
+        },
+        fail: function(message) {
+          return Promise.fail(Failure.message(message));
+        },
+        binop: function(op, lhs, rhs) {
+          return combine([_this["eval"](lhs), _this["eval"](rhs)]).map(function(_arg) {
+            var l, r;
+            l = _arg[0], r = _arg[1];
+            return OPERATORS[op](l.value, r.value);
+          });
+        },
+        extern: function(name, value) {
+          return _this["eval"](value).map(function(v) {
+            return EXTERN[name](v.value);
+          });
+        },
+        rescue: function(expr, default_) {
+          return _this["eval"](expr).or(_this["eval"](default_));
         }
       });
     };
-    toForce = [];
-    resultThunks.each(function(key, thunk) {
-      return toForce.push(thunk.rescue(function(failure) {
-        results.set(key, [null, [Dependency.failure(failure)]]);
-        resultThunks.set(key, Promise.fail(failure));
-        return Promise.unit(null);
-      }).after(function(val, deps) {
-        deps = uniq(deps, function(x, y) {
-          return x.equals(y);
-        });
-        return results.set(key, [val, deps]);
-      }));
-    });
-    return Promise.combine(toForce).map(function() {
-      return results;
-    });
-  };
+
+    return Scope;
+
+  })();
   return function(semantics, table, id, client, finish) {
-    var entity, key, onFailure, onSuccess, _i, _len, _ref3;
-    _ref3 = semantics.keys();
-    for (_i = 0, _len = _ref3.length; _i < _len; _i++) {
-      key = _ref3[_i];
-      semantics.modify(key, function(val) {
-        if (val instanceof Semantic) {
-          return val;
-        }
-        return Semantic.fromJSON(val);
-      });
-    }
+    var allCompiled, compile, entity, onFailure, onSuccess, optimize;
+    optimize = Gibbon.optimize, compile = Gibbon.compile;
+    allCompiled = new Hash;
+    semantics.each(function(key, semantic) {
+      var compiled;
+      compiled = optimize(compile(semantic));
+      return allCompiled.set(key, compiled);
+    });
     entity = Value.entity(table, id);
     onFailure = function(fail) {
       return finish(fail);
     };
     onSuccess = function(vals) {
-      var deps, val, _ref4;
-      _ref4 = vals.get('/'), val = _ref4[0], deps = _ref4[1];
-      if (val) {
-        return finish(null, vals);
-      } else {
-        return finish(deps[0].failure);
-      }
+      DEBUG.log("final stack size: " + (DEBUG.getStackSize()));
+      return finish(null, vals);
     };
-    return evalAll(semantics, entity, client).force(onFailure, onSuccess);
+    return new Context(client, entity, allCompiled).evalAll().force(onFailure, onSuccess);
   };
 })();
 // Generated by CoffeeScript 1.6.3
@@ -2803,7 +3107,7 @@ Gibbon.IR = IR = (function(_super) {
     block: ['name', 'body'],
     app: ['block', 'arg'],
     query: ['expr', 'annotations'],
-    localQuery: ['expr', 'key'],
+    localQuery: ['key'],
     fail: ['message'],
     binop: ['op', 'lhs', 'rhs'],
     extern: ['name', 'value'],
@@ -2830,10 +3134,6 @@ Gibbon.IR = IR = (function(_super) {
     return IR.query(this, annotations);
   };
 
-  IR.prototype.localQuery = function(key) {
-    return IR.localQuery(this, key);
-  };
-
   IR.prototype.binop = function(op, other) {
     return IR.binop(op, this, other);
   };
@@ -2854,12 +3154,57 @@ Gibbon.IR = IR = (function(_super) {
     return IR.len(this);
   };
 
-  IR.prototype.seq = function(name, f) {
-    name = nameGen(name);
-    return IR.bind(name, this, f(IR.variable(name)));
-  };
-
-  IR.prototype.mapList = function(f) {
+  IR.prototype.isAsync = function() {
+    return this.cases({
+      query: function() {
+        return true;
+      },
+      localQuery: function() {
+        return true;
+      },
+      other: function() {
+        var sub, _i, _len, _ref1;
+        _ref1 = this.subtrees();
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          sub = _ref1[_i];
+          if (sub.isAsync()) {
+            return true;
+          }
+        }
+        return false;
+      }
+    });
+  };
+
+  IR.prototype.isSimple = function() {
+    return this.cases({
+      variable: function() {
+        return true;
+      },
+      constant: function() {
+        return true;
+      },
+      global: function() {
+        return true;
+      },
+      binop: function(op, l, r) {
+        return l.isSimple() && r.isSimple();
+      },
+      extern: function(n, v) {
+        return v.isSimple();
+      },
+      other: function() {
+        return false;
+      }
+    });
+  };
+
+  IR.prototype.seq = function(name, f) {
+    name = nameGen(name);
+    return IR.bind(name, this, f(IR.variable(name)));
+  };
+
+  IR.prototype.mapList = function(f) {
     var elName, ixName;
     elName = nameGen('el');
     ixName = nameGen('i');
@@ -2919,7 +3264,6 @@ Gibbon.IR = IR = (function(_super) {
       },
       app: double,
       query: single,
-      localQuery: single,
       binop: function(op, l, r) {
         return [l, r];
       },
@@ -2983,9 +3327,6 @@ Gibbon.IR = IR = (function(_super) {
       query: function(e, a) {
         return IR.query(f(e), a);
       },
-      localQuery: function(e, k) {
-        return IR.localQuery(f(e), k);
-      },
       binop: function(o, l, r) {
         return IR.binop(o, f(l), f(r));
       },
@@ -3021,17 +3362,25 @@ Gibbon.IR = IR = (function(_super) {
       return false;
     }
     return this.cases({
+      global: function() {
+        return true;
+      },
+      constant: function(v) {
+        return v === other.value;
+      },
+      variable: function(name) {
+        return name === other.name;
+      },
       branch: function(cond, ifTrue, ifFalse) {
         return cond.equals(other.cond) && ifTrue.equals(other.ifTrue) && ifFalse.equals(other.ifFalse);
       },
       bind: function(name, val, expr) {
+        var subst;
         if (!val.equals(other.value)) {
           return false;
         }
-        return expr.equals(other.replace(IR.variable(other.name), IR.variable(name)));
-      },
-      variable: function(name) {
-        return name === other.name;
+        subst = other.expr.subst(other.name, IR.variable(name));
+        return expr.equals(subst);
       },
       delist: function(expr, index) {
         return expr.equals(other.expr) && index.equals(other.index);
@@ -3049,14 +3398,66 @@ Gibbon.IR = IR = (function(_super) {
         }
         return true;
       },
+      foldList: function(list, out, arg, accumArg, idxArg, body) {
+        var subst;
+        if (!list.equals(other.list)) {
+          return false;
+        }
+        if (!out.equals(other.out)) {
+          return false;
+        }
+        subst = other.body.subst(other.arg, IR.variable(arg)).subst(other.accumArg, IR.variable(accumArg)).subst(other.idxArg, IR.variable(idxArg));
+        return body.equals(subst);
+      },
+      mapList: function(list, arg, idxArg, body) {
+        var subst;
+        if (!list.equals(other.list)) {
+          return false;
+        }
+        subst = other.body.subst(other.arg, IR.variable(arg)).subst(other.idxArg, IR.variable(idxArg));
+        return body.equals(subst);
+      },
+      zipLists: function(first, second) {
+        return first.equals(other.first) && second.equals(other.second);
+      },
+      filterList: function(list, arg, body) {
+        if (!list.equals(other.list)) {
+          return false;
+        }
+        return body.equals(other.body.subst(other.arg, IR.variable(arg)));
+      },
+      squishList: function(list) {
+        return list.equals(other.list);
+      },
+      len: function(list) {
+        return list.equals(other.list);
+      },
       pair: function(x, y) {
         return x.equals(other.first) && y.equals(other.second);
       },
+      block: function(name, body) {
+        return false;
+      },
+      app: function(block, arg) {
+        return block.equals(other.block) && arg.equals(other.arg);
+      },
       query: function(expr, annotations) {
         return JSON.stringify(annotations) === JSON.stringify(other.annotations) && expr.equals(other.expr);
       },
-      localQuery: function(expr, key) {
-        return key === other.key && expr.equals(other.expr);
+      localQuery: function(key) {
+        return key === other.key;
+      },
+      fail: function() {
+        return false;
+      },
+      binop: function(op, lhs, rhs) {
+        return op === other.op && lhs.equals(other.lhs) && rhs.equals(other.rhs);
+      },
+      extern: function(name, value) {
+        return name === other.name && value.equals(other.value);
+      },
+      rescue: function(expr, default_) {
+        return expr.equals(other.expr) && default_.equals(other["default"]);
       }
     });
   };
@@ -3087,7 +3488,7 @@ Gibbon.IR = IR = (function(_super) {
         return name;
       },
       delist: function(e, i) {
-        return "([" + i + "] " + (e.inspect()) + ")";
+        return "([" + (i.inspect()) + "] " + (e.inspect()) + ")";
       },
       depair: function(e, k) {
         return "([" + k + "] " + (e.inspect()) + ")";
@@ -3113,9 +3514,15 @@ Gibbon.IR = IR = (function(_super) {
       foldList: function(list, out, arg, next, i, body) {
         return "(FOLDR " + (list.inspect()) + " " + (out.inspect()) + " " + arg + " " + next + " " + i + " " + (body.inspect()) + ")";
       },
+      filterList: function(list, arg, body) {
+        return "(FILTER " + (list.inspect()) + " " + arg + " " + (body.inspect()) + ")";
+      },
       zipLists: function(x, y) {
         return "(ZIP " + (x.inspect()) + " " + (y.inspect()) + ")";
       },
+      squishList: function(l) {
+        return "(SQUISH " + (l.inspect()) + ")";
+      },
       pair: function(x, y) {
         return "(PAIR " + (x.inspect()) + " " + (y.inspect()) + ")";
       },
@@ -3129,7 +3536,7 @@ Gibbon.IR = IR = (function(_super) {
         return "(APPLY " + (b.inspect()) + " " + (a.inspect()) + ")";
       },
       localQuery: function(k) {
-        return "(@" + k + " " + (e.inspect()) + ")";
+        return "@" + k;
       },
       fail: function(m) {
         return "(FAIL " + m + ")";
@@ -3177,10 +3584,10 @@ Gibbon.compile = (function() {
         return input.query(annotations);
       },
       localAccessor: function(key) {
-        return input.localQuery(key);
+        return IR.localQuery(key);
       },
-      func: function(name, args) {
-        var arg, argTypes, compArgs;
+      func: function(name, args, tvars) {
+        var arg, compArgs;
         compArgs = (function() {
           var _i, _len, _results;
           _results = [];
@@ -3190,23 +3597,14 @@ Gibbon.compile = (function() {
           }
           return _results;
         })();
-        argTypes = (function() {
-          var _i, _len, _results;
-          _results = [];
-          for (_i = 0, _len = args.length; _i < _len; _i++) {
-            arg = args[_i];
-            _results.push(arg.type);
-          }
-          return _results;
-        })();
-        return stdlib[name].compile(input, compArgs, this.type, argTypes);
+        return stdlib[name].compile(input, compArgs, tvars);
       },
       literal: function(syntax) {
         return IR.constant(syntax.value);
       },
-      list: function(elements) {
-        var e;
-        return IR.list((function() {
+      list: function(elements, squish) {
+        var e, list;
+        list = IR.list((function() {
           var _i, _len, _results;
           _results = [];
           for (_i = 0, _len = elements.length; _i < _len; _i++) {
@@ -3215,6 +3613,11 @@ Gibbon.compile = (function() {
           }
           return _results;
         })());
+        if (squish) {
+          return list.squish();
+        } else {
+          return list;
+        }
       },
       pair: function(x, y) {
         return IR.pair(compile(x, context), compile(y, context));
@@ -3229,12 +3632,315 @@ Gibbon.compile = (function() {
       }
     });
   };
-  return function(semantics) {
-    var out;
-    out = new Hash;
-    semantics.each(function(k, v) {
-      return out.set(k, compile(v));
+  return function(semantic) {
+    return compile(semantic);
+  };
+})();
+// Generated by CoffeeScript 1.6.3
+Gibbon.optimize = (function() {
+  var insertBindings, partialEval;
+  insertBindings = function(expr) {
+    return expr;
+  };
+  partialEval = function(expr) {
+    return expr.cases({
+      depair: function(expr, key) {
+        return partialEval(expr).cases({
+          pair: function() {
+            DEBUG.log("inlining lookup " + key + " of " + (this.inspect()));
+            return this[key];
+          },
+          other: function() {
+            return this.depair(key);
+          }
+        });
+      },
+      delist: function(expr, index) {
+        return partialEval(expr).cases({
+          list: function(els) {
+            DEBUG.log("inlining lookup " + index + " of " + (this.inspect()));
+            return els[index];
+          },
+          other: function() {
+            return this.delist(index);
+          }
+        });
+      },
+      branch: function(cond, ifTrue, ifFalse) {
+        ifTrue = partialEval(ifTrue);
+        ifFalse = partialEval(ifFalse);
+        if (ifTrue.equals(ifFalse)) {
+          DEBUG.log("eliminating condition in equivalent branches: " + (this.inspect()));
+          return ifTrue;
+        }
+        return partialEval(cond).cases({
+          constant: function(value) {
+            if (value) {
+              DEBUG.log("eliminating dead false branch " + (ifFalse.inspect()));
+              return ifTrue;
+            } else {
+              DEBUG.log("eliminating dead true branch " + (ifTrue.inspect()));
+              return ifFalse;
+            }
+          },
+          branch: function(innerCond, innerTrue, innerFalse) {
+            if (innerTrue._tag === 'constant' && innerFalse._tag === 'constant') {
+              DEBUG.log("eliminating nested if " + (this.inspect()));
+              if (innerTrue.value) {
+                return partialEval(innerCond.branch(ifTrue, ifFalse));
+              } else {
+                return partialEval(innerCond.branch(ifFalse, ifTrue));
+              }
+            } else {
+              return this.branch(ifTrue, ifFalse);
+            }
+          },
+          extern: function(name, arg) {
+            if (name === '!') {
+              DEBUG.log("eliminating if negation in condition " + (this.inspect()));
+              return partialEval(arg.branch(ifFalse, ifTrue));
+            } else {
+              return this.branch(ifTrue, ifFalse);
+            }
+          },
+          other: function() {
+            return this.branch(ifTrue, ifFalse);
+          }
+        });
+      },
+      app: function(block, arg) {
+        return partialEval(block).cases({
+          block: function(argName, body) {
+            return partialEval(body.subst(argName, arg));
+          },
+          other: function() {
+            return this.app(partialEval(arg));
+          }
+        });
+      },
+      mapList: function(list, arg, ixName, body) {
+        return list.cases({
+          list: function(elements) {
+            var el, i, mapped, _i, _len;
+            DEBUG.log("inlining MAP");
+            for (i = _i = 0, _len = elements.length; _i < _len; i = ++_i) {
+              el = elements[i];
+              DEBUG.log(("subst " + arg + "=" + (el.inspect()) + " ") + ("" + ixName + "=" + i + " " + (body.inspect())));
+              partialEval(body.subst(arg, el).subst(ixName, IR.constant(i)));
+            }
+            mapped = (function() {
+              var _j, _len1, _results;
+              _results = [];
+              for (_j = 0, _len1 = elements.length; _j < _len1; _j++) {
+                el = elements[_j];
+                _results.push(body.subst(arg, el));
+              }
+              return _results;
+            })();
+            return partialEval(IR.list(mapped));
+          },
+          other: function() {
+            return IR.mapList(this, arg, ixName, partialEval(body));
+          }
+        });
+      },
+      foldList: function(list, out, arg, accum, ixName, body) {
+        return partialEval(list).cases({
+          list: function(elements) {
+            var _loop;
+            DEBUG.log("inlining FOLDR");
+            _loop = function(i) {
+              var next;
+              if (i >= elements.length) {
+                return partialEval(out);
+              }
+              next = _loop(i + 1);
+              DEBUG.log(("subst " + arg + "=" + (elements[i].inspect()) + " ") + ("" + accum + "=" + (next.inspect()) + " ") + ("" + ixName + "=i " + (body.inspect())));
+              return body.subst(arg, elements[i]).subst(accum, next).subst(ixName, IR.constant(i));
+            };
+            return partialEval(_loop(0));
+          },
+          other: function() {
+            return IR.foldList(this, partialEval(out), arg, accum, ixName, partialEval(body));
+          }
+        });
+      },
+      len: function(list) {
+        return partialEval(list).cases({
+          list: function(elements) {
+            DEBUG.log("optimizing out len from " + (this.inspect()));
+            return IR.constant(elements.length);
+          },
+          mapList: function(list) {
+            DEBUG.log("optimizing MAP out of len");
+            return partialEval(list.len());
+          },
+          zipLists: function(l, r) {
+            DEBUG.log("optimizing ZIP out of len");
+            return partialEval(l.len());
+          },
+          other: function() {
+            return this.len();
+          }
+        });
+      },
+      zipLists: function(l, r) {
+        var e, elements, i;
+        l = partialEval(l);
+        r = partialEval(r);
+        if (!(l._tag === 'list' && r._tag === 'list')) {
+          return IR.zipLists(l, r);
+        }
+        elements = (function() {
+          var _i, _len, _results;
+          _results = [];
+          for (i = _i = 0, _len = l.length; _i < _len; i = ++_i) {
+            e = l[i];
+            _results.push(IR.pair(e, r[i]));
+          }
+          return _results;
+        })();
+        return partialEval(IR.list(elements));
+      },
+      extern: function(op, arg) {
+        return partialEval(arg).cases({
+          constant: function(value) {
+            if (/Math\.(\w+)/.test(op)) {
+              return IR.constant(Math[RegExp.$1](value));
+            }
+            return IR.constant((function() {
+              switch (op) {
+                case '!':
+                  return !value;
+                case '-':
+                  return -value;
+                default:
+                  throw "unknown operator " + op;
+              }
+            })());
+          },
+          other: function() {
+            return IR.extern(op, this);
+          }
+        });
+      },
+      binop: function(op, left, right) {
+        var l, r, _ref;
+        left = partialEval(left);
+        right = partialEval(right);
+        if (!(left._tag === 'constant' && right._tag === 'constant')) {
+          return IR.binop(op, left, right);
+        }
+        DEBUG.log("constant-folding " + (left.binop(op, right).inspect()));
+        _ref = [left.value, right.value], l = _ref[0], r = _ref[1];
+        return IR.constant((function() {
+          switch (op) {
+            case '+':
+              return l + r;
+            case '*':
+              return l * r;
+            case '/':
+              return l / r;
+            case '%':
+              return l % r;
+            case '===':
+              return l === r;
+            case '<':
+              return l < r;
+            case '>':
+              return l > r;
+            case '<=':
+              return l <= r;
+            case '>=':
+              return l >= r;
+          }
+        })());
+      },
+      rescue: function(expr, default_) {
+        var alwaysFails, alwaysSucceeds;
+        expr = partialEval(expr);
+        alwaysSucceeds = function(e) {
+          return e.cases({
+            query: function() {
+              return false;
+            },
+            localQuery: function() {
+              return false;
+            },
+            fail: function() {
+              return false;
+            },
+            rescue: function() {
+              return true;
+            },
+            squishList: function() {
+              return true;
+            },
+            other: function() {
+              var subtree, _i, _len, _ref;
+              _ref = this.subtrees();
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                subtree = _ref[_i];
+                console.log("checking alwaysSucceeds " + (subtree.inspect()));
+                if (!alwaysSucceeds(subtree)) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          });
+        };
+        alwaysFails = function(e) {
+          return e.cases({
+            query: function() {
+              return false;
+            },
+            localQuery: function() {
+              return false;
+            },
+            fail: function() {
+              return true;
+            },
+            rescue: function() {
+              return false;
+            },
+            squishList: function() {
+              return false;
+            },
+            other: function() {
+              var subtree, _i, _len, _ref;
+              _ref = this.subtrees();
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                subtree = _ref[_i];
+                console.log("checking alwaysFails " + (subtree.inspect()));
+                if (alwaysFails(subtree)) {
+                  return true;
+                }
+              }
+              return false;
+            }
+          });
+        };
+        if (alwaysSucceeds(expr)) {
+          DEBUG.log("eliminating dead default branch of " + (this.inspect()));
+          return expr;
+        } else if (alwaysFails(expr)) {
+          DEBUG.log("eliminating dead main branch of " + (this.inspect()));
+          return partialEval(default_);
+        } else {
+          return IR.rescue(expr, partialEval(default_));
+        }
+      },
+      other: function() {
+        return this.map(partialEval);
+      }
     });
+  };
+  return function(expr) {
+    var out;
+    DEBUG.log("=== OPTIMIZING " + (expr.inspect()));
+    out = insertBindings(partialEval(expr));
+    DEBUG.log("==> " + (out.inspect()));
     return out;
   };
 })();
@@ -3242,42 +3948,11 @@ Gibbon.compile = (function() {
 var stdlib;
 
 stdlib = Gibbon.stdlib = (function() {
-  var allBooleans, anyBooleans, combine, compEquals, iFalse, iTrue, iter, unit, vFalse, vTrue;
-  unit = Promise.unit;
-  iter = Promise.iter;
-  combine = Promise.combine;
+  var compEquals, iFalse, iTrue, vFalse, vTrue;
   vTrue = Value.boolean(true);
   vFalse = Value.boolean(false);
   iTrue = IR.constant(true);
   iFalse = IR.constant(false);
-  anyBooleans = function(promises) {
-    var out, step;
-    step = function(cond, next) {
-      if (cond.value) {
-        return unit(vTrue);
-      } else {
-        return next();
-      }
-    };
-    out = function() {
-      return unit(vFalse);
-    };
-    return iter(promises, step, out);
-  };
-  allBooleans = function(promises) {
-    var out, step;
-    step = function(cond, next) {
-      if (cond.value) {
-        return next();
-      } else {
-        return unit(vFalse);
-      }
-    };
-    out = function() {
-      return unit(vTrue);
-    };
-    return iter(promises, step, out);
-  };
   compEquals = function(x, y, type) {
     var direct;
     direct = function() {
@@ -3310,24 +3985,6 @@ 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() {
-            return Promise.fail('non-exhaustive cases');
-          };
-          return iter(list.elements, step, out);
-        });
-      },
       compile: function(_, _arg) {
         var alts;
         alts = _arg[0];
@@ -3338,32 +3995,10 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "case-eq": {
       type: parse.type('case-eq [%a : %b] = %a -> %b'),
-      impl: function(evalInput, evalList) {
-        return combine([evalInput, evalList]).then(function(_arg) {
-          var input, list, out, step;
-          input = _arg[0], list = _arg[1];
-          step = function(pair, next) {
-            return pair.first.then(function(test) {
-              return input.equals(test).then(function(vBool) {
-                if (vBool.value) {
-                  return pair.second;
-                } else {
-                  return next();
-                }
-              });
-            });
-          };
-          out = function() {
-            return Promise.fail('non-exhaustive cases');
-          };
-          return iter(list.elements, step, out);
-        });
-      },
-      compile: function(input, _arg, _, _arg1) {
-        var alts, argType, eqType;
+      compile: function(input, _arg, tvars) {
+        var alts, eqType;
         alts = _arg[0];
-        argType = _arg1[0];
-        eqType = argType.of.first;
+        eqType = tvars.get('a');
         return alts.foldList(IR.fail('non-exhaustive cases'), function(el, next) {
           var first, second;
           first = el.depair('first');
@@ -3374,14 +4009,10 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "case-eq-default": {
       type: parse.type('case-eq-default %b [%a : %b] = %a -> %b'),
-      impl: function(evalInput, evalDefault, evalList) {
-        return stdlib['case-eq'].impl(evalInput, evalList).or(evalDefault);
-      },
-      compile: function(input, _arg, _, _arg1) {
-        var alts, argType, default_, eqType;
+      compile: function(input, _arg, tvars) {
+        var alts, default_, eqType;
         default_ = _arg[0], alts = _arg[1];
-        argType = _arg1[0];
-        eqType = argType.of.first;
+        eqType = tvars.get('a');
         return alts.foldList(default_, function(el, next) {
           var first, second;
           first = el.depair('first');
@@ -3392,11 +4023,6 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "any-true?": {
       type: parse.type('any-true? = [bool] -> bool'),
-      impl: function(evalList) {
-        return evalList.then(function(list) {
-          return anyBooleans(list.elements);
-        });
-      },
       compile: function(list) {
         return list.foldList(iFalse, function(el, next) {
           return el.branch(iTrue, next);
@@ -3405,11 +4031,6 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "all-true?": {
       type: parse.type('all-true? = [bool] -> bool'),
-      impl: function(evalList) {
-        return evalList.then(function(list) {
-          return allBooleans(list.elements);
-        });
-      },
       compile: function(list) {
         return list.foldList(iTrue, function(el, next) {
           return el.branch(next, iFalse);
@@ -3418,24 +4039,9 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "any?": {
       type: parse.type('any? { %a -> bool } = [%a] -> bool'),
-      impl: function(evalList, evalBlock) {
-        return combine([evalList, evalBlock]).then(function(_arg) {
-          var block, e, fn, list;
-          list = _arg[0], block = _arg[1];
-          fn = block.fn;
-          return anyBooleans((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;
-          })());
-        });
-      },
-      compile: function(list, block) {
+      compile: function(list, _arg) {
+        var block;
+        block = _arg[0];
         return list.foldList(iFalse, function(el, next) {
           return block.app(el).branch(iTrue, next);
         });
@@ -3443,24 +4049,9 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "all?": {
       type: parse.type('all? { %a -> bool } = [%a] -> bool'),
-      impl: function(evalList, evalBlock) {
-        return combine([evalList, evalBlock]).then(function(_arg) {
-          var block, e, fn, list;
-          list = _arg[0], block = _arg[1];
-          fn = block.fn;
-          return allBooleans((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;
-          })());
-        });
-      },
-      compile: function(list, block) {
+      compile: function(list, _arg) {
+        var block;
+        block = _arg[0];
         return list.foldList(iTrue, function(el, next) {
           return block.app(el).branch(next, iFalse);
         });
@@ -3468,40 +4059,17 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "include?": {
       type: parse.type('include? %a = [%a] -> bool'),
-      impl: function(evalList, evalElement) {
-        return combine([evalElement, evalList]).then(function(_arg) {
-          var booleans, el, list, p;
-          el = _arg[0], list = _arg[1];
-          booleans = (function() {
-            var _i, _len, _ref, _results;
-            _ref = list.elements;
-            _results = [];
-            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-              p = _ref[_i];
-              _results.push(p.then(function(x) {
-                return el.equals(x);
-              }));
-            }
-            return _results;
-          })();
-          return anyBooleans(booleans);
-        });
-      },
-      compile: function(list, needle, _, _arg) {
-        var listType;
-        listType = _arg[0];
+      compile: function(list, _arg, tvars) {
+        var elType, needle;
+        needle = _arg[0];
+        elType = tvars.get('a');
         return list.foldList(iFalse, function(el, next) {
-          return compEquals(el, needle, listType.of).branch(iTrue, next);
+          return compEquals(el, needle, elType).branch(iTrue, next);
         });
       }
     },
     "empty?": {
       type: parse.type('empty? = [%] -> bool'),
-      impl: function(evalList) {
-        return evalList.map(function(list) {
-          return Value.boolean(list.length === 0);
-        });
-      },
       compile: function(list) {
         return list.foldList(iTrue, function() {
           return iFalse;
@@ -3510,40 +4078,10 @@ stdlib = Gibbon.stdlib = (function() {
     },
     weight: {
       type: parse.type('weight [numeric : numeric] = % -> numeric'),
-      impl: function(_, eWeights) {
-        return eWeights.then(function(weights) {
-          return combine(weights.elements).then(function(pairs) {
-            var denominator, numerator, p, process;
-            numerator = 0;
-            denominator = 0;
-            process = function(pair) {
-              return 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 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');
-              }
-              return unit(Value.number(numerator / denominator));
-            });
-          });
-        });
-      },
-      compile: function(_, weights) {
-        var ratio;
-        return ratio = weights.foldList(IR.pair(IR.constant(0), IR.constant(0)), function(el, next) {
+      compile: function(_, _arg) {
+        var ratio, weights;
+        weights = _arg[0];
+        ratio = weights.foldList(IR.pair(IR.constant(0), IR.constant(0)), function(el, next) {
           var denominator, numerator, value, weight, weighted;
           value = el.depair('first');
           weight = el.depair('second');
@@ -3552,40 +4090,14 @@ stdlib = Gibbon.stdlib = (function() {
           weighted = value.binop('*', weight);
           return IR.pair(numerator.binop('+', weighted), denominator.binop('+', weight));
         });
+        return ratio.depair('first').binop('/', ratio.depair('second'));
       }
     },
     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 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);
-            });
-          });
-        });
-      },
-      compile: function(input, block) {
+      compile: function(input, _arg) {
+        var block;
+        block = _arg[0];
         return input.filterList(function(el) {
           return block.app(el);
         });
@@ -3593,49 +4105,25 @@ stdlib = Gibbon.stdlib = (function() {
     },
     scale: {
       type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
-      impl: function(eInput, eDomain, eRange) {
-        return combine([eInput, eDomain, eRange]).then(function(_arg) {
-          var bounds, dom, input, range;
-          input = _arg[0], dom = _arg[1], range = _arg[2];
-          bounds = 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);
-          });
-        });
+      compile: function(input, _arg) {
+        var dom, domHigh, domLow, domSize, range, rangeHigh, rangeLow, rangeSize, retranslated, scaled, translated;
+        dom = _arg[0], range = _arg[1];
+        domLow = dom.depair('first');
+        domHigh = dom.depair('second');
+        rangeLow = range.depair('first');
+        rangeHigh = range.depair('second');
+        input = input.binop('<', domLow).branch(domLow, input);
+        input = input.binop('>', domHigh).branch(domHigh, input);
+        domSize = domHigh.binop('+', domLow.extern('-'));
+        rangeSize = rangeHigh.binop('+', rangeLow.extern('-'));
+        translated = input.binop('+', domLow.extern('-'));
+        scaled = translated.binop('*', rangeSize.binop('/', domSize));
+        retranslated = scaled.binop('+', rangeLow);
+        return 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((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;
-            })());
-          });
-        });
-      },
       compile: function(list, _arg) {
         var block;
         block = _arg[0];
@@ -3646,27 +4134,12 @@ stdlib = Gibbon.stdlib = (function() {
     },
     count: {
       type: parse.type('count = [%a] -> numeric'),
-      impl: function(evalList) {
-        return evalList.map(function(list) {
-          return Value.number(list.elements.length);
-        });
+      compile: function(list) {
+        return list.len();
       }
     },
     sum: {
       type: parse.type('sum = [numeric] -> numeric'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return 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 unit(Value.number(out));
-          });
-        });
-      },
       compile: function(list) {
         return list.foldList(IR.constant(0), function(el, next) {
           return el.binop('+', next);
@@ -3675,40 +4148,6 @@ stdlib = Gibbon.stdlib = (function() {
     },
     "case-sum": {
       type: parse.type('case-sum [bool : numeric] = % -> numeric'),
-      impl: function(_, evalList) {
-        return evalList.then(function(list) {
-          return combine(list.elements).then(function(elements) {
-            var first, numbers, second;
-            numbers = (function() {
-              var _i, _len, _ref, _results;
-              _results = [];
-              for (_i = 0, _len = elements.length; _i < _len; _i++) {
-                _ref = elements[_i], first = _ref.first, second = _ref.second;
-                _results.push((function(first, second) {
-                  return first.then(function(cond) {
-                    if (!cond.value) {
-                      return unit(0);
-                    }
-                    return second.map(function(v) {
-                      return v.value;
-                    });
-                  });
-                })(first, second));
-              }
-              return _results;
-            })();
-            return combine(numbers).then(function(nums) {
-              var num, out, _i, _len;
-              out = 0;
-              for (_i = 0, _len = nums.length; _i < _len; _i++) {
-                num = nums[_i];
-                out += num;
-              }
-              return unit(Value.number(out));
-            });
-          });
-        });
-      },
       compile: function(_, _arg) {
         var list;
         list = _arg[0];
@@ -3722,56 +4161,18 @@ stdlib = Gibbon.stdlib = (function() {
     },
     first: {
       type: parse.type('first = [%a] -> %a'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return val.elements[0];
-        });
-      },
       compile: function(list) {
-        return list.delist(0);
+        return list.delist(IR.constant(0));
       }
     },
     squish: {
       type: parse.type('squish = [%a] -> [%a]'),
-      impl: function(list) {
-        return list.then(function(_arg) {
-          var elements, promise, wrapped;
-          elements = _arg.elements;
-          wrapped = (function() {
-            var _i, _len, _results;
-            _results = [];
-            for (_i = 0, _len = elements.length; _i < _len; _i++) {
-              promise = elements[_i];
-              _results.push(promise.then(function(e) {
-                return e.resolve().map(function(e) {
-                  return [e.promise()];
-                });
-              }).or(unit([])));
-            }
-            return _results;
-          })();
-          return combine(wrapped).map(function(lists) {
-            return Value.list(catLists(lists));
-          });
-        });
-      },
       compile: function(list) {
-        return list.filterList(function(el) {
-          return IR.rescue(el.seq('v', function(_) {
-            return iTrue;
-          }), iFalse);
-        });
+        return list.squishList();
       }
     },
     add: {
       type: parse.type('add numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value + rhs.value);
-        });
-      },
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
@@ -3780,13 +4181,6 @@ stdlib = Gibbon.stdlib = (function() {
     },
     sub: {
       type: parse.type('sub numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value - rhs.value);
-        });
-      },
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
@@ -3795,42 +4189,24 @@ stdlib = Gibbon.stdlib = (function() {
     },
     id: {
       type: parse.type('id = %a -> %a'),
-      impl: function(x) {
-        return x;
-      },
       compile: function(input) {
         return input;
       }
     },
     "else": {
       type: parse.type('else = % -> bool'),
-      impl: function(_) {
-        return unit(vTrue);
-      },
       compile: function(_) {
         return iTrue;
       }
     },
     not: {
       type: parse.type('not = bool -> bool'),
-      impl: function(evalBool) {
-        return evalBool.map(function(bool) {
-          return Value.boolean(!bool.value);
-        });
-      },
       compile: function(input) {
         return input.extern('!');
       }
     },
     gt: {
       type: parse.type('gt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value > rhs.value);
-        });
-      },
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
@@ -3839,13 +4215,6 @@ stdlib = Gibbon.stdlib = (function() {
     },
     lt: {
       type: parse.type('lt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value < rhs.value);
-        });
-      },
       compile: function(input, _arg) {
         var num;
         num = _arg[0];
@@ -3854,18 +4223,10 @@ stdlib = Gibbon.stdlib = (function() {
     },
     eq: {
       type: parse.type('eq %a = %a -> bool'),
-      impl: function(input, obj) {
-        return combine([input, obj]).then(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return lhs.equals(rhs);
-        });
-      },
-      compile: function(input, _arg, _, _arg1) {
-        var obj, objType;
+      compile: function(input, _arg, tvars) {
+        var obj;
         obj = _arg[0];
-        objType = _arg1[0];
-        return compEquals(input, obj, objType);
+        return compEquals(input, obj, tvars.get('a'));
       }
     }
   };
@@ -3873,7 +4234,7 @@ stdlib = Gibbon.stdlib = (function() {
 // Generated by CoffeeScript 1.6.3
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
-    var analyzeList, getType, getValue, lists;
+    var analyzeList, getType, getValue, listLookup, lists;
     getType = function(id, accessorName, t, callback) {
       var fields;
       if (!tables.hasOwnProperty(id)) {
@@ -3923,6 +4284,15 @@ Gibbon.jsonConsumer = (function() {
         }
       });
     };
+    listLookup = function(id, listName, v, callback) {
+      var list;
+      list = lists[listName].values;
+      if (list.indexOf(id) >= 0) {
+        return callback(null, v.boolean(true));
+      } else {
+        return callback(null, v.boolean(false));
+      }
+    };
     return {
       analyzeQuery: function(id, query, t, callback) {
         switch (query.type) {
@@ -3935,7 +4305,11 @@ Gibbon.jsonConsumer = (function() {
         }
       },
       performQuery: function(id, annotations, v, callback) {
-        return getValue(id, annotations, v, callback);
+        if ('list' in annotations) {
+          return listLookup(id, annotations.list, v, callback);
+        } else {
+          return getValue(id, annotations, v, callback);
+        }
       }
     };
   };