Class ExtendedIterator<T>

Implements this as an Iterable so it's allowed to be used with "for of" loops.

Lazy

Yields non-overlapping chunks (tuples) of length from this iterator.

Example

iter([1,2,3,4,5,6,7,8,9]).chunk(3).toArray() // [[1,2,3], [4,5,6], [7,8,9]]
iter([1,2,3,4,5,6,7,8,9]).chunk(2, 0).toArray() // [[1,2], [3,4], [5,6], [7,8], [9, 0]]
Copy

Lazy

Returns size length subsequences of this iterator.

See

• https://docs.python.org/3/library/itertools.html#itertools.combinations for more info.
• https://docs.python.org/3/library/itertools.html#itertools.combinations_with_replacement for more info.

Lazy

Filters/compresses this iterator to only values that correspond to truthy values in selectors.

Lazy

Concatenates this iterator with the given iterators, in order of: [this.iterator, ...others].

Start iterating through this iterator, but don't return the values from this method.

Lazy

Makes this iterator cycle infinitely through it's values.

Example

equal(iter([1,2,3]).cycle().take(5).toArray(), [1,2,3,1,2])
Copy

Lazy

Distributes this iterator's values among n amount of smaller iterators. Does not maintain order so if order is important, use divide instead.

Divides this iterator into n amount of smaller iterators while maintaining order. Note, this method will fully iterate through this iterator before returning a result. If you don't want this behavior and don't care about order then use distribute instead.

Lazy

Drop/skip values in this iterator while the passed predicate returns a truthy value.

Lazy

Attaches the index to each value as a pair like: [0, value], [1, value], etc.

Return true if every element in this iterator matches the predicate.

Deprecated

Use consume instead, as this is the more standard name for this type of method. Start iterating through this iterator, but don't return the values from this method.

Lazy

Returns a new ExtendedIterator that filters each element in this iterator.

Lazy

Maps and filters the input iterator in the same iteratee function.

Finds the first value that passes a truthy value to predicate, then returns it. Only consumes the iterator's values up to the found value, then stops. So if it's not found, then the iterator is exhausted.

Finds the index of the first value that passes a truthy vale to predicate, then returns it. Only consumes the iterator's values up to the found value, then stops. So if it's not found, then the iterator is exhausted.

Maps this iterator to a new value R and flattens any resulting iterables or iterators by a depth of 1. Behaves the same as Array.prototype.flatMap.

Lazy

Flatten this iterator by a known depth or deeply.

Iterate over this iterator using the array.prototype.forEach style of method.

Groups consecutive keys in the input iterator by some key identifier function or property. Functionally equivalent to the itertools.groupby function in Python. Generally the input iterator needs to be sorted by the same key. Each iteration will return the next group of values with the same key, until the key changes. So unless the input iterator is sorted beforehand, you may have broken up groups with the same keys.

Example

groupby('AAAABBBCCDAABBB') // =>
   // ['A', ['A', 'A', 'A', 'A']],
   // ['B', ['B', 'B', 'B']],
   // ['C', ['C', 'C']],
   // ['D', ['D']],
   // ['A', ['A', 'A']],
   // ['B', ['B', 'B', 'B']]
Copy

Returns true if value strictly equals some value in this iterator.

Returns this iterator as a string with each value joined by separator.

Consumes this iterator and returns the number of values/items in it.

Lazy

Returns a new ExtendedIterator that maps each element in this iterator to a new value.

Returns the maximum value from this iterator.

Returns the minimum value from this iterator.

Returns the minimum and maximum from this iterator as a tuple: [min, max].

Returns a { value, done } object that adheres to the Iterator interface.

Iterates and finds the element at index. Returns undefined if not found.

Lazy

Return a new iterator of pairs (tuples) of the values in this one. The number of pairs will always be one fewer than this iterator. Will be empty if this iterator has fewer than two values.

Example

iter([1,2,3]).pairwise().toArray() // [[1,2], [2,3]]
iter([1]).pairwise().toArray() // []
Copy

Partitions this iterator into a tuple of [falsey, truthy] corresponding to what predicate returns for each value.

Peek ahead of where the current iteration is. This doesn't consume any values of the iterator.

Lazy

Returns all successive size length permutations of this iterator. The permutations are emitted in lexicographic ordering according to this iterator. So if this iterator is sorted, the permutations will be in sorted order. Elements in the permutations are treated as unique based on their position in the iterator, not on their value. So if the input iterator is unique, then there will be no repeat values.

See

https://docs.python.org/3/library/itertools.html#itertools.permutations for more info.

Lazy

Maps key from T in each value of this iterator.

Lazy

Prepends this iterator with the given iterators, in order of: [...args, this.iterator].

Lazy

Returns the cartesian product of this iterator with other iterators after it.

See

https://docs.python.org/3/library/itertools.html#itertools.product for more info.

Calls Promise.all on all collected values.

Calls Promise.race on all collected values.

Returns the number of times the predicate returns a truthy value.

Reduces this iterator to a single value.

Lazy

Resumes this iterator a certain number of times after it's next value returns { done: true }.

Example

const it = iter([1,2,3]).resume(1);
equal(it.toArray(), [1,2,3]);
equal(it.toArray(), [1,2,3]);
equal(it.toArray(), []);
Copy

Lazy

Reverses this iterator's order. Note that in order to reverse, it will attempt to iterate fully once, which could cause significant memory usage. So because of this, only use on finite iterators.

Collects all values from this iterator, then shuffles the order of it's values.

Lazy

Works like Array.prototype.slice, returns a new slice of this iterator.

Note

This does not support negative start and end indices, as it's not possible to know the length of the iterator while iterating.

Return true if only one element in this iterator matches the predicate.

Collects all values from this iterator, then sorts them.

Take n number of values from this iterator.

Lazy

Take all elements from this iterator while the given predicate returns a truthy value.

Lazy

Tap into this iterator by supplying func which is passed each value of this iterator. The return value of func is unused and this method is purely designed for a designated place to perform side effects.

Example

iter([1,2,3])
   .tap(console.log) // logs 1, 2, 3 to the console
   .map(n => n * n)
   .tap(console.log) // logs 1, 4, 9 to the console
   .toArray() // returns [1, 4, 9]
Copy

Lazy

Returns n independent iterators, each of which is a copy of this iterator at the time of calling tee. Once tee has made a split, do not modify or call upon the original iterator, as the new iterators will not be updated/informed. This caches the original iterator's values as the new iterators are iterated through. So depending on the size of the original iterator, there could be significant memory overhead in using tee. tee's intended use is to iterate over the returned iterators in parallel, or at least somewhat in parallel. In general, if one returned iterator consumes most or all of it's values, then it is faster to just use toArray and then iterate over that.

Iterates and collects all values into an Array.

Shorthand for new Map<K, V>(this). The type of this iterator must extend any[] for this to work. And you may also need to pass in your own values for the generics: e.g. iterator.toMap<string, number>();

Shorthand for new Set(this).

Lazy

Returns a new iterator of triplets (tuples) of the values in this one. The number of triplets will always be two fewer than the number of values in this iterator. Will be empty if this iterator has fewer than three values.

Lazy

Filters this iterator to only unique values.

Lazy

The inverse of zip and zipLongest. This method disaggregates the elements of this iterator. The nth iterator in the returned tuple contains the nth element of each value in this iterator. The length of the returned tuple is determined by the length of the first value in this iterator.

Lazy

Yields sliding windows (tuples) of length from this iterator. Each window is separated by offset number of elements.

Example

iter([1,2,3,4,5]).windows(2, 1).toArray() // [[1,2], [2,3], [3,4], [4,5]]
iter([1,2,3,4,5]).windows(2, 3).toArray() // [[1,2], [4,5]]
iter([1,2,3,4,5]).windows(3, 3, 0).toArray() // [[1,2,3], [4,5,0]]
Copy

Lazy

Aggregates this iterator and any number of others into one. Stops when one of the iterables is empty.

Lazy

Aggregates this iterator and any number of others into one. Stops when all of the iterables is empty.