itertools 1.7.0 → 2.0.0-beta1

package/builtins.js.flow

@@ -1,294 +0,0 @@
-// @flow strict
-
-import { first } from './custom';
-import { count, ifilter, imap, izip, izip3, takewhile } from './itertools';
-import type { Maybe, Predicate, Primitive } from './types';
-import { identityPredicate, keyToCmp, numberIdentity, primitiveIdentity } from './utils';
-
-/**
- * Returns true when all of the items in iterable are truthy.  An optional key
- * function can be used to define what truthiness means for this specific
- * collection.
- *
- * Examples:
- *
- *     all([])                           // => true
- *     all([0])                          // => false
- *     all([0, 1, 2])                    // => false
- *     all([1, 2, 3])                    // => true
- *
- * Examples with using a key function:
- *
- *     all([2, 4, 6], n => n % 2 === 0)  // => true
- *     all([2, 4, 5], n => n % 2 === 0)  // => false
- *
- */
-export function all<T>(iterable: Iterable<T>, keyFn: Predicate<T> = identityPredicate): boolean {
-    for (let item of iterable) {
-        if (!keyFn(item)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-/**
- * Returns true when any of the items in iterable are truthy.  An optional key
- * function can be used to define what truthiness means for this specific
- * collection.
- *
- * Examples:
- *
- *     any([])                           // => false
- *     any([0])                          // => false
- *     any([0, 1, null, undefined])      // => true
- *
- * Examples with using a key function:
- *
- *     any([1, 4, 5], n => n % 2 === 0)  // => true
- *     any([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false
- *
- */
-export function any<T>(iterable: Iterable<T>, keyFn: Predicate<T> = identityPredicate): boolean {
-    for (let item of iterable) {
-        if (keyFn(item)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Returns true when any of the items in the iterable are equal to the target object.
- *
- * Examples:
- *
- *     contains([], 'whatever')         // => false
- *     contains([3], 42)                // => false
- *     contains([3], 3)                 // => true
- *     contains([0, 1, 2], 2)           // => true
- *
- */
-export function contains<T>(haystack: Iterable<T>, needle: T): boolean {
-    return any(haystack, (x) => x === needle);
-}
-
-/**
- * Returns an iterable of enumeration pairs.  Iterable must be a sequence, an
- * iterator, or some other object which supports iteration.  The elements
- * produced by returns a tuple containing a counter value (starting from 0 by
- * default) and the values obtained from iterating over given iterable.
- *
- * Example:
- *
- *     import { enumerate } from 'itertools';
- *
- *     console.log([...enumerate(['hello', 'world'])]);
- *     // [0, 'hello'], [1, 'world']]
- */
-export function* enumerate<T>(iterable: Iterable<T>, start: number = 0): Iterable<[number, T]> {
-    let index: number = start;
-    for (let value of iterable) {
-        yield [index++, value];
-    }
-}
-
-/**
- * Non-lazy version of ifilter().
- */
-export function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): Array<T> {
-    return Array.from(ifilter(iterable, predicate));
-}
-
-/**
- * Returns an iterator object for the given iterable.  This can be used to
- * manually get an iterator for any iterable datastructure.  The purpose and
- * main use case of this function is to get a single iterator (a thing with
- * state, think of it as a "cursor") which can only be consumed once.
- */
-export function iter<T>(iterable: Iterable<T>): Iterator<T> {
-    // TODO: Not sure why Flow choked on this expression below, but at least we lock down the
-    // type transformation in the function signature this way.
-    // $FlowFixMe[incompatible-use]
-    return iterable[Symbol.iterator]();
-}
-
-/**
- * Non-lazy version of imap().
- */
-export function map<T, V>(iterable: Iterable<T>, mapper: (T) => V): Array<V> {
-    return Array.from(imap(iterable, mapper));
-}
-
-/**
- * Return the largest item in an iterable.  Only works for numbers, as ordering
- * is pretty poorly defined on any other data type in JS.  The optional `keyFn`
- * argument specifies a one-argument ordering function like that used for
- * sorted().
- *
- * If the iterable is empty, `undefined` is returned.
- *
- * If multiple items are maximal, the function returns either one of them, but
- * which one is not defined.
- */
-export function max<T>(iterable: Iterable<T>, keyFn: (T) => number = numberIdentity): Maybe<T> {
-    return reduce_(iterable, (x, y) => (keyFn(x) > keyFn(y) ? x : y));
-}
-
-/**
- * Return the smallest item in an iterable.  Only works for numbers, as
- * ordering is pretty poorly defined on any other data type in JS.  The
- * optional `keyFn` argument specifies a one-argument ordering function like
- * that used for sorted().
- *
- * If the iterable is empty, `undefined` is returned.
- *
- * If multiple items are minimal, the function returns either one of them, but
- * which one is not defined.
- */
-export function min<T>(iterable: Iterable<T>, keyFn: (T) => number = numberIdentity): Maybe<T> {
-    return reduce_(iterable, (x, y) => (keyFn(x) < keyFn(y) ? x : y));
-}
-
-/**
- * Internal helper for the range function
- */
-function _range(start: number, stop: number, step: number): Iterable<number> {
-    const counter = count(start, step);
-    const pred = step >= 0 ? (n) => n < stop : (n) => n > stop;
-    return takewhile(counter, pred);
-}
-
-/**
- * Returns an iterator producing all the numbers in the given range one by one,
- * starting from `start` (default 0), as long as `i < stop`, in increments of
- * `step` (default 1).
- *
- * `range(a)` is a convenient shorthand for `range(0, a)`.
- *
- * Various valid invocations:
- *
- *     range(5)           // [0, 1, 2, 3, 4]
- *     range(2, 5)        // [2, 3, 4]
- *     range(0, 5, 2)     // [0, 2, 4]
- *     range(5, 0, -1)    // [5, 4, 3, 2, 1]
- *     range(-3)          // []
- *
- * For a positive `step`, the iterator will keep producing values `n` as long
- * as the stop condition `n < stop` is satisfied.
- *
- * For a negative `step`, the iterator will keep producing values `n` as long
- * as the stop condition `n > stop` is satisfied.
- *
- * The produced range will be empty if the first value to produce already does
- * not meet the value constraint.
- */
-export function range(a: number, ...rest: Array<number>): Iterable<number> {
-    const args = [a, ...rest]; // "a" was only used by Flow to make at least one value mandatory
-    switch (args.length) {
-        case 1:
-            return _range(0, args[0], 1);
-        case 2:
-            return _range(args[0], args[1], 1);
-        case 3:
-            return _range(args[0], args[1], args[2]);
-        /* istanbul ignore next */
-        default:
-            throw new Error('invalid number of arguments');
-    }
-}
-
-/**
- * Apply function of two arguments cumulatively to the items of sequence, from
- * left to right, so as to reduce the sequence to a single value.  For example:
- *
- *     reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)
- *
- * calculates
- *
- *     (((((0+1)+2)+3)+4)+5)
- *
- * The left argument, `x`, is the accumulated value and the right argument,
- * `y`, is the update value from the sequence.
- *
- * **Difference between `reduce()` and `reduce\_()`**:  `reduce()` requires an
- * explicit initializer, whereas `reduce_()` will automatically use the first
- * item in the given iterable as the initializer.  When using `reduce()`, the
- * initializer value is placed before the items of the sequence in the
- * calculation, and serves as a default when the sequence is empty.  When using
- * `reduce_()`, and the given iterable is empty, then no default value can be
- * derived and `undefined` will be returned.
- */
-export function reduce<T, O>(iterable: Iterable<T>, reducer: (O, T, number) => O, start: O): O {
-    const it = iter(iterable);
-    let output = start;
-    for (const [index, item] of enumerate(it)) {
-        output = reducer(output, item, index);
-    }
-    return output;
-}
-
-/**
- * See reduce().
- */
-export function reduce_<T>(iterable: Iterable<T>, reducer: (T, T, number) => T): Maybe<T> {
-    const it = iter(iterable);
-    const start = first(it);
-    if (start === undefined) {
-        return undefined;
-    } else {
-        return reduce(it, reducer, start);
-    }
-}
-
-/**
- * Return a new sorted list from the items in iterable.
- *
- * Has two optional arguments:
- *
- * * `keyFn` specifies a function of one argument providing a primitive
- *   identity for each element in the iterable.  that will be used to compare.
- *   The default value is to use a default identity function that is only
- *   defined for primitive types.
- *
- * * `reverse` is a boolean value.  If `true`, then the list elements are
- *   sorted as if each comparison were reversed.
- */
-export function sorted<T>(
-    iterable: Iterable<T>,
-    keyFn: (T) => Primitive = primitiveIdentity,
-    reverse: boolean = false
-): Array<T> {
-    const result = Array.from(iterable);
-    result.sort(keyToCmp(keyFn)); // sort in-place
-
-    if (reverse) {
-        result.reverse(); // reverse in-place
-    }
-
-    return result;
-}
-
-/**
- * Sums the items of an iterable from left to right and returns the total.  The
- * sum will defaults to 0 if the iterable is empty.
- */
-export function sum(iterable: Iterable<number>): number {
-    return reduce(iterable, (x, y) => x + y, 0);
-}
-
-/**
- * See izip.
- */
-export function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Array<[T1, T2]> {
-    return Array.from(izip(xs, ys));
-}
-
-/**
- * See izip3.
- */
-export function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Array<[T1, T2, T3]> {
-    return Array.from(izip3(xs, ys, zs));
-}

package/custom.d.ts

@@ -1,7 +0,0 @@
-import { Maybe, Predicate } from './types';
-
-export function icompact<T>(iterable: Iterable<T>): Iterable<NonNullable<T>>;
-export function compact<T>(iterable: Iterable<T>): Array<NonNullable<T>>;
-export function compactObject<O extends object>(obj: O): { [K in keyof O]: NonNullable<O[K]> };
-export function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): Maybe<T>;
-export function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): Iterable<S>;

package/custom.js

@@ -1,186 +0,0 @@
-"use strict";
-
-var _regeneratorRuntime2 = require("@babel/runtime/regenerator");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.icompact = icompact;
-exports.compact = compact;
-exports.compactObject = compactObject;
-exports.first = first;
-exports.flatmap = flatmap;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _itertools = require("./itertools");
-
-var _moreItertools = require("./more-itertools");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-var _marked = /*#__PURE__*/_regeneratorRuntime2.mark(icompact);
-
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function isDefined(x) {
-  return x !== undefined;
-}
-/**
- * Returns an iterable, filtering out any `undefined` values from the input
- * iterable.  This function is useful to convert a list of `Maybe<T>`'s to
- * a list of `T`'s, discarding all the undefined values:
- *
- *     >>> compact([1, 2, undefined, 3])
- *     [1, 2, 3]
- */
-
-
-function icompact(iterable) {
-  var _iterator, _step, item;
-
-  return _regenerator["default"].wrap(function icompact$(_context) {
-    while (1) {
-      switch (_context.prev = _context.next) {
-        case 0:
-          _iterator = _createForOfIteratorHelper(iterable);
-          _context.prev = 1;
-
-          _iterator.s();
-
-        case 3:
-          if ((_step = _iterator.n()).done) {
-            _context.next = 10;
-            break;
-          }
-
-          item = _step.value;
-
-          if (!(typeof item !== 'undefined')) {
-            _context.next = 8;
-            break;
-          }
-
-          _context.next = 8;
-          return item;
-
-        case 8:
-          _context.next = 3;
-          break;
-
-        case 10:
-          _context.next = 15;
-          break;
-
-        case 12:
-          _context.prev = 12;
-          _context.t0 = _context["catch"](1);
-
-          _iterator.e(_context.t0);
-
-        case 15:
-          _context.prev = 15;
-
-          _iterator.f();
-
-          return _context.finish(15);
-
-        case 18:
-        case "end":
-          return _context.stop();
-      }
-    }
-  }, _marked, null, [[1, 12, 15, 18]]);
-}
-/**
- * See icompact().
- */
-
-
-function compact(iterable) {
-  return Array.from(icompact(iterable));
-}
-/**
- * Removes all undefined values from the given object.  Returns a new object.
- *
- *     >>> compactObject({ a: 1, b: undefined, c: 0 })
- *     { a: 1, c: 0 }
- *
- */
-
-
-function compactObject(obj) {
-  var result = {};
-
-  for (var _i = 0, _Object$entries = Object.entries(obj); _i < _Object$entries.length; _i++) {
-    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-        _key = _Object$entries$_i[0],
-        value = _Object$entries$_i[1];
-
-    if (typeof value !== 'undefined') {
-      result[_key] = value;
-    }
-  }
-
-  return result;
-}
-/**
- * Returns the first item in the iterable for which the predicate holds, if
- * any.  If no such item exists, `undefined` is returned.  The default
- * predicate is any defined value.
- */
-
-
-function first(iterable, keyFn) {
-  var fn = keyFn || isDefined;
-
-  var _iterator2 = _createForOfIteratorHelper(iterable),
-      _step2;
-
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var value = _step2.value;
-
-      if (fn(value)) {
-        return value;
-      }
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
-  }
-
-  return undefined;
-}
-/**
- * Returns 0 or more values for every value in the given iterable.
- * Technically, it's just calling map(), followed by flatten(), but it's a very
- * useful operation if you want to map over a structure, but not have a 1:1
- * input-output mapping.  Instead, if you want to potentially return 0 or more
- * values per input element, use flatmap():
- *
- * For example, to return all numbers `n` in the input iterable `n` times:
- *
- *     >>> const repeatN = n => repeat(n, n);
- *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]
- *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0
- *
- */
-
-
-function flatmap(iterable, mapper) {
-  return (0, _moreItertools.flatten)((0, _itertools.imap)(iterable, mapper));
-}

package/custom.js.flow

@@ -1,82 +0,0 @@
-// @flow strict
-
-import { imap } from './itertools';
-import { flatten } from './more-itertools';
-import type { Maybe, Predicate } from './types';
-
-function isDefined<T>(x: T): boolean {
-    return x !== undefined;
-}
-
-/**
- * Returns an iterable, filtering out any `undefined` values from the input
- * iterable.  This function is useful to convert a list of `Maybe<T>`'s to
- * a list of `T`'s, discarding all the undefined values:
- *
- *     >>> compact([1, 2, undefined, 3])
- *     [1, 2, 3]
- */
-export function* icompact<T>(iterable: Iterable<T>): Iterable<$NonMaybeType<T>> {
-    for (let item of iterable) {
-        if (typeof item !== 'undefined') {
-            yield item;
-        }
-    }
-}
-
-/**
- * See icompact().
- */
-export function compact<T>(iterable: Iterable<T>): Array<$NonMaybeType<T>> {
-    return Array.from(icompact(iterable));
-}
-
-/**
- * Removes all undefined values from the given object.  Returns a new object.
- *
- *     >>> compactObject({ a: 1, b: undefined, c: 0 })
- *     { a: 1, c: 0 }
- *
- */
-export function compactObject<O: { +[key: string]: mixed }>(obj: O): $ObjMap<O, <T>(T) => $NonMaybeType<T>> {
-    let result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (typeof value !== 'undefined') {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-/**
- * Returns the first item in the iterable for which the predicate holds, if
- * any.  If no such item exists, `undefined` is returned.  The default
- * predicate is any defined value.
- */
-export function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): Maybe<T> {
-    const fn = keyFn || isDefined;
-    for (let value of iterable) {
-        if (fn(value)) {
-            return value;
-        }
-    }
-    return undefined;
-}
-
-/**
- * Returns 0 or more values for every value in the given iterable.
- * Technically, it's just calling map(), followed by flatten(), but it's a very
- * useful operation if you want to map over a structure, but not have a 1:1
- * input-output mapping.  Instead, if you want to potentially return 0 or more
- * values per input element, use flatmap():
- *
- * For example, to return all numbers `n` in the input iterable `n` times:
- *
- *     >>> const repeatN = n => repeat(n, n);
- *     >>> [...flatmap([0, 1, 2, 3, 4], repeatN)]
- *     [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]  // note: no 0
- *
- */
-export function flatmap<T, S>(iterable: Iterable<T>, mapper: (T) => Iterable<S>): Iterable<S> {
-    return flatten(imap(iterable, mapper));
-}

package/index.d.ts

@@ -1,52 +0,0 @@
-export { Predicate, Primitive } from './types';
-
-export {
-    all,
-    any,
-    contains,
-    enumerate,
-    filter,
-    iter,
-    map,
-    max,
-    min,
-    range,
-    reduce,
-    sorted,
-    sum,
-    zip,
-    zip3,
-} from './builtins';
-export {
-    chain,
-    compress,
-    count,
-    cycle,
-    dropwhile,
-    groupby,
-    icompress,
-    ifilter,
-    imap,
-    izip,
-    izip2,
-    izip3,
-    izipMany,
-    izipLongest,
-    permutations,
-    takewhile,
-    zipLongest,
-    zipMany,
-} from './itertools';
-export {
-    chunked,
-    flatten,
-    heads,
-    itake,
-    pairwise,
-    partition,
-    roundrobin,
-    take,
-    uniqueEverseen,
-    uniqueJustseen,
-} from './more-itertools';
-export { compact, compactObject, first, flatmap, icompact } from './custom';