goodguide-gibbon 0.3.8 → 0.4.0

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

@@ -854,7 +854,8 @@ Gibbon.AST = AST = (function(_super) {
     string: ['value'],
     subst: ['flow'],
     block: ['flow'],
-    list: ['elements'],
+    list: ['elements', 'squish'],
+    defaulted: ['body', 'alternative'],
     query: ['type', 'name'],
     func: ['name', 'args'],
     pair: ['first', 'second'],
@@ -902,9 +903,11 @@ Gibbon.AST = AST = (function(_super) {
       block: function(flow) {
         return "{ " + (flow.inspect()) + " }";
       },
-      list: function(els) {
-        var el;
-        return "[ " + (((function() {
+      list: function(els, squish) {
+        var close, el, open;
+        open = squish ? '[*' : '[';
+        close = squish ? '*]' : ']';
+        return "" + open + " " + (((function() {
           var _i, _len, _results;
           _results = [];
           for (_i = 0, _len = els.length; _i < _len; _i++) {
@@ -912,7 +915,10 @@ Gibbon.AST = AST = (function(_super) {
             _results.push(el.inspect());
           }
           return _results;
-        })()).join(', ')) + " ]";
+        })()).join(', ')) + " " + close;
+      },
+      defaulted: function(body, alt) {
+        return "" + (body.inspect()) + " | " + (alt.inspect());
       },
       func: function(name, args) {
         var arg;
@@ -1002,52 +1008,51 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
 })(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, query, queryExpr, question, rbrace, rbrack, regex, rparen, signature, simpleType, singletonFlow, str, string, stringExpr, substExpr, succeed, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
-  string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
-  Parsimmon.Parser.prototype.expected = function(message) {
-    var _this = this;
-    return Parsimmon.Parser(function(stream, i, onSuccess) {
-      return _this._(stream, i, onSuccess, function(newStream, _, defMessage) {
-        var at;
-        at = stream.slice(0, 10) || 'EOF';
-        throw new Error("Parse Error: expected " + (message || defMessage) + " (at '" + at + "')");
-      });
-    });
+  var accessor, accessorExpr, arrow, arrowType, assertString, bang, blankLines, blockExpr, blockType, comma, commaSepFlows, comment, component, concrete, decimal, decimalExpr, defaulted, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, innerFrame, integer, integerExpr, isString, label, labelVal, lbrace, lbrack, lexeme, lines, listExpr, listType, lparen, lsplat, metadata, multiline, name, nativeId, nativeType, nonDefaultedFlow, nonPairedFlow, numericExpr, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, query, queryExpr, rbrace, rbrack, regex, rparen, rsplat, signature, simpleType, singletonFlow, squishListExpr, str, string, stringExpr, substExpr, succeed, tag, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
+  tag = function(name, parser) {
+    return parser.tag(name);
   };
-  Parsimmon.Parser.prototype.named = function(name) {
+  Parsimmon.Parser.prototype.tag = function(name) {
     var _this = this;
     return Parsimmon.Parser(function(stream, i, onSuccess, onFailure) {
-      return _this._(stream, i, onSuccess, function() {
-        return onFailure(stream, i, name);
+      return _this._(stream, i, onSuccess, function(stream, newI, expected) {
+        return onFailure(stream, newI, name);
       });
     });
   };
-  whitespace = regex(/^[\n\s]+/);
+  string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
+  whitespace = regex(/^[ \t]*/);
+  blankLines = regex(/^[\n\s]+/);
   comment = regex(/^#.*?(\n|$)/);
-  ignore = (whitespace.or(comment)).many();
+  lines = (blankLines.or(comment)).many();
   lexeme = function(p) {
-    return p.skip(ignore);
+    return p.skip(whitespace);
   };
-  identifier = regex(/^[a-z][\w-]*[?]?/i);
-  arrow = lexeme(string('->'));
-  define = lexeme(string(':='));
-  pair = lexeme(string(':'));
-  lbrace = lexeme(string('{'));
+  multiline = function(p) {
+    return p.skip(lines);
+  };
+  identifier = tag('an identifier', regex(/^[a-z][\w-]*[?]?/i));
+  arrow = multiline(string('->'));
+  define = multiline(string(':='));
+  pair = multiline(string(':'));
+  lbrace = multiline(string('{'));
   rbrace = lexeme(string('}'));
-  lbrack = lexeme(string('['));
+  lbrack = multiline(string('['));
   rbrack = lexeme(string(']'));
-  lparen = lexeme(string('('));
+  lparen = multiline(string('('));
   rparen = lexeme(string(')'));
   comma = lexeme(string(','));
-  question = lexeme(string('?'));
-  query = lexeme(string('.').then(identifier.expected()));
-  accessor = lexeme(string('@').then(identifier.expected()));
+  defaulted = multiline(string('|'));
+  lsplat = multiline(string('[*'));
+  rsplat = lexeme(string('*]'));
+  query = lexeme(string('.').then(identifier));
+  accessor = lexeme(string('@').then(identifier));
   name = lexeme(identifier);
-  str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'").expected()));
-  fraction = lexeme(regex(/^\d+\/\d+/));
-  decimal = lexeme(regex(/^\d+\.\d+/));
-  percent = lexeme(regex(/^\d+%/));
-  integer = lexeme(regex(/^\d+/));
+  str = lexeme(string("'").then(regex(/^[^']*/)).skip(string("'")));
+  fraction = tag('a fraction', lexeme(regex(/^\d+\/\d+/)));
+  decimal = tag('a decimal', lexeme(regex(/^\d+\.\d+/)));
+  percent = tag('a percentage', lexeme(regex(/^\d+%/)));
+  integer = tag('a number', lexeme(regex(/^\d+/)));
   label = lexeme(identifier.skip(string(':')));
   labelVal = lexeme(regex(/^[^\n]*/));
   variable = lexeme(string('%').then(identifier));
@@ -1080,25 +1085,25 @@ parse = Gibbon.parse = (function() {
   });
   numericExpr = percentExpr.or(decimalExpr.or(fractionExpr.or(integerExpr)));
   parenFlow = lparen.then(function() {
-    return flow.expected().skip(rparen.expected());
+    return flow.skip(rparen);
   });
   substExpr = parenFlow.map(function(fl) {
     return AST.subst(fl);
   });
   listExpr = lbrack.then(function() {
-    return flow.skip(comma).many().then(function(els) {
-      return flow.or(succeed(null)).then(function(final) {
-        if (final) {
-          els.push(final);
-        }
-        return rbrack.expected().result(AST.list(els));
-      });
+    return commaSepFlows.then(function(els) {
+      return rbrack.result(AST.list(els, false));
+    });
+  });
+  squishListExpr = lsplat.then(function() {
+    return commaSepFlows.then(function(els) {
+      return rsplat.result(AST.list(els, true));
     });
   });
   blockExpr = lbrace.then(function() {
-    return flow.skip(rbrace.expected());
+    return flow.skip(rbrace);
   }).map(AST.block);
-  expr = queryExpr.or(accessorExpr.or(substExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr))))));
+  expr = tag('an expr', queryExpr.or(accessorExpr.or(substExpr.or(squishListExpr.or(listExpr.or(stringExpr.or(blockExpr.or(numericExpr))))))));
   singletonFlow = expr.map(function(e) {
     return AST.flow(e, null);
   });
@@ -1107,7 +1112,7 @@ parse = Gibbon.parse = (function() {
       return AST.func(funcName, args);
     });
   });
-  component = expr.or(func);
+  component = multiline(expr.or(func));
   nonPairedFlow = component.then(function(first) {
     return arrow.then(component).many().map(function(rest) {
       var comp, cursor, _i, _len;
@@ -1119,34 +1124,47 @@ parse = Gibbon.parse = (function() {
       return cursor;
     });
   });
-  flow = nonPairedFlow.then(function(first) {
-    return pair.then(flow).map(function(second) {
+  nonDefaultedFlow = nonPairedFlow.then(function(first) {
+    return pair.then(nonDefaultedFlow).map(function(second) {
       return AST.flow(AST.pair(first, second), null);
     }).or(succeed(first));
   });
+  flow = tag('a flow', nonDefaultedFlow.then(function(body) {
+    return defaulted.then(flow).map(function(alternative) {
+      return AST.flow(AST.defaulted(body, alternative), null);
+    }).or(succeed(body));
+  }));
+  commaSepFlows = flow.skip(comma.or(succeed(null)).then(lines)).many().then(function(els) {
+    return flow.or(succeed(null)).map(function(final) {
+      if (final) {
+        els.push(final);
+      }
+      return els;
+    });
+  });
   metadata = label.then(function(key) {
     return labelVal.map(function(text) {
       return AST.metadata(key, text);
     });
   });
-  definition = metadata.many().then(function(md) {
+  definition = tag('a definition', metadata.many().then(function(md) {
     return name.then(function(n) {
-      return define.then(innerFrame.expected()).map(function(fl) {
+      return define.then(innerFrame).map(function(fl) {
         return AST.definition(md, n, fl);
       });
     });
-  });
+  }));
   frame = definition.many().then(function(defs) {
-    return flow.expected().map(function(fl) {
+    return flow.map(function(fl) {
       return AST.frame(defs, fl);
     });
   });
-  parenFrame = lparen.then(frame).skip(rparen.expected());
+  parenFrame = lparen.then(frame).skip(rparen.then(lines));
   freeFrame = flow.map(function(fl) {
     return AST.frame([], fl);
   });
   innerFrame = parenFrame.or(freeFrame);
-  program = ignore.then(frame);
+  program = lines.then(frame);
   tassign = lexeme(string('='));
   bang = lexeme(string('!'));
   nativeId = lexeme(regex(/^\w+/));
@@ -1158,27 +1176,27 @@ parse = Gibbon.parse = (function() {
   });
   wildType = wildcard.result(TypeAST.wildcard());
   listType = lbrack.then(function() {
-    return type.skip(rbrack.expected()).map(function(t) {
+    return type.skip(rbrack).map(function(t) {
       return TypeAST.list(t);
     });
   });
   parenType = lparen.then(function() {
-    return type.skip(rparen.expected());
+    return type.skip(rparen);
   });
   blockType = lbrace.then(function() {
-    return arrowType.skip(rbrace.expected()).map(function(t) {
+    return arrowType.skip(rbrace).map(function(t) {
       return TypeAST.block(t);
     });
   });
   nativeType = bang.then(nativeId).map(TypeAST["native"]);
-  simpleType = (typeVar.or(wildType.or(listType.or(parenType.or(blockType.or(concrete.or(nativeType))))))).named('a simple type');
+  simpleType = typeVar.or(wildType.or(listType.or(parenType.or(blockType.or(concrete.or(nativeType))))));
   type = simpleType.then(function(first) {
-    return pair.then(type.expected()).map(function(second) {
+    return pair.then(type).map(function(second) {
       return TypeAST.pair(first, second);
     }).or(succeed(first));
   });
   arrowType = type.then(function(first) {
-    return arrow.then(type.expected()).map(function(second) {
+    return arrow.then(type).map(function(second) {
       return TypeAST.arrow(first, second);
     });
   });
@@ -1189,7 +1207,7 @@ parse = Gibbon.parse = (function() {
       });
     });
   });
-  fullSignature = ignore.then(signature);
+  fullSignature = lines.then(signature);
   isString = function(s) {
     return typeof s === 'string' || s instanceof String;
   };
@@ -1233,10 +1251,11 @@ Gibbon.Semantic = Semantic = (function(_super) {
     localAccessor: ['name'],
     pair: ['first', 'second'],
     block: ['body'],
-    list: ['elements'],
+    list: ['elements', 'squish'],
     flow: ['type', 'head', 'tail'],
     func: ['name', 'args'],
-    subst: ['flow']
+    subst: ['flow'],
+    defaulted: ['body', 'alternative']
   });
 
   return Semantic;
@@ -1719,6 +1738,12 @@ analyze = Gibbon.analyze = (function() {
             input = TypeExpr.variable('.input');
             push(TypeExpr.expr(flow), TypeExpr.param('block', [input, TypeExpr.expr(subFlow)]));
             return _this.analyzeFlow(subFlow, input, push);
+          },
+          defaulted: function(body, alt) {
+            push(TypeExpr.expr(body), TypeExpr.expr(alt));
+            push(TypeExpr.expr(flow), TypeExpr.expr(alt));
+            _this.analyzeFlow(body, global, push);
+            return _this.analyzeFlow(alt, global, push);
           }
         });
       };
@@ -1926,7 +1951,7 @@ analyze = Gibbon.analyze = (function() {
               block: function(flow) {
                 return Semantic.block(toSemanticTree(flow));
               },
-              list: function(elements) {
+              list: function(elements, squish) {
                 var e;
                 return Semantic.list((function() {
                   var _i, _len, _results;
@@ -1936,7 +1961,10 @@ analyze = Gibbon.analyze = (function() {
                     _results.push(toSemanticTree(e));
                   }
                   return _results;
-                })());
+                })(), squish);
+              },
+              defaulted: function(body, alt) {
+                return Semantic.defaulted(toSemanticTree(body), toSemanticTree(alt));
               },
               integer: function() {
                 return Semantic.literal(this);
@@ -2094,7 +2122,7 @@ analyze = Gibbon.analyze = (function() {
   };
 })();
 // Generated by CoffeeScript 1.6.3
-var Dependency, Promise, Value, eval_, _ref, _ref1,
+var Dependency, Failure, Promise, Value, eval_, _ref, _ref1, _ref2,
   __hasProp = {}.hasOwnProperty,
   __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
   __slice = [].slice;
@@ -2337,6 +2365,23 @@ Promise = (function() {
     });
   };
 
+  Promise.prototype.rescue = function(fn) {
+    var _this = this;
+    return new Promise(function(fail, cb) {
+      var rescue;
+      rescue = function(failure) {
+        return fn(failure).depends([Dependency.failure(failure)]).force(fail, cb);
+      };
+      return _this.force(rescue, cb);
+    });
+  };
+
+  Promise.prototype.or = function(other) {
+    return this.rescue(function(_) {
+      return other;
+    });
+  };
+
   Promise.prototype.depends = function(deps) {
     var _this = this;
     return new Promise(function(fail, cc) {
@@ -2441,21 +2486,65 @@ Promise = (function() {
 
 })();
 
-Dependency = (function(_super) {
+Gibbon.Failure = Failure = (function(_super) {
+  __extends(Failure, _super);
+
+  function Failure() {
+    _ref1 = Failure.__super__.constructor.apply(this, arguments);
+    return _ref1;
+  }
+
+  Failure.types({
+    query: ['id', 'annotations'],
+    composite: ['failures']
+  });
+
+  Failure.prototype.equals = function(other) {
+    if (this._tag !== other._tag) {
+      return false;
+    }
+    return this.cases({
+      query: function(id, annotations) {
+        if (annotations !== other.annotations) {
+          return false;
+        }
+        if (id !== other.id) {
+          return false;
+        }
+      },
+      composite: function(failures) {
+        var failure, i, _i, _len;
+        for (i = _i = 0, _len = failures.length; _i < _len; i = ++_i) {
+          failure = failures[i];
+          if (!failure.equals(other.failures[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+    });
+  };
+
+  return Failure;
+
+})(Union);
+
+Gibbon.Dependency = Dependency = (function(_super) {
   __extends(Dependency, _super);
 
   function Dependency() {
-    _ref1 = Dependency.__super__.constructor.apply(this, arguments);
-    return _ref1;
+    _ref2 = Dependency.__super__.constructor.apply(this, arguments);
+    return _ref2;
   }
 
   Dependency.types({
     query: ['entity', 'query'],
-    lexical: ['key']
+    lexical: ['key'],
+    failure: ['failure']
   });
 
   Dependency.prototype.equals = function(other) {
-    if (this.tag !== other.tag) {
+    if (this._tag !== other._tag) {
       return false;
     }
     return this.cases({
@@ -2470,6 +2559,9 @@ Dependency = (function(_super) {
       },
       lexical: function(key) {
         return key === other.key;
+      },
+      failure: function(failure) {
+        return failure.equals(other.failure);
       }
     });
   };
@@ -2481,6 +2573,9 @@ Dependency = (function(_super) {
       },
       lexical: function(definition) {
         return "@" + definition.name;
+      },
+      failure: function(failure) {
+        return "!";
       }
     });
   };
@@ -2567,9 +2662,9 @@ eval_ = Gibbon["eval"] = (function() {
           eSecond = evalFlow(second, global);
           return Promise.unit(Value.pair(eFirst, eSecond));
         },
-        list: function(elements) {
-          var e;
-          elements = (function() {
+        list: function(elements, squished) {
+          var e, list;
+          list = Promise.unit(Value.list((function() {
             var _i, _len, _results;
             _results = [];
             for (_i = 0, _len = elements.length; _i < _len; _i++) {
@@ -2577,13 +2672,20 @@ eval_ = Gibbon["eval"] = (function() {
               _results.push(evalFlow(e, global));
             }
             return _results;
-          })();
-          return Promise.unit(Value.list(elements));
+          })()));
+          if (squished) {
+            return stdlib.squish.impl(list);
+          } else {
+            return list;
+          }
         },
         block: function(body) {
           return Promise.unit(Value.block(function(inputPromise) {
             return evalFlow(body, inputPromise);
           }));
+        },
+        defaulted: function(body, alt) {
+          return evalFlow(body, global).or(evalFlow(alt, global));
         }
       });
     };
@@ -2592,10 +2694,10 @@ eval_ = Gibbon["eval"] = (function() {
     });
   };
   return function(semantics, table, id, client, finish) {
-    var entity, key, onFailure, onSuccess, _i, _len, _ref2;
-    _ref2 = semantics.keys();
-    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-      key = _ref2[_i];
+    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;
@@ -2617,12 +2719,40 @@ eval_ = Gibbon["eval"] = (function() {
 var stdlib;
 
 stdlib = Gibbon.stdlib = (function() {
-  var combine, iter, unit, vFalse, vTrue;
+  var allBooleans, anyBooleans, combine, iter, unit, vFalse, vTrue;
   unit = Promise.unit;
   iter = Promise.iter;
   combine = Promise.combine;
   vTrue = Value.boolean(true);
   vFalse = Value.boolean(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);
+  };
   return {
     "case": {
       type: parse.type('case [bool : %b] = % -> %b'),
@@ -2639,20 +2769,67 @@ stdlib = Gibbon.stdlib = (function() {
             });
           };
           out = function() {
-            throw new Error('Runtime Error: non-exhaustive cases');
+            return Promise.fail('non-exhaustive cases');
           };
           return iter(list.elements, step, out);
         });
       }
     },
+    "case-eq": {
+      type: parse.type('case-eq [%a : %b] = %a -> %b'),
+      impl: function(evalInput, evalList) {
+        debugger;
+        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);
+        });
+      }
+    },
+    "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);
+      }
+    },
+    "any-true?": {
+      type: parse.type('any-true? = [bool] -> bool'),
+      impl: function(evalList) {
+        return evalList.then(function(list) {
+          return anyBooleans(list.elements);
+        });
+      }
+    },
+    "all-true?": {
+      type: parse.type('all-true? = [bool] -> bool'),
+      impl: function(evalList) {
+        return evalList.then(function(list) {
+          return allBooleans(list.elements);
+        });
+      }
+    },
     "any?": {
       type: parse.type('any? { %a -> bool } = [%a] -> bool'),
       impl: function(evalList, evalBlock) {
         return combine([evalList, evalBlock]).then(function(_arg) {
-          var block, booleans, e, fn, list, out, step;
+          var block, e, fn, list;
           list = _arg[0], block = _arg[1];
           fn = block.fn;
-          booleans = (function() {
+          return anyBooleans((function() {
             var _i, _len, _ref, _results;
             _ref = list.elements;
             _results = [];
@@ -2661,18 +2838,7 @@ stdlib = Gibbon.stdlib = (function() {
               _results.push(fn(e));
             }
             return _results;
-          })();
-          step = function(cond, next) {
-            if (cond.value) {
-              return unit(vTrue);
-            } else {
-              return next();
-            }
-          };
-          out = function() {
-            return unit(vFalse);
-          };
-          return iter(booleans, step, out);
+          })());
         });
       }
     },
@@ -2680,10 +2846,10 @@ stdlib = Gibbon.stdlib = (function() {
       type: parse.type('all? { %a -> bool } = [%a] -> bool'),
       impl: function(evalList, evalBlock) {
         return combine([evalList, evalBlock]).then(function(_arg) {
-          var block, booleans, e, fn, list, out, step;
+          var block, e, fn, list;
           list = _arg[0], block = _arg[1];
           fn = block.fn;
-          booleans = (function() {
+          return allBooleans((function() {
             var _i, _len, _ref, _results;
             _ref = list.elements;
             _results = [];
@@ -2692,18 +2858,30 @@ stdlib = Gibbon.stdlib = (function() {
               _results.push(fn(e));
             }
             return _results;
-          })();
-          step = function(cond, next) {
-            if (cond.value) {
-              return next();
-            } else {
-              return unit(vFalse);
+          })());
+        });
+      }
+    },
+    "include?": {
+      type: parse.type('include? %a = [%a] -> bool'),
+      impl: function(evalList, evalElement) {
+        debugger;
+        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);
+              }));
             }
-          };
-          out = function() {
-            return trueP;
-          };
-          return Promise.iter(booleans, step, out);
+            return _results;
+          })();
+          return anyBooleans(booleans);
         });
       }
     },
@@ -2743,8 +2921,7 @@ stdlib = Gibbon.stdlib = (function() {
               if (denominator === 0) {
                 return Promise.fail('cannot divide by zero');
               }
-              debugger;
-              return Promise.unit(Value.number(numerator / denominator));
+              return unit(Value.number(numerator / denominator));
             });
           });
         });
@@ -2847,7 +3024,42 @@ stdlib = Gibbon.stdlib = (function() {
               e = vals[_i];
               out += e.value;
             }
-            return Promise.unit(Value.number(out));
+            return unit(Value.number(out));
+          });
+        });
+      }
+    },
+    "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 el, numbers;
+            numbers = (function() {
+              var _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = elements.length; _i < _len; _i++) {
+                el = elements[_i];
+                _results.push(el.first.then(function(cond) {
+                  if (!cond.value) {
+                    return unit(0);
+                  }
+                  return el.second.map(function(v) {
+                    return v.value;
+                  });
+                }));
+              }
+              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));
+            });
           });
         });
       }
@@ -2860,6 +3072,39 @@ stdlib = Gibbon.stdlib = (function() {
         });
       }
     },
+    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.map(function(e) {
+                return [e];
+              }).or(unit([])));
+            }
+            return _results;
+          })();
+          return combine(wrapped).map(function(lists) {
+            var e;
+            return Value.list((function() {
+              var _i, _len, _ref, _results;
+              _ref = catLists(lists);
+              _results = [];
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                e = _ref[_i];
+                _results.push(unit(e));
+              }
+              return _results;
+            })());
+          });
+        });
+      }
+    },
     add: {
       type: parse.type('add numeric = numeric -> numeric'),
       impl: function(input, num) {
@@ -2892,6 +3137,14 @@ stdlib = Gibbon.stdlib = (function() {
         return unit(vTrue);
       }
     },
+    not: {
+      type: parse.type('not = bool -> bool'),
+      impl: function(evalBool) {
+        return evalBool.map(function(bool) {
+          return Value.boolean(!bool.value);
+        });
+      }
+    },
     gt: {
       type: parse.type('gt numeric = numeric -> bool'),
       impl: function(input, num) {
@@ -2948,15 +3201,15 @@ Gibbon.jsonConsumer = (function() {
     getValue = function(id, annotations, v, callback) {
       var entity, values;
       if (!tables.hasOwnProperty(annotations.table)) {
-        return callback(new Error("no such type " + annotations.table));
+        throw new Error("no such type " + annotations.table);
       }
       values = tables[annotations.table].values;
       if (!values[id]) {
-        return callback(new Error("no entity with id " + id));
+        return callback(Failure.query(id, annotations));
       }
       entity = values[id];
-      if (!entity.hasOwnProperty(annotations.name)) {
-        return callback(null, null);
+      if (!(entity.hasOwnProperty(annotations.name) && (entity[annotations.name] != null))) {
+        return callback(Failure.query(id, annotations));
       }
       return callback(null, v.fromJSON(entity[annotations.name]));
     };