itertools 2.3.1 → 2.4.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-type Predicate<T> = (value: T) => boolean;
+type Predicate<T> = (value: T, index: number) => boolean;
 type Primitive = string | number | boolean;
 
 /**
@@ -6,7 +6,7 @@ type Primitive = string | number | boolean;
  * any. If no predicate is given, it will return the first value returned by
  * the iterable.
  */
-declare function find<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined;
+declare function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined;
 /**
  * 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
@@ -25,7 +25,7 @@ declare function find<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undef
  *     all([2, 4, 5], n => n % 2 === 0)  // => false
  *
  */
-declare function every<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
+declare function every<T>(iterable: Iterable<T>, predicate?: Predicate<T>): boolean;
 /**
  * Returns true when some of the items in iterable are truthy.  An optional key
  * function can be used to define what truthiness means for this specific
@@ -43,7 +43,7 @@ declare function every<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
  *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false
  *
  */
-declare function some<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
+declare function some<T>(iterable: Iterable<T>, predicate?: Predicate<T>): boolean;
 /**
  * Alias of `every()`.
  */
@@ -81,7 +81,7 @@ declare function enumerate<T>(iterable: Iterable<T>, start?: number): IterableIt
 /**
  * Non-lazy version of ifilter().
  */
-declare function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): N[];
+declare function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];
 declare function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];
 /**
  * Returns an iterator object for the given iterable.  This can be used to
@@ -189,11 +189,60 @@ declare function sum(iterable: Iterable<number>): number;
 /**
  * See izip.
  */
-declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Array<[T1, T2]>;
+declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][];
 /**
  * See izip3.
  */
-declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Array<[T1, T2, T3]>;
+declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][];
+
+/**
+ * Returns an iterable, filtering out any "nullish" values from the iterable.
+ *
+ *     >>> compact([1, 2, undefined, 3, null])
+ *     [1, 2, 3]
+ *
+ * For an eager version, @see compact().
+ */
+declare function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T>;
+/**
+ * Returns an array, filtering out any "nullish" values from the iterable.
+ *
+ *     >>> compact([1, 2, undefined, 3, null])
+ *     [1, 2, 3]
+ *
+ * For a lazy version, @see icompact().
+ */
+declare function compact<T>(iterable: Iterable<T | null | undefined>): T[];
+/**
+ * Removes all "nullish" values from the given object. Returns a new object.
+ *
+ *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })
+ *     { a: 1, c: 0 }
+ *
+ */
+declare function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V>;
+/**
+ * Almost an alias of find(). There only is a difference if no key fn is
+ * provided. In that case, `find()` will return the first item in the iterable,
+ * whereas `first()` will return the first non-`undefined` value in the
+ * iterable.
+ */
+declare function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | 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
+ *
+ */
+declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S>;
 
 /**
  * Returns an iterator that returns elements from the first iterable until it
@@ -272,6 +321,10 @@ declare const izip2: typeof izip;
  * fillvalue.  Iteration continues until the longest iterable is exhausted.
  */
 declare function izipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): IterableIterator<[T1 | D, T2 | D]>;
+/**
+ * See izipLongest2, but for three.
+ */
+declare function izipLongest3<T1, T2, T3, D = undefined>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>, filler?: D): IterableIterator<[T1 | D, T2 | D, T3 | D]>;
 /**
  * Like the other izips (`izip`, `izip3`, etc), but generalized to take an
  * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.
@@ -305,7 +358,8 @@ declare function repeat<T>(thing: T, times?: number): IterableIterator<T>;
  * predicate is true.
  */
 declare function takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;
-declare function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): Array<[T1 | D, T2 | D]>;
+declare function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][];
+declare function zipLongest3<T1, T2, T3, D>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>, filler?: D): [T1 | D, T2 | D, T3 | D][];
 declare const izipLongest: typeof izipLongest2;
 declare const zipLongest: typeof zipLongest2;
 declare function zipMany<T>(...iters: Iterable<T>[]): T[][];
@@ -331,6 +385,14 @@ declare function chunked<T>(iterable: Iterable<T>, size: number): IterableIterat
  *
  */
 declare function flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T>;
+/**
+ * Intersperse filler element `value` among the items in `iterable`.
+ *
+ *     >>> [...intersperse(-1, range(1, 5))]
+ *     [1, -1, 2, -1, 3, -1, 4]
+ *
+ */
+declare function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V>;
 /**
  * Returns an iterable containing only the first `n` elements of the given
  * iterable.
@@ -360,7 +422,7 @@ declare function pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]>;
  *     [0, 2, 4, 6, 8]
  *
  */
-declare function partition<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): [N[], Exclude<T, N>[]];
+declare function partition<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): [N[], Exclude<T, N>[]];
 declare function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];
 /**
  * Yields the next item from each iterable in turn, alternating between them.
@@ -381,7 +443,7 @@ declare function roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T>;
  * This is also different from `zipLongest()`, since the number of items in
  * each round can decrease over time, rather than being filled with a filler.
  */
-declare function heads<T>(...iters: Array<Iterable<T>>): IterableIterator<T[]>;
+declare function heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]>;
 /**
  * Non-lazy version of itake().
  */
@@ -418,53 +480,4 @@ declare function dupes<T>(iterable: Iterable<T>, keyFn?: (item: T) => Primitive)
  */
 declare function uniqueJustseen<T>(iterable: Iterable<T>, keyFn?: (item: T) => Primitive): IterableIterator<T>;
 
-/**
- * Returns an iterable, filtering out any "nullish" values from the iterable.
- *
- *     >>> compact([1, 2, undefined, 3, null])
- *     [1, 2, 3]
- *
- * For an eager version, @see compact().
- */
-declare function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T>;
-/**
- * Returns an array, filtering out any "nullish" values from the iterable.
- *
- *     >>> compact([1, 2, undefined, 3, null])
- *     [1, 2, 3]
- *
- * For a lazy version, @see icompact().
- */
-declare function compact<T>(iterable: Iterable<T | null | undefined>): T[];
-/**
- * Removes all "nullish" values from the given object. Returns a new object.
- *
- *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })
- *     { a: 1, c: 0 }
- *
- */
-declare function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V>;
-/**
- * Almost an alias of find(). There only is a difference if no key fn is
- * provided. In that case, `find()` will return the first item in the iterable,
- * whereas `first()` will return the first non-`undefined` value in the
- * iterable.
- */
-declare function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | 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
- *
- */
-declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S>;
-
-export { type Predicate, type Primitive, all, any, chain, chunked, compact, compactObject, compress, contains, count, cycle, dropwhile, dupes, enumerate, every, filter, find, first, flatmap, flatten, groupby, heads, icompact, icompress, ifilter, imap, islice, itake, iter, izip, izip2, izip3, izipLongest, izipMany, map, max, min, pairwise, partition, permutations, range, reduce, repeat, roundrobin, some, sorted, sum, take, takewhile, uniqueEverseen, uniqueJustseen, zip, zip3, zipLongest, zipMany };
+export { type Predicate, type Primitive, all, any, chain, chunked, compact, compactObject, compress, contains, count, cycle, dropwhile, dupes, enumerate, every, filter, find, first, flatmap, flatten, groupby, heads, icompact, icompress, ifilter, imap, intersperse, islice, itake, iter, izip, izip2, izip3, izipLongest, izipLongest3, izipMany, map, max, min, pairwise, partition, permutations, range, reduce, repeat, roundrobin, some, sorted, sum, take, takewhile, uniqueEverseen, uniqueJustseen, zip, zip3, zipLongest, zipLongest3, zipMany };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-type Predicate<T> = (value: T) => boolean;
+type Predicate<T> = (value: T, index: number) => boolean;
 type Primitive = string | number | boolean;
 
 /**
@@ -6,7 +6,7 @@ type Primitive = string | number | boolean;
  * any. If no predicate is given, it will return the first value returned by
  * the iterable.
  */
-declare function find<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undefined;
+declare function find<T>(iterable: Iterable<T>, predicate?: Predicate<T>): T | undefined;
 /**
  * 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
@@ -25,7 +25,7 @@ declare function find<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | undef
  *     all([2, 4, 5], n => n % 2 === 0)  // => false
  *
  */
-declare function every<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
+declare function every<T>(iterable: Iterable<T>, predicate?: Predicate<T>): boolean;
 /**
  * Returns true when some of the items in iterable are truthy.  An optional key
  * function can be used to define what truthiness means for this specific
@@ -43,7 +43,7 @@ declare function every<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
  *     some([{name: 'Bob'}, {name: 'Alice'}], person => person.name.startsWith('C'))  // => false
  *
  */
-declare function some<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): boolean;
+declare function some<T>(iterable: Iterable<T>, predicate?: Predicate<T>): boolean;
 /**
  * Alias of `every()`.
  */
@@ -81,7 +81,7 @@ declare function enumerate<T>(iterable: Iterable<T>, start?: number): IterableIt
 /**
  * Non-lazy version of ifilter().
  */
-declare function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): N[];
+declare function filter<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): N[];
 declare function filter<T>(iterable: Iterable<T>, predicate: Predicate<T>): T[];
 /**
  * Returns an iterator object for the given iterable.  This can be used to
@@ -189,11 +189,60 @@ declare function sum(iterable: Iterable<number>): number;
 /**
  * See izip.
  */
-declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Array<[T1, T2]>;
+declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): [T1, T2][];
 /**
  * See izip3.
  */
-declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Array<[T1, T2, T3]>;
+declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): [T1, T2, T3][];
+
+/**
+ * Returns an iterable, filtering out any "nullish" values from the iterable.
+ *
+ *     >>> compact([1, 2, undefined, 3, null])
+ *     [1, 2, 3]
+ *
+ * For an eager version, @see compact().
+ */
+declare function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T>;
+/**
+ * Returns an array, filtering out any "nullish" values from the iterable.
+ *
+ *     >>> compact([1, 2, undefined, 3, null])
+ *     [1, 2, 3]
+ *
+ * For a lazy version, @see icompact().
+ */
+declare function compact<T>(iterable: Iterable<T | null | undefined>): T[];
+/**
+ * Removes all "nullish" values from the given object. Returns a new object.
+ *
+ *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })
+ *     { a: 1, c: 0 }
+ *
+ */
+declare function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V>;
+/**
+ * Almost an alias of find(). There only is a difference if no key fn is
+ * provided. In that case, `find()` will return the first item in the iterable,
+ * whereas `first()` will return the first non-`undefined` value in the
+ * iterable.
+ */
+declare function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | 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
+ *
+ */
+declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S>;
 
 /**
  * Returns an iterator that returns elements from the first iterable until it
@@ -272,6 +321,10 @@ declare const izip2: typeof izip;
  * fillvalue.  Iteration continues until the longest iterable is exhausted.
  */
 declare function izipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): IterableIterator<[T1 | D, T2 | D]>;
+/**
+ * See izipLongest2, but for three.
+ */
+declare function izipLongest3<T1, T2, T3, D = undefined>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>, filler?: D): IterableIterator<[T1 | D, T2 | D, T3 | D]>;
 /**
  * Like the other izips (`izip`, `izip3`, etc), but generalized to take an
  * unlimited amount of input iterables.  Think `izip(*iterables)` in Python.
@@ -305,7 +358,8 @@ declare function repeat<T>(thing: T, times?: number): IterableIterator<T>;
  * predicate is true.
  */
 declare function takewhile<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T>;
-declare function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): Array<[T1 | D, T2 | D]>;
+declare function zipLongest2<T1, T2, D>(xs: Iterable<T1>, ys: Iterable<T2>, filler?: D): [T1 | D, T2 | D][];
+declare function zipLongest3<T1, T2, T3, D>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>, filler?: D): [T1 | D, T2 | D, T3 | D][];
 declare const izipLongest: typeof izipLongest2;
 declare const zipLongest: typeof zipLongest2;
 declare function zipMany<T>(...iters: Iterable<T>[]): T[][];
@@ -331,6 +385,14 @@ declare function chunked<T>(iterable: Iterable<T>, size: number): IterableIterat
  *
  */
 declare function flatten<T>(iterableOfIterables: Iterable<Iterable<T>>): IterableIterator<T>;
+/**
+ * Intersperse filler element `value` among the items in `iterable`.
+ *
+ *     >>> [...intersperse(-1, range(1, 5))]
+ *     [1, -1, 2, -1, 3, -1, 4]
+ *
+ */
+declare function intersperse<T, V>(value: V, iterable: Iterable<T>): IterableIterator<T | V>;
 /**
  * Returns an iterable containing only the first `n` elements of the given
  * iterable.
@@ -360,7 +422,7 @@ declare function pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]>;
  *     [0, 2, 4, 6, 8]
  *
  */
-declare function partition<T, N extends T>(iterable: Iterable<T>, predicate: (item: T) => item is N): [N[], Exclude<T, N>[]];
+declare function partition<T, N extends T>(iterable: Iterable<T>, predicate: (item: T, index: number) => item is N): [N[], Exclude<T, N>[]];
 declare function partition<T>(iterable: Iterable<T>, predicate: Predicate<T>): [T[], T[]];
 /**
  * Yields the next item from each iterable in turn, alternating between them.
@@ -381,7 +443,7 @@ declare function roundrobin<T>(...iters: Iterable<T>[]): IterableIterator<T>;
  * This is also different from `zipLongest()`, since the number of items in
  * each round can decrease over time, rather than being filled with a filler.
  */
-declare function heads<T>(...iters: Array<Iterable<T>>): IterableIterator<T[]>;
+declare function heads<T>(...iters: Iterable<T>[]): IterableIterator<T[]>;
 /**
  * Non-lazy version of itake().
  */
@@ -418,53 +480,4 @@ declare function dupes<T>(iterable: Iterable<T>, keyFn?: (item: T) => Primitive)
  */
 declare function uniqueJustseen<T>(iterable: Iterable<T>, keyFn?: (item: T) => Primitive): IterableIterator<T>;
 
-/**
- * Returns an iterable, filtering out any "nullish" values from the iterable.
- *
- *     >>> compact([1, 2, undefined, 3, null])
- *     [1, 2, 3]
- *
- * For an eager version, @see compact().
- */
-declare function icompact<T>(iterable: Iterable<T | null | undefined>): IterableIterator<T>;
-/**
- * Returns an array, filtering out any "nullish" values from the iterable.
- *
- *     >>> compact([1, 2, undefined, 3, null])
- *     [1, 2, 3]
- *
- * For a lazy version, @see icompact().
- */
-declare function compact<T>(iterable: Iterable<T | null | undefined>): T[];
-/**
- * Removes all "nullish" values from the given object. Returns a new object.
- *
- *     >>> compactObject({ a: 1, b: undefined, c: 0, d: null })
- *     { a: 1, c: 0 }
- *
- */
-declare function compactObject<K extends string, V>(obj: Record<K, V | null | undefined>): Record<K, V>;
-/**
- * Almost an alias of find(). There only is a difference if no key fn is
- * provided. In that case, `find()` will return the first item in the iterable,
- * whereas `first()` will return the first non-`undefined` value in the
- * iterable.
- */
-declare function first<T>(iterable: Iterable<T>, keyFn?: Predicate<T>): T | 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
- *
- */
-declare function flatmap<T, S>(iterable: Iterable<T>, mapper: (item: T) => Iterable<S>): IterableIterator<S>;
-
-export { type Predicate, type Primitive, all, any, chain, chunked, compact, compactObject, compress, contains, count, cycle, dropwhile, dupes, enumerate, every, filter, find, first, flatmap, flatten, groupby, heads, icompact, icompress, ifilter, imap, islice, itake, iter, izip, izip2, izip3, izipLongest, izipMany, map, max, min, pairwise, partition, permutations, range, reduce, repeat, roundrobin, some, sorted, sum, take, takewhile, uniqueEverseen, uniqueJustseen, zip, zip3, zipLongest, zipMany };
+export { type Predicate, type Primitive, all, any, chain, chunked, compact, compactObject, compress, contains, count, cycle, dropwhile, dupes, enumerate, every, filter, find, first, flatmap, flatten, groupby, heads, icompact, icompress, ifilter, imap, intersperse, islice, itake, iter, izip, izip2, izip3, izipLongest, izipLongest3, izipMany, map, max, min, pairwise, partition, permutations, range, reduce, repeat, roundrobin, some, sorted, sum, take, takewhile, uniqueEverseen, uniqueJustseen, zip, zip3, zipLongest, zipLongest3, zipMany };

package/dist/index.js

@@ -53,6 +53,11 @@ function* flatten(iterableOfIterables) {
     }
   }
 }
+function intersperse(value, iterable) {
+  const stream = flatten(izip(repeat(value), iterable));
+  stream.next();
+  return stream;
+}
 function* itake(n, iterable) {
   const it = iter(iterable);
   let count2 = n;
@@ -80,8 +85,9 @@ function* pairwise(iterable) {
 function partition(iterable, predicate) {
   const good = [];
   const bad = [];
+  let index = 0;
   for (const item of iterable) {
-    if (predicate(item)) {
+    if (predicate(item, index++)) {
       good.push(item);
     } else {
       bad.push(item);
@@ -195,11 +201,12 @@ function* cycle(iterable) {
   }
 }
 function* dropwhile(iterable, predicate) {
+  let index = 0;
   const it = iter(iterable);
   let res;
   while (!(res = it.next()).done) {
     const value = res.value;
-    if (!predicate(value)) {
+    if (!predicate(value, index++)) {
       yield value;
       break;
     }
@@ -217,8 +224,7 @@ function* groupby(iterable, keyFn = primitiveIdentity) {
     while (currentKey === tgtKey) {
       yield currentValue;
       const nextVal = it.next();
-      if (nextVal.done)
-        return;
+      if (nextVal.done) return;
       currentValue = nextVal.value;
       currentKey = keyFn(currentValue);
     }
@@ -245,8 +251,9 @@ function* icompress(data, selectors) {
   }
 }
 function* ifilter(iterable, predicate) {
+  let index = 0;
   for (const value of iterable) {
-    if (predicate(value)) {
+    if (predicate(value, index++)) {
       yield value;
     }
   }
@@ -265,24 +272,18 @@ function* islice(iterable, stopOrStart, possiblyStop, step = 1) {
     start = 0;
     stop = stopOrStart;
   }
-  if (start < 0)
-    throw new Error("start cannot be negative");
-  if (stop !== null && stop < 0)
-    throw new Error("stop cannot be negative");
-  if (step <= 0)
-    throw new Error("step cannot be negative");
+  if (start < 0) throw new Error("start cannot be negative");
+  if (stop !== null && stop < 0) throw new Error("stop cannot be negative");
+  if (step <= 0) throw new Error("step cannot be negative");
   let i = -1;
   const it = iter(iterable);
   let res;
   while (true) {
     i++;
-    if (stop !== null && i >= stop)
-      return;
+    if (stop !== null && i >= stop) return;
     res = it.next();
-    if (res.done)
-      return;
-    if (i < start)
-      continue;
+    if (res.done) return;
+    if (i < start) continue;
     if ((i - start) % step === 0) {
       yield res.value;
     }
@@ -331,6 +332,22 @@ function* izipLongest2(xs, ys, filler) {
     }
   }
 }
+function* izipLongest3(xs, ys, zs, filler) {
+  const filler_ = filler;
+  const ixs = iter(xs);
+  const iys = iter(ys);
+  const izs = iter(zs);
+  for (; ; ) {
+    const x = ixs.next();
+    const y = iys.next();
+    const z = izs.next();
+    if (x.done && y.done && z.done) {
+      return;
+    } else {
+      yield [!x.done ? x.value : filler_, !y.done ? y.value : filler_, !z.done ? z.value : filler_];
+    }
+  }
+}
 function* izipMany(...iters) {
   const iterables = iters.map(iter);
   for (; ; ) {
@@ -345,7 +362,7 @@ function* izipMany(...iters) {
 function* permutations(iterable, r) {
   const pool = Array.from(iterable);
   const n = pool.length;
-  const x = r === void 0 ? n : r;
+  const x = r != null ? r : n;
   if (x > n) {
     return;
   }
@@ -387,18 +404,21 @@ function* repeat(thing, times) {
   }
 }
 function* takewhile(iterable, predicate) {
+  let index = 0;
   const it = iter(iterable);
   let res;
   while (!(res = it.next()).done) {
     const value = res.value;
-    if (!predicate(value))
-      return;
+    if (!predicate(value, index++)) return;
     yield value;
   }
 }
 function zipLongest2(xs, ys, filler) {
   return Array.from(izipLongest2(xs, ys, filler));
 }
+function zipLongest3(xs, ys, zs, filler) {
+  return Array.from(izipLongest3(xs, ys, zs, filler));
+}
 var izipLongest = izipLongest2;
 var zipLongest = zipLongest2;
 function zipMany(...iters) {
@@ -406,33 +426,36 @@ function zipMany(...iters) {
 }
 
 // src/builtins.ts
-function find(iterable, keyFn) {
+function find(iterable, predicate) {
   const it = iter(iterable);
-  if (keyFn === void 0) {
+  if (predicate === void 0) {
     const value = it.next();
-    return value.done ? value.value : value.value;
+    return value.done ? void 0 : value.value;
   } else {
     let res;
+    let i = 0;
     while (!(res = it.next()).done) {
       const value = res.value;
-      if (keyFn(value)) {
+      if (predicate(value, i++)) {
         return value;
       }
     }
     return void 0;
   }
 }
-function every(iterable, keyFn = identityPredicate) {
+function every(iterable, predicate = identityPredicate) {
+  let index = 0;
   for (const item of iterable) {
-    if (!keyFn(item)) {
+    if (!predicate(item, index++)) {
       return false;
     }
   }
   return true;
 }
-function some(iterable, keyFn = identityPredicate) {
+function some(iterable, predicate = identityPredicate) {
+  let index = 0;
   for (const item of iterable) {
-    if (keyFn(item)) {
+    if (predicate(item, index++)) {
       return true;
     }
   }
@@ -573,6 +596,7 @@ export {
   icompress,
   ifilter,
   imap,
+  intersperse,
   islice,
   itake,
   iter,
@@ -580,6 +604,7 @@ export {
   izip2,
   izip3,
   izipLongest,
+  izipLongest3,
   izipMany,
   map,
   max,
@@ -601,6 +626,7 @@ export {
   zip,
   zip3,
   zipLongest,
+  zipLongest3,
   zipMany
 };
 // istanbul ignore else -- @preserve