├── .gitignore ├── .travis.yml ├── package.json ├── LICENSE ├── README.md ├── src └── functify.js ├── test └── test_spec.js └── dist └── functify.js /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - "iojs" 4 | script: npm test 5 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "functify", 3 | "version": "0.4.0", 4 | "description": "Add functional methods like map, reduce, filter, etc. iterables (ES6 Iterators).", 5 | "main": "dist/functify.js", 6 | "directories": { 7 | "test": "test" 8 | }, 9 | "scripts": { 10 | "test": "mocha --compilers js:babel-core/register test/test_spec.js", 11 | "build": "browserify ./src/functify.js -t [ babelify] -o dist/functify.js -s functify" 12 | }, 13 | "repository": { 14 | "type": "git", 15 | "url": "https://github.com/kevinb7/functify" 16 | }, 17 | "author": "Kevin Barabash ", 18 | "license": "MIT", 19 | "devDependencies": { 20 | "babel": "^5.8.23", 21 | "babel-core": "^5.8.25", 22 | "babelify": "^6.3.0", 23 | "browserify": "^11.1.0", 24 | "mocha": "^2.1.0" 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Kevin Barabash 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # functify 2 | [![Build Status](https://travis-ci.org/kevinbarabash/functify.svg?branch=v0.3.3)](https://travis-ci.org/kevinbarabash/functify) 3 | 4 | Add functional methods like map, reduce, filter, etc. to iterables (ES6 Iterators). 5 | 6 | ## Why 7 | 8 | Only Array has handy functions like map, reduce, filter, etc. Other iterable 9 | objects such as Map, Set, String, NodeList, and your own iterables don't. It 10 | would be nice if all iterables had access these functions. 11 | 12 | Unfortunately, the Array versions of map and filter return a new array. This 13 | results in wasted memory allocation when chaining map and filter. Iterators fix 14 | this. A value is only computed when the final iterator in chain is asked for the 15 | next value. The intermediate values are passed through the chain but aren't 16 | permenantly stored anywhere. 17 | 18 | This sounds an awful like transducers. It is, the main difference is that 19 | methods can be called in-line as opposed composing function _a priori_. 20 | 21 | ## Usage 22 | 23 | let f = require('functify'); 24 | 25 | let numbers = f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); 26 | 27 | for (let odd in numbers.filter(n => n % 2)) { 28 | console.log(n); // 1, 3, 5, ... 29 | } 30 | 31 | for (let even in numbers.filter(n => !(n % 2))) { 32 | console.log(n); // 2, 4, 6, ... 33 | } 34 | 35 | for (let [odd, even] in numbers.split(n => n % 2, n => !(n % 2)).zip()) { 36 | console.log(`odd = ${odd}, even = ${even}`); // [1, 2], [3, 4], ... 37 | } 38 | 39 | for (let square in numbers.take(3).map(n => n * n)) { 40 | console.log(square); // 1, 4, 9 41 | } 42 | 43 | ## Maps and Objects 44 | 45 | The new Map class in ES6 has three methods which return iterators: 46 | 47 | - `keys()` 48 | - `values()` 49 | - `entries()` 50 | 51 | A Map instance itself can be used as an iterator, e.g. 52 | 53 | let map = new Map(); 54 | map.set('x', 5); 55 | map.set('y', 10); 56 | 57 | for (let [k, v] of map) { 58 | console.log(`map['${k}'] = ${v}`); // map['x'] = 5, map['y'] = 10 59 | } 60 | 61 | `functify` wraps Map instances and exposes versions of `keys()`, `values()`, 62 | and `entries()` that methods like `map()` and `filter()` can be chained to, e.g. 63 | 64 | for (let v2 of functify(map).entries().map(pair => pair[1] * pair[1])) { 65 | console.log(v2); // 25, 100 66 | } 67 | 68 | Note: chaining in the opposite order is not allowed because map may return 69 | something that isn't an entry, i.e. a [key, value] pair. 70 | 71 | Plain old JavaScript objects do not have methods. ES5 has the static method 72 | `Object.keys()` and there is a pre-strawman proposal to add `Object.values()` 73 | and `Object.entries()`. The problem with these methods is that they return 74 | arrays which consume memory. 75 | 76 | `functify` wraps Object instances, adding `keys()`, `values()`, and `entries()` 77 | methods along with all the other methods that `functify` provides. 78 | 79 | let obj = { 80 | x: 5, 81 | y: 10 82 | } 83 | 84 | for (let [k, v] of functify(obj)) { 85 | console.log(`obj['${k}'] = ${v}`); // obj['x'] = 5, obj['y'] = 10 86 | } 87 | 88 | The combines the simple creation and access syntax of Objects with the powerful 89 | iterators provided by Map. 90 | 91 | ## Implementation Details 92 | 93 | functify wraps iterables in an object with methods to performan map, reduce, 94 | filter, etc. This object is also iterable. Here's how: 95 | 96 | class Functified { 97 | constructor(iterable) { 98 | this.iterable = iterable; 99 | } 100 | 101 | *[Symbol.iterator]() { 102 | for (let value of this.iterable) { 103 | yield value; 104 | } 105 | } 106 | 107 | // various instance and static methods 108 | 109 | In order to make it easier to write methods on Functified there's also a static 110 | method `fromGenerator(generator)` which takes a generator and returns an iterator. 111 | 112 | static fromGenerator(generator) { 113 | return funcitify({ 114 | [Symbol.iterator]: generator 115 | }); 116 | } 117 | 118 | This allows methods to be easily implemented. Here's the implementation for `map`: 119 | 120 | map(callback) { 121 | var iterable = this.iterable; 122 | return Functified.fromGenerator(function* () { 123 | for (let value of iterable) { 124 | yield callback(value); 125 | } 126 | }); 127 | } 128 | 129 | ## Pausable 130 | 131 | Sometimes you may want to take some of the values from the iterator, do something 132 | with those values, and then resume taking values where you left of at some point 133 | in the future. Normally you would have to resort to creating an iterator and 134 | calling `next()` manually, e.g. 135 | 136 | var numbers = [1,2,3,4,5]; 137 | var iterator = numbers[Symbol.iterator](); 138 | 139 | for (let i = 0; i < 2; i++) { 140 | console.log(iterator.next().value); 141 | } 142 | 143 | // do something else 144 | 145 | while (true) { 146 | let result = iterator.next(); 147 | if (result.done) { 148 | break; 149 | } 150 | let value = iterator.next().value; 151 | let square = value * value; 152 | console.log(value * value); 153 | } 154 | 155 | The `toPausable()` creates an iterator Below is an example of how this works. 156 | 157 | var numbers = [1,2,3,4,5]; 158 | var pausableNumbers = numbers.toPausable(); 159 | 160 | for (let n of pausableNumbers.take(2)) { 161 | console.log(n); // 1 2 162 | } 163 | 164 | // do something else 165 | 166 | for (let n of pausableNumbers.map(x => x * x).takeUntil(x => x > 16)) { 167 | console.log(n); // 9 16 168 | } 169 | -------------------------------------------------------------------------------- /src/functify.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | 3 | class Functified { 4 | 5 | constructor(iterable) { 6 | // avoid re-wrapping iterables that have already been Functified 7 | if (iterable.isFunctified) { 8 | return iterable; 9 | } 10 | this.iterable = iterable; 11 | this.isFunctified = true; 12 | } 13 | 14 | *[Symbol.iterator]() { 15 | for (let value of this.iterable) { 16 | yield value; 17 | } 18 | } 19 | 20 | // fn(iterable) -> generator function 21 | custom(fn) { 22 | return Functified.fromGenerator(fn(this.iterable)); 23 | } 24 | 25 | // alias dedupe, unique 26 | distinct() { 27 | var iterable = this.iterable; 28 | var memory = new Set(); 29 | return Functified.fromGenerator(function* () { 30 | for (let value of iterable) { 31 | if (!memory.has(value)) { 32 | memory.add(value); 33 | yield value; 34 | } 35 | } 36 | }); 37 | } 38 | 39 | filter(callback) { 40 | var iterable = this.iterable; 41 | return Functified.fromGenerator(function* () { 42 | for (let value of iterable) { 43 | if (callback(value)) { 44 | yield value; 45 | } 46 | } 47 | }); 48 | } 49 | 50 | flatten() { 51 | var iterable = this.iterable; 52 | return Functified.fromGenerator(function* () { 53 | for (let value of iterable) { 54 | if (value[Symbol.iterator]) { 55 | yield* functify(value).flatten(); 56 | } else { 57 | yield value; 58 | } 59 | } 60 | }); 61 | } 62 | 63 | groupBy(...predicates) { 64 | return functify(predicates.map(fn => this.filter(fn))); 65 | } 66 | 67 | groupByMap(map) { 68 | return functify(map).map(([name, fn]) => [name, this.filter(fn)]); 69 | } 70 | 71 | repeat(n = 1) { 72 | var iterable = this.iterable; 73 | return Functified.fromGenerator(function* () { 74 | var i = 0; 75 | while (i++ < n) { 76 | for (let value of iterable) { 77 | yield value; 78 | } 79 | } 80 | }); 81 | } 82 | 83 | // alias for repeat 84 | loop(n = 1) { 85 | console.warn("deprecating loop(n), use repeat(n) instead"); 86 | return this.repeat(n); 87 | } 88 | 89 | map(callback) { 90 | var iterable = this.iterable; 91 | return Functified.fromGenerator(function* () { 92 | for (let value of iterable) { 93 | yield callback(value); 94 | } 95 | }); 96 | } 97 | 98 | skip(n) { 99 | var iterable = this.iterable; 100 | return Functified.fromGenerator(function* () { 101 | var i = 0; 102 | for (let value of iterable) { 103 | if (i < n) { 104 | i++; 105 | } else { 106 | yield value; 107 | } 108 | } 109 | }); 110 | } 111 | 112 | skipWhile(predicate) { 113 | var iterable = this.iterable; 114 | return Functified.fromGenerator(function* () { 115 | var skip = true; 116 | for (let value of iterable) { 117 | if (!predicate(value)) { 118 | skip = false; 119 | } 120 | if (!skip) { 121 | yield value; 122 | } 123 | } 124 | }); 125 | } 126 | 127 | take(n) { 128 | // using an explicit iterator supports pausable iteratables 129 | var iterator = this.iterable[Symbol.iterator](); 130 | var self = this; 131 | return Functified.fromGenerator(function* () { 132 | let i = 0; 133 | if (self.hasOwnProperty("startValue") && self.isPausable) { 134 | yield self.startValue; 135 | i++; 136 | } 137 | while (i < n) { 138 | var result = iterator.next(); 139 | if (result.done) { 140 | break; 141 | } else { 142 | yield result.value; 143 | i++; 144 | } 145 | } 146 | }); 147 | } 148 | 149 | takeUntil(predicate) { 150 | var iterator = this.iterable[Symbol.iterator](); 151 | var self = this; 152 | return Functified.fromGenerator(function* () { 153 | if (self.hasOwnProperty("startValue") && self.isPausable) { 154 | yield self.startValue; 155 | } 156 | while (true) { 157 | var result = iterator.next(); 158 | if (result.done) { 159 | break; 160 | } else { 161 | if (predicate(result.value)) { 162 | // save the value so we can yield if takeUntil is called again 163 | self.startValue = result.value; 164 | break; 165 | } else { 166 | yield result.value; 167 | } 168 | } 169 | } 170 | }); 171 | } 172 | 173 | enumerate(start = 0) { 174 | var iterable = this.iterable; 175 | return Functified.fromGenerator(function* () { 176 | let i = start; 177 | for (let value of iterable) { 178 | yield [i++, value]; 179 | } 180 | }); 181 | } 182 | 183 | zip() { 184 | return Functified.zip(this.iterable); 185 | } 186 | 187 | // reducing functions 188 | every(callback) { 189 | for (let value of this.iterable) { 190 | if (!callback(value)) { 191 | return false; 192 | } 193 | } 194 | return true; 195 | } 196 | 197 | reduce(callback, initialValue) { 198 | let accum = initialValue; 199 | let iterator = this.iterable[Symbol.iterator](); 200 | 201 | if (accum === undefined) { 202 | let result = iterator.next(); 203 | if (result.done) { 204 | throw "not enough values to reduce"; 205 | } else { 206 | accum = result.value; 207 | } 208 | } 209 | 210 | while (true) { 211 | let result = iterator.next(); 212 | if (result.done) { 213 | break; 214 | } else { 215 | accum = callback(accum, result.value); 216 | } 217 | } 218 | 219 | return accum; 220 | } 221 | 222 | some(callback) { 223 | for (let value of this.iterable) { 224 | if (callback(value)) { 225 | return true; 226 | } 227 | } 228 | return false; 229 | } 230 | 231 | entries() { 232 | if (this.iterable.entries) { 233 | return new Functified(this.iterable.entries()); 234 | } else { 235 | throw "doesn't have entries"; 236 | } 237 | } 238 | 239 | keys() { 240 | if (this.iterable.keys) { 241 | return new Functified(this.iterable.keys()); 242 | } else { 243 | throw "doesn't have keys"; 244 | } 245 | } 246 | 247 | values() { 248 | if (this.iterable.values) { 249 | return new Functified(this.iterable.values()); 250 | } else { 251 | throw "doesn't have values"; 252 | } 253 | } 254 | 255 | toArray() { 256 | var result = []; 257 | for (let value of this.iterable) { 258 | result.push(value); 259 | } 260 | return result; 261 | } 262 | 263 | toObject() { 264 | var result = {}; 265 | for (let value of this.iterable) { 266 | if (Array.isArray(value)) { 267 | result[value[0]] = value[1]; 268 | } 269 | } 270 | return result; 271 | } 272 | 273 | toPausable() { 274 | var iterator = this.iterable[Symbol.iterator](); 275 | var functified = Functified.fromGenerator(function* () { 276 | while (true) { 277 | var result = iterator.next(); 278 | if (result.done) { 279 | break; 280 | } else { 281 | yield result.value; 282 | } 283 | } 284 | }); 285 | functified.isPausable = true; 286 | return functified; 287 | } 288 | 289 | toString() { 290 | var i = 0; 291 | var result = "["; 292 | result += this.reduce((str, n) => str + (i++ > 0 ? `, ${n}` : `${n}`), ""); 293 | result += "]"; 294 | return result; 295 | } 296 | 297 | // static methods 298 | static fromGenerator(generator) { 299 | return functify({ 300 | [Symbol.iterator]: generator 301 | }); 302 | } 303 | 304 | static fromObject(obj) { 305 | return functify({ 306 | [Symbol.iterator]: function* () { 307 | for (var key in obj) { 308 | if (obj.hasOwnProperty(key)) { 309 | yield [key, obj[key]]; 310 | } 311 | } 312 | }, 313 | entries() { 314 | return Functified.fromGenerator(function* () { 315 | for (var key in obj) { 316 | if (obj.hasOwnProperty(key)) { 317 | yield [key, obj[key]]; 318 | } 319 | } 320 | }); 321 | }, 322 | keys() { 323 | return Functified.fromGenerator(function* () { 324 | for (var key in obj) { 325 | if (obj.hasOwnProperty(key)) { 326 | yield key; 327 | } 328 | } 329 | }); 330 | }, 331 | values() { 332 | return Functified.fromGenerator(function* () { 333 | for (var key in obj) { 334 | if (obj.hasOwnProperty(key)) { 335 | yield obj[key]; 336 | } 337 | } 338 | }); 339 | } 340 | }); 341 | } 342 | 343 | static range(start, stop, step = 1) { 344 | if (arguments.length === 1) { 345 | stop = start; 346 | start = 0; 347 | } 348 | return Functified.fromGenerator(function* () { 349 | let i = start; 350 | if (step > 0) { 351 | while (i < stop) { 352 | yield i; 353 | i += step; 354 | } 355 | } else if (step < 0) { 356 | while (i > stop) { 357 | yield i; 358 | i += step; 359 | } 360 | } else { 361 | throw "step should not equal 0" 362 | } 363 | }); 364 | }; 365 | 366 | static zip(...iterables) { 367 | // assume if a single value is passed in it must contain an array 368 | if (iterables.length === 1) { 369 | iterables = iterables[0]; 370 | } 371 | return Functified.fromGenerator(function* () { 372 | var iterators = iterables.map(iterable => { 373 | if (iterable[Symbol.iterator]) { 374 | return iterable[Symbol.iterator](); 375 | } else { 376 | throw "can't zip a non-iterable"; 377 | } 378 | }); 379 | while (true) { 380 | let vector = []; 381 | for (let iterator of iterators) { 382 | var result = iterator.next(); 383 | if (result.done) { 384 | return; // finished 385 | } else { 386 | vector.push(result.value); 387 | } 388 | } 389 | yield vector; 390 | } 391 | }); 392 | } 393 | } 394 | 395 | function functify(iterable) { 396 | if (!iterable[Symbol.iterator]) { 397 | return Functified.fromObject(iterable); 398 | } else { 399 | return new Functified(iterable); 400 | } 401 | } 402 | 403 | functify.fromGenerator = Functified.fromGenerator; 404 | functify.range = Functified.range; 405 | functify.zip = Functified.zip; 406 | 407 | export default functify; 408 | -------------------------------------------------------------------------------- /test/test_spec.js: -------------------------------------------------------------------------------- 1 | var assert = require("assert"); 2 | var functify = require("../src/functify.js"); 3 | 4 | describe("functify", () => { 5 | var numbers, result; 6 | 7 | beforeEach(() => { 8 | numbers = functify([1,2,3,4,5]); 9 | result = []; 10 | }); 11 | 12 | describe("Basic operations", () => { 13 | it("should return an iterable", () => { 14 | for (let num of numbers) { 15 | result.push(num); 16 | } 17 | assert.deepEqual(result, [1,2,3,4,5]); 18 | }); 19 | 20 | it("should filter iterables", () => { 21 | for (let num of numbers.filter(n => n % 2)) { 22 | result.push(num); 23 | } 24 | assert.deepEqual(result, [1,3,5]); 25 | }); 26 | 27 | it("should map iterables", () => { 28 | for (let num of numbers.map(n => n * n)) { 29 | result.push(num); 30 | } 31 | assert.deepEqual(result, [1,4,9,16,25]); 32 | }); 33 | 34 | it("should chain methods", () => { 35 | for (let num of numbers.filter(n => n % 2).map(n => n * n)) { 36 | result.push(num); 37 | } 38 | assert.deepEqual(result, [1,9,25]); 39 | }); 40 | 41 | it("should group iterables using predicates", () => { 42 | var [odds, evens] = numbers.groupBy(x => x % 2, x => x % 2 === 0); 43 | var evenResult = []; 44 | var oddResult = []; 45 | for (let num of evens) { 46 | evenResult.push(num); 47 | } 48 | for (let num of odds) { 49 | oddResult.push(num); 50 | } 51 | assert.deepEqual(evenResult, [2,4]); 52 | assert.deepEqual(oddResult, [1,3,5]); 53 | }); 54 | 55 | it("should groupByMap using a Map of predicates", () => { 56 | var map = new Map(); 57 | map.set("odd", x => x % 2); 58 | map.set("even", x => x % 2 === 0); 59 | result = {}; 60 | for (let [key = "", val = 0] of numbers.groupByMap(map)) { 61 | result[key] = []; 62 | for (let item of val) { 63 | result[key].push(item); 64 | } 65 | } 66 | assert.deepEqual(result, { 67 | "odd": [1,3,5], 68 | "even": [2,4] 69 | }); 70 | }); 71 | 72 | it("should zip iterables", () => { 73 | var pairs = numbers.groupBy(x => x % 2, x => x % 2 === 0).zip(); 74 | for (let pair of pairs) { 75 | result.push(pair); 76 | } 77 | assert.deepEqual(result, [[1,2],[3,4]]); 78 | }); 79 | 80 | it("should produce a string representation", () => { 81 | assert.equal(numbers.toString(), "[1, 2, 3, 4, 5]"); 82 | }); 83 | 84 | it("should reduce to produce a sum", () => { 85 | var sum = numbers.reduce((accum, value) => accum + value, 0); 86 | assert.equal(sum, 15); 87 | }); 88 | 89 | it("should reduce to produce a sum without an initialValue", () => { 90 | var sum = numbers.reduce((accum, value) => accum + value); 91 | assert.equal(sum, 15); 92 | }); 93 | 94 | it("should implement some()", () => { 95 | result = numbers.some(num => num > 3); 96 | assert.equal(result, true); 97 | result = numbers.some(num => num < 0); 98 | assert.equal(result, false); 99 | }); 100 | 101 | it("should implement every()", () => { 102 | result = numbers.every(num => num > 0); 103 | assert.equal(result, true); 104 | result = numbers.every(num => num > 1); 105 | assert.equal(result, false); 106 | }); 107 | 108 | it("should take the first 2", () => { 109 | for (let num of numbers.take(2)) { 110 | result.push(num); 111 | } 112 | assert.deepEqual(result, [1,2]); 113 | }); 114 | 115 | it("should take all if n > length", () => { 116 | for (let num of numbers.take(10)) { 117 | result.push(num); 118 | } 119 | assert.equal(result.length, 5); 120 | assert.deepEqual(result, [1,2,3,4,5]); 121 | }); 122 | 123 | it("should skip the first 2", () => { 124 | for (let num of numbers.skip(2)) { 125 | result.push(num); 126 | } 127 | assert.deepEqual(result, [3,4,5]); 128 | }); 129 | 130 | it("should skip all if n >= length", () => { 131 | for (let num of numbers.skip(10)) { 132 | result.push(num); 133 | } 134 | assert.deepEqual(result, []); 135 | }); 136 | 137 | it("should skipWhile predicate is true", () => { 138 | for (let num of numbers.skipWhile(x => x < 3)) { 139 | result.push(num); 140 | } 141 | assert.deepEqual(result, [3,4,5]); 142 | }); 143 | 144 | it("should skip all if skipWhile predice is always true", () => { 145 | for (let num of numbers.skipWhile(x => true)) { 146 | result.push(num); 147 | } 148 | assert.deepEqual(result, []); 149 | }); 150 | 151 | it("should flatten nested arrays", () => { 152 | var nested = functify([1, [2, 3], [], [[4], 5], [[]]]); 153 | for (let num of nested.flatten()) { 154 | result.push(num); 155 | } 156 | assert.deepEqual(result, [1,2,3,4,5]); 157 | }); 158 | 159 | it("should remove duplicates", () => { 160 | numbers = functify([1, 1, 2, 3, 5]); 161 | for (let num of numbers.distinct()) { 162 | result.push(num); 163 | } 164 | assert.deepEqual(result, [1,2,3,5]); 165 | }); 166 | 167 | it("should repeat", () => { 168 | for (let num of numbers.repeat(2)) { 169 | result.push(num); 170 | } 171 | assert.deepEqual(result, [1,2,3,4,5,1,2,3,4,5]); 172 | }); 173 | 174 | it("should stop an infinite loop with take", () => { 175 | for (let num of numbers.repeat(Infinity).take(8)) { 176 | result.push(num); 177 | } 178 | assert.deepEqual(result, [1,2,3,4,5,1,2,3]); 179 | }); 180 | 181 | it("should return an array", () => { 182 | result = numbers.toArray(); 183 | assert.deepEqual(result, [1, 2, 3, 4, 5]); 184 | }); 185 | 186 | it("should always take the first n if not pausable", () => { 187 | for (let num of numbers.take(3)) { 188 | result.push(num); 189 | } 190 | assert.deepEqual(result, [1,2,3]); 191 | result = []; 192 | 193 | for (let num of numbers.take(3)) { 194 | result.push(num); 195 | } 196 | assert.deepEqual(result, [1,2,3]); 197 | }); 198 | 199 | it("should take until a predicate is true", () => { 200 | for (let num of numbers.takeUntil(x => x > 2)) { 201 | result.push(num); 202 | } 203 | assert.deepEqual(result, [1,2]); 204 | }); 205 | 206 | it("should return an object", () => { 207 | const obj = { x: 5, y: 10 }; 208 | const result = functify(obj).entries().toObject(); 209 | 210 | assert.deepEqual(result, { x: 5, y: 10 }); 211 | }); 212 | }); 213 | 214 | describe("enumerate", () => { 215 | it("should iterate over [index, value] entries", function () { 216 | let results = {}; 217 | let fruit = ["apple", "banana", "grapes"]; 218 | for (let [k, v] of functify(fruit).enumerate()) { 219 | results[k] = v; 220 | } 221 | assert.equal(results[0], "apple"); 222 | assert.equal(results[1], "banana"); 223 | assert.equal(results[2], "grapes"); 224 | }); 225 | 226 | it("should start at the given index", function () { 227 | let results = {}; 228 | let fruit = ["apple", "banana", "grapes"]; 229 | for (let [k, v] of functify(fruit).enumerate(1)) { 230 | results[k] = v; 231 | } 232 | assert.equal(results[1], "apple"); 233 | assert.equal(results[2], "banana"); 234 | assert.equal(results[3], "grapes"); 235 | }); 236 | }); 237 | 238 | describe("range", () => { 239 | it("should generate a range of numbers", () => { 240 | for (let num of functify.range(0,5)) { 241 | result.push(num); 242 | } 243 | assert.deepEqual(result, [0,1,2,3,4]); 244 | }); 245 | 246 | it("should generate a range of numbers with a negative step", () => { 247 | for (let num of functify.range(5,0,-1)) { 248 | result.push(num); 249 | } 250 | assert.deepEqual(result, [5,4,3,2,1]); 251 | }); 252 | 253 | it("should generate numbers to Infinity", () => { 254 | for (let num of functify.range(0, Infinity).take(20)) { 255 | result.push(num); 256 | } 257 | assert.equal(result[19], 19); 258 | }); 259 | 260 | it("should generate numbers to -Infinity", () => { 261 | for (let num of functify.range(0, -Infinity, -1).take(20)) { 262 | result.push(num); 263 | } 264 | assert.equal(result[19], -19); 265 | }); 266 | }); 267 | 268 | describe("Pausables", () => { 269 | it("should create a pausable iteratble that works with take", () => { 270 | var pausableNumbers = numbers.toPausable(); 271 | 272 | for (let num of pausableNumbers.take(1)) { 273 | result.push(num); 274 | } 275 | assert.deepEqual(result, [1]); 276 | result = []; 277 | 278 | for (let num of pausableNumbers.take(2)) { 279 | result.push(num); 280 | } 281 | assert.deepEqual(result, [2,3]); 282 | }); 283 | 284 | it("should create a pausable iteratble when chaining", () => { 285 | var pausableSquares = numbers.map(x => x * x).toPausable(); 286 | 287 | for (let num of pausableSquares.take(1)) { 288 | result.push(num); 289 | } 290 | assert.deepEqual(result, [1]); 291 | result = []; 292 | 293 | for (let num of pausableSquares.take(2)) { 294 | result.push(num); 295 | } 296 | assert.deepEqual(result, [4,9]); 297 | }); 298 | 299 | it("should allow chaining after the first take", () => { 300 | var pausableNumbers = numbers.toPausable(); 301 | 302 | for (let num of pausableNumbers.take(1)) { 303 | result.push(num); 304 | } 305 | assert.deepEqual(result, [1]); 306 | result = []; 307 | 308 | for (let num of pausableNumbers.map(x => x * x).take(2)) { 309 | result.push(num); 310 | } 311 | assert.deepEqual(result, [4,9]); 312 | }); 313 | 314 | it("should always take until from the start if not pausable", () => { 315 | for (let num of numbers.takeUntil(x => x > 2)) { 316 | result.push(num); 317 | } 318 | assert.deepEqual(result, [1,2]); 319 | 320 | result = []; 321 | for (let num of numbers.takeUntil(x => x > 4)) { 322 | result.push(num); 323 | } 324 | assert.deepEqual(result, [1,2,3,4]); 325 | }); 326 | 327 | it("should take until from the last position if pausable", () => { 328 | var pausableNumbers = numbers.toPausable(); 329 | 330 | for (let num of pausableNumbers.takeUntil(x => x > 2)) { 331 | result.push(num); 332 | } 333 | assert.deepEqual(result, [1,2]); 334 | 335 | result = []; 336 | for (let num of pausableNumbers.takeUntil(x => x > 4)) { 337 | result.push(num); 338 | } 339 | assert.deepEqual(result, [3,4]); 340 | }); 341 | 342 | it("should filter a pausable iterable", () => { 343 | var pausableOdds = numbers.toPausable().filter(x => x % 2); 344 | 345 | for (let num of pausableOdds.take(2)) { 346 | result.push(num); 347 | } 348 | assert.deepEqual(result, [1,3]); 349 | 350 | result = []; 351 | for (let num of pausableOdds.take(2)) { 352 | result.push(num); 353 | } 354 | assert.deepEqual(result, [5]); 355 | }); 356 | 357 | it("should allow take and takeUntil on the same pausable", () => { 358 | var pausableNumbers = numbers.toPausable(); 359 | 360 | for (let num of pausableNumbers.takeUntil(x => x > 2)) { 361 | result.push(num); 362 | } 363 | assert.deepEqual(result, [1,2]); 364 | 365 | result = []; 366 | for (let num of pausableNumbers.take(2)) { 367 | result.push(num); 368 | } 369 | assert.deepEqual(result, [3,4]); 370 | }); 371 | }); 372 | 373 | describe("Sets", () => { 374 | it("should work with sets", function () { 375 | var colors = new Set(); 376 | 377 | colors.add("red"); 378 | colors.add("green"); 379 | colors.add("blue"); 380 | 381 | for (let color of functify(colors)) { 382 | result.push(color); 383 | } 384 | 385 | assert(result.indexOf("red") !== -1); 386 | assert(result.indexOf("green") !== -1); 387 | assert(result.indexOf("blue") !== -1); 388 | 389 | assert.equal(result.length, 3); 390 | }); 391 | }); 392 | 393 | describe("Objects", () => { 394 | it("should return an iterable of entries for Objects", () => { 395 | let obj = { x: 5, y: 10 }; 396 | let result = {}; 397 | for (let [k, v] of functify(obj)) { 398 | result[k] = v; 399 | } 400 | assert.equal(result.x, 5); 401 | assert.equal(result.y, 10); 402 | }); 403 | 404 | it("should have .keys()", () => { 405 | let obj = { x: 5, y: 10 }; 406 | let result = []; 407 | for (let key of functify(obj).keys()) { 408 | result.push(key); 409 | } 410 | assert.deepEqual(result, ['x', 'y']); 411 | }); 412 | 413 | it("should have .values()", () => { 414 | let obj = { x: 5, y: 10 }; 415 | let result = []; 416 | for (let value of functify(obj).values()) { 417 | result.push(value); 418 | } 419 | assert.deepEqual(result, [5, 10]); 420 | }); 421 | 422 | it("should have .entries()", () => { 423 | let obj = { x: 5, y: 10 }; 424 | let result = {}; 425 | for (let [k, v] of functify(obj).entries()) { 426 | result[k] = v; 427 | } 428 | assert.equal(result.x, 5); 429 | assert.equal(result.y, 10); 430 | }); 431 | }); 432 | 433 | describe("Maps", () => { 434 | it("should return an iterable of entries for Maps", () => { 435 | let map = new Map(); 436 | map.set('x', 5); 437 | map.set('y', 10); 438 | let result = {}; 439 | for (let [k, v] of functify(map)) { 440 | result[k] = v; 441 | } 442 | assert.equal(result.x, 5); 443 | assert.equal(result.y, 10); 444 | }); 445 | 446 | it("should have .keys()", () => { 447 | let map = new Map(); 448 | map.set('x', 5); 449 | map.set('y', 10); 450 | let result = []; 451 | for (let key of functify(map).keys()) { 452 | result.push(key); 453 | } 454 | assert.deepEqual(result, ['x', 'y']); 455 | }); 456 | 457 | it("should have .values()", () => { 458 | let map = new Map(); 459 | map.set('x', 5); 460 | map.set('y', 10); 461 | let result = []; 462 | for (let value of map.values()) { 463 | result.push(value); 464 | } 465 | assert.deepEqual(result, [5, 10]); 466 | }); 467 | 468 | it("should have .entries()", () => { 469 | let map = new Map(); 470 | map.set('x', 5); 471 | map.set('y', 10); 472 | let result = {}; 473 | for (let [k, v] of functify(map).entries()) { 474 | result[k] = v; 475 | } 476 | assert.equal(result.x, 5); 477 | assert.equal(result.y, 10); 478 | }); 479 | 480 | it("should return chainable iterators", () => { 481 | let map = new Map(); 482 | map.set('x', 5); 483 | map.set('y', 10); 484 | let result = []; 485 | for (let v of functify(map).entries().map(pair => pair[1] * pair[1])) { 486 | result.push(v); 487 | } 488 | assert.deepEqual(result, [25, 100]); 489 | }); 490 | }); 491 | 492 | describe("static methods", () => { 493 | it("zip should work with an array", () => { 494 | let result = []; 495 | for (let [x, y] of functify.zip([[1,2],[5,10]])) { 496 | result.push([x, y]); 497 | } 498 | assert.deepEqual(result, [[1, 5], [2, 10]]); 499 | }); 500 | 501 | it("zip should work with multiple arguments", () => { 502 | let result = []; 503 | for (let [x, y] of functify.zip([1,2],[5,10])) { 504 | result.push([x, y]); 505 | } 506 | assert.deepEqual(result, [[1, 5], [2, 10]]); 507 | }); 508 | }); 509 | }); 510 | -------------------------------------------------------------------------------- /dist/functify.js: -------------------------------------------------------------------------------- 1 | (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.functify = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o generator function 101 | value: function custom(fn) { 102 | return Functified.fromGenerator(fn(this.iterable)); 103 | } 104 | }, { 105 | key: "distinct", 106 | 107 | // alias dedupe, unique 108 | value: function distinct() { 109 | var iterable = this.iterable; 110 | var memory = new Set(); 111 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 112 | var _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, value; 113 | 114 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 115 | while (1) switch (context$3$0.prev = context$3$0.next) { 116 | case 0: 117 | _iteratorNormalCompletion2 = true; 118 | _didIteratorError2 = false; 119 | _iteratorError2 = undefined; 120 | context$3$0.prev = 3; 121 | _iterator2 = iterable[Symbol.iterator](); 122 | 123 | case 5: 124 | if (_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done) { 125 | context$3$0.next = 14; 126 | break; 127 | } 128 | 129 | value = _step2.value; 130 | 131 | if (memory.has(value)) { 132 | context$3$0.next = 11; 133 | break; 134 | } 135 | 136 | memory.add(value); 137 | context$3$0.next = 11; 138 | return value; 139 | 140 | case 11: 141 | _iteratorNormalCompletion2 = true; 142 | context$3$0.next = 5; 143 | break; 144 | 145 | case 14: 146 | context$3$0.next = 20; 147 | break; 148 | 149 | case 16: 150 | context$3$0.prev = 16; 151 | context$3$0.t0 = context$3$0["catch"](3); 152 | _didIteratorError2 = true; 153 | _iteratorError2 = context$3$0.t0; 154 | 155 | case 20: 156 | context$3$0.prev = 20; 157 | context$3$0.prev = 21; 158 | 159 | if (!_iteratorNormalCompletion2 && _iterator2["return"]) { 160 | _iterator2["return"](); 161 | } 162 | 163 | case 23: 164 | context$3$0.prev = 23; 165 | 166 | if (!_didIteratorError2) { 167 | context$3$0.next = 26; 168 | break; 169 | } 170 | 171 | throw _iteratorError2; 172 | 173 | case 26: 174 | return context$3$0.finish(23); 175 | 176 | case 27: 177 | return context$3$0.finish(20); 178 | 179 | case 28: 180 | case "end": 181 | return context$3$0.stop(); 182 | } 183 | }, callee$2$0, this, [[3, 16, 20, 28], [21,, 23, 27]]); 184 | })); 185 | } 186 | }, { 187 | key: "filter", 188 | value: function filter(callback) { 189 | var iterable = this.iterable; 190 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 191 | var _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, value; 192 | 193 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 194 | while (1) switch (context$3$0.prev = context$3$0.next) { 195 | case 0: 196 | _iteratorNormalCompletion3 = true; 197 | _didIteratorError3 = false; 198 | _iteratorError3 = undefined; 199 | context$3$0.prev = 3; 200 | _iterator3 = iterable[Symbol.iterator](); 201 | 202 | case 5: 203 | if (_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done) { 204 | context$3$0.next = 13; 205 | break; 206 | } 207 | 208 | value = _step3.value; 209 | 210 | if (!callback(value)) { 211 | context$3$0.next = 10; 212 | break; 213 | } 214 | 215 | context$3$0.next = 10; 216 | return value; 217 | 218 | case 10: 219 | _iteratorNormalCompletion3 = true; 220 | context$3$0.next = 5; 221 | break; 222 | 223 | case 13: 224 | context$3$0.next = 19; 225 | break; 226 | 227 | case 15: 228 | context$3$0.prev = 15; 229 | context$3$0.t0 = context$3$0["catch"](3); 230 | _didIteratorError3 = true; 231 | _iteratorError3 = context$3$0.t0; 232 | 233 | case 19: 234 | context$3$0.prev = 19; 235 | context$3$0.prev = 20; 236 | 237 | if (!_iteratorNormalCompletion3 && _iterator3["return"]) { 238 | _iterator3["return"](); 239 | } 240 | 241 | case 22: 242 | context$3$0.prev = 22; 243 | 244 | if (!_didIteratorError3) { 245 | context$3$0.next = 25; 246 | break; 247 | } 248 | 249 | throw _iteratorError3; 250 | 251 | case 25: 252 | return context$3$0.finish(22); 253 | 254 | case 26: 255 | return context$3$0.finish(19); 256 | 257 | case 27: 258 | case "end": 259 | return context$3$0.stop(); 260 | } 261 | }, callee$2$0, this, [[3, 15, 19, 27], [20,, 22, 26]]); 262 | })); 263 | } 264 | }, { 265 | key: "flatten", 266 | value: function flatten() { 267 | var iterable = this.iterable; 268 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 269 | var _iteratorNormalCompletion4, _didIteratorError4, _iteratorError4, _iterator4, _step4, value; 270 | 271 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 272 | while (1) switch (context$3$0.prev = context$3$0.next) { 273 | case 0: 274 | _iteratorNormalCompletion4 = true; 275 | _didIteratorError4 = false; 276 | _iteratorError4 = undefined; 277 | context$3$0.prev = 3; 278 | _iterator4 = iterable[Symbol.iterator](); 279 | 280 | case 5: 281 | if (_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done) { 282 | context$3$0.next = 16; 283 | break; 284 | } 285 | 286 | value = _step4.value; 287 | 288 | if (!value[Symbol.iterator]) { 289 | context$3$0.next = 11; 290 | break; 291 | } 292 | 293 | return context$3$0.delegateYield(functify(value).flatten(), "t0", 9); 294 | 295 | case 9: 296 | context$3$0.next = 13; 297 | break; 298 | 299 | case 11: 300 | context$3$0.next = 13; 301 | return value; 302 | 303 | case 13: 304 | _iteratorNormalCompletion4 = true; 305 | context$3$0.next = 5; 306 | break; 307 | 308 | case 16: 309 | context$3$0.next = 22; 310 | break; 311 | 312 | case 18: 313 | context$3$0.prev = 18; 314 | context$3$0.t1 = context$3$0["catch"](3); 315 | _didIteratorError4 = true; 316 | _iteratorError4 = context$3$0.t1; 317 | 318 | case 22: 319 | context$3$0.prev = 22; 320 | context$3$0.prev = 23; 321 | 322 | if (!_iteratorNormalCompletion4 && _iterator4["return"]) { 323 | _iterator4["return"](); 324 | } 325 | 326 | case 25: 327 | context$3$0.prev = 25; 328 | 329 | if (!_didIteratorError4) { 330 | context$3$0.next = 28; 331 | break; 332 | } 333 | 334 | throw _iteratorError4; 335 | 336 | case 28: 337 | return context$3$0.finish(25); 338 | 339 | case 29: 340 | return context$3$0.finish(22); 341 | 342 | case 30: 343 | case "end": 344 | return context$3$0.stop(); 345 | } 346 | }, callee$2$0, this, [[3, 18, 22, 30], [23,, 25, 29]]); 347 | })); 348 | } 349 | }, { 350 | key: "groupBy", 351 | value: function groupBy() { 352 | var _this = this; 353 | 354 | for (var _len = arguments.length, predicates = Array(_len), _key = 0; _key < _len; _key++) { 355 | predicates[_key] = arguments[_key]; 356 | } 357 | 358 | return functify(predicates.map(function (fn) { 359 | return _this.filter(fn); 360 | })); 361 | } 362 | }, { 363 | key: "groupByMap", 364 | value: function groupByMap(map) { 365 | var _this2 = this; 366 | 367 | return functify(map).map(function (_ref) { 368 | var _ref2 = _slicedToArray(_ref, 2); 369 | 370 | var name = _ref2[0]; 371 | var fn = _ref2[1]; 372 | return [name, _this2.filter(fn)]; 373 | }); 374 | } 375 | }, { 376 | key: "repeat", 377 | value: function repeat() { 378 | var n = arguments[0] === undefined ? 1 : arguments[0]; 379 | 380 | var iterable = this.iterable; 381 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 382 | var i, _iteratorNormalCompletion5, _didIteratorError5, _iteratorError5, _iterator5, _step5, value; 383 | 384 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 385 | while (1) switch (context$3$0.prev = context$3$0.next) { 386 | case 0: 387 | i = 0; 388 | 389 | case 1: 390 | if (!(i++ < n)) { 391 | context$3$0.next = 30; 392 | break; 393 | } 394 | 395 | _iteratorNormalCompletion5 = true; 396 | _didIteratorError5 = false; 397 | _iteratorError5 = undefined; 398 | context$3$0.prev = 5; 399 | _iterator5 = iterable[Symbol.iterator](); 400 | 401 | case 7: 402 | if (_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done) { 403 | context$3$0.next = 14; 404 | break; 405 | } 406 | 407 | value = _step5.value; 408 | context$3$0.next = 11; 409 | return value; 410 | 411 | case 11: 412 | _iteratorNormalCompletion5 = true; 413 | context$3$0.next = 7; 414 | break; 415 | 416 | case 14: 417 | context$3$0.next = 20; 418 | break; 419 | 420 | case 16: 421 | context$3$0.prev = 16; 422 | context$3$0.t0 = context$3$0["catch"](5); 423 | _didIteratorError5 = true; 424 | _iteratorError5 = context$3$0.t0; 425 | 426 | case 20: 427 | context$3$0.prev = 20; 428 | context$3$0.prev = 21; 429 | 430 | if (!_iteratorNormalCompletion5 && _iterator5["return"]) { 431 | _iterator5["return"](); 432 | } 433 | 434 | case 23: 435 | context$3$0.prev = 23; 436 | 437 | if (!_didIteratorError5) { 438 | context$3$0.next = 26; 439 | break; 440 | } 441 | 442 | throw _iteratorError5; 443 | 444 | case 26: 445 | return context$3$0.finish(23); 446 | 447 | case 27: 448 | return context$3$0.finish(20); 449 | 450 | case 28: 451 | context$3$0.next = 1; 452 | break; 453 | 454 | case 30: 455 | case "end": 456 | return context$3$0.stop(); 457 | } 458 | }, callee$2$0, this, [[5, 16, 20, 28], [21,, 23, 27]]); 459 | })); 460 | } 461 | }, { 462 | key: "loop", 463 | 464 | // alias for repeat 465 | value: function loop() { 466 | var n = arguments[0] === undefined ? 1 : arguments[0]; 467 | 468 | console.warn("deprecating loop(n), use repeat(n) instead"); 469 | return this.repeat(n); 470 | } 471 | }, { 472 | key: "map", 473 | value: function map(callback) { 474 | var iterable = this.iterable; 475 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 476 | var _iteratorNormalCompletion6, _didIteratorError6, _iteratorError6, _iterator6, _step6, value; 477 | 478 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 479 | while (1) switch (context$3$0.prev = context$3$0.next) { 480 | case 0: 481 | _iteratorNormalCompletion6 = true; 482 | _didIteratorError6 = false; 483 | _iteratorError6 = undefined; 484 | context$3$0.prev = 3; 485 | _iterator6 = iterable[Symbol.iterator](); 486 | 487 | case 5: 488 | if (_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done) { 489 | context$3$0.next = 12; 490 | break; 491 | } 492 | 493 | value = _step6.value; 494 | context$3$0.next = 9; 495 | return callback(value); 496 | 497 | case 9: 498 | _iteratorNormalCompletion6 = true; 499 | context$3$0.next = 5; 500 | break; 501 | 502 | case 12: 503 | context$3$0.next = 18; 504 | break; 505 | 506 | case 14: 507 | context$3$0.prev = 14; 508 | context$3$0.t0 = context$3$0["catch"](3); 509 | _didIteratorError6 = true; 510 | _iteratorError6 = context$3$0.t0; 511 | 512 | case 18: 513 | context$3$0.prev = 18; 514 | context$3$0.prev = 19; 515 | 516 | if (!_iteratorNormalCompletion6 && _iterator6["return"]) { 517 | _iterator6["return"](); 518 | } 519 | 520 | case 21: 521 | context$3$0.prev = 21; 522 | 523 | if (!_didIteratorError6) { 524 | context$3$0.next = 24; 525 | break; 526 | } 527 | 528 | throw _iteratorError6; 529 | 530 | case 24: 531 | return context$3$0.finish(21); 532 | 533 | case 25: 534 | return context$3$0.finish(18); 535 | 536 | case 26: 537 | case "end": 538 | return context$3$0.stop(); 539 | } 540 | }, callee$2$0, this, [[3, 14, 18, 26], [19,, 21, 25]]); 541 | })); 542 | } 543 | }, { 544 | key: "skip", 545 | value: function skip(n) { 546 | var iterable = this.iterable; 547 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 548 | var i, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, value; 549 | 550 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 551 | while (1) switch (context$3$0.prev = context$3$0.next) { 552 | case 0: 553 | i = 0; 554 | _iteratorNormalCompletion7 = true; 555 | _didIteratorError7 = false; 556 | _iteratorError7 = undefined; 557 | context$3$0.prev = 4; 558 | _iterator7 = iterable[Symbol.iterator](); 559 | 560 | case 6: 561 | if (_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done) { 562 | context$3$0.next = 17; 563 | break; 564 | } 565 | 566 | value = _step7.value; 567 | 568 | if (!(i < n)) { 569 | context$3$0.next = 12; 570 | break; 571 | } 572 | 573 | i++; 574 | context$3$0.next = 14; 575 | break; 576 | 577 | case 12: 578 | context$3$0.next = 14; 579 | return value; 580 | 581 | case 14: 582 | _iteratorNormalCompletion7 = true; 583 | context$3$0.next = 6; 584 | break; 585 | 586 | case 17: 587 | context$3$0.next = 23; 588 | break; 589 | 590 | case 19: 591 | context$3$0.prev = 19; 592 | context$3$0.t0 = context$3$0["catch"](4); 593 | _didIteratorError7 = true; 594 | _iteratorError7 = context$3$0.t0; 595 | 596 | case 23: 597 | context$3$0.prev = 23; 598 | context$3$0.prev = 24; 599 | 600 | if (!_iteratorNormalCompletion7 && _iterator7["return"]) { 601 | _iterator7["return"](); 602 | } 603 | 604 | case 26: 605 | context$3$0.prev = 26; 606 | 607 | if (!_didIteratorError7) { 608 | context$3$0.next = 29; 609 | break; 610 | } 611 | 612 | throw _iteratorError7; 613 | 614 | case 29: 615 | return context$3$0.finish(26); 616 | 617 | case 30: 618 | return context$3$0.finish(23); 619 | 620 | case 31: 621 | case "end": 622 | return context$3$0.stop(); 623 | } 624 | }, callee$2$0, this, [[4, 19, 23, 31], [24,, 26, 30]]); 625 | })); 626 | } 627 | }, { 628 | key: "skipWhile", 629 | value: function skipWhile(predicate) { 630 | var iterable = this.iterable; 631 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 632 | var skip, _iteratorNormalCompletion8, _didIteratorError8, _iteratorError8, _iterator8, _step8, value; 633 | 634 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 635 | while (1) switch (context$3$0.prev = context$3$0.next) { 636 | case 0: 637 | skip = true; 638 | _iteratorNormalCompletion8 = true; 639 | _didIteratorError8 = false; 640 | _iteratorError8 = undefined; 641 | context$3$0.prev = 4; 642 | _iterator8 = iterable[Symbol.iterator](); 643 | 644 | case 6: 645 | if (_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done) { 646 | context$3$0.next = 15; 647 | break; 648 | } 649 | 650 | value = _step8.value; 651 | 652 | if (!predicate(value)) { 653 | skip = false; 654 | } 655 | 656 | if (skip) { 657 | context$3$0.next = 12; 658 | break; 659 | } 660 | 661 | context$3$0.next = 12; 662 | return value; 663 | 664 | case 12: 665 | _iteratorNormalCompletion8 = true; 666 | context$3$0.next = 6; 667 | break; 668 | 669 | case 15: 670 | context$3$0.next = 21; 671 | break; 672 | 673 | case 17: 674 | context$3$0.prev = 17; 675 | context$3$0.t0 = context$3$0["catch"](4); 676 | _didIteratorError8 = true; 677 | _iteratorError8 = context$3$0.t0; 678 | 679 | case 21: 680 | context$3$0.prev = 21; 681 | context$3$0.prev = 22; 682 | 683 | if (!_iteratorNormalCompletion8 && _iterator8["return"]) { 684 | _iterator8["return"](); 685 | } 686 | 687 | case 24: 688 | context$3$0.prev = 24; 689 | 690 | if (!_didIteratorError8) { 691 | context$3$0.next = 27; 692 | break; 693 | } 694 | 695 | throw _iteratorError8; 696 | 697 | case 27: 698 | return context$3$0.finish(24); 699 | 700 | case 28: 701 | return context$3$0.finish(21); 702 | 703 | case 29: 704 | case "end": 705 | return context$3$0.stop(); 706 | } 707 | }, callee$2$0, this, [[4, 17, 21, 29], [22,, 24, 28]]); 708 | })); 709 | } 710 | }, { 711 | key: "take", 712 | value: function take(n) { 713 | // using an explicit iterator supports pausable iteratables 714 | var iterator = this.iterable[Symbol.iterator](); 715 | var self = this; 716 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 717 | var i, result; 718 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 719 | while (1) switch (context$3$0.prev = context$3$0.next) { 720 | case 0: 721 | i = 0; 722 | 723 | if (!(self.hasOwnProperty("startValue") && self.isPausable)) { 724 | context$3$0.next = 5; 725 | break; 726 | } 727 | 728 | context$3$0.next = 4; 729 | return self.startValue; 730 | 731 | case 4: 732 | i++; 733 | 734 | case 5: 735 | if (!(i < n)) { 736 | context$3$0.next = 16; 737 | break; 738 | } 739 | 740 | result = iterator.next(); 741 | 742 | if (!result.done) { 743 | context$3$0.next = 11; 744 | break; 745 | } 746 | 747 | return context$3$0.abrupt("break", 16); 748 | 749 | case 11: 750 | context$3$0.next = 13; 751 | return result.value; 752 | 753 | case 13: 754 | i++; 755 | 756 | case 14: 757 | context$3$0.next = 5; 758 | break; 759 | 760 | case 16: 761 | case "end": 762 | return context$3$0.stop(); 763 | } 764 | }, callee$2$0, this); 765 | })); 766 | } 767 | }, { 768 | key: "takeUntil", 769 | value: function takeUntil(predicate) { 770 | var iterator = this.iterable[Symbol.iterator](); 771 | var self = this; 772 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 773 | var result; 774 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 775 | while (1) switch (context$3$0.prev = context$3$0.next) { 776 | case 0: 777 | if (!(self.hasOwnProperty("startValue") && self.isPausable)) { 778 | context$3$0.next = 3; 779 | break; 780 | } 781 | 782 | context$3$0.next = 3; 783 | return self.startValue; 784 | 785 | case 3: 786 | if (!true) { 787 | context$3$0.next = 18; 788 | break; 789 | } 790 | 791 | result = iterator.next(); 792 | 793 | if (!result.done) { 794 | context$3$0.next = 9; 795 | break; 796 | } 797 | 798 | return context$3$0.abrupt("break", 18); 799 | 800 | case 9: 801 | if (!predicate(result.value)) { 802 | context$3$0.next = 14; 803 | break; 804 | } 805 | 806 | // save the value so we can yield if takeUntil is called again 807 | self.startValue = result.value; 808 | return context$3$0.abrupt("break", 18); 809 | 810 | case 14: 811 | context$3$0.next = 16; 812 | return result.value; 813 | 814 | case 16: 815 | context$3$0.next = 3; 816 | break; 817 | 818 | case 18: 819 | case "end": 820 | return context$3$0.stop(); 821 | } 822 | }, callee$2$0, this); 823 | })); 824 | } 825 | }, { 826 | key: "enumerate", 827 | value: function enumerate() { 828 | var start = arguments[0] === undefined ? 0 : arguments[0]; 829 | 830 | var iterable = this.iterable; 831 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 832 | var i, _iteratorNormalCompletion9, _didIteratorError9, _iteratorError9, _iterator9, _step9, value; 833 | 834 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 835 | while (1) switch (context$3$0.prev = context$3$0.next) { 836 | case 0: 837 | i = start; 838 | _iteratorNormalCompletion9 = true; 839 | _didIteratorError9 = false; 840 | _iteratorError9 = undefined; 841 | context$3$0.prev = 4; 842 | _iterator9 = iterable[Symbol.iterator](); 843 | 844 | case 6: 845 | if (_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done) { 846 | context$3$0.next = 13; 847 | break; 848 | } 849 | 850 | value = _step9.value; 851 | context$3$0.next = 10; 852 | return [i++, value]; 853 | 854 | case 10: 855 | _iteratorNormalCompletion9 = true; 856 | context$3$0.next = 6; 857 | break; 858 | 859 | case 13: 860 | context$3$0.next = 19; 861 | break; 862 | 863 | case 15: 864 | context$3$0.prev = 15; 865 | context$3$0.t0 = context$3$0["catch"](4); 866 | _didIteratorError9 = true; 867 | _iteratorError9 = context$3$0.t0; 868 | 869 | case 19: 870 | context$3$0.prev = 19; 871 | context$3$0.prev = 20; 872 | 873 | if (!_iteratorNormalCompletion9 && _iterator9["return"]) { 874 | _iterator9["return"](); 875 | } 876 | 877 | case 22: 878 | context$3$0.prev = 22; 879 | 880 | if (!_didIteratorError9) { 881 | context$3$0.next = 25; 882 | break; 883 | } 884 | 885 | throw _iteratorError9; 886 | 887 | case 25: 888 | return context$3$0.finish(22); 889 | 890 | case 26: 891 | return context$3$0.finish(19); 892 | 893 | case 27: 894 | case "end": 895 | return context$3$0.stop(); 896 | } 897 | }, callee$2$0, this, [[4, 15, 19, 27], [20,, 22, 26]]); 898 | })); 899 | } 900 | }, { 901 | key: "zip", 902 | value: function zip() { 903 | return Functified.zip(this.iterable); 904 | } 905 | }, { 906 | key: "every", 907 | 908 | // reducing functions 909 | value: function every(callback) { 910 | var _iteratorNormalCompletion10 = true; 911 | var _didIteratorError10 = false; 912 | var _iteratorError10 = undefined; 913 | 914 | try { 915 | for (var _iterator10 = this.iterable[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) { 916 | var value = _step10.value; 917 | 918 | if (!callback(value)) { 919 | return false; 920 | } 921 | } 922 | } catch (err) { 923 | _didIteratorError10 = true; 924 | _iteratorError10 = err; 925 | } finally { 926 | try { 927 | if (!_iteratorNormalCompletion10 && _iterator10["return"]) { 928 | _iterator10["return"](); 929 | } 930 | } finally { 931 | if (_didIteratorError10) { 932 | throw _iteratorError10; 933 | } 934 | } 935 | } 936 | 937 | return true; 938 | } 939 | }, { 940 | key: "reduce", 941 | value: function reduce(callback, initialValue) { 942 | var accum = initialValue; 943 | var iterator = this.iterable[Symbol.iterator](); 944 | 945 | if (accum === undefined) { 946 | var result = iterator.next(); 947 | if (result.done) { 948 | throw "not enough values to reduce"; 949 | } else { 950 | accum = result.value; 951 | } 952 | } 953 | 954 | while (true) { 955 | var result = iterator.next(); 956 | if (result.done) { 957 | break; 958 | } else { 959 | accum = callback(accum, result.value); 960 | } 961 | } 962 | 963 | return accum; 964 | } 965 | }, { 966 | key: "some", 967 | value: function some(callback) { 968 | var _iteratorNormalCompletion11 = true; 969 | var _didIteratorError11 = false; 970 | var _iteratorError11 = undefined; 971 | 972 | try { 973 | for (var _iterator11 = this.iterable[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) { 974 | var value = _step11.value; 975 | 976 | if (callback(value)) { 977 | return true; 978 | } 979 | } 980 | } catch (err) { 981 | _didIteratorError11 = true; 982 | _iteratorError11 = err; 983 | } finally { 984 | try { 985 | if (!_iteratorNormalCompletion11 && _iterator11["return"]) { 986 | _iterator11["return"](); 987 | } 988 | } finally { 989 | if (_didIteratorError11) { 990 | throw _iteratorError11; 991 | } 992 | } 993 | } 994 | 995 | return false; 996 | } 997 | }, { 998 | key: "entries", 999 | value: function entries() { 1000 | if (this.iterable.entries) { 1001 | return new Functified(this.iterable.entries()); 1002 | } else { 1003 | throw "doesn't have entries"; 1004 | } 1005 | } 1006 | }, { 1007 | key: "keys", 1008 | value: function keys() { 1009 | if (this.iterable.keys) { 1010 | return new Functified(this.iterable.keys()); 1011 | } else { 1012 | throw "doesn't have keys"; 1013 | } 1014 | } 1015 | }, { 1016 | key: "values", 1017 | value: function values() { 1018 | if (this.iterable.values) { 1019 | return new Functified(this.iterable.values()); 1020 | } else { 1021 | throw "doesn't have values"; 1022 | } 1023 | } 1024 | }, { 1025 | key: "toArray", 1026 | value: function toArray() { 1027 | var result = []; 1028 | var _iteratorNormalCompletion12 = true; 1029 | var _didIteratorError12 = false; 1030 | var _iteratorError12 = undefined; 1031 | 1032 | try { 1033 | for (var _iterator12 = this.iterable[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) { 1034 | var value = _step12.value; 1035 | 1036 | result.push(value); 1037 | } 1038 | } catch (err) { 1039 | _didIteratorError12 = true; 1040 | _iteratorError12 = err; 1041 | } finally { 1042 | try { 1043 | if (!_iteratorNormalCompletion12 && _iterator12["return"]) { 1044 | _iterator12["return"](); 1045 | } 1046 | } finally { 1047 | if (_didIteratorError12) { 1048 | throw _iteratorError12; 1049 | } 1050 | } 1051 | } 1052 | 1053 | return result; 1054 | } 1055 | }, { 1056 | key: "toObject", 1057 | value: function toObject() { 1058 | var result = {}; 1059 | var _iteratorNormalCompletion13 = true; 1060 | var _didIteratorError13 = false; 1061 | var _iteratorError13 = undefined; 1062 | 1063 | try { 1064 | for (var _iterator13 = this.iterable[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) { 1065 | var value = _step13.value; 1066 | 1067 | if (Array.isArray(value)) { 1068 | result[value[0]] = value[1]; 1069 | } 1070 | } 1071 | } catch (err) { 1072 | _didIteratorError13 = true; 1073 | _iteratorError13 = err; 1074 | } finally { 1075 | try { 1076 | if (!_iteratorNormalCompletion13 && _iterator13["return"]) { 1077 | _iterator13["return"](); 1078 | } 1079 | } finally { 1080 | if (_didIteratorError13) { 1081 | throw _iteratorError13; 1082 | } 1083 | } 1084 | } 1085 | 1086 | return result; 1087 | } 1088 | }, { 1089 | key: "toPausable", 1090 | value: function toPausable() { 1091 | var iterator = this.iterable[Symbol.iterator](); 1092 | var functified = Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 1093 | var result; 1094 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 1095 | while (1) switch (context$3$0.prev = context$3$0.next) { 1096 | case 0: 1097 | if (!true) { 1098 | context$3$0.next = 10; 1099 | break; 1100 | } 1101 | 1102 | result = iterator.next(); 1103 | 1104 | if (!result.done) { 1105 | context$3$0.next = 6; 1106 | break; 1107 | } 1108 | 1109 | return context$3$0.abrupt("break", 10); 1110 | 1111 | case 6: 1112 | context$3$0.next = 8; 1113 | return result.value; 1114 | 1115 | case 8: 1116 | context$3$0.next = 0; 1117 | break; 1118 | 1119 | case 10: 1120 | case "end": 1121 | return context$3$0.stop(); 1122 | } 1123 | }, callee$2$0, this); 1124 | })); 1125 | functified.isPausable = true; 1126 | return functified; 1127 | } 1128 | }, { 1129 | key: "toString", 1130 | value: function toString() { 1131 | var i = 0; 1132 | var result = "["; 1133 | result += this.reduce(function (str, n) { 1134 | return str + (i++ > 0 ? ", " + n : "" + n); 1135 | }, ""); 1136 | result += "]"; 1137 | return result; 1138 | } 1139 | }], [{ 1140 | key: "fromGenerator", 1141 | 1142 | // static methods 1143 | value: function fromGenerator(generator) { 1144 | return functify(_defineProperty({}, Symbol.iterator, generator)); 1145 | } 1146 | }, { 1147 | key: "fromObject", 1148 | value: function fromObject(obj) { 1149 | var _functify2; 1150 | 1151 | return functify((_functify2 = {}, _defineProperty(_functify2, Symbol.iterator, regeneratorRuntime.mark(function callee$2$0() { 1152 | var key; 1153 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 1154 | while (1) switch (context$3$0.prev = context$3$0.next) { 1155 | case 0: 1156 | context$3$0.t0 = regeneratorRuntime.keys(obj); 1157 | 1158 | case 1: 1159 | if ((context$3$0.t1 = context$3$0.t0()).done) { 1160 | context$3$0.next = 8; 1161 | break; 1162 | } 1163 | 1164 | key = context$3$0.t1.value; 1165 | 1166 | if (!obj.hasOwnProperty(key)) { 1167 | context$3$0.next = 6; 1168 | break; 1169 | } 1170 | 1171 | context$3$0.next = 6; 1172 | return [key, obj[key]]; 1173 | 1174 | case 6: 1175 | context$3$0.next = 1; 1176 | break; 1177 | 1178 | case 8: 1179 | case "end": 1180 | return context$3$0.stop(); 1181 | } 1182 | }, callee$2$0, this); 1183 | })), _defineProperty(_functify2, "entries", function entries() { 1184 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$3$0() { 1185 | var key; 1186 | return regeneratorRuntime.wrap(function callee$3$0$(context$4$0) { 1187 | while (1) switch (context$4$0.prev = context$4$0.next) { 1188 | case 0: 1189 | context$4$0.t0 = regeneratorRuntime.keys(obj); 1190 | 1191 | case 1: 1192 | if ((context$4$0.t1 = context$4$0.t0()).done) { 1193 | context$4$0.next = 8; 1194 | break; 1195 | } 1196 | 1197 | key = context$4$0.t1.value; 1198 | 1199 | if (!obj.hasOwnProperty(key)) { 1200 | context$4$0.next = 6; 1201 | break; 1202 | } 1203 | 1204 | context$4$0.next = 6; 1205 | return [key, obj[key]]; 1206 | 1207 | case 6: 1208 | context$4$0.next = 1; 1209 | break; 1210 | 1211 | case 8: 1212 | case "end": 1213 | return context$4$0.stop(); 1214 | } 1215 | }, callee$3$0, this); 1216 | })); 1217 | }), _defineProperty(_functify2, "keys", function keys() { 1218 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$3$0() { 1219 | var key; 1220 | return regeneratorRuntime.wrap(function callee$3$0$(context$4$0) { 1221 | while (1) switch (context$4$0.prev = context$4$0.next) { 1222 | case 0: 1223 | context$4$0.t0 = regeneratorRuntime.keys(obj); 1224 | 1225 | case 1: 1226 | if ((context$4$0.t1 = context$4$0.t0()).done) { 1227 | context$4$0.next = 8; 1228 | break; 1229 | } 1230 | 1231 | key = context$4$0.t1.value; 1232 | 1233 | if (!obj.hasOwnProperty(key)) { 1234 | context$4$0.next = 6; 1235 | break; 1236 | } 1237 | 1238 | context$4$0.next = 6; 1239 | return key; 1240 | 1241 | case 6: 1242 | context$4$0.next = 1; 1243 | break; 1244 | 1245 | case 8: 1246 | case "end": 1247 | return context$4$0.stop(); 1248 | } 1249 | }, callee$3$0, this); 1250 | })); 1251 | }), _defineProperty(_functify2, "values", function values() { 1252 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$3$0() { 1253 | var key; 1254 | return regeneratorRuntime.wrap(function callee$3$0$(context$4$0) { 1255 | while (1) switch (context$4$0.prev = context$4$0.next) { 1256 | case 0: 1257 | context$4$0.t0 = regeneratorRuntime.keys(obj); 1258 | 1259 | case 1: 1260 | if ((context$4$0.t1 = context$4$0.t0()).done) { 1261 | context$4$0.next = 8; 1262 | break; 1263 | } 1264 | 1265 | key = context$4$0.t1.value; 1266 | 1267 | if (!obj.hasOwnProperty(key)) { 1268 | context$4$0.next = 6; 1269 | break; 1270 | } 1271 | 1272 | context$4$0.next = 6; 1273 | return obj[key]; 1274 | 1275 | case 6: 1276 | context$4$0.next = 1; 1277 | break; 1278 | 1279 | case 8: 1280 | case "end": 1281 | return context$4$0.stop(); 1282 | } 1283 | }, callee$3$0, this); 1284 | })); 1285 | }), _functify2)); 1286 | } 1287 | }, { 1288 | key: "range", 1289 | value: function range(start, stop) { 1290 | var step = arguments[2] === undefined ? 1 : arguments[2]; 1291 | 1292 | if (arguments.length === 1) { 1293 | stop = start; 1294 | start = 0; 1295 | } 1296 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 1297 | var i; 1298 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 1299 | while (1) switch (context$3$0.prev = context$3$0.next) { 1300 | case 0: 1301 | i = start; 1302 | 1303 | if (!(step > 0)) { 1304 | context$3$0.next = 10; 1305 | break; 1306 | } 1307 | 1308 | case 2: 1309 | if (!(i < stop)) { 1310 | context$3$0.next = 8; 1311 | break; 1312 | } 1313 | 1314 | context$3$0.next = 5; 1315 | return i; 1316 | 1317 | case 5: 1318 | i += step; 1319 | context$3$0.next = 2; 1320 | break; 1321 | 1322 | case 8: 1323 | context$3$0.next = 20; 1324 | break; 1325 | 1326 | case 10: 1327 | if (!(step < 0)) { 1328 | context$3$0.next = 19; 1329 | break; 1330 | } 1331 | 1332 | case 11: 1333 | if (!(i > stop)) { 1334 | context$3$0.next = 17; 1335 | break; 1336 | } 1337 | 1338 | context$3$0.next = 14; 1339 | return i; 1340 | 1341 | case 14: 1342 | i += step; 1343 | context$3$0.next = 11; 1344 | break; 1345 | 1346 | case 17: 1347 | context$3$0.next = 20; 1348 | break; 1349 | 1350 | case 19: 1351 | throw "step should not equal 0"; 1352 | 1353 | case 20: 1354 | case "end": 1355 | return context$3$0.stop(); 1356 | } 1357 | }, callee$2$0, this); 1358 | })); 1359 | } 1360 | }, { 1361 | key: "zip", 1362 | value: function zip() { 1363 | for (var _len2 = arguments.length, iterables = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { 1364 | iterables[_key2] = arguments[_key2]; 1365 | } 1366 | 1367 | // assume if a single value is passed in it must contain an array 1368 | if (iterables.length === 1) { 1369 | iterables = iterables[0]; 1370 | } 1371 | return Functified.fromGenerator(regeneratorRuntime.mark(function callee$2$0() { 1372 | var iterators, vector, _iteratorNormalCompletion14, _didIteratorError14, _iteratorError14, _iterator14, _step14, iterator, result; 1373 | 1374 | return regeneratorRuntime.wrap(function callee$2$0$(context$3$0) { 1375 | while (1) switch (context$3$0.prev = context$3$0.next) { 1376 | case 0: 1377 | iterators = iterables.map(function (iterable) { 1378 | if (iterable[Symbol.iterator]) { 1379 | return iterable[Symbol.iterator](); 1380 | } else { 1381 | throw "can't zip a non-iterable"; 1382 | } 1383 | }); 1384 | 1385 | case 1: 1386 | if (!true) { 1387 | context$3$0.next = 37; 1388 | break; 1389 | } 1390 | 1391 | vector = []; 1392 | _iteratorNormalCompletion14 = true; 1393 | _didIteratorError14 = false; 1394 | _iteratorError14 = undefined; 1395 | context$3$0.prev = 6; 1396 | _iterator14 = iterators[Symbol.iterator](); 1397 | 1398 | case 8: 1399 | if (_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done) { 1400 | context$3$0.next = 19; 1401 | break; 1402 | } 1403 | 1404 | iterator = _step14.value; 1405 | result = iterator.next(); 1406 | 1407 | if (!result.done) { 1408 | context$3$0.next = 15; 1409 | break; 1410 | } 1411 | 1412 | return context$3$0.abrupt("return"); 1413 | 1414 | case 15: 1415 | vector.push(result.value); 1416 | 1417 | case 16: 1418 | _iteratorNormalCompletion14 = true; 1419 | context$3$0.next = 8; 1420 | break; 1421 | 1422 | case 19: 1423 | context$3$0.next = 25; 1424 | break; 1425 | 1426 | case 21: 1427 | context$3$0.prev = 21; 1428 | context$3$0.t0 = context$3$0["catch"](6); 1429 | _didIteratorError14 = true; 1430 | _iteratorError14 = context$3$0.t0; 1431 | 1432 | case 25: 1433 | context$3$0.prev = 25; 1434 | context$3$0.prev = 26; 1435 | 1436 | if (!_iteratorNormalCompletion14 && _iterator14["return"]) { 1437 | _iterator14["return"](); 1438 | } 1439 | 1440 | case 28: 1441 | context$3$0.prev = 28; 1442 | 1443 | if (!_didIteratorError14) { 1444 | context$3$0.next = 31; 1445 | break; 1446 | } 1447 | 1448 | throw _iteratorError14; 1449 | 1450 | case 31: 1451 | return context$3$0.finish(28); 1452 | 1453 | case 32: 1454 | return context$3$0.finish(25); 1455 | 1456 | case 33: 1457 | context$3$0.next = 35; 1458 | return vector; 1459 | 1460 | case 35: 1461 | context$3$0.next = 1; 1462 | break; 1463 | 1464 | case 37: 1465 | case "end": 1466 | return context$3$0.stop(); 1467 | } 1468 | }, callee$2$0, this, [[6, 21, 25, 33], [26,, 28, 32]]); 1469 | })); 1470 | } 1471 | }]); 1472 | 1473 | return Functified; 1474 | })(); 1475 | 1476 | function functify(iterable) { 1477 | if (!iterable[Symbol.iterator]) { 1478 | return Functified.fromObject(iterable); 1479 | } else { 1480 | return new Functified(iterable); 1481 | } 1482 | } 1483 | 1484 | functify.fromGenerator = Functified.fromGenerator; 1485 | functify.range = Functified.range; 1486 | functify.zip = Functified.zip; 1487 | 1488 | exports["default"] = functify; 1489 | module.exports = exports["default"]; 1490 | // finished 1491 | 1492 | },{}]},{},[1])(1) 1493 | }); --------------------------------------------------------------------------------