fairmont - npm Package Compare versions

Comparing version 1.0.0-beta-13 to 1.0.0-beta-14

lib/iterator.js

 // Generated by CoffeeScript 1.9.3
 (function() {
-  var assert, async, call, curry, describe, promise, ref, ref1;
+  var assert, describe, ref,
+    slice = [].slice;
 
   ref = require("./helpers"), assert = ref.assert, describe = ref.describe;
 
-  curry = require("./core").curry;
-
-  promise = require("when");
-
-  ref1 = (function() {
-    var call, lift, ref1;
-    ref1 = require("when/generator"), lift = ref1.lift, call = ref1.call;
-    return {
-      async: lift,
-      call: call
-    };
-  })(), call = ref1.call, async = ref1.async;
-
   describe("Iterator functions", function(context) {
-    var _foldr, _unzip, add, all, any, assoc, average, binary, cat, collect, compact, delimit, detach, each, first, flatten, flip, fold, foldr, isDefined, isFunction, isIterable, isIterator, iterate, iterator, join, last, leave, lines, map, negate, partition, project, property, query, ref2, reject, repeat, sample, second, select, skip, split, sum, take, ternary, third, unzip, w, where, wrap, zip;
+    var $, Method, _flatten, add, all, any, assoc, async, asyncIterator, average, binary, cat, collect, compact, compose, curry, delimit, each, either, events, filter, first, flatten, fold, foldr, has, identity, isAsyncIterable, isAsyncIterator, isAsyncIteratorFunction, isDefined, isFunction, isGenerator, isIterable, isIterator, isIteratorFunction, isSource, iterator, iteratorFunction, join, lines, map, negate, partition, project, promise, property, query, reduce, reduceRight, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, reject, repeat, resolve, second, select, split, sum, take, takeN, ternary, unzip, where, zip;
     isIterable = function(x) {
-      return x[Symbol.iterator] != null;
+      return (x != null ? x[Symbol.iterator] : void 0) != null;
     };
@@ -28,53 +16,86 @@ context.test("isIterable", function() {
     });
+    isAsyncIterable = function(x) {
+      return (x != null ? x[Symbol.asyncIterator] : void 0) != null;
+    };
     isIterator = function(x) {
-      return (x != null ? x.next : void 0) != null;
+      return ((x != null ? x.next : void 0) != null) && isIterable(x);
     };
+    isAsyncIterator = function(x) {
+      return ((x != null ? x.next : void 0) != null) && isAsyncIterable(x);
+    };
+    Method = require("./multimethods").Method;
+    iterator = Method.create();
     isFunction = require("./type").isFunction;
-    wrap = require("./core").wrap;
-    iterator = function(x) {
-      if (isIterable(x)) {
-        return x[Symbol.iterator]();
-      } else if (isIterator(x)) {
-        return x;
-      } else if ((isFunction(x)) && (x.length === 0)) {
-        return {
-          next: x
-        };
-      } else {
-        return {
-          next: wrap(x)
-        };
-      }
-    };
-    context.test("isIterator", function() {
-      return assert(isIterator(iterator([1, 2, 3])));
+    Method.define(iterator, isFunction, function(f) {
+      f.next = f;
+      f[Symbol.iterator] = function() {
+        return this["this"];
+      };
+      return f;
     });
-    context.test("iterator", function() {
-      return assert(isFunction((iterator([1, 2, 3])).next));
+    isGenerator = require("./type").isGenerator;
+    async = require("./generator").async;
+    Method.define(iterator, isGenerator, function(g) {
+      var f;
+      f = async(g);
+      f.next = f;
+      f[Symbol.asyncIterator] = function() {
+        return this["this"];
+      };
+      return f;
     });
-    iterate = function(x) {
-      var f, i;
-      i = iterator(x);
-      f = async(function*() {
-        var done, ref2, value;
-        ref2 = i.next(), done = ref2.done, value = ref2.value;
-        return {
-          done: done,
-          value: (yield value)
-        };
-      });
-      f[Symbol.iterator] = wrap(i);
+    Method.define(iterator, isIterable, function(i) {
+      return i[Symbol.iterator]();
+    });
+    Method.define(iterator, isAsyncIterable, function(i) {
+      return i[Symbol.asyncIterator]();
+    });
+    asyncIterator = Method.create();
+    Method.define(asyncIterator, isFunction, function(f) {
+      f.next = f;
+      f[Symbol.asyncIterator] = function() {
+        return this["this"];
+      };
       return f;
+    });
+    Method.define(iterator, isGenerator, function(g) {
+      var f;
+      f = async(g);
+      f.next = f;
+      f[Symbol.asyncIterator] = function() {
+        return this["this"];
+      };
+      return f;
+    });
+    Method = require("./multimethods").Method;
+    iteratorFunction = Method.create();
+    isFunction = require("./type").isFunction;
+    isIteratorFunction = function(f) {
+      return (isFunction(f)) && (isIterator(f));
     };
-    context.test("iterate", function*() {
-      var i;
-      i = iterate([1, 2, 3]);
-      assert(isIterable(i));
-      assert(((yield i())).value === 1);
-      assert(((yield i())).value === 2);
-      assert(((yield i())).value === 3);
-      return assert(((yield i())).done);
+    isAsyncIteratorFunction = function(f) {
+      return (isFunction(f)) && (isAsyncIterator(f));
+    };
+    either = require("./logical").either;
+    Method.define(iteratorFunction, either(isIterable, isAsyncIterable), function(x) {
+      return iteratorFunction(iterator(x));
     });
+    Method.define(iteratorFunction, either(isIterator, isAsyncIterator), function(i) {
+      return iterator((function() {
+        return i.next();
+      }));
+    });
+    either = require("./logical").either;
+    ref1 = require("./type"), isFunction = ref1.isFunction, isGenerator = ref1.isGenerator;
+    Method.define(iteratorFunction, either(isFunction, isGenerator), function(f) {
+      return iterator(f);
+    });
+    either = require("./logical").either;
+    identity = require("./core").identity;
+    Method.define(iteratorFunction, either(isIteratorFunction, isAsyncIteratorFunction), identity);
+    context.test("iteratorFunction", function() {
+      return assert(isIteratorFunction(iteratorFunction([1, 2, 3, 4, 5])));
+    });
     repeat = function(x) {
-      return function() {
+      return iterator(function() {
         return {
@@ -84,111 +105,187 @@ done: false,
         };
-      };
+      });
     };
-    collect = async(function*(i) {
-      var done, ref2, result, value;
-      i = iterate(i);
-      done = false;
-      result = [];
-      while (!done) {
+    $ = (function() {
+      return true;
+    });
+    Method = require("./multimethods").Method;
+    collect = Method.create();
+    Method.define(collect, $, function(x) {
+      return collect(iteratorFunction(x));
+    });
+    Method.define(collect, isIteratorFunction, function(i) {
+      var done, ref2, results, value;
+      results = [];
+      while (true) {
+        ref2 = i(), done = ref2.done, value = ref2.value;
+        if (done) {
+          break;
+        }
+        results.push(value);
+      }
+      return results;
+    });
+    async = require("./generator").async;
+    Method.define(collect, isAsyncIteratorFunction, async(function*(i) {
+      var done, ref2, results, value;
+      results = [];
+      while (true) {
         ref2 = (yield i()), done = ref2.done, value = ref2.value;
-        if (!done) {
-          result.push(value);
+        if (done) {
+          break;
         }
+        results.push(value);
       }
-      return result;
-    });
-    context.test("collect", function*() {
+      return results;
+    }));
+    context.test("collect", function() {
       var first;
       first = require("./array").first;
-      return assert((first((yield collect([1, 2, 3, 4, 5])))) === 1);
+      return assert((first(collect([1, 2, 3, 4, 5]))) === 1);
     });
-    each = async(function*(f, i) {
-      var done, ref2, value;
-      i = iterate(i);
-      done = false;
-      while (!done) {
-        ref2 = (yield i()), done = ref2.done, value = ref2.value;
-        if (!done) {
-          f(value);
+    map = Method.create();
+    Method.define(map, Function, $, function(f, x) {
+      return map(f, iteratorFunction(x));
+    });
+    Method.define(map, Function, isIteratorFunction, function(f, i) {
+      return iterator(function() {
+        var done, ref2, value;
+        ref2 = i(), done = ref2.done, value = ref2.value;
+        if (done) {
+          return {
+            done: done
+          };
+        } else {
+          return {
+            done: done,
+            value: f(value)
+          };
         }
-      }
-      return void 0;
+      });
     });
-    map = curry(function(f, i) {
-      i = iterate(i);
-      return async(function*() {
+    Method.define(map, Function, isAsyncIteratorFunction, function(f, i) {
+      iterator(function*() {
         var done, ref2, value;
         ref2 = (yield i()), done = ref2.done, value = ref2.value;
-        if (!done) {
+        if (done) {
           return {
-            done: done,
-            value: (yield promise(f(value)))
+            done: done
           };
         } else {
           return {
-            done: done
+            done: done,
+            value: f(value)
           };
         }
       });
+      return map = curry(binary(map));
     });
     context.test("map", function() {
-      var double, x;
-      double = function(x) {
-        return x * 2;
-      };
-      x = collect(map(double, [1, 2, 3]));
-      return assert(x[1] === 4);
+      var i;
+      i = map(Math.sqrt, [1, 4, 9]);
+      assert(i().value === 1);
+      assert(i().value === 2);
+      assert(i().value === 3);
+      return assert(i().done);
     });
-    ternary = require("./core").ternary;
-    fold = curry(ternary(async(function*(x, f, i) {
-      var done, ref2, value;
-      i = iterate(i);
-      done = false;
-      while (!done) {
-        ref2 = (yield promise(i())), done = ref2.done, value = ref2.value;
-        if (!done) {
-          x = f(x, value);
+    ref2 = require("./core"), curry = ref2.curry, compose = ref2.compose, binary = ref2.binary;
+    each = curry(binary(compose(collect, map)));
+    context.test("each", function() {
+      var last;
+      last = require("./array").last;
+      return assert((last(each((function(x) {
+        return x + 1;
+      }), [1, 2, 3, 4, 5]))) === 6);
+    });
+    ref3 = require("./core"), curry = ref3.curry, ternary = ref3.ternary;
+    fold = Method.create();
+    Method.define(fold, $, Function, $, function(x, f, y) {
+      return fold(x, f, iteratorFunction(y));
+    });
+    Method.define(fold, $, Function, isIteratorFunction, function(x, f, i) {
+      var done, ref4, value;
+      while (true) {
+        ref4 = i(), done = ref4.done, value = ref4.value;
+        if (done) {
+          break;
         }
+        x = f(x, value);
       }
       return x;
-    })));
+    });
+    Method.define(fold, $, Function, isAsyncIteratorFunction, async(function*(x, f, i) {
+      var done, ref4, value;
+      while (true) {
+        ref4 = (yield i()), done = ref4.done, value = ref4.value;
+        if (done) {
+          break;
+        }
+        x = f(x, value);
+      }
+      return x;
+    }));
+    reduce = fold = curry(ternary(fold));
     add = require("./numeric").add;
-    context.test("fold", function*() {
-      return assert(((yield fold(0, add, [1, 2, 3, 4, 5]))) === 15);
+    context.test("fold/reduce", function() {
+      var sum;
+      sum = fold(0, add);
+      return assert((sum([1, 2, 3, 4, 5])) === 15);
     });
-    flip = require("./core").flip;
-    detach = require("./object").detach;
-    _foldr = flip(ternary(detach(Array.prototype.reduceRight)));
-    foldr = curry(ternary(async(function*(x, f, i) {
-      return _foldr(x, f, (yield collect(iterate(i))));
-    })));
-    context.test("foldr", function*() {
-      return assert(((yield foldr("", add, "panama"))) === "amanap");
+    ref4 = require("./core"), curry = ref4.curry, ternary = ref4.ternary;
+    foldr = Method.create();
+    Method.define(foldr, $, Function, $, function(x, f, y) {
+      return foldr(x, f, iteratorFunction(y));
     });
-    select = curry(function(f, i) {
-      var done;
-      i = iterate(i);
-      done = false;
-      return async(function*() {
-        var found, ref2, value;
-        if (!done) {
-          found = false;
-          while (!(done || found)) {
-            ref2 = (yield promise(i())), value = ref2.value, done = ref2.done;
-            if (!done) {
-              found = f(value);
-            }
+    Method.define(foldr, $, Function, isIteratorFunction, function(x, f, i) {
+      return (collect(i)).reduceRight(f, x);
+    });
+    Method.define(foldr, $, Function, isAsyncIteratorFunction, async(function*(x, f, i) {
+      return ((yield collect(i))).reduceRight(f, x);
+    }));
+    reduceRight = foldr = curry(ternary(foldr));
+    add = require("./numeric").add;
+    context.test("foldr/reduceRight", function() {
+      return assert((foldr("", add, "panama")) === "amanap");
+    });
+    select = Method.create();
+    Method.define(select, Function, $, function(f, x) {
+      return select(f, iteratorFunction(x));
+    });
+    Method.define(select, Function, isIteratorFunction, function(f, i) {
+      return iterator(function() {
+        var done, ref5, value;
+        while (true) {
+          ref5 = i(), done = ref5.done, value = ref5.value;
+          if (done || (f(value))) {
+            break;
           }
-          if (found) {
-            return {
-              done: done,
-              value: value
-            };
-          } else {
-            return {
-              done: done
-            };
+        }
+        if (done) {
+          return {
+            done: done
+          };
+        } else {
+          return {
+            value: value,
+            done: done
+          };
+        }
+      });
+    });
+    Method.define(select, Function, isIteratorFunction, function(f, i) {
+      return iterator(function() {
+        var done, ref5, value;
+        while (true) {
+          ref5 = i(), done = ref5.done, value = ref5.value;
+          if (done || (f(value))) {
+            break;
           }
+        }
+        if (done) {
+          return {
+            done: done
+          };
         } else {
           return {
+            value: value,
             done: done
@@ -199,7 +296,10 @@ };
     });
-    context.test("select", function*() {
-      var odd, second;
-      second = require("./array").second;
+    ref5 = require("./core"), binary = ref5.binary, curry = ref5.curry;
+    select = filter = curry(binary(select));
+    context.test("select", function() {
+      var i, odd;
       odd = require("./numeric").odd;
-      return assert((second((yield collect(select(odd, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))))) === 3);
+      i = select(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      assert(i().value === 1);
+      return assert(i().value === 3);
     });
@@ -210,123 +310,162 @@ negate = require("./logical").negate;
     });
-    context.test("reject", function*() {
-      var odd, second;
-      second = require("./array").second;
+    context.test("reject", function() {
+      var i, odd;
       odd = require("./numeric").odd;
-      return assert((second((yield collect(reject(odd, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))))) === 2);
+      i = reject(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      assert(i().value === 2);
+      return assert(i().value === 4);
     });
-    binary = require("./core").binary;
-    any = curry(binary(async(function*(f, i) {
-      var done, found, ref2, value;
-      i = iterate(i);
-      done = false;
-      found = false;
-      while (!(done || found)) {
-        ref2 = (yield promise(i())), done = ref2.done, value = ref2.value;
-        if (!done) {
-          found = f(value);
+    any = Method.create();
+    Method.define(any, Function, $, function(f, x) {
+      return any(f, iteratorFunction(x));
+    });
+    Method.define(any, Function, isIteratorFunction, function(f, i) {
+      var done, ref6, value;
+      while (true) {
+        ref6 = i(), done = ref6.done, value = ref6.value;
+        if (done || (f(value))) {
+          break;
         }
       }
-      return found;
-    })));
-    context.test("any", function*() {
-      var count, odd, test;
+      return !done;
+    });
+    Method.define(any, Function, isAsyncIteratorFunction, async(function*(f, i) {
+      var done, ref6, value;
+      while (true) {
+        ref6 = (yield i()), done = ref6.done, value = ref6.value;
+        if (done || (f(value))) {
+          break;
+        }
+      }
+      return !done;
+    }));
+    ref6 = require("./core"), curry = ref6.curry, binary = ref6.binary;
+    any = curry(binary(any));
+    context.test("any", function() {
+      var odd;
       odd = require("./numeric").odd;
-      count = 0;
-      test = function(x) {
-        count++;
-        return odd(x);
-      };
-      assert((yield any(test, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])));
-      return assert(count === 2);
+      assert(any(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]));
+      return assert(!(any(odd, [2, 4, 6])));
     });
-    all = curry(binary(async(function*(f, i) {
-      return !(yield any(negate(f), i));
-    })));
-    context.test("all", function*() {
+    all = Method.create();
+    Method.define(all, Function, $, function(f, x) {
+      return all(f, iteratorFunction(x));
+    });
+    Method.define(all, Function, isIteratorFunction, function(f, i) {
+      return !any(negate(f), i);
+    });
+    Method.define(all, Function, isAsyncIteratorFunction, async(function*(f, i) {
+      return !((yield any(negate(f), i)));
+    }));
+    all = curry(binary(all));
+    context.test("all", function() {
       var odd;
       odd = require("./numeric").odd;
-      assert(!((yield all(odd, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))));
-      return assert((yield all((function() {
-        return true;
-      }), "foobar")));
+      assert(!(all(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])));
+      return assert(all(odd, [1, 3, 5]));
     });
-    zip = function(i, j) {
-      i = iterate(i);
-      j = iterate(j);
-      return async(function*() {
-        var _i, _j;
-        if ((_i = (yield i())).done || (_j = j()).done) {
+    zip = Method.create();
+    Method.define(zip, Function, $, $, function(f, x, y) {
+      return zip(f, iteratorFunction(x), iteratorFunction(y));
+    });
+    Method.define(zip, Function, isIteratorFunction, isIteratorFunction, function(f, i, j) {
+      return iterator(function() {
+        var x, y;
+        x = i();
+        y = j();
+        if (!x.done && !y.done) {
           return {
-            done: true
+            value: f(x.value, y.value),
+            done: false
           };
         } else {
           return {
-            done: false,
-            value: [_i.value, _j.value]
+            done: true
           };
         }
       });
-    };
-    context.test("zip", function*() {
-      var ref2, second, third;
-      ref2 = require("./array"), second = ref2.second, third = ref2.third;
-      return assert((second(third((yield collect(zip([1, 2, 3], [4, 5, 6])))))) === 6);
     });
-    _unzip = function(arg, arg1) {
-      var a, ax, b, bx;
-      ax = arg[0], bx = arg[1];
-      a = arg1[0], b = arg1[1];
-      ax.push(a);
-      bx.push(b);
-      return [ax, bx];
+    context.test("zip", function() {
+      var i, pair;
+      pair = function(x, y) {
+        return [x, y];
+      };
+      i = zip(pair, [1, 2, 3], [4, 5, 6]);
+      assert(i().value[0] === 1);
+      assert(i().value[1] === 5);
+      assert(i().value[0] === 3);
+      return assert(i().done);
+    });
+    unzip = function(f, i) {
+      return fold([[], []], f, i);
     };
-    unzip = function(i) {
-      return fold([[], []], _unzip, i);
-    };
     context.test("unzip", function() {
-      var first, toString;
-      first = require("./array").first;
-      toString = require("./string").toString;
-      return assert((fold("", add, first(collect(unzip(zip("panama", "canary")))))) === "panama");
+      var pair, unpair;
+      pair = function(x, y) {
+        return [x, y];
+      };
+      unpair = function(arg, arg1) {
+        var a, ax, b, bx;
+        ax = arg[0], bx = arg[1];
+        a = arg1[0], b = arg1[1];
+        ax.push(a);
+        bx.push(b);
+        return [ax, bx];
+      };
+      return assert((unzip(unpair, zip(pair, "panama", "canary")))[0][0] === "p");
     });
-    ref2 = require("./array"), first = ref2.first, second = ref2.second;
-    assoc = async(function(i) {
-      return (function*(i) {
-        var done, ref3, result, value;
-        result = {};
-        while (!done) {
-          ref3 = (yield i()), done = ref3.done, value = ref3.value;
-          if (value != null) {
-            result[first(value)] = second(value);
-          }
+    ref7 = require("./array"), first = ref7.first, second = ref7.second;
+    assoc = Method.create();
+    Method.define(assoc, $, function(x) {
+      return assoc(iteratorFunction(x));
+    });
+    Method.define(assoc, isIteratorFunction, function(i) {
+      var done, ref8, result, value;
+      result = {};
+      while (true) {
+        ref8 = i(), done = ref8.done, value = ref8.value;
+        if (done) {
+          break;
         }
-        return result;
-      })(iterate(i));
+        result[first(value)] = second(value);
+      }
+      return result;
     });
-    context.test("assoc", function*() {
-      return assert(((yield assoc([["foo", 1], ["bar", 2]]))).foo === 1);
+    Method.define(assoc, isAsyncIteratorFunction, function*(i) {
+      var done, ref8, result, value;
+      result = {};
+      while (true) {
+        ref8 = (yield i()), done = ref8.done, value = ref8.value;
+        if (done) {
+          break;
+        }
+        result[first(value)] = second(value);
+      }
+      return result;
     });
+    context.test("assoc", function() {
+      return assert((assoc([["foo", 1], ["bar", 2]])).foo === 1);
+    });
     property = require("./object").property;
-    w = require("./string").w;
-    project = curry(binary(async(function*(p, i) {
-      return (yield map(property(p), i));
-    })));
-    third = require("./array").third;
+    curry = require("./core").curry;
+    project = curry(function(p, i) {
+      return map(property(p), i);
+    });
     context.test("project", function() {
-      return assert((third(collect(project("length", w("one two three"))))) === 5);
+      var i, w;
+      w = require("./string").w;
+      i = project("length", w("one two three"));
+      return assert(i().value === 3);
     });
-    flatten = function(ax) {
-      return fold([], (function(r, a) {
-        if (a.forEach != null) {
-          r.push.apply(r, flatten(a));
-        } else {
-          r.push(a);
-        }
-        return r;
-      }), ax);
+    _flatten = function(ax, a) {
+      if (isIterable(a)) {
+        return ax.concat(flatten(a));
+      } else {
+        ax.push(a);
+        return ax;
+      }
     };
+    flatten = fold([], _flatten);
     context.test("flatten", function() {
-      return (function*(data) {
-        return assert((second((yield flatten(data)))) === 2);
-      })([1, [2, 3], 4, [5, [6, 7]]]);
+      return assert((flatten([1, [2, 3], 4, [5, [6, 7]]]))[1] === 2);
     });
@@ -336,16 +475,24 @@ isDefined = require("./type").isDefined;
     context.test("compact", function() {
-      return assert((second(collect(compact([1, null, null, 2])))) === 2);
+      var i;
+      i = compact([1, null, null, 2]);
+      assert(i().value === 1);
+      return assert(i().value === 2);
     });
-    partition = curry(function(n, i) {
-      var done;
-      i = iterate(i);
-      done = false;
-      return async(function*() {
-        var batch, ref3, value;
+    partition = Method.create();
+    Method.define(partition, Number, $, function(n, x) {
+      return partition(n, iteratorFunction(x));
+    });
+    Method.define(partition, Number, isIteratorFunction, function(n, i) {
+      return iterator(function() {
+        var batch, done, ref8, value;
         batch = [];
-        while (!(done || batch.length === n)) {
-          ref3 = (yield promise(i())), done = ref3.done, value = ref3.value;
-          if (!done) {
-            batch.push(value);
+        while (true) {
+          ref8 = i(), done = ref8.done, value = ref8.value;
+          if (done) {
+            break;
           }
+          batch.push(value);
+          if (batch.length === n) {
+            break;
+          }
         }
@@ -364,28 +511,23 @@ if (done) {
     });
-    context.test("partition", function() {
-      var ref3;
-      ref3 = require("./array"), first = ref3.first, second = ref3.second;
-      return assert((first(second(collect(partition(2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))))) === 2);
-    });
-    take = curry(function(n, i) {
-      var done;
-      i = iterate(i);
-      done = false;
-      return async(function*() {
-        var ref3, value;
-        if (!(done || n-- === 0)) {
-          ref3 = (yield promise(i())), done = ref3.done, value = ref3.value;
+    Method.define(partition, Number, isAsyncIteratorFunction, function(n, i) {
+      return iterator(function*() {
+        var batch, done, ref8, value;
+        batch = [];
+        while (true) {
+          ref8 = (yield i()), done = ref8.done, value = ref8.value;
           if (done) {
-            return {
-              done: done
-            };
-          } else {
-            return {
-              done: done,
-              value: value
-            };
+            break;
           }
+          batch.push(value);
+          if (batch.length === n) {
+            break;
+          }
+        }
+        if (done) {
+          return {
+            done: done
+          };
         } else {
-          done = true;
           return {
+            value: batch,
             done: done
@@ -396,26 +538,8 @@ };
     });
-    last = require("./array").last;
-    context.test("take", function() {
-      return assert((last(collect(take(3, [1, 2, 3, 4, 5])))) === 3);
+    context.test("partition", function() {
+      var i;
+      i = partition(2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      assert(i().value[0] === 0);
+      return assert(i().value[0] === 2);
     });
-    leave = curry(binary(async(function*(n, i) {
-      return ((yield collect(i))).slice(0, -n);
-    })));
-    context.test("leave", function() {
-      return assert((last(leave(3, [1, 2, 3, 4, 5]))) === 2);
-    });
-    skip = curry(binary(async(function*(n, i) {
-      return ((yield collect(i))).slice(n);
-    })));
-    context.test("skip", function() {
-      return assert((first(skip(3, [1, 2, 3, 4, 5]))) === 4);
-    });
-    sample = curry(function(n, i) {
-      var _sample;
-      _sample = function() {
-        return Math.random() < n;
-      };
-      return select(_sample, i);
-    });
-    context.test("sample");
     add = require("./numeric").add;
@@ -438,5 +562,52 @@ sum = fold(0, add);
     });
+    take = Method.create();
+    Method.define(take, Function, $, function(f, x) {
+      return take(f, iteratorFunction(x));
+    });
+    Method.define(take, Function, isIteratorFunction, function(f, i) {
+      return iterator(function() {
+        var done, ref8, value;
+        if (!done) {
+          ref8 = i(), done = ref8.done, value = ref8.value;
+          if (!done && (f(value))) {
+            return {
+              value: value,
+              done: false
+            };
+          } else {
+            return {
+              done: true
+            };
+          }
+        }
+      });
+    });
+    take = curry(binary(take));
+    context.test("take");
+    takeN = (function() {
+      var f;
+      f = function(n, i) {
+        if (i == null) {
+          i = 0;
+        }
+        return function() {
+          return i++ < n;
+        };
+      };
+      return function(n, i) {
+        return take(f(n), i);
+      };
+    })();
+    context.test("takeN", function() {
+      var i;
+      i = takeN(3, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+      assert(i().value === 0);
+      assert(i().value === 1);
+      assert(i().value === 2);
+      return assert(i().done);
+    });
     cat = require("./array").cat;
     join = fold("", add);
     context.test("join", function() {
+      var w;
       w = require("./string").w;
@@ -457,2 +628,3 @@ return assert((join(w("one two three"))) === "onetwothree");
     context.test("delimit", function() {
+      var w;
       w = require("./string").w;
@@ -462,3 +634,2 @@ return assert((delimit(", ", w("one two three"))) === "one, two, three");
     query = require("./object").query;
-    cat = require("./array").cat;
     where = curry(function(example, i) {
@@ -468,35 +639,96 @@ return select(query(example), i);
     context.test("where", function() {
-      return assert((collect(where(["a", 1], zip(repeat("a"), [1, 2, 3, 1, 2, 3])))).length === 2);
+      var pair;
+      pair = function(x, y) {
+        return [x, y];
+      };
+      return assert((collect(where(["a", 1], zip(pair, repeat("a"), [1, 2, 3, 1, 2, 3])))).length === 2);
     });
-    split = curry(function(f, i) {
-      var done, lines;
+    split = Method.create();
+    Method.define(split, Function, $, function(f, x) {
+      return split(f, iteratorFunction(x));
+    });
+    Method.define(split, Function, isIteratorFunction, function(f, i) {
+      var lines, remainder;
       lines = [];
-      done = false;
-      return async(function*() {
-        var k, len, line, ref3, ref4, value;
-        if (done) {
-          ({
-            done: done
-          });
-        } else if (lines.length > 0) {
-          lines.shift();
+      remainder = "";
+      return iterator(function() {
+        var done, k, last, ref8, ref9, value;
+        if (lines.length > 0) {
+          return {
+            value: lines.shift(),
+            done: false
+          };
         } else {
-          ref3 = (yield i()), value = ref3.value, done = ref3.done;
+          ref8 = i(), value = ref8.value, done = ref8.done;
           if (!done) {
-            ref4 = f(value);
-            for (k = 0, len = ref4.length; k < len; k++) {
-              line = ref4[k];
-              if (value !== "") {
-                lines.push({
-                  value: line,
-                  done: false
-                });
-              }
-            }
+            ref9 = f(value), first = ref9[0], lines = 3 <= ref9.length ? slice.call(ref9, 1, k = ref9.length - 1) : (k = 1, []), last = ref9[k++];
+            first = remainder + first;
+            remainder = last;
+            return {
+              value: first,
+              done: done
+            };
+          } else if (remainder !== "") {
+            value = remainder;
+            remainder = "";
+            return {
+              value: value,
+              done: false
+            };
+          } else {
+            return {
+              done: done
+            };
           }
         }
-        return lines.shift();
       });
     });
-    context.test("split");
+    Method.define(split, Function, isIteratorFunction, function(f, i) {
+      var lines, remainder;
+      lines = [];
+      remainder = "";
+      return iterator(function*() {
+        var done, k, last, ref8, ref9, value;
+        if (lines.length > 0) {
+          return {
+            value: lines.shift(),
+            done: false
+          };
+        } else {
+          ref8 = (yield i()), value = ref8.value, done = ref8.done;
+          if (!done) {
+            ref9 = f(value), first = ref9[0], lines = 3 <= ref9.length ? slice.call(ref9, 1, k = ref9.length - 1) : (k = 1, []), last = ref9[k++];
+            first = remainder + first;
+            remainder = last;
+            return {
+              value: first,
+              done: done
+            };
+          } else if (remainder !== "") {
+            value = remainder;
+            remainder = "";
+            return {
+              value: value,
+              done: false
+            };
+          } else {
+            return {
+              done: done
+            };
+          }
+        }
+      });
+    });
+    split = curry(binary(split));
+    context.test("split", function() {
+      var i;
+      i = split((function(x) {
+        return x.split("\n");
+      }), ["one\ntwo\n", "three\nfour"]);
+      assert(i().value === "one");
+      assert(i().value === "two");
+      assert(i().value === "three");
+      assert(i().value === "four");
+      return assert(i().done);
+    });
     lines = split(function(s) {
@@ -515,17 +747,89 @@ return s.split("\n");
     });
+    ref8 = require("when"), promise = ref8.promise, reject = ref8.reject, resolve = ref8.resolve;
+    has = require("./object").has;
+    events = Method.create();
+    isSource = compose(isFunction, property("on"));
+    Method.define(events, String, isSource, function(name, source) {
+      return events({
+        name: name,
+        end: "end",
+        error: "error"
+      }, source);
+    });
+    Method.define(events, Object, isSource, function(map, source) {
+      var dequeue, done, end, enqueue, error, name, pending, resolved;
+      name = map.name, end = map.end, error = map.error;
+      done = false;
+      pending = [];
+      resolved = [];
+      enqueue = function(x) {
+        var ref9;
+        if (pending.length === 0) {
+          return resolved.push(x);
+        } else {
+          ref9 = pending.shift(), resolve = ref9.resolve, reject = ref9.reject;
+          return x.then(resolve)["catch"](reject);
+        }
+      };
+      dequeue = function() {
+        if (resolved.length === 0) {
+          if (!done) {
+            return promise(function(resolve, reject) {
+              return pending.push({
+                resolve: resolve,
+                reject: reject
+              });
+            });
+          } else {
+            return resolve({
+              done: done
+            });
+          }
+        } else {
+          return resolved.shift();
+        }
+      };
+      source.on(name, function(value) {
+        return enqueue(resolve({
+          done: done,
+          value: value
+        }));
+      });
+      source.on(end, function() {
+        return done = true;
+      });
+      source.on(error, function() {
+        return enqueue(reject(error));
+      });
+      return asyncIterator(dequeue);
+    });
+    events = curry(binary(events));
+    context.test("events", function*() {
+      var createReadStream, i;
+      createReadStream = require("fs").createReadStream;
+      i = events("data", createReadStream("test/lines.txt"));
+      assert(((yield i())).value.toString() === "one\ntwo\nthree\n");
+      return console.log((yield i()));
+    });
     return module.exports = {
       isIterable: isIterable,
+      isAsyncIterable: isAsyncIterable,
       iterator: iterator,
       isIterator: isIterator,
-      iterate: iterate,
+      isAsyncIterator: isAsyncIterator,
+      iteratorFunction: iteratorFunction,
+      isIteratorFunction: isIteratorFunction,
+      isAsyncIteratorFunction: isAsyncIteratorFunction,
       collect: collect,
       map: map,
       fold: fold,
+      reduce: reduce,
       foldr: foldr,
+      reduceRight: reduceRight,
       select: select,
       reject: reject,
+      filter: filter,
       any: any,
       all: all,
       zip: zip,
-      unzip: unzip,
       assoc: assoc,
@@ -536,6 +840,2 @@ project: project,
       partition: partition,
-      take: take,
-      leave: leave,
-      skip: skip,
-      sample: sample,
       sum: sum,
@@ -546,3 +846,6 @@ average: average,
       where: where,
-      repeat: repeat
+      lines: lines,
+      split: split,
+      take: take,
+      takeN: takeN
     };
@@ -549,0 +852,0 @@ });

lib/multimethods.js

 // Generated by CoffeeScript 1.9.3
 (function() {
-  var Method, assert, create, define, describe, dispatch, ref,
+  var Method, assert, create, define, describe, dispatch, lookup, ref,
     slice = [].slice,
@@ -8,3 +8,3 @@ extend = 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; },
 
-  dispatch = function(method, ax) {
+  lookup = function(method, ax) {
     var arg, best, bi, bx, f, i, len, p, ref, ref1, term, ti, tx;
@@ -36,2 +36,5 @@ best = {
               p += 5;
+            } else {
+              p = 0;
+              break;
             }
@@ -52,26 +55,18 @@ } else {
     if (best.f.constructor === Function) {
-      return best.f.apply(best, ax);
+      return best.f;
     } else {
-      return best.f;
+      return function() {
+        return best.f;
+      };
     }
   };
 
-  create = function() {
-    var arg, args, description, m, map;
-    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
-    args = args.slice(0, 2);
-    map = description = void 0;
-    while ((arg = args.shift())) {
-      switch (arg.constructor) {
-        case String:
-          if (description == null) {
-            description = arg;
-          }
-          break;
-        case Function:
-          if (map == null) {
-            map = arg;
-          }
-      }
-    }
+  dispatch = function(method, ax) {
+    var f;
+    f = lookup(method, ax);
+    return f.apply(null, ax);
+  };
+
+  create = function(options) {
+    var k, m, v;
     m = function() {
@@ -83,7 +78,11 @@ var args;
     m.entries = [];
-    m["default"] = function() {
-      throw new TypeError("No method matches arguments.");
-    };
-    m.map = map;
-    m.description = description;
+    for (k in options) {
+      v = options[k];
+      m[k] = v;
+    }
+    if (m["default"] == null) {
+      m["default"] = function() {
+        throw new TypeError("No method matches arguments.");
+      };
+    }
     return m;
@@ -100,3 +99,4 @@ };
     create: create,
-    define: define
+    define: define,
+    lookup: lookup
   };
@@ -113,3 +113,5 @@
       var fib;
-      fib = Method.create("Fibonacci sequence");
+      fib = Method.create({
+        description: "Fibonacci sequence"
+      });
       Method.define(fib, (function(n) {
@@ -172,4 +174,6 @@ return n <= 0;
       var bar;
-      bar = Method.create(function(x) {
-        return [x];
+      bar = Method.create({
+        map: function(x) {
+          return [x];
+        }
       });
@@ -228,7 +232,19 @@ Method.define(bar, String, function() {
     });
-    return context.test("Multimethods are functions, too", function() {
+    context.test("Multimethods are functions", function() {
       return assert(Method.create().constructor === Function);
     });
+    return context.test("Lookups", function() {
+      var f, foo;
+      foo = Method.create();
+      Method.define(foo, Number, function(x) {
+        return x + x;
+      });
+      Method.define(foo, String, function(x) {
+        return false;
+      });
+      f = Method.lookup(foo, [7]);
+      return assert((f(7)) === 14);
+    });
   });
 
 }).call(this);

package.json

 {
   "name": "fairmont",
-  "version": "1.0.0-beta-13",
+  "version": "1.0.0-beta-14",
   "description": "A collection of useful functions and utilities.",
@@ -5,0 +5,0 @@ "files": [

No alert changes

Improved metrics

Total package byte prevSize

151631

increased by16.43%

Lines of code

2715

increased by13.46%

Worsened metrics

Number of low supply chain risk alerts

6

increased by20%

No dependency changes