goodguide-gibbon 0.3.6 → 0.3.7

data/Gemfile

@@ -4,5 +4,6 @@ gemspec
 gem 'minitest', '~> 4.0'
 gem 'wrong'
 gem 'pry'
+gem 'pry-debugger'
 
 gem 'rake'

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.3.6'
+      '0.3.7'
     end
   end
 end

data/lib/goodguide/gibbon.rb

@@ -4,6 +4,47 @@ require 'pathname'
 
 module GoodGuide
   module Gibbon
+    module Util
+      extend self
+      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)
+        }
+
+        js_hash[:each].methodcall js_hash, iterator
+
+        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)
+        end
+        js_hash
+      end
+
+      def obj_to_ruby(o)
+        case o
+        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)
+          end
+          out
+        else
+          o
+        end
+      end
+    end
+
     def self.root
       Pathname.new(__FILE__).dirname.parent.parent
     end
@@ -58,6 +99,12 @@ module GoodGuide
     class QueryError < StandardError; end
 
     class RuntimeError < StandardError; end
+    class MissingData < RuntimeError
+      attr_reader :query_type, :id, :annotations
+      def initialize(type, id, annotations)
+        @query_type, @id, @annotations = type, id, annotations
+      end
+    end
 
     class Program
       def self.compile(source, info={})
@@ -100,7 +147,7 @@ module GoodGuide
           self.semantics, entity_id, runtime_client.to_js
         )
 
-        raise RuntimeError.new(error) if error
+        raise error if error
         values
       end
     end
@@ -120,7 +167,7 @@ module GoodGuide
 
     private
       def get_query(type)
-        query = self.class.queries[type]
+        query = self.class.queries[type.to_s]
         raise "no such query #{type}" if query.nil?
         query
       end
@@ -130,8 +177,8 @@ module GoodGuide
           cb = args.pop
           err, val = begin
             [nil, send(method, *args)]
-          rescue QueryError => e
-            [e.to_s, nil]
+          rescue QueryError, RuntimeError => e
+            [e, nil]
           end
 
           cb.call(err, val)
@@ -140,6 +187,8 @@ module GoodGuide
     end
 
     class StaticClient < AbstractClient
+      include Util
+
       def query_error!(*a)
         raise QueryError.new(*a)
       end
@@ -147,7 +196,7 @@ module GoodGuide
       def analyze_query(input_id, query, t)
         query_impl = get_query(query.type)
         analysis = instance_exec(input_id, query.name, t, &query_impl)
-        analysis[:annotations][:_query_type] = query.type
+        analysis[:annotations]['_query_type'] = query.type
         analysis
       end
 
@@ -157,17 +206,33 @@ module GoodGuide
     end
 
     class RuntimeClient < AbstractClient
+      include Util
       def perform_query(id, annotations, v)
-        query = get_query(annotations[:_query_type])
+        annotations = obj_to_ruby(annotations)
+
+        query_type = annotations.delete('_query_type')
+
+        # stash this data in case missing_data! is called
+        @last_query_type = query_type
+        @last_annotations = annotations
+        @last_id = id
+
+        query = get_query(query_type)
         instance_exec(id, annotations, v, &query)
       end
 
+      def missing_data!
+        raise MissingData.new(@last_query_type, @last_id, @last_annotations)
+      end
+
       def to_js
         { :performQuery => proc_for(:perform_query) }
       end
     end
 
     class Context
+      include Util
+
       attr_reader :gibbon
       def initialize(js={})
         if js.is_a? Hash
@@ -209,43 +274,6 @@ module GoodGuide
         [output, error]
       end
 
-      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)
-        }
-
-        js_hash[:each].methodcall js_hash, iterator
-
-        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)
-        end
-        js_hash
-      end
-
-      def obj_to_ruby(o)
-        case o
-        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)
-          end
-          out
-        else
-          o
-        end
-      end
     end
 
     class JS < V8::Context

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

@@ -1034,7 +1034,7 @@ parse = Gibbon.parse = (function() {
   lexeme = function(p) {
     return p.skip(ignore);
   };
-  identifier = regex(/^[a-z][\w-]*/i);
+  identifier = regex(/^[a-z][\w-]*[?]?/i);
   arrow = lexeme(string('->'));
   define = lexeme(string(':='));
   pair = lexeme(string(':'));
@@ -1219,241 +1219,6 @@ parse = Gibbon.parse = (function() {
   return parse;
 })();
 // Generated by CoffeeScript 1.6.3
-var stdlib;
-
-stdlib = Gibbon.stdlib = (function() {
-  return {
-    "case": {
-      type: parse.type('case [bool : %b] = % -> %b'),
-      impl: function(_, evalList) {
-        return evalList.then(function(list) {
-          var out, step;
-          step = function(pair, next) {
-            return pair.first.then(function(cond) {
-              if (cond.value) {
-                return pair.second;
-              } else {
-                return next();
-              }
-            });
-          };
-          out = function() {
-            throw new Error('Runtime Error: non-exhaustive cases');
-          };
-          return Promise.iter(list.elements, step, out);
-        });
-      }
-    },
-    weight: {
-      type: parse.type('weight [numeric : numeric] = % -> numeric'),
-      impl: function(_, eWeights) {
-        return eWeights.then(function(weights) {
-          return Promise.combine(weights.elements).then(function(pairs) {
-            var denominator, numerator, p, process;
-            numerator = 0;
-            denominator = 0;
-            process = function(pair) {
-              return Promise.combine([pair.first, pair.second]).after(function(_arg) {
-                var first, second;
-                first = _arg[0], second = _arg[1];
-                numerator += first.value * second.value;
-                return denominator += second.value;
-              });
-            };
-            return Promise.combine((function() {
-              var _i, _len, _results;
-              _results = [];
-              for (_i = 0, _len = pairs.length; _i < _len; _i++) {
-                p = pairs[_i];
-                _results.push(process(p));
-              }
-              return _results;
-            })()).then(function() {
-              if (denominator === 0) {
-                return Promise.fail('cannot divide by zero');
-              }
-              debugger;
-              return Promise.unit(Value.number(numerator / denominator));
-            });
-          });
-        });
-      }
-    },
-    filter: {
-      type: parse.type('filter { %a -> bool } = [%a] -> [%a]'),
-      impl: function(evalInput, evalBlock) {
-        return evalBlock.then(function(block) {
-          var fn;
-          fn = block.fn;
-          return evalInput.then(function(list) {
-            var check, e, out;
-            out = [];
-            check = function(thunk) {
-              return fn(thunk).after(function(bool) {
-                if (bool.value) {
-                  return out.push(thunk);
-                }
-              });
-            };
-            return Promise.combine((function() {
-              var _i, _len, _ref, _results;
-              _ref = list.elements;
-              _results = [];
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                e = _ref[_i];
-                _results.push(check(e));
-              }
-              return _results;
-            })()).map(function() {
-              return Value.list(out);
-            });
-          });
-        });
-      }
-    },
-    scale: {
-      type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
-      impl: function(eInput, eDomain, eRange) {
-        return Promise.combine([eInput, eDomain, eRange]).then(function(_arg) {
-          var bounds, dom, input, range;
-          input = _arg[0], dom = _arg[1], range = _arg[2];
-          bounds = Promise.combine([dom.first, dom.second, range.first, range.second]);
-          return bounds.map(function(_arg1) {
-            var domHigh, domLow, domSize, rangeHigh, rangeLow, rangeSize, retranslated, scaled, translated;
-            domLow = _arg1[0], domHigh = _arg1[1], rangeLow = _arg1[2], rangeHigh = _arg1[3];
-            if (input.value < domLow.value) {
-              input = domLow;
-            } else if (input.value > domHigh.value) {
-              input = domHigh;
-            }
-            domSize = domHigh.value - domLow.value;
-            rangeSize = rangeHigh.value - rangeLow.value;
-            translated = input.value - domLow.value;
-            scaled = translated * rangeSize / domSize;
-            retranslated = scaled + rangeLow.value;
-            return Value.number(retranslated);
-          });
-        });
-      }
-    },
-    map: {
-      type: parse.type('map { %a -> %b } = [%a] -> [%b]'),
-      impl: function(evalList, evalBlock) {
-        return evalList.then(function(list) {
-          return evalBlock.map(function(block) {
-            var e, fn;
-            fn = block.fn;
-            return Value.list((function() {
-              var _i, _len, _ref, _results;
-              _ref = list.elements;
-              _results = [];
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                e = _ref[_i];
-                _results.push(fn(e));
-              }
-              return _results;
-            })());
-          });
-        });
-      }
-    },
-    count: {
-      type: parse.type('count = [%a] -> numeric'),
-      impl: function(evalList) {
-        return evalList.map(function(list) {
-          return Value.number(list.elements.length);
-        });
-      }
-    },
-    sum: {
-      type: parse.type('sum = [numeric] -> numeric'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return Promise.combine(val.elements).then(function(vals) {
-            var e, out, _i, _len;
-            out = 0;
-            for (_i = 0, _len = vals.length; _i < _len; _i++) {
-              e = vals[_i];
-              out += e.value;
-            }
-            return Promise.unit(Value.number(out));
-          });
-        });
-      }
-    },
-    first: {
-      type: parse.type('first = [%a] -> %a'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return val.elements[0];
-        });
-      }
-    },
-    add: {
-      type: parse.type('add numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value + rhs.value);
-        });
-      }
-    },
-    sub: {
-      type: parse.type('sub numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value - rhs.value);
-        });
-      }
-    },
-    id: {
-      type: parse.type('id = %a -> %a'),
-      impl: function(x) {
-        return x;
-      }
-    },
-    "else": {
-      type: parse.type('else = % -> bool'),
-      impl: function(_) {
-        return Promise.unit(Value.boolean(true));
-      }
-    },
-    gt: {
-      type: parse.type('gt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value > rhs.value);
-        });
-      }
-    },
-    lt: {
-      type: parse.type('lt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value < rhs.value);
-        });
-      }
-    },
-    eq: {
-      type: parse.type('eq %a = %a -> bool'),
-      impl: function(input, obj) {
-        return Promise.combine([input, obj]).then(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return lhs.equals(rhs);
-        });
-      }
-    }
-  };
-})();
-// Generated by CoffeeScript 1.6.3
 var Semantic, Type, TypeLookup, analyze, _ref, _ref1, _ref2,
   __hasProp = {}.hasOwnProperty,
   __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
@@ -2874,6 +2639,317 @@ eval_ = Gibbon["eval"] = (function() {
   };
 })();
 // Generated by CoffeeScript 1.6.3
+var stdlib;
+
+stdlib = Gibbon.stdlib = (function() {
+  var combine, iter, unit, vFalse, vTrue;
+  unit = Promise.unit;
+  iter = Promise.iter;
+  combine = Promise.combine;
+  vTrue = Value.boolean(true);
+  vFalse = Value.boolean(false);
+  return {
+    "case": {
+      type: parse.type('case [bool : %b] = % -> %b'),
+      impl: function(_, evalList) {
+        return evalList.then(function(list) {
+          var out, step;
+          step = function(pair, next) {
+            return pair.first.then(function(cond) {
+              if (cond.value) {
+                return pair.second;
+              } else {
+                return next();
+              }
+            });
+          };
+          out = function() {
+            throw new Error('Runtime Error: non-exhaustive cases');
+          };
+          return iter(list.elements, step, out);
+        });
+      }
+    },
+    "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;
+          list = _arg[0], block = _arg[1];
+          fn = block.fn;
+          booleans = (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;
+          })();
+          step = function(cond, next) {
+            if (cond.value) {
+              return unit(vTrue);
+            } else {
+              return next();
+            }
+          };
+          out = function() {
+            return unit(vFalse);
+          };
+          return iter(booleans, step, out);
+        });
+      }
+    },
+    "all?": {
+      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;
+          list = _arg[0], block = _arg[1];
+          fn = block.fn;
+          booleans = (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;
+          })();
+          step = function(cond, next) {
+            if (cond.value) {
+              return next();
+            } else {
+              return unit(vFalse);
+            }
+          };
+          out = function() {
+            return trueP;
+          };
+          return Promise.iter(booleans, step, out);
+        });
+      }
+    },
+    "empty?": {
+      type: parse.type('empty? = [%] -> bool'),
+      impl: function(evalList) {
+        return evalList.map(function(list) {
+          return Value.boolean(list.length === 0);
+        });
+      }
+    },
+    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');
+              }
+              debugger;
+              return Promise.unit(Value.number(numerator / denominator));
+            });
+          });
+        });
+      }
+    },
+    filter: {
+      type: parse.type('filter { %a -> bool } = [%a] -> [%a]'),
+      impl: function(evalInput, evalBlock) {
+        return evalBlock.then(function(block) {
+          var fn;
+          fn = block.fn;
+          return evalInput.then(function(list) {
+            var check, e, out;
+            out = [];
+            check = function(thunk) {
+              return fn(thunk).after(function(bool) {
+                if (bool.value) {
+                  return out.push(thunk);
+                }
+              });
+            };
+            return combine((function() {
+              var _i, _len, _ref, _results;
+              _ref = list.elements;
+              _results = [];
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                e = _ref[_i];
+                _results.push(check(e));
+              }
+              return _results;
+            })()).map(function() {
+              return Value.list(out);
+            });
+          });
+        });
+      }
+    },
+    scale: {
+      type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
+      impl: function(eInput, eDomain, eRange) {
+        return 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);
+          });
+        });
+      }
+    },
+    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;
+            })());
+          });
+        });
+      }
+    },
+    count: {
+      type: parse.type('count = [%a] -> numeric'),
+      impl: function(evalList) {
+        return evalList.map(function(list) {
+          return Value.number(list.elements.length);
+        });
+      }
+    },
+    sum: {
+      type: parse.type('sum = [numeric] -> numeric'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return combine(val.elements).then(function(vals) {
+            var e, out, _i, _len;
+            out = 0;
+            for (_i = 0, _len = vals.length; _i < _len; _i++) {
+              e = vals[_i];
+              out += e.value;
+            }
+            return Promise.unit(Value.number(out));
+          });
+        });
+      }
+    },
+    first: {
+      type: parse.type('first = [%a] -> %a'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return val.elements[0];
+        });
+      }
+    },
+    add: {
+      type: parse.type('add numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value + rhs.value);
+        });
+      }
+    },
+    sub: {
+      type: parse.type('sub numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value - rhs.value);
+        });
+      }
+    },
+    id: {
+      type: parse.type('id = %a -> %a'),
+      impl: function(x) {
+        return x;
+      }
+    },
+    "else": {
+      type: parse.type('else = % -> bool'),
+      impl: function(_) {
+        return unit(vTrue);
+      }
+    },
+    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);
+        });
+      }
+    },
+    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);
+        });
+      }
+    },
+    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);
+        });
+      }
+    }
+  };
+})();
+// Generated by CoffeeScript 1.6.3
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
     var analyzeList, getType, getValue, lists;

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

@@ -1028,7 +1028,7 @@ parse = Gibbon.parse = (function() {
   lexeme = function(p) {
     return p.skip(ignore);
   };
-  identifier = regex(/^[a-z][\w-]*/i);
+  identifier = regex(/^[a-z][\w-]*[?]?/i);
   arrow = lexeme(string('->'));
   define = lexeme(string(':='));
   pair = lexeme(string(':'));
@@ -1213,241 +1213,6 @@ parse = Gibbon.parse = (function() {
   return parse;
 })();
 // Generated by CoffeeScript 1.6.3
-var stdlib;
-
-stdlib = Gibbon.stdlib = (function() {
-  return {
-    "case": {
-      type: parse.type('case [bool : %b] = % -> %b'),
-      impl: function(_, evalList) {
-        return evalList.then(function(list) {
-          var out, step;
-          step = function(pair, next) {
-            return pair.first.then(function(cond) {
-              if (cond.value) {
-                return pair.second;
-              } else {
-                return next();
-              }
-            });
-          };
-          out = function() {
-            throw new Error('Runtime Error: non-exhaustive cases');
-          };
-          return Promise.iter(list.elements, step, out);
-        });
-      }
-    },
-    weight: {
-      type: parse.type('weight [numeric : numeric] = % -> numeric'),
-      impl: function(_, eWeights) {
-        return eWeights.then(function(weights) {
-          return Promise.combine(weights.elements).then(function(pairs) {
-            var denominator, numerator, p, process;
-            numerator = 0;
-            denominator = 0;
-            process = function(pair) {
-              return Promise.combine([pair.first, pair.second]).after(function(_arg) {
-                var first, second;
-                first = _arg[0], second = _arg[1];
-                numerator += first.value * second.value;
-                return denominator += second.value;
-              });
-            };
-            return Promise.combine((function() {
-              var _i, _len, _results;
-              _results = [];
-              for (_i = 0, _len = pairs.length; _i < _len; _i++) {
-                p = pairs[_i];
-                _results.push(process(p));
-              }
-              return _results;
-            })()).then(function() {
-              if (denominator === 0) {
-                return Promise.fail('cannot divide by zero');
-              }
-              debugger;
-              return Promise.unit(Value.number(numerator / denominator));
-            });
-          });
-        });
-      }
-    },
-    filter: {
-      type: parse.type('filter { %a -> bool } = [%a] -> [%a]'),
-      impl: function(evalInput, evalBlock) {
-        return evalBlock.then(function(block) {
-          var fn;
-          fn = block.fn;
-          return evalInput.then(function(list) {
-            var check, e, out;
-            out = [];
-            check = function(thunk) {
-              return fn(thunk).after(function(bool) {
-                if (bool.value) {
-                  return out.push(thunk);
-                }
-              });
-            };
-            return Promise.combine((function() {
-              var _i, _len, _ref, _results;
-              _ref = list.elements;
-              _results = [];
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                e = _ref[_i];
-                _results.push(check(e));
-              }
-              return _results;
-            })()).map(function() {
-              return Value.list(out);
-            });
-          });
-        });
-      }
-    },
-    scale: {
-      type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
-      impl: function(eInput, eDomain, eRange) {
-        return Promise.combine([eInput, eDomain, eRange]).then(function(_arg) {
-          var bounds, dom, input, range;
-          input = _arg[0], dom = _arg[1], range = _arg[2];
-          bounds = Promise.combine([dom.first, dom.second, range.first, range.second]);
-          return bounds.map(function(_arg1) {
-            var domHigh, domLow, domSize, rangeHigh, rangeLow, rangeSize, retranslated, scaled, translated;
-            domLow = _arg1[0], domHigh = _arg1[1], rangeLow = _arg1[2], rangeHigh = _arg1[3];
-            if (input.value < domLow.value) {
-              input = domLow;
-            } else if (input.value > domHigh.value) {
-              input = domHigh;
-            }
-            domSize = domHigh.value - domLow.value;
-            rangeSize = rangeHigh.value - rangeLow.value;
-            translated = input.value - domLow.value;
-            scaled = translated * rangeSize / domSize;
-            retranslated = scaled + rangeLow.value;
-            return Value.number(retranslated);
-          });
-        });
-      }
-    },
-    map: {
-      type: parse.type('map { %a -> %b } = [%a] -> [%b]'),
-      impl: function(evalList, evalBlock) {
-        return evalList.then(function(list) {
-          return evalBlock.map(function(block) {
-            var e, fn;
-            fn = block.fn;
-            return Value.list((function() {
-              var _i, _len, _ref, _results;
-              _ref = list.elements;
-              _results = [];
-              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-                e = _ref[_i];
-                _results.push(fn(e));
-              }
-              return _results;
-            })());
-          });
-        });
-      }
-    },
-    count: {
-      type: parse.type('count = [%a] -> numeric'),
-      impl: function(evalList) {
-        return evalList.map(function(list) {
-          return Value.number(list.elements.length);
-        });
-      }
-    },
-    sum: {
-      type: parse.type('sum = [numeric] -> numeric'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return Promise.combine(val.elements).then(function(vals) {
-            var e, out, _i, _len;
-            out = 0;
-            for (_i = 0, _len = vals.length; _i < _len; _i++) {
-              e = vals[_i];
-              out += e.value;
-            }
-            return Promise.unit(Value.number(out));
-          });
-        });
-      }
-    },
-    first: {
-      type: parse.type('first = [%a] -> %a'),
-      impl: function(list) {
-        return list.then(function(val) {
-          return val.elements[0];
-        });
-      }
-    },
-    add: {
-      type: parse.type('add numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value + rhs.value);
-        });
-      }
-    },
-    sub: {
-      type: parse.type('sub numeric = numeric -> numeric'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.number(lhs.value - rhs.value);
-        });
-      }
-    },
-    id: {
-      type: parse.type('id = %a -> %a'),
-      impl: function(x) {
-        return x;
-      }
-    },
-    "else": {
-      type: parse.type('else = % -> bool'),
-      impl: function(_) {
-        return Promise.unit(Value.boolean(true));
-      }
-    },
-    gt: {
-      type: parse.type('gt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value > rhs.value);
-        });
-      }
-    },
-    lt: {
-      type: parse.type('lt numeric = numeric -> bool'),
-      impl: function(input, num) {
-        return Promise.combine([input, num]).map(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return Value.boolean(lhs.value < rhs.value);
-        });
-      }
-    },
-    eq: {
-      type: parse.type('eq %a = %a -> bool'),
-      impl: function(input, obj) {
-        return Promise.combine([input, obj]).then(function(_arg) {
-          var lhs, rhs;
-          lhs = _arg[0], rhs = _arg[1];
-          return lhs.equals(rhs);
-        });
-      }
-    }
-  };
-})();
-// Generated by CoffeeScript 1.6.3
 var Semantic, Type, TypeLookup, analyze, _ref, _ref1, _ref2,
   __hasProp = {}.hasOwnProperty,
   __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
@@ -2846,6 +2611,317 @@ eval_ = Gibbon["eval"] = (function() {
   };
 })();
 // Generated by CoffeeScript 1.6.3
+var stdlib;
+
+stdlib = Gibbon.stdlib = (function() {
+  var combine, iter, unit, vFalse, vTrue;
+  unit = Promise.unit;
+  iter = Promise.iter;
+  combine = Promise.combine;
+  vTrue = Value.boolean(true);
+  vFalse = Value.boolean(false);
+  return {
+    "case": {
+      type: parse.type('case [bool : %b] = % -> %b'),
+      impl: function(_, evalList) {
+        return evalList.then(function(list) {
+          var out, step;
+          step = function(pair, next) {
+            return pair.first.then(function(cond) {
+              if (cond.value) {
+                return pair.second;
+              } else {
+                return next();
+              }
+            });
+          };
+          out = function() {
+            throw new Error('Runtime Error: non-exhaustive cases');
+          };
+          return iter(list.elements, step, out);
+        });
+      }
+    },
+    "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;
+          list = _arg[0], block = _arg[1];
+          fn = block.fn;
+          booleans = (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;
+          })();
+          step = function(cond, next) {
+            if (cond.value) {
+              return unit(vTrue);
+            } else {
+              return next();
+            }
+          };
+          out = function() {
+            return unit(vFalse);
+          };
+          return iter(booleans, step, out);
+        });
+      }
+    },
+    "all?": {
+      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;
+          list = _arg[0], block = _arg[1];
+          fn = block.fn;
+          booleans = (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;
+          })();
+          step = function(cond, next) {
+            if (cond.value) {
+              return next();
+            } else {
+              return unit(vFalse);
+            }
+          };
+          out = function() {
+            return trueP;
+          };
+          return Promise.iter(booleans, step, out);
+        });
+      }
+    },
+    "empty?": {
+      type: parse.type('empty? = [%] -> bool'),
+      impl: function(evalList) {
+        return evalList.map(function(list) {
+          return Value.boolean(list.length === 0);
+        });
+      }
+    },
+    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');
+              }
+              debugger;
+              return Promise.unit(Value.number(numerator / denominator));
+            });
+          });
+        });
+      }
+    },
+    filter: {
+      type: parse.type('filter { %a -> bool } = [%a] -> [%a]'),
+      impl: function(evalInput, evalBlock) {
+        return evalBlock.then(function(block) {
+          var fn;
+          fn = block.fn;
+          return evalInput.then(function(list) {
+            var check, e, out;
+            out = [];
+            check = function(thunk) {
+              return fn(thunk).after(function(bool) {
+                if (bool.value) {
+                  return out.push(thunk);
+                }
+              });
+            };
+            return combine((function() {
+              var _i, _len, _ref, _results;
+              _ref = list.elements;
+              _results = [];
+              for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+                e = _ref[_i];
+                _results.push(check(e));
+              }
+              return _results;
+            })()).map(function() {
+              return Value.list(out);
+            });
+          });
+        });
+      }
+    },
+    scale: {
+      type: parse.type('scale (numeric:numeric) (numeric:numeric) = numeric -> numeric'),
+      impl: function(eInput, eDomain, eRange) {
+        return 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);
+          });
+        });
+      }
+    },
+    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;
+            })());
+          });
+        });
+      }
+    },
+    count: {
+      type: parse.type('count = [%a] -> numeric'),
+      impl: function(evalList) {
+        return evalList.map(function(list) {
+          return Value.number(list.elements.length);
+        });
+      }
+    },
+    sum: {
+      type: parse.type('sum = [numeric] -> numeric'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return combine(val.elements).then(function(vals) {
+            var e, out, _i, _len;
+            out = 0;
+            for (_i = 0, _len = vals.length; _i < _len; _i++) {
+              e = vals[_i];
+              out += e.value;
+            }
+            return Promise.unit(Value.number(out));
+          });
+        });
+      }
+    },
+    first: {
+      type: parse.type('first = [%a] -> %a'),
+      impl: function(list) {
+        return list.then(function(val) {
+          return val.elements[0];
+        });
+      }
+    },
+    add: {
+      type: parse.type('add numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value + rhs.value);
+        });
+      }
+    },
+    sub: {
+      type: parse.type('sub numeric = numeric -> numeric'),
+      impl: function(input, num) {
+        return combine([input, num]).map(function(_arg) {
+          var lhs, rhs;
+          lhs = _arg[0], rhs = _arg[1];
+          return Value.number(lhs.value - rhs.value);
+        });
+      }
+    },
+    id: {
+      type: parse.type('id = %a -> %a'),
+      impl: function(x) {
+        return x;
+      }
+    },
+    "else": {
+      type: parse.type('else = % -> bool'),
+      impl: function(_) {
+        return unit(vTrue);
+      }
+    },
+    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);
+        });
+      }
+    },
+    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);
+        });
+      }
+    },
+    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);
+        });
+      }
+    }
+  };
+})();
+// Generated by CoffeeScript 1.6.3
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
     var analyzeList, getType, getValue, lists;

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: goodguide-gibbon
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: therubyracer
@@ -55,7 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2471759766594341795
+      hash: 3075766379386117662
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2471759766594341795
+      hash: 3075766379386117662
 requirements: []
 rubyforge_project: goodguide-gibbon
 rubygems_version: 1.8.23