Iterables by Vangware
🔁 Iterable and AsyncIterable utils.
Usage
📦 Node
Install @vangware/iterables as a dependency:
pnpm add @vangware/iterables
# or
npm install @vangware/iterables
# or
yarn add @vangware/iterablesImport it and use it:
import { iterableToArray, map } from "@vangware/iterables";
const mapDouble = map((value: number) => value * 2);
iterableToArray(mapDouble([1, 2, 3])); // [2, 4, 6]🦕 Deno
Import @vangware/iterables using the npm: prefix, and use it directly:
import { iterableToArray, map } from "npm:@vangware/iterables";
const mapDouble = map((value: number) => value * 2);
iterableToArray(mapDouble([1, 2, 3])); // [2, 4, 6]🌎 Browser
Import @vangware/iterables using esm.sh, and use it directly:
<script type="module">
import { iterableToArray, map } from "https://esm.sh/@vangware/iterables";
const mapDouble = map(value => value * 2);
iterableToArray(mapDouble([1, 2, 3])); // [2, 4, 6]
</script>Useful links
- 📝 Documentation: TypeDoc generated documentation.
- ⏳ Changelog: List of changes between versions.
- ✅ Tests Coverage: Coveralls page with tests coverage.
Common
createIterableIterator
▸ createIterableIterator<GeneratorFunction>(generatorFunction):
GeneratorFunction extends
IsomorphicGeneratorFunction<Item>
? GeneratorFunction extends Function<never, { next: (…args: [] |
[void]) => Promise<IteratorResult<Item, void>> ; return?:
(value?: void | PromiseLike<void>) =>
Promise<IteratorResult<Item, void>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, void>> }> ? { [asyncIterator]: () =>
AsyncIterableIterator<Item> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Item, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Item, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, any>> } : { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : never
Takes a generator function and returns an iterable iterator or asynchronous iterable iterator object.
Type parameters
| Name | Type |
|---|---|
GeneratorFunction | extends IsomorphicGeneratorFunction |
Parameters
| Name | Type | Description |
|---|---|---|
generatorFunction | GeneratorFunction | Generator to be used every time [Symbol.iterator] is called. |
Returns
GeneratorFunction extends
IsomorphicGeneratorFunction<Item>
? GeneratorFunction extends Function<never, { next: (…args: [] |
[void]) => Promise<IteratorResult<Item, void>> ; return?:
(value?: void | PromiseLike<void>) =>
Promise<IteratorResult<Item, void>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, void>> }> ? { [asyncIterator]: () =>
AsyncIterableIterator<Item> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Item, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Item, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, any>> } : { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : never
Iterable iterator object.
Example
const identityGenerator = function* (value) {
yield value;
};
const iterableIterator = createIterableIterator(identityGenerator);
const fooIdentity = iterableIterator("foo");
for (const value of fooIdentity) {
console.log(value); // "foo"
}
// Same IterableIterator as above, return values again:
for (const value of fooIdentity) {
console.log(value); // "foo"
}forEach
▸ forEach<Item>(callback): <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable, void>
For each function for iterables and asynchronous iterables.
Type parameters
| Name |
|---|
Item |
Parameters
| Name | Type | Description |
|---|---|---|
callback | Unary<Item, void> | Function to be called for every item of the iterable. |
Returns
fn
Curried function that expects an iterable to loop over and has callback set in
context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable, void>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable, void>
Example
const logEach = forEach(console.log);
logEach([1, 2, 3]); // Logs 1, 2 and 3 separatelygetIterator
▸ getIterator<Iterable>(iterable): Iterable extends
IsomorphicIterable<Item> ? Iterable extends { [asyncIterator]: () =>
AsyncIterator<Item, any, undefined> } ? { next: (…args: [] |
[Item]) => Promise<IteratorResult<Item, Item>> ; return?:
(value?: Item | PromiseLike<Item>) =>
Promise<IteratorResult<Item, Item>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, Item>> } : { next: (…args: [] |
[Item]) => IteratorResult<Item, Item> ; return?: (value?: Item)
=> IteratorResult<Item, Item> ; throw?: (e?: any) =>
IteratorResult<Item, Item> } : never
Get a Symbol.iterator from an iterable or a Symbol.asyncIterator from an
asynchronous iterable.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to get the iterator from. |
Returns
Iterable extends IsomorphicIterable<Item> ? Iterable extends {
[asyncIterator]: () => AsyncIterator<Item, any, undefined> } ? {
next: (…args: [] | [Item]) => Promise<IteratorResult<Item,
Item>> ; return?: (value?: Item | PromiseLike<Item>) =>
Promise<IteratorResult<Item, Item>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, Item>> } : { next: (…args: [] |
[Item]) => IteratorResult<Item, Item> ; return?: (value?: Item)
=> IteratorResult<Item, Item> ; throw?: (e?: any) =>
IteratorResult<Item, Item> } : never
Iterator instance.
Example
const iterator = getIterator([1, 2, 3]);
iterator.next(); // { value: 1, done: false }
iterator.next(); // { value: 2, done: false }
iterator.next(); // { value: 3, done: false }
iterator.next(); // { value: undefined, done: true }handleCurriedIsomorphicIterable
▸ handleCurriedIsomorphicIterable<Iterable2Item, Iterable1Item,
Output>(iterator): (asyncIterator:
Unary<IsomorphicIterable<Iterable2Item>,
Unary<IsomorphicIterable<Iterable1Item>,
Function<ReadOnlyArray<never>, AsyncGenerator<Output, void,
void>>>>) => <Iterable2>(iterable2: Iterable2) =>
<Iterable1>(iterable1: Iterable1) => Iterable2 extends {
[asyncIterator]: () => AsyncIterator<Iterable2Item, any, undefined> }
? { [asyncIterator]: () => AsyncIterableIterator<Output> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<Output,
any>> ; return?: (value?: any) => Promise<IteratorResult<Output,
any>> ; throw?: (e?: any) => Promise<IteratorResult<Output,
any>> } : Iterable1 extends { [asyncIterator]: () =>
AsyncIterator<Iterable1Item, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<Output> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<Output, any>> ; return?:
(value?: any) => Promise<IteratorResult<Output, any>> ; throw?:
(e?: any) => Promise<IteratorResult<Output, any>> } : {
[iterator]: () => IterableIterator<Output> ; next: (…args: [] |
[undefined]) => IteratorResult<Output, any> ; return?: (value?:
any) => IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Takes a generator for iterables, then a generator for async iterables and last 2 iterables, using the proper generator automatically.
Type parameters
| Name | Type |
|---|---|
Iterable2Item | unknown |
Iterable1Item | unknown |
Output | unknown |
Parameters
| Name | Type | Description |
|---|---|---|
iterator | Unary<Iterable<Iterable2Item>, Unary<Iterable<Iterable1Item>, Function<ReadOnlyArray<never>, Generator<Output, void, void>>>> | Function to be used with non async iterables. |
Returns
fn
Curried function with iterator in context.
▸ (asyncIterator): <Iterable2>(iterable2: Iterable2) =>
<Iterable1>(iterable1: Iterable1) => Iterable2 extends {
[asyncIterator]: () => AsyncIterator<Iterable2Item, any, undefined> }
? { [asyncIterator]: () => AsyncIterableIterator<Output> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<Output,
any>> ; return?: (value?: any) => Promise<IteratorResult<Output,
any>> ; throw?: (e?: any) => Promise<IteratorResult<Output,
any>> } : Iterable1 extends { [asyncIterator]: () =>
AsyncIterator<Iterable1Item, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<Output> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<Output, any>> ; return?:
(value?: any) => Promise<IteratorResult<Output, any>> ; throw?:
(e?: any) => Promise<IteratorResult<Output, any>> } : {
[iterator]: () => IterableIterator<Output> ; next: (…args: [] |
[undefined]) => IteratorResult<Output, any> ; return?: (value?:
any) => IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Parameters
| Name | Type |
|---|---|
asyncIterator | Unary<IsomorphicIterable<Iterable2Item>, Unary<IsomorphicIterable<Iterable1Item>, Function<ReadOnlyArray<never>, AsyncGenerator<Output, void, void>>>> |
Returns
fn
▸ <Iterable2>(iterable2): <Iterable1>(iterable1: Iterable1) =>
Iterable2 extends { [asyncIterator]: () => AsyncIterator<Iterable2Item,
any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<Output> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : Iterable1 extends {
[asyncIterator]: () => AsyncIterator<Iterable1Item, any, undefined> }
? { [asyncIterator]: () => AsyncIterableIterator<Output> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<Output,
any>> ; return?: (value?: any) => Promise<IteratorResult<Output,
any>> ; throw?: (e?: any) => Promise<IteratorResult<Output,
any>> } : { [iterator]: () => IterableIterator<Output> ; next:
(…args: [] | [undefined]) => IteratorResult<Output, any> ;
return?: (value?: any) => IteratorResult<Output, any> ; throw?:
(e?: any) => IteratorResult<Output, any> }
Type parameters
| Name | Type |
|---|---|
Iterable2 | extends IsomorphicIterable<Iterable2Item> |
Parameters
| Name | Type |
|---|---|
iterable2 | Iterable2 |
Returns
fn
▸ <Iterable1>(iterable1): Iterable2 extends { [asyncIterator]: () =>
AsyncIterator<Iterable2Item, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<Output> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<Output, any>> ; return?:
(value?: any) => Promise<IteratorResult<Output, any>> ; throw?:
(e?: any) => Promise<IteratorResult<Output, any>> } : Iterable1
extends { [asyncIterator]: () => AsyncIterator<Iterable1Item, any,
undefined> } ? { [asyncIterator]: () => AsyncIterableIterator<Output>
; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : { [iterator]: () =>
IterableIterator<Output> ; next: (…args: [] | [undefined]) =>
IteratorResult<Output, any> ; return?: (value?: any) =>
IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Type parameters
| Name | Type |
|---|---|
Iterable1 | extends IsomorphicIterable<Iterable1Item> |
Parameters
| Name | Type |
|---|---|
iterable1 | Iterable1 |
Returns
Iterable2 extends { [asyncIterator]: () => AsyncIterator<Iterable2Item,
any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<Output> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : Iterable1 extends {
[asyncIterator]: () => AsyncIterator<Iterable1Item, any, undefined> }
? { [asyncIterator]: () => AsyncIterableIterator<Output> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<Output,
any>> ; return?: (value?: any) => Promise<IteratorResult<Output,
any>> ; throw?: (e?: any) => Promise<IteratorResult<Output,
any>> } : { [iterator]: () => IterableIterator<Output> ; next:
(…args: [] | [undefined]) => IteratorResult<Output, any> ;
return?: (value?: any) => IteratorResult<Output, any> ; throw?:
(e?: any) => IteratorResult<Output, any> }
Example
const handle = handleCurriedIsomorphicIterable(
iterable2 => iterable1 =>
function* () {
yield* iterable2;
yield* iterable1;
},
)(
iterable2 => iterable1 =>
async function* () {
yield* iterable2;
yield* iterable1;
},
);
handle(nonAsyncIterable)(nonAsyncIterable); // IterableIterator
handle(asyncIterable)(nonAsyncIterable); // AsyncIterableIteratorhandleIsomorphicIterable
▸ handleIsomorphicIterable<Item, Output>(iterator): (asyncIterator:
Unary<IsomorphicIterable<Item>, Function<ReadOnlyArray<never>,
AsyncGenerator<Output, void, void>>>) => <Iterable>(iterable:
Iterable) => Iterable extends { [asyncIterator]: () =>
AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<Output> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : { [iterator]: () =>
IterableIterator<Output> ; next: (…args: [] | [undefined]) =>
IteratorResult<Output, any> ; return?: (value?: any) =>
IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Takes a generator for iterables, then a generator for async iterables and last an iterable, using the proper generator automatically.
Type parameters
| Name | Type |
|---|---|
Item | unknown |
Output | unknown |
Parameters
| Name | Type | Description |
|---|---|---|
iterator | Unary<Iterable<Item>, Function<ReadOnlyArray<never>, Generator<Output, void, void>>> | Function to be used with non async iterables. |
Returns
fn
Curried function with iterator in context.
▸ (asyncIterator): <Iterable>(iterable: Iterable) => Iterable extends {
[asyncIterator]: () => AsyncIterator<Item, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<Output> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<Output,
any>> ; return?: (value?: any) => Promise<IteratorResult<Output,
any>> ; throw?: (e?: any) => Promise<IteratorResult<Output,
any>> } : { [iterator]: () => IterableIterator<Output> ; next:
(…args: [] | [undefined]) => IteratorResult<Output, any> ;
return?: (value?: any) => IteratorResult<Output, any> ; throw?:
(e?: any) => IteratorResult<Output, any> }
Parameters
| Name | Type |
|---|---|
asyncIterator | Unary<IsomorphicIterable<Item>, Function<ReadOnlyArray<never>, AsyncGenerator<Output, void, void>>> |
Returns
fn
▸ <Iterable>(iterable): Iterable extends { [asyncIterator]: () =>
AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<Output> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : { [iterator]: () =>
IterableIterator<Output> ; next: (…args: [] | [undefined]) =>
IteratorResult<Output, any> ; return?: (value?: any) =>
IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
Iterable extends { [asyncIterator]: () => AsyncIterator<Item, any,
undefined> } ? { [asyncIterator]: () => AsyncIterableIterator<Output>
; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Output, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Output, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Output, any>> } : { [iterator]: () =>
IterableIterator<Output> ; next: (…args: [] | [undefined]) =>
IteratorResult<Output, any> ; return?: (value?: any) =>
IteratorResult<Output, any> ; throw?: (e?: any) =>
IteratorResult<Output, any> }
Example
const handle = handleIsomorphicIterable(
iterable =>
function* () {
yield* iterable;
},
)(
iterable =>
async function* () {
yield* iterable;
},
);
handle(nonAsyncIterable); // IterableIterator
handle(asyncIterable); // AsyncIterableIteratorGenerators
GeneratorOutput
Ƭ GeneratorOutput<Iterable>: Iterable extends
IsomorphicIterable<infer Item> ? Iterable extends
ReadOnlyAsyncIterable<Item>
?
ReadOnlyAsyncIterableIterator<Item>
:
ReadOnlyIterableIterator<Item>
: never
IsomorphicIterable generator function optional return value.
Remarks
Generator functions in this library can return either an ReadOnlyAsyncIterableIterator or an ReadOnlyIterableIterator depending on the input. This type simplifies the output of said functions.
See
Type parameters
| Name | Description |
|---|---|
Iterable | IsomorphicIterable to get the output from. |
IsomorphicGeneratorFunction
Ƭ IsomorphicGeneratorFunction<Item>:
Function<ReadOnlyArray<never>,
ReadOnlyAsyncIterator<Item>
| ReadOnlyIterator<Item>>
Function that returns an iterator or an asynchronous iterator.
Remarks
This is mainly used for in the createIterableIterator function, to infer the type of the generator function and the output.
See
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the iterator or asynchronous iterator. |
ReadOnlyAsyncIterable
Ƭ ReadOnlyAsyncIterable<Item>: ReadOnly<AsyncIterable<Item>>
Read-only AsyncIterable.
Remarks
This is just an read-only alternative to AsyncIterable to avoid unwanted
mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the AsyncIterable. |
ReadOnlyAsyncIterableIterator
Ƭ ReadOnlyAsyncIterableIterator<Item>:
ReadOnly<AsyncIterableIterator<Item>>
Read-only AsyncIterableIterator.
Remarks
This is just an read-only alternative to AsyncIterableIterator to avoid
unwanted mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the AsyncIterableIterator. |
ReadOnlyAsyncIterator
Ƭ ReadOnlyAsyncIterator<Item, Return, Next>:
ReadOnly<AsyncIterator<Item, Return, Next>>
Read-only AsyncIterator.
Remarks
This is just an read-only alternative to AsyncIterator to avoid unwanted
mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the AsyncIterator. |
Return | void | Type of the return value in the AsyncIterator. |
Next | void | Type of the next value in the AsyncIterator. |
ReadOnlyIterable
Ƭ ReadOnlyIterable<Item>: ReadOnly<Iterable<Item>>
Read-only Iterable.
Remarks
This is just an read-only alternative to Iterable to avoid unwanted mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the Iterable. |
ReadOnlyIterableIterator
Ƭ ReadOnlyIterableIterator<Item>:
ReadOnly<IterableIterator<Item>>
Read-only IterableIterator.
Remarks
This is just an read-only alternative to IterableIterator to avoid unwanted
mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the IterableIterator. |
ReadOnlyIterator
Ƭ ReadOnlyIterator<Item, Return, Next>: ReadOnly<Iterator<Item,
Return, Next>>
Read-only Iterator.
Remarks
This is just an read-only alternative to Iterator to avoid unwanted mutations.
Type parameters
| Name | Type | Description |
|---|---|---|
Item | unknown | Type of the items in the Iterator. |
Return | void | Type of the return value in the Iterator. |
Next | void | Type of the next value in the Iterator. |
append
▸ append<TailIterable>(tailIterable):
<InitialIterable>(initialIterable: InitialIterable) => TailIterable
extends IsomorphicIterable<TailItem> ? InitialIterable extends
IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Appends one iterable or asynchronous iterable to another.
Type parameters
| Name | Type |
|---|---|
TailIterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
tailIterable | TailIterable | Iterable or asynchronous to be appended. |
Returns
fn
Curried generator function with tailIterable set in context.
▸ <InitialIterable>(initialIterable): TailIterable extends
IsomorphicIterable<TailItem> ? InitialIterable extends
IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Type parameters
| Name | Type |
|---|---|
InitialIterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
initialIterable | InitialIterable |
Returns
TailIterable extends IsomorphicIterable<TailItem> ? InitialIterable
extends IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Example
const appendNumbers = append([0, 1, 2, 3, 4]);
appendNumbers(["foo", "bar"]); // ["foo", "bar", 0, 1, 2, 3, 4]
appendNumbers([]); // [0, 1, 2, 3, 4]drop
▸ drop(amount): <Iterable>(iterable: Iterable) =>
GeneratorOutput<Iterable>
Drop the specified amount of items from the given iterable or asynchronous iterable.
Parameters
| Name | Type | Description |
|---|---|---|
amount | number | bigint | Amount of items to drop. |
Returns
fn
Curried function with amount in context.
▸ <Iterable>(iterable):
GeneratorOutput<Iterable>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
GeneratorOutput<Iterable>
Example
const drop2 = drop(2);
drop2([1, 2, 3, 4, 5]); // [3, 4, 5]filter
▸ filter<Item, Filtered>(predicate): <Iterable>(iterable:
Iterable) =>
GeneratorOutput<Iterable>
Filters items in an iterable or asynchronous iterable against a predicate and
returns items that evaluated to true.
Type parameters
| Name | Type |
|---|---|
Item | Item |
Filtered | never |
Parameters
| Name | Type | Description |
|---|---|---|
predicate | Single<Filtered> extends Single<never> ? Unary<Item, boolean> : Predicate<Item, Filtered> | Predicate function to evaluate each item. |
Returns
fn
Curried function with predicate set in context.
▸ <Iterable>(iterable):
GeneratorOutput<Iterable>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
GeneratorOutput<Iterable>
Example
const filterEven = filter((number: number) => number % 2 === 0);
iterableToArray(filterEven([1, 2, 3, 4])); // [2, 4]
iterableToArray(filterEven([1, 3, 5, 7])); // []flat
▸ flat<Iterable>(iterable): Iterable extends
IsomorphicIterable<Item> ? Item extends IsomorphicIterable<SubItem>
? Item extends { [asyncIterator]: () => AsyncIterator<SubItem, any,
undefined> } ? { [asyncIterator]: () => AsyncIterableIterator<SubItem>
; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<SubItem, any>> ; return?: (value?: any)
=> Promise<IteratorResult<SubItem, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<SubItem, any>> } : { [iterator]: () =>
IterableIterator<SubItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<SubItem, any> ; return?: (value?: any) =>
IteratorResult<SubItem, any> ; throw?: (e?: any) =>
IteratorResult<SubItem, any> } : Iterable extends { [asyncIterator]:
() => AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: ()
=> AsyncIterableIterator<Item> ; next: (…args: [] | [undefined])
=> Promise<IteratorResult<Item, any>> ; return?: (value?: any)
=> Promise<IteratorResult<Item, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, any>> } : { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : never
Flattens one level of the given iterable or asynchronous iterable.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to flatten. |
Returns
Iterable extends IsomorphicIterable<Item> ? Item extends
IsomorphicIterable<SubItem> ? Item extends { [asyncIterator]: () =>
AsyncIterator<SubItem, any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<SubItem> ; next: (…args: [] | [undefined])
=> Promise<IteratorResult<SubItem, any>> ; return?: (value?:
any) => Promise<IteratorResult<SubItem, any>> ; throw?: (e?:
any) => Promise<IteratorResult<SubItem, any>> } : { [iterator]: ()
=> IterableIterator<SubItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<SubItem, any> ; return?: (value?: any) =>
IteratorResult<SubItem, any> ; throw?: (e?: any) =>
IteratorResult<SubItem, any> } : Iterable extends { [asyncIterator]:
() => AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: ()
=> AsyncIterableIterator<Item> ; next: (…args: [] | [undefined])
=> Promise<IteratorResult<Item, any>> ; return?: (value?: any)
=> Promise<IteratorResult<Item, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, any>> } : { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : never
Iterable with flatten items.
Example
flat([1, 2, [3, 4]]); // [1, 2, 3, 4]initial
▸ initial<Iterable>(iterable): Iterable extends ReadOnlyArray ? {
[iterator]: () => IterableIterator<Initial<Iterable>[number]> ;
next: (…args: [] | [undefined]) =>
IteratorResult<Initial<Iterable>[number], any> ; return?:
(value?: any) => IteratorResult<Initial<Iterable>[number], any>
; throw?: (e?: any) => IteratorResult<Initial<Iterable>[number],
any> } :
GeneratorOutput<Iterable>
Get all elements except the last one of an iterable or asynchronous iterable.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to get the items from. |
Returns
Iterable extends ReadOnlyArray ? { [iterator]: () =>
IterableIterator<Initial<Iterable>[number]> ; next: (…args: []
| [undefined]) => IteratorResult<Initial<Iterable>[number], any>
; return?: (value?: any) =>
IteratorResult<Initial<Iterable>[number], any> ; throw?: (e?:
any) => IteratorResult<Initial<Iterable>[number], any> } :
GeneratorOutput<Iterable>
Iterable with all items except the last one.
Example
initial([1, 2, 3]); // [1, 2]intersperse
▸ intersperse<Separator>(separator): <Item>(iterable:
IsomorphicIterable<Item>) => { [iterator]: () =>
IterableIterator<Separator | Item> ; next: (…args: [] |
[undefined]) => IteratorResult<Separator | Item, any> ; return?:
(value?: any) => IteratorResult<Separator | Item, any> ; throw?:
(e?: any) => IteratorResult<Separator | Item, any> }
Add the given separator between each element of the given iterable or
asynchronous iterable.
Type parameters
| Name |
|---|
Separator |
Parameters
| Name | Type | Description |
|---|---|---|
separator | Separator | Separator to add between each element. |
Returns
fn
Curried function with separator in context.
▸ <Item>(iterable): Object
Type parameters
| Name |
|---|
Item |
Parameters
| Name | Type |
|---|---|
iterable | IsomorphicIterable<Item> |
Returns
Object
| Name | Type |
|---|---|
[iterator] | () => IterableIterator<Separator | Item> |
next | (…args: [] | [undefined]) => IteratorResult<Separator | Item, any> |
return? | (value?: any) => IteratorResult<Separator | Item, any> |
throw? | (e?: any) => IteratorResult<Separator | Item, any> |
Example
const intersperseComma = intersperse(",");
intersperseComma([1, 2, 3]); // [1, ",", 2, ",", 3]map
▸ map<Item, MappedItem>(mapper): <Iterable>(iterable: Iterable)
=> Iterable extends { [asyncIterator]: () => AsyncIterator<Item, any,
undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<MappedItem> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<MappedItem, any>> ;
return?: (value?: any) => Promise<IteratorResult<MappedItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<MappedItem,
any>> } : { [iterator]: () => IterableIterator<MappedItem> ; next:
(…args: [] | [undefined]) => IteratorResult<MappedItem, any> ;
return?: (value?: any) => IteratorResult<MappedItem, any> ;
throw?: (e?: any) => IteratorResult<MappedItem, any> }
Map for iterables and asynchronous iterables.
Type parameters
| Name |
|---|
Item |
MappedItem |
Parameters
| Name | Type | Description |
|---|---|---|
mapper | Unary<Item, MappedItem> | Mapper function. |
Returns
fn
Generator function with mapper function set in context.
▸ <Iterable>(iterable): Iterable extends { [asyncIterator]: () =>
AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<MappedItem> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<MappedItem, any>> ;
return?: (value?: any) => Promise<IteratorResult<MappedItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<MappedItem,
any>> } : { [iterator]: () => IterableIterator<MappedItem> ; next:
(…args: [] | [undefined]) => IteratorResult<MappedItem, any> ;
return?: (value?: any) => IteratorResult<MappedItem, any> ;
throw?: (e?: any) => IteratorResult<MappedItem, any> }
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
Iterable extends { [asyncIterator]: () => AsyncIterator<Item, any,
undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<MappedItem> ; next: (…args: [] |
[undefined]) => Promise<IteratorResult<MappedItem, any>> ;
return?: (value?: any) => Promise<IteratorResult<MappedItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<MappedItem,
any>> } : { [iterator]: () => IterableIterator<MappedItem> ; next:
(…args: [] | [undefined]) => IteratorResult<MappedItem, any> ;
return?: (value?: any) => IteratorResult<MappedItem, any> ;
throw?: (e?: any) => IteratorResult<MappedItem, any> }
Example
const double = value => value * 2;
const mapDouble = map(double);
mapDouble([1, 2, 3]); // [2, 4, 6]objectToEntries
▸ objectToEntries<Key, Value>(input): Object
Yields all entries of an object (including symbols).
Type parameters
| Name | Type |
|---|---|
Key | extends PropertyKey |
Value | Value |
Parameters
| Name | Type | Description |
|---|---|---|
input | ReadOnlyRecord<Key, Value> | Object to get entries from. |
Returns
Object
Iterable with entries of the given object (including symbols).
| Name | Type |
|---|---|
[iterator] | () => IterableIterator<Entry<Key, Value> | Entry<Extract<keyof ReadOnly<Record<Key, Value>>, string>, Value>> |
next | (…args: [] | [undefined]) => IteratorResult<Entry<Key, Value> | Entry<Extract<keyof ReadOnly<Record<Key, Value>>, string>, Value>, any> |
return? | (value?: any) => IteratorResult<Entry<Key, Value> | Entry<Extract<keyof ReadOnly<Record<Key, Value>>, string>, Value>, any> |
throw? | (e?: any) => IteratorResult<Entry<Key, Value> | Entry<Extract<keyof ReadOnly<Record<Key, Value>>, string>, Value>, any> |
Example
const entries = objectEntries({ a: 1, b: 2 });
entries.next(); // { value: ["a", 1], done: false }
entries.next(); // { value: ["b", 2], done: false }
entries.next(); // { value: undefined, done: true }prepend
▸ prepend<InitialIterable>(initialIterable):
<TailIterable>(tailIterable: TailIterable) => TailIterable extends
IsomorphicIterable<TailItem> ? InitialIterable extends
IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Prepends one iterable or asynchronous iterable to another.
Type parameters
| Name | Type |
|---|---|
InitialIterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
initialIterable | InitialIterable | Iterable to be appended. |
Returns
fn
Curried generator function with initialIterable set in context.
▸ <TailIterable>(tailIterable): TailIterable extends
IsomorphicIterable<TailItem> ? InitialIterable extends
IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Type parameters
| Name | Type |
|---|---|
TailIterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
tailIterable | TailIterable |
Returns
TailIterable extends IsomorphicIterable<TailItem> ? InitialIterable
extends IsomorphicIterable<InitialItem> ? TailIterable extends {
[asyncIterator]: () => AsyncIterator<TailItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<TailItem | InitialItem> ;
next: (…args: [] | [undefined]) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; return?:
(value?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> ; throw?: (e?: any) => Promise<IteratorResult<TailItem |
InitialItem, any>> } : InitialIterable extends { [asyncIterator]: ()
=> AsyncIterator<InitialItem, any, undefined> } ? { [asyncIterator]:
() => AsyncIterableIterator<TailItem | InitialItem> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<TailItem |
InitialItem, any>> ; return?: (value?: any) =>
Promise<IteratorResult<TailItem | InitialItem, any>> ; throw?:
(e?: any) => Promise<IteratorResult<TailItem | InitialItem,
any>> } : { [iterator]: () => IterableIterator<TailItem |
InitialItem> ; next: (…args: [] | [undefined]) =>
IteratorResult<TailItem | InitialItem, any> ; return?: (value?:
any) => IteratorResult<TailItem | InitialItem, any> ; throw?:
(e?: any) => IteratorResult<TailItem | InitialItem, any> } :
never : never
Example
const prependNumbers = prepend([0, 1, 2, 3, 4]);
prependNumbers(["foo", "bar"]); // [0, 1, 2, 3, 4, "foo", "bar"]range
▸ range<Step>(step): (from: Step extends bigint ? bigint :
number) => (to: Step extends bigint ? bigint : number) => {
[iterator]: () => IterableIterator<number> ; next: (…args: [] |
[undefined]) => IteratorResult<number, any> ; return?: (value?:
any) => IteratorResult<number, any> ; throw?: (e?: any) =>
IteratorResult<number, any> }
Range iterable generator (from from to to).
Type parameters
| Name | Type |
|---|---|
Step | extends number | bigint |
Parameters
| Name | Type | Description |
|---|---|---|
step | Step | Step size. |
Returns
fn
Curried function with step set in context.
▸ (from): (to: Step extends bigint ? bigint : number) => {
[iterator]: () => IterableIterator<number> ; next: (…args: [] |
[undefined]) => IteratorResult<number, any> ; return?: (value?:
any) => IteratorResult<number, any> ; throw?: (e?: any) =>
IteratorResult<number, any> }
Parameters
| Name | Type |
|---|---|
from | Step extends bigint ? bigint : number |
Returns
fn
▸ (to): Object
Parameters
| Name | Type |
|---|---|
to | Step extends bigint ? bigint : number |
Returns
Object
| Name | Type |
|---|---|
[iterator] | () => IterableIterator<number> |
next | (…args: [] | [undefined]) => IteratorResult<number, any> |
return? | (value?: any) => IteratorResult<number, any> |
throw? | (e?: any) => IteratorResult<number, any> |
Example
[...range(1)(0)(5)]; // [0, 1, 2, 3, 4, 5]
[...range(1)(5)(0)]; // [5, 4, 3, 2, 1, 0]repeat
▸ repeat(times): <Item>(item: Item) => { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> }
Repeat given item the specified amount of times (can be BigInt or Infinity
times) as an iterable.
Parameters
| Name | Type |
|---|---|
times | number | bigint |
Returns
fn
Curried function with item in context.
▸ <Item>(item): Object
Type parameters
| Name |
|---|
Item |
Parameters
| Name | Type |
|---|---|
item | Item |
Returns
Object
| Name | Type |
|---|---|
[iterator] | () => IterableIterator<Item> |
next | (…args: [] | [undefined]) => IteratorResult<Item, any> |
return? | (value?: any) => IteratorResult<Item, any> |
throw? | (e?: any) => IteratorResult<Item, any> |
Example
const repeat3Times = repeat(3);
repeat3Times("foo"); // ["foo", "foo", "foo"]take
▸ take(amount): <Iterable>(iterable: Iterable) =>
GeneratorOutput<Iterable>
Take the given amount of items from the iterable or asynchronous iterable.
Parameters
| Name | Type | Description |
|---|---|---|
amount | number | bigint | Amount of items to take. |
Returns
fn
Curried function with amount in context.
▸ <Iterable>(iterable):
GeneratorOutput<Iterable>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
GeneratorOutput<Iterable>
Example
const take2 = take(2);
take2([1, 2, 3, 4, 5]); // [1, 2]toIterable
▸ toIterable<ValueOrIterable>(valueOrIterable): ValueOrIterable
extends IsomorphicIterable<Item> ? Item extends { [asyncIterator]: ()
=> AsyncIterator<Item, any, undefined> } ? { [asyncIterator]: () =>
AsyncIterableIterator<Item> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<Item, any>> ; return?: (value?: any) =>
Promise<IteratorResult<Item, any>> ; throw?: (e?: any) =>
Promise<IteratorResult<Item, any>> } : { [iterator]: () =>
IterableIterator<Item> ; next: (…args: [] | [undefined]) =>
IteratorResult<Item, any> ; return?: (value?: any) =>
IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : { [iterator]: () =>
IterableIterator<ValueOrIterable> ; next: (…args: [] |
[undefined]) => IteratorResult<ValueOrIterable, any> ; return?:
(value?: any) => IteratorResult<ValueOrIterable, any> ; throw?:
(e?: any) => IteratorResult<ValueOrIterable, any> }
Takes a value, iterable or asynchronous iterable and yields it.
Type parameters
| Name | Description |
|---|---|
ValueOrIterable | Generic of value or iterable to yield. |
Parameters
| Name | Type | Description |
|---|---|---|
valueOrIterable | ValueOrIterable | Vale or iterable to yield. |
Returns
ValueOrIterable extends IsomorphicIterable<Item> ? Item extends {
[asyncIterator]: () => AsyncIterator<Item, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<Item> ; next: (…args:
[] | [undefined]) => Promise<IteratorResult<Item, any>> ;
return?: (value?: any) => Promise<IteratorResult<Item, any>> ;
throw?: (e?: any) => Promise<IteratorResult<Item, any>> } : {
[iterator]: () => IterableIterator<Item> ; next: (…args: [] |
[undefined]) => IteratorResult<Item, any> ; return?: (value?:
any) => IteratorResult<Item, any> ; throw?: (e?: any) =>
IteratorResult<Item, any> } : { [iterator]: () =>
IterableIterator<ValueOrIterable> ; next: (…args: [] |
[undefined]) => IteratorResult<ValueOrIterable, any> ; return?:
(value?: any) => IteratorResult<ValueOrIterable, any> ; throw?:
(e?: any) => IteratorResult<ValueOrIterable, any> }
Yielded item or iterable.
Example
const iterable = toIterable(1);
const iterator = getIterator(iterable);
iterator.next(); // { value: 1, done: false }
iterator.next(); // { value: undefined, done: true }See
unique
▸ unique<Iterable>(iterable):
GeneratorOutput<Iterable>
Returns a single instance of each item in the iterable or asynchronous iterable.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to be filtered. |
Returns
GeneratorOutput<Iterable>
Generators with a single instance of each item of the iterable.
Example
unique([1, 2, 3, 4, 1, 2, 3, 4]); // [1, 2, 3, 4]zip
▸ zip<FirstIterable>(iterableFirst):
<SecondIterable>(iterableSecond: SecondIterable) => FirstIterable extends
IsomorphicIterable<FirstItem> ? SecondIterable extends
IsomorphicIterable<SecondItem> ? FirstIterable extends {
[asyncIterator]: () => AsyncIterator<FirstItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<readonly [FirstItem,
SecondItem]> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
return?: (value?: any) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; throw?: (e?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> } :
SecondIterable extends { [asyncIterator]: () =>
AsyncIterator<SecondItem, any, undefined> } ? { [asyncIterator]: ()
=> AsyncIterableIterator<readonly [FirstItem, SecondItem]> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; return?: (value?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
throw?: (e?: any) => Promise<IteratorResult<readonly [FirstItem,
SecondItem], any>> } : { [iterator]: () => IterableIterator<readonly
[FirstItem, SecondItem]> ; next: (…args: [] | [undefined]) =>
IteratorResult<readonly [FirstItem, SecondItem], any> ; return?:
(value?: any) => IteratorResult<readonly [FirstItem, SecondItem],
any> ; throw?: (e?: any) => IteratorResult<readonly [FirstItem,
SecondItem], any> } : never : never
Takes two iterables or asynchronous iterable and returns a new iterable or asynchronous iterable with the length of the shortest iterable with tuples containing the items from both.
Type parameters
| Name | Type |
|---|---|
FirstIterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterableFirst | FirstIterable | One of the iterables to be zipped. |
Returns
fn
Curried function with iterableFirst in context.
▸ <SecondIterable>(iterableSecond): FirstIterable extends
IsomorphicIterable<FirstItem> ? SecondIterable extends
IsomorphicIterable<SecondItem> ? FirstIterable extends {
[asyncIterator]: () => AsyncIterator<FirstItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<readonly [FirstItem,
SecondItem]> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
return?: (value?: any) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; throw?: (e?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> } :
SecondIterable extends { [asyncIterator]: () =>
AsyncIterator<SecondItem, any, undefined> } ? { [asyncIterator]: ()
=> AsyncIterableIterator<readonly [FirstItem, SecondItem]> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; return?: (value?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
throw?: (e?: any) => Promise<IteratorResult<readonly [FirstItem,
SecondItem], any>> } : { [iterator]: () => IterableIterator<readonly
[FirstItem, SecondItem]> ; next: (…args: [] | [undefined]) =>
IteratorResult<readonly [FirstItem, SecondItem], any> ; return?:
(value?: any) => IteratorResult<readonly [FirstItem, SecondItem],
any> ; throw?: (e?: any) => IteratorResult<readonly [FirstItem,
SecondItem], any> } : never : never
Type parameters
| Name | Type |
|---|---|
SecondIterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterableSecond | SecondIterable |
Returns
FirstIterable extends IsomorphicIterable<FirstItem> ? SecondIterable
extends IsomorphicIterable<SecondItem> ? FirstIterable extends {
[asyncIterator]: () => AsyncIterator<FirstItem, any, undefined> } ? {
[asyncIterator]: () => AsyncIterableIterator<readonly [FirstItem,
SecondItem]> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
return?: (value?: any) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; throw?: (e?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> } :
SecondIterable extends { [asyncIterator]: () =>
AsyncIterator<SecondItem, any, undefined> } ? { [asyncIterator]: ()
=> AsyncIterableIterator<readonly [FirstItem, SecondItem]> ; next:
(…args: [] | [undefined]) => Promise<IteratorResult<readonly
[FirstItem, SecondItem], any>> ; return?: (value?: any) =>
Promise<IteratorResult<readonly [FirstItem, SecondItem], any>> ;
throw?: (e?: any) => Promise<IteratorResult<readonly [FirstItem,
SecondItem], any>> } : { [iterator]: () => IterableIterator<readonly
[FirstItem, SecondItem]> ; next: (…args: [] | [undefined]) =>
IteratorResult<readonly [FirstItem, SecondItem], any> ; return?:
(value?: any) => IteratorResult<readonly [FirstItem, SecondItem],
any> ; throw?: (e?: any) => IteratorResult<readonly [FirstItem,
SecondItem], any> } : never : never
Example
const zipNumbers = zip([0, 1, 2]);
zipNumbers([3, 4, 5]); // [[0, 3], [1, 4], [2, 5]]zipIndex
▸ zipIndex<SecondIterable>(iterableSecond): SecondIterable extends
IsomorphicIterable<SecondItem> ? SecondIterable extends {
[asyncIterator]: () => AsyncIterator<SecondItem, any, undefined> } ?
{ [asyncIterator]: () => AsyncIterableIterator<readonly [number,
SecondItem]> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<readonly [number, SecondItem], any>> ;
return?: (value?: any) => Promise<IteratorResult<readonly [number,
SecondItem], any>> ; throw?: (e?: any) =>
Promise<IteratorResult<readonly [number, SecondItem], any>> } : {
[iterator]: () => IterableIterator<readonly [number, SecondItem]> ;
next: (…args: [] | [undefined]) => IteratorResult<readonly [number,
SecondItem], any> ; return?: (value?: any) =>
IteratorResult<readonly [number, SecondItem], any> ; throw?: (e?:
any) => IteratorResult<readonly [number, SecondItem], any> } :
never
Yields a tuple for each item in the iterable with the index of said item.
Type parameters
| Name | Type |
|---|---|
SecondIterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterableSecond | SecondIterable |
Returns
SecondIterable extends IsomorphicIterable<SecondItem> ? SecondIterable
extends { [asyncIterator]: () => AsyncIterator<SecondItem, any,
undefined> } ? { [asyncIterator]: () => AsyncIterableIterator<readonly
[number, SecondItem]> ; next: (…args: [] | [undefined]) =>
Promise<IteratorResult<readonly [number, SecondItem], any>> ;
return?: (value?: any) => Promise<IteratorResult<readonly [number,
SecondItem], any>> ; throw?: (e?: any) =>
Promise<IteratorResult<readonly [number, SecondItem], any>> } : {
[iterator]: () => IterableIterator<readonly [number, SecondItem]> ;
next: (…args: [] | [undefined]) => IteratorResult<readonly [number,
SecondItem], any> ; return?: (value?: any) =>
IteratorResult<readonly [number, SecondItem], any> ; throw?: (e?:
any) => IteratorResult<readonly [number, SecondItem], any> } :
never
Example
zipIndex(["foo", "bar"]); // [[0, "foo"], [1, "bar"]]Yields
Tuples with the index of each item.
Reducers
ReducerOutput
Ƭ ReducerOutput<Iterable, Output>: Iterable extends
IsomorphicIterable<infer Item> ? Iterable extends
ReadOnlyAsyncIterable<Item>
? Promise<Output> : Output : never
IsomorphicIterable reducer function optional return value.
Remarks
When reducing an IsomorphicIterable with a reducer function, the output can be
either a Promise or a regular value depending on the input.
See
Template
Type of the items in the IsomorphicIterable.
Type parameters
| Name | Type | Description |
|---|---|---|
Iterable | extends IsomorphicIterable | - |
Output | Output | Type of the output. |
count
▸ count<Item>(predicate): <Iterable>(iterable: Iterable) =>
ReducerOutput<GeneratorOutput<Iterable>,
number>
Counts the number of items that satisfy a predicate in the given iterable or asynchronous iterable.
Type parameters
| Name |
|---|
Item |
Parameters
| Name | Type | Description |
|---|---|---|
predicate | Filter<Item> | Predicate function for items to be counted. |
Returns
fn
Curried function with predicate in context.
▸ <Iterable>(iterable):
ReducerOutput<GeneratorOutput<Iterable>,
number>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<GeneratorOutput<Iterable>,
number>
Example
const countOdds = count((number: number) => number % 2 !== 1);
countOdds([1, 2, 3, 4, 5]); // 3
countOdds([0, 2, 4, 6, 8]); // 0entriesToObject
▸ entriesToObject<Iterable>(iterable):
ReducerOutput<Iterable,
ReadOnlyRecord<EntryKey<IsomorphicIterableItem<Iterable>>,
EntryValue<IsomorphicIterableItem<Iterable>>>>
Takes an entries iterable or asynchronous iterable and returns an object.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Entry> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable,
ReadOnlyRecord<EntryKey<IsomorphicIterableItem<Iterable>>,
EntryValue<IsomorphicIterableItem<Iterable>>>>
Object constructed from entries.
Example
entriesToObject([["key", "value"]]); // { key: "value" }
entriesToObject([
["foo", "bar"],
["number", 1],
]); // { foo: "bar", number: 1 }every
▸ every<Item, Predicated>(predicate): <Iterable>(iterable:
Iterable) =>
ReducerOutput<Iterable, boolean>
Evaluates items in an iterable or asynchronous iterable against a predicate and
returns true if all items evaluates to true.
Type parameters
| Name | Type |
|---|---|
Item | Item |
Predicated | never |
Parameters
| Name | Type | Description |
|---|---|---|
predicate | Single<Predicated> extends Single<never> ? Unary<Item, boolean> : Predicate<Item, Predicated> | Predicate function to evaluate each item. |
Returns
fn
Curried function with predicate set in context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable, boolean>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable, boolean>
Example
const everyEven = every((number: number) => number % 2 === 0);
everyEven([2, 4, 6, 8]); // true
everyEven([1, 2, 3, 4]); // falsefind
▸ find<Item>(predicate): <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable,
Maybe<Item>>
Returns the value of the first item in the iterable or asynchronous iterable
where predicate is true, undefined otherwise.
Type parameters
| Name |
|---|
Item |
Parameters
| Name | Type | Description |
|---|---|---|
predicate | Unary<Item, boolean> | Predicate function to search for item. |
Returns
fn
Curried function with predicate set in context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable,
Maybe<Item>>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable,
Maybe<Item>>
Example
const findEven = find((number: number) => number % 2 === 0);
findEven([1, 2, 3, 4]); // 2
findEven([1, 3, 5, 7]); // undefinedgroupBy
▸ groupBy<Item, Key>(grouper): <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable,
ReadOnlyRecord<Key, ReadOnlyArray<Item>>>
Groups values of an iterable or asynchronous iterable in an object based on the
output of the grouper function.
Type parameters
| Name | Type |
|---|---|
Item | Item |
Key | extends PropertyKey |
Parameters
| Name | Type | Description |
|---|---|---|
grouper | Unary<Item, Key> | Grouper function. |
Returns
fn
Object with grouped values.
▸ <Iterable>(iterable):
ReducerOutput<Iterable,
ReadOnlyRecord<Key, ReadOnlyArray<Item>>>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable,
ReadOnlyRecord<Key, ReadOnlyArray<Item>>>
Example
const groupByType = groupBy((value: number) =>
number % 2 === 0 ? "even" : "odd",
);
groupByType([1, 2, 3, 4, 5]); // { even: [2, 4], odd: [1, 3, 5] }head
▸ head<Iterable>(iterable): Iterable extends ReadOnlyArray ?
Head<Iterable> : Maybe<IsomorphicIterableItem<Iterable>>
Get first element of an iterable or asynchronous iterable (undefined if it is
empty).
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to get the first element from. |
Returns
Iterable extends ReadOnlyArray ? Head<Iterable> :
Maybe<IsomorphicIterableItem<Iterable>>
First element of the iterable (undefined if empty).
Example
head([1, 2, 3]); // 1includes
▸ includes<SearchItem>(searchItem): <Iterable>(iterable: Iterable)
=> ReducerOutput<Iterable,
boolean>
Tries to find the given searchItem in iterable or asynchronous iterable.
Type parameters
| Name |
|---|
SearchItem |
Parameters
| Name | Type | Description |
|---|---|---|
searchItem | SearchItem | Item to search. |
Returns
fn
Curried function with searchItem set in context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable, boolean>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable, boolean>
Example
const includesTwo = includes(2);
includesTwo([1, 2, 3, 4]); // true
includesTwo([1, 3, 5, 7]); // falseiterableToArray
▸ iterableToArray<Iterable>(iterable): Iterable extends
IsomorphicIterable<Item> ? Iterable extends { [asyncIterator]: () =>
AsyncIterator<Item, any, undefined> } ?
Promise<ReadOnlyArray<Item>> : ReadOnlyArray<Item> : never
Turns given iterable or asynchronous iterable into an array.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable to be turned into an array. |
Returns
Iterable extends IsomorphicIterable<Item> ? Iterable extends {
[asyncIterator]: () => AsyncIterator<Item, any, undefined> } ?
Promise<ReadOnlyArray<Item>> : ReadOnlyArray<Item> : never
Array made of iterable items.
Example
iterableToArray([1, 2, 3, 4]); // [1, 2, 3, 4]join
▸ join(separator): <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable, string>
Takes a separator string and a iterable or asynchronous iterable and returns a
string with the concatenation of all the elements separated by the separator.
Parameters
| Name | Type | Description |
|---|---|---|
separator | string | String to use as separator. |
Returns
fn
Curried function with separator in context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable, string>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable, string>
Example
const joinWithSpaces = join(" ");
joinWithSpaces([1, 2, 3]); // "1 2 3"length
▸ length<Iterable>(iterable):
ReducerOutput<Iterable, number>
Get the length of an iterable or asynchronous iterable.
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<unknown> |
Parameters
| Name | Type | Description |
|---|---|---|
iterable | Iterable | Iterable or asynchronous iterable to get the length from. |
Returns
ReducerOutput<Iterable, number>
Promise with the length of the iterable.
Example
length([1, 2, 3]); // 3reduce
▸ reduce<Item, Accumulator>(reducer): (initialValue: Accumulator)
=> <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable,
Accumulator>
Reducer function for iterables and asynchronous iterables.
Type parameters
| Name |
|---|
Item |
Accumulator |
Parameters
| Name | Type | Description |
|---|---|---|
reducer | Reducer<Item, Accumulator> | Reducer function. |
Returns
fn
Curried function with reducer in context.
▸ (initialValue): <Iterable>(iterable: Iterable) =>
ReducerOutput<Iterable,
Accumulator>
Parameters
| Name | Type |
|---|---|
initialValue | Accumulator |
Returns
fn
▸ <Iterable>(iterable):
ReducerOutput<Iterable,
Accumulator>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable,
Accumulator>
Example
const sum = Accumulator<number>(item => total => total + item);
const sumFrom0 = sum(0);
sumFrom0([1, 2, 3]); // 6some
▸ some<Item, Predicated>(predicate): <Iterable>(iterable:
Iterable) =>
ReducerOutput<Iterable, boolean>
Evaluates items in an iterable or asynchronous iterable against a predicate and
returns true if any item evaluates to true.
Type parameters
| Name | Type |
|---|---|
Item | Item |
Predicated | never |
Parameters
| Name | Type | Description |
|---|---|---|
predicate | Single<Predicated> extends Single<never> ? Unary<Item, boolean> : Predicate<Item, Predicated> | Predicate function to evaluate each item. |
Returns
fn
Curried function with predicate set in context.
▸ <Iterable>(iterable):
ReducerOutput<Iterable, boolean>
Type parameters
| Name | Type |
|---|---|
Iterable | extends IsomorphicIterable<Item> |
Parameters
| Name | Type |
|---|---|
iterable | Iterable |
Returns
ReducerOutput<Iterable, boolean>
Example
const someEven = some((number: number) => number % 2 === 0);
someEven([1, 2, 3, 4]); // true
someEven([1, 3, 5, 7]); // false