interface AsyncStream<T>
A possibly infinite asynchronous sequence of elements of type T. See the Stream documentation and the AsyncStream API documentation
Companion namespace: AsyncStream
Extends: AsyncStreamable<T>, AsyncFastIterable<T>
Implemented by: AsyncStream.NonEmpty<T>, AsyncStreamBase<T>
Type parameters
| Name | Description |
|---|---|
| T | the element type |
const s1 = AsyncStream.empty<number>()
const s2 = AsyncStream.of(1, 3, 2)
const s3 = AsyncStream.from(Stream.range({ start: 10, amount: 15 }))
Methods
[Symbol.asyncIterator]
undocumented
[Symbol.asyncIterator]append
Returns the current stream succeeded by the given value
appendvalueDefinition
append(value: AsyncOptLazy<T>): AsyncStream.NonEmpty<T>;
Parameters
| Name | Type | Description |
|---|---|---|
value | AsyncOptLazy<T> | the value to append |
await AsyncStream.of(1, 2, 3).append(4).toArray()
// => [1, 2, 3, 4]
O(1)
assumeNonEmpty
Returns the stream as a non-empty instance.
assumeNonEmptyDefinition
assumeNonEmpty(): AsyncStream.NonEmpty<T>;
RimbuError.EmptyCollectionAssumedNonEmptyError if the stream is known to be empty.
AsyncStream.from(Stream.range({ amount: 100 })).assumeNonEmpty()
// => type: AsyncStream.NonEmpty<number>
the function does not actually check if the stream is empty, so treat with extra care @note O(1)
asyncStream
Returns an async stream of elements of type T.
asyncStreamcollect
Returns an AsyncStream containing the resulting elements from applying the given collectFun to each element in this Stream.
collectcollectFun to each element in this Stream.Definition
collect<R>(collectFun: AsyncCollectFun<T, R>): AsyncStream<R>;
Type parameters
| Name | Description |
|---|---|
| R | the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
collectFun | AsyncCollectFun<T, R> | a potentially asynchronous function taking the parameters below and returning a new element or a skip token - value: the next element - index: the element index - skip: an element that can be returned if the current element should be skipped - halt: a function that, if called, ensures that no new elements are passed |
await AsyncStream.of(1, 2, 3).collect(async (v, i, skip, halt) => {
if (i === 0) return skip;
if (i === 1) halt();
return String(v)
}).toArray();
// => ['1']
O(1)
concat
Returns an AsyncStream containing the elements of this stream followed by all elements produced by the others array of AsyncStreamSources.
concatothers array of AsyncStreamSources.Definitions
concat<T2 = T>(...others: ArrayNonEmpty<AsyncStreamSource.NonEmpty<T2>>): AsyncStream.NonEmpty<T | T2>;
concat<T2 = T>(...others: ArrayNonEmpty<AsyncStreamSource<T2>>): AsyncStream<T | T2>;
Type parameters
| Name | Default | Description |
|---|---|---|
| T2 | T | the element type of the stream to concatenate |
Parameters
| Name | Type | Description |
|---|---|---|
others | ArrayNonEmpty<AsyncStreamSource.NonEmpty<T2>> | a series of AsyncStreamSources to concatenate. |
await AsyncStream.of(1, 2, 3).concat([4, 5], () => [6, 7]).toArray()
// [1, 2, 3, 4, 5, 6, 7]
O(1)
contains
Returns true if the AsyncStream contains given amount instances of given value, using given eq function.
containsamount instances of given value, using given eq function.Definition
contains(value: T, options?: {
amount?: number | undefined;
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): Promise<boolean>;
Parameters
| Name | Type | Description |
|---|---|---|
value | T | the value to search for |
options | {amount?: number | undefined;eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties = amount: (default: 1) the amount of values the Stream should contain - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements - negate: (default: false) when true will negate the given predicate |
const source = Stream.from('marmot')
await source.contains('m') // => true
await source.contains('m', 2) // => true
await source.contains('m', 3) // => false
await source.contains('q') // => false
O(N)
containsSlice
Returns true if this stream contains the same sequence of elements as the given source, false otherwise.
containsSlicesource, false otherwise.Definition
containsSlice(source: AsyncStreamSource.NonEmpty<T>, options?: {
eq?: Eq<T> | undefined;
amount?: number | undefined;
}): Promise<boolean>;
Parameters
| Name | Type | Description |
|---|---|---|
source | AsyncStreamSource.NonEmpty<T> | a non-empty async stream source containing the element sequence to find |
options | {eq?: Eq<T> | undefined;amount?: number | undefined;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the function to use to test element equality - negate: (default: false) when true will negate the given Eq function |
await AsyncStream.of(1, 2, 3, 4, 5).containsSlice([2, 3, 4])
// => true
await AsyncStream.of(1, 2, 3, 4, 5).containsSlice([4, 3, 2])
// => false
count
Returns the amount of elements in the AsyncStream.
countDefinition
count(): Promise<number>;
await AsyncStream.of(1, 2, 3).count() // => 3
O(N) for most types of Stream @note be careful not to use on infinite streams
countElement
Returns the amount of elements that are equal according to the given eq to the given value in the AsyncStream.
countElementeq to the given value in the AsyncStream.Definition
countElement(value: T, options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): Promise<number>;
Parameters
| Name | Type | Description |
|---|---|---|
value | T | the value to compare to |
options | {eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the given Eq function |
await AsyncStream.of(1, 2, 3).countElement(2) // => 1
await AsyncStream.of(1, 2, 3).countElement(2, { negate: true }) // => 2
O(N) @note be careful not to use on infinite streams
distinctPrevious
Returns an AsyncStream containing non-repetitive elements of the source stream, where repetitive elements are compared using the optionally given eq equality function.
distinctPreviouseq equality function.Definition
distinctPrevious(options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
options | {eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 1, 2, 2, 3, 1).distinctPrevious().toArray()
// => [1, 2, 3, 1]
drop
Returns an AsyncStream that skips the first amount elements of this stream and returns the rest.
dropamount elements of this stream and returns the rest.Definition
drop(amount: number): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
amount | number | the amount of elements to skip |
await AsyncStream.of(1, 2, 3).drop(1).toArray() // => [2, 3]
O(N)
dropWhile
Returns an AsyncStream that contains the elements of this stream starting from the first element that does not satisfy given pred function.
dropWhilepred function.Definition
dropWhile(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element and its index |
options | {negate?: boolean | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).dropWhile(async v => v < 2).toArray()
// => [2, 3]
O(N)
elementAt
Returns the element in the AsyncStream at the given index, or a fallback value (default undefined) otherwise.
elementAtDefinitions
elementAt(index: number): Promise<T | undefined>;
elementAt<O>(index: number, otherwise: AsyncOptLazy<O>): Promise<T | O>;
Parameters
| Name | Type | Description |
|---|---|---|
index | number | the index of the element to retrieve |
await AsyncStream.of(1, 2, 3).elementAt(1) // => 2
await AsyncStream.of(1, 2, 3).elementAt(5) // => undefined
await AsyncStream.of(1, 2, 3).elementAt(5, 'a') // => 'a'
await AsyncStream.of(1, 2, 3).elementAt(5, async () => 'a') // => 'a'
O(N) for most types of Stream
equals
Returns true if the sequence of elements in this stream are equal to the sequence in the other stream according to the provided eq function.
equalsother stream according to the provided eq function.Definition
equals(other: AsyncStreamSource<T>, options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): Promise<boolean>;
Parameters
| Name | Type | Description |
|---|---|---|
other | AsyncStreamSource<T> | the other async stream to compare |
options | {eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the eq function |
await AsyncStream.of(1, 2, 3).equals([1, 2, 3]) // => true
await AsyncStream.of(1, 2, 3, 4).equals([1, 2, 3]) // => false
don't use on potentially infinite streams @note O(N)
every
Returns true if every element of the AsyncStream satifies given pred function.
everypred function.Definition
every(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): Promise<boolean>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element and its index |
options | {negate?: boolean | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).every((v, i) => v + i > 10) // => false
await AsyncStream.of(1, 2, 3).every(async (v, i) => v + i < 10) // => true
O(N)
filter
Returns an AsyncStream containing only those elements from this stream for which the given pred function returns true.
filterpred function returns true.Definitions
filter<TF extends T>(pred: (value: T, index: number, halt: () => void) => value is TF, options?: {
negate?: false | undefined;
}): AsyncStream<TF>;
filter<TF extends T>(pred: (value: T, index: number, halt: () => void) => value is TF, options: {
negate: true;
}): AsyncStream<Exclude<T, TF>>;
filter(pred: (value: T, index: number, halt: () => void) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): AsyncStream<T>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| TF | T |
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number, halt: () => void) => value is TF | a potentially asynchronous function taking an element and its index, and returning true if the element should be included in the resulting stream. |
options | {negate?: false | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
if the predicate is a type guard, the return type is automatically inferred @note O(1)
await AsyncStream.of(1, 2, 3).filter(async (v, i) => v + i !== 3).toArray()
// => [1, 3]
await AsyncStream.of(1, 2, 3).filter(async (v, i) => v + i !== 3, { negate: true }).toArray()
// => [2]
filterPure
Returns an AsyncStream containing only those elements from this stream for which the given pred function returns true.
filterPurepred function returns true.Definitions
filterPure<A extends readonly unknown[], TF extends T>(options: {
pred: (value: T, ...args: A) => value is TF;
negate?: false | undefined;
}, ...args: A): AsyncStream<T>;
filterPure<A extends readonly unknown[], TF extends T>(options: {
pred: (value: T, ...args: A) => value is TF;
negate: true;
}, ...args: A): AsyncStream<Exclude<T, TF>>;
filterPure<A extends readonly unknown[]>(options: {
pred: (value: T, ...args: A) => MaybePromise<boolean>;
negate?: boolean | undefined;
}, ...args: A): AsyncStream<T>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| A | readonly unknown[] | the type of the arguments to be passed to the pred function after each element |
| TF | T |
Parameters
| Name | Type | Description |
|---|---|---|
options | {pred: (value: T, ...args: A) => value is TF;negate?: false | undefined;} | object specifying the following properties - pred: a potentially asynchronous function taking an element the optionaly given args, and returning true if the element should be included in the resulting stream.- negate: (default: false) when true will negate the given predicate |
args | A | (optional) the extra arguments to pass to the given mapFun |
if the predicate is a type guard, the return type is automatically inferred @note O(1)
await AsyncStream.of(1, 2, 3).filterPure({ pred: Object.is }, 2).toArray()
// => [2]
await AsyncStream.of(1, 2, 3).filterPure({ pred: Object.is, negate: true }, 2).toArray()
// => [1, 3]
find
Returns the first element for which the given pred function returns true, or a fallback value otherwise.
findpred function returns true, or a fallback value otherwise.Definitions
find<O, TF extends T>(pred: (value: T, index: number) => value is TF, options?: {
occurrance?: number | undefined;
negate?: false | undefined;
otherwise: AsyncOptLazy<O>;
}): Promise<TF | O>;
find<O, TF extends T>(pred: (value: T, index: number) => value is TF, options: {
occurrance?: number | undefined;
negate: true;
otherwise: AsyncOptLazy<O>;
}): Promise<Exclude<T, TF> | O>;
find<TF extends T>(pred: (value: T, index: number) => value is TF, options?: {
occurrance?: number | undefined;
negate?: false | undefined;
otherwise?: undefined;
}): Promise<T | undefined>;
find<TF extends T>(pred: (value: T, index: number) => value is TF, options: {
occurrance?: number | undefined;
negate: true;
otherwise?: undefined;
}): Promise<Exclude<T, TF> | undefined>;
find<O>(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
occurrance?: number | undefined;
negate?: boolean | undefined;
otherwise: AsyncOptLazy<O>;
}): Promise<T | O>;
find(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
occurrance?: number | undefined;
negate?: boolean | undefined;
otherwise?: undefined;
}): Promise<T | undefined>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| O | the optional value type to return no value was found | |
| TF | T |
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => value is TF | a potentially asynchronous predicate function taking an element and its index |
options | {occurrance?: number | undefined;negate?: false | undefined;otherwise: AsyncOptLazy<O>;} | (optional) object specifying the following properties - occurrance: (default: 1) the occurrance number to look for - otherwise: (default: undefined) an OptLazy value to be returned if the Stream is empty |
if the predicate is a type guard, the return type is automatically inferred
const isEven = async (v: number) => v % 2 === 0
await AsyncStream.of(1, 2, 3, 4).find(isEven) // => 2
await AsyncStream.of(1, 2, 3, 4).find(isEven, { occurrance: 2 }) // => 4
await AsyncStream.of(1, 2, 3, 4).find(isEven, { occurrance: 3 }) // => undefined
await AsyncStream.of(1, 2, 3, 4).find(isEven, { occurrance: 3, otherwise: 'a' })
// => 'a'
O(N)
first
Returns the first element of the AsyncStream, or a fallback value (default undefined) if the stream is empty.
firstDefinitions
first(): Promise<T | undefined>;
first<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>;
await AsyncStream.of(1, 2, 3).first() // => 1
await AsyncStream.empty<number>().first() // => undefined
await AsyncStream.empty<number>().first(0) // => 0
await AsyncStream.empty<number>().first(async () => 0) // => 0
O(1)
flatMap
Returns an AsyncStream consisting of the concatenation of flatMapFun applied to each element.
flatMapflatMapFun applied to each element.Definition
flatMap<T2>(flatMapFun: (value: T, index: number, halt: () => void) => AsyncStreamSource<T2>): AsyncStream<T2>;
Type parameters
| Name | Description |
|---|---|
| T2 | the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
flatMapFun | (value: T, index: number, halt: () => void) => AsyncStreamSource<T2> | a potentially asynchronous function receiving the inputs described below and returning a StreamSource of new elements- value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed |
O(1)
await AsyncStream.of(1, 2, 3).flatMap(async (v, i, halt) => {
if (i >= 1) halt();
return [v, i, v + i]
}).toArray()
// => [1, 0, 1, 2, 1, 3]
flatZip
Returns an AsyncStream consisting of the concatenation of flatMapFun applied to each element, zipped with the element that was provided to the function.
flatZipflatMapFun applied to each element, zipped with the element that was provided to the function.Definition
flatZip<T2>(flatMapFun: (value: T, index: number, halt: () => void) => AsyncStreamSource<T2>): AsyncStream<[T, T2]>;
Type parameters
| Name | Description |
|---|---|
| T2 | the result element type |
Parameters
| Name | Type | Description |
|---|---|---|
flatMapFun | (value: T, index: number, halt: () => void) => AsyncStreamSource<T2> | a function receiving the inputs described below and returning an AsyncStreamSource of new elements- value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed |
O(1)
await AsyncStream.of(1, 2, 3).flatZip((v, i, halt) => {
if (i >= 1) halt();
return [v, i, v + i]
}).toArray()
// => [[1, 1], [1, 0], [1, 1], [2, 2], [2, 1], [2, 3]]
fold
Returns the value resulting from applying the given the given next function to a current state (initially the given init value), and the next stream value, and returning the new state. When all elements are processed, the resulting state is returned.
foldnext function to a current state (initially the given init value), and the next stream value, and returning the new state. When all elements are processed, the resulting state is returned.Definition
fold<R>(init: AsyncOptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => MaybePromise<R>): Promise<R>;
Type parameters
| Name | Description |
|---|---|
| R | the resulting type |
Parameters
| Name | Type | Description |
|---|---|---|
init | AsyncOptLazy<R> | the initial result/state value |
next | (current: R, value: T, index: number, halt: () => void) => MaybePromise<R> | a potentially asynchronous function taking the parameters below and returning the new result/state value - current: the current result/state value, initially init.- value: the next Stream value - index: the index of the given value - halt: a function that, if called, ensures that no new elements are passed |
console.log(await AsyncStream.empty<number>().fold(5, async (current, value) => current + value))
// => 5
console.log(await AsyncStream.of(1, 2, 3).fold(() => 5, (current, value) => current + value))
// => 11 (= 5 + 1 + 2 + 3)
foldStream
Returns an AsyncStream containing the values resulting from applying the given the given next function to a current state (initially the given init value), and the next stream value, and returning the new state.
foldStreamnext function to a current state (initially the given init value), and the next stream value, and returning the new state.Definition
foldStream<R>(init: AsyncOptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => MaybePromise<R>): AsyncStream<R>;
Type parameters
| Name | Description |
|---|---|
| R | the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
init | AsyncOptLazy<R> | the initial result/state value |
next | (current: R, value: T, index: number, halt: () => void) => MaybePromise<R> | a function taking the parameters below and returning the new result/state value - current: the current result/state value, initially init.- value: the next Stream value - index: the index of the given value - halt: a function that, if called, ensures that no new elements are passed |
console.log(
await AsyncStream.empty<number>()
.foldStream(5, async (current, value) => current + value)
.toArray()
)
// => []
console.log(
await AsyncStream.of(1, 2, 3)
.foldStream(() => 5, (current, value) => current + value)
.toArray()
)
// => [6, 8, 11]
forEach
Performs given function f for each element of the Stream, using given state as initial traversal state.
forEachf for each element of the Stream, using given state as initial traversal state.Definition
forEach(f: (value: T, index: number, halt: () => void) => MaybePromise<void>, options?: {
state?: TraverseState | undefined;
}): Promise<void>;
Parameters
| Name | Type | Description |
|---|---|---|
f | (value: T, index: number, halt: () => void) => MaybePromise<void> | the potentially asynchronous function to perform for each element, receiving: - value: the next element - index: the index of the element - halt: a function that, if called, ensures that no new elements are passed |
options | {state?: TraverseState | undefined;} | (optional) object specifying the following properties - state: (optional) the traverse state |
if f is an async function, each call will be awaited consecutively
await AsyncStream.of(1, 2, 3).forEach(async (v, i, halt) => {
console.log(v);
if (i >= 1) halt();
})
// => 1, 2
O(N)
forEachPure
Performs given function f for each element of the Stream, with the optionally given args as extra arguments.
forEachPuref for each element of the Stream, with the optionally given args as extra arguments.Definition
forEachPure<A extends readonly unknown[]>(f: (value: T, ...args: A) => MaybePromise<void>, ...args: A): Promise<void>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| A | readonly unknown[] | the type of the extra arguments to pass |
Parameters
| Name | Type | Description |
|---|---|---|
f | (value: T, ...args: A) => MaybePromise<void> | the potentially asynchronous function to perform for each element, optionally receiving given extra args. |
args | A | a list of extra arguments to pass to given f for each element when needed |
if f is an async function, each call will be awaited consecutively
await AsyncStream.of(1, 2, 3).forEachPure(console.log, 'sheep')
// => logs:
// 1 sheep
// 2 sheep
// 3 sheep
O(N)
groupBy
Returns a promise resolving to the result of applying the valueToKey function to calculate a key for each value, and feeding the tuple of the key and the value to the collector reducer, and finally returning its result. If no collector is given, the default collector will return a JS multimap of the type Map<K, V[]>.
groupByvalueToKey function to calculate a key for each value, and feeding the tuple of the key and the value to the collector reducer, and finally returning its result. If no collector is given, the default collector will return a JS multimap of the type Map<K, V[]>.Definitions
groupBy<K, R, T2 extends readonly [K, T] = [K, T]>(valueToKey: (value: T, index: number) => MaybePromise<K>, options: {
collector: AsyncReducer.Accept<[K, T] | T2, R>;
}): Promise<R>;
groupBy<K>(valueToKey: (value: T, index: number) => MaybePromise<K>, options?: {
collector?: undefined;
}): Promise<Map<K, T[]>>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| K | the key type | ||
| R | the collector output type | ||
| T2 | readonly [K, T] | [K, T] |
Parameters
| Name | Type | Description |
|---|---|---|
valueToKey | (value: T, index: number) => MaybePromise<K> | potentially async function taking a value and its index, and returning the corresponding key |
options | {collector: AsyncReducer.Accept<[K, T] | T2, R>;} | (optional) an object containing the following properties: - collector: (default: Reducer.toArray()) a reducer that collects the incoming tuple of key and value, and provides the output |
await AsyncStream.of(1, 2, 3).groupBy((v) => v % 2)
// => Map {0 => [2], 1 => [1, 3]}
indexed
Returns an AsyncStream where each element in this stream is paired with its index
indexedDefinition
indexed(options?: {
startIndex?: number | undefined;
}): AsyncStream<[number, T]>;
Parameters
| Name | Type | Description |
|---|---|---|
options | {startIndex?: number | undefined;} | (optional) object specifying the following properties - startIndex: (optional) an alternative start index to use |
await AsyncStream.of(1, 2, 3).indexed().toArray()
// => [[0, 1], [1, 2], [2, 3]]
O(1)
indexOf
Returns the index of the occurrance instance of given searchValue in the AsyncStream, using given eq function, or undefined if no such value is found.
indexOfoccurrance instance of given searchValue in the AsyncStream, using given eq function, or undefined if no such value is found.Definition
indexOf(searchValue: T, options?: {
occurrance?: number | undefined;
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): Promise<number | undefined>;
Parameters
| Name | Type | Description |
|---|---|---|
searchValue | T | the element to search for |
options | {occurrance?: number | undefined;eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - occurrance - (default: 1) the occurrance to search for - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the given Eq function |
const source = AsyncStream.from('marmot')
await source.indexOf('m') // => 0
await source.indexOf('m', { occurrance: 2 }) // => 3
await source.indexOf('m', { occurrance: 3 }) // => undefined
await source.indexOf('q') // => undefined
O(N)
indexWhere
Returns the index of the given occurrance instance of the element in the AsyncStream that satisfies given pred function, or undefined if no such instance is found.
indexWhereoccurrance instance of the element in the AsyncStream that satisfies given pred function, or undefined if no such instance is found.Definition
indexWhere(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
occurrance?: number | undefined;
negate?: boolean | undefined;
}): Promise<number | undefined>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element and its index |
options | {occurrance?: number | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - occurrance: (default: 1) the occurrance to search for - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).indexWhere((v, i) => v + i > 2) // => 1
await AsyncStream.of(1, 2, 3).indexWhere(async (v, i) => v + i > 2, { occurrance: 2 }) // => 2
O(N)
indicesOf
Returns an AsyncStream containing the indicies of the occurrance of the given searchValue, according to given eq function.
indicesOfsearchValue, according to given eq function.Definition
indicesOf(searchValue: T, options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
}): AsyncStream<number>;
Parameters
| Name | Type | Description |
|---|---|---|
searchValue | T | the value to search for |
options | {eq?: Eq<T> | undefined;negate?: boolean | undefined;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the given Eq function |
await AsyncStream.from('marmot').indicesOf('m').toArray()
// => [0, 3]
O(N)
indicesWhere
Returns an AsyncStream containing the indices of the elements for which the given pred function returns true.
indicesWherepred function returns true.Definition
indicesWhere(pred: (value: T) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): AsyncStream<number>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element |
options | {negate?: boolean | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).indicesWhere((v, i) => v + i !== 3).toArray()
// => [0, 2]
O(N)
intersperse
Returns an AsyncStream with all elements from the given sep AsyncStreamSource between two elements of this stream.
interspersesep AsyncStreamSource between two elements of this stream.Definition
intersperse(sep: AsyncStreamSource<T>): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
sep | AsyncStreamSource<T> | the AsyncStreamSource to insert between each element of this Stream |
await AsyncStream.of(1, 2, 3).intersperse("ab").toArray()
// => [1, 'a', 'b', 2, 'a', 'b', 3]
O(1)
join
Returns a string resulting from converting each element to string with options.valueToString, interspersed with options.sep, starting with options.start and ending with options.end.
joinoptions.valueToString, interspersed with options.sep, starting with options.start and ending with options.end.Definition
join(options?: {
sep?: string | undefined;
start?: string | undefined;
end?: string | undefined;
valueToString?: ((value: T) => MaybePromise<string>) | undefined;
ifEmpty?: string | undefined;
}): Promise<string>;
Parameters
| Name | Type | Description |
|---|---|---|
options | {sep?: string | undefined;start?: string | undefined;end?: string | undefined;valueToString?: ((value: T) => MaybePromise<string>) | undefined;ifEmpty?: string | undefined;} | (optional) object specifying the following properties - sep: (optional) a seperator to insert between each Stream element - start: (optional) a start string to prepend at the start - end: (optional) an end string to append at the end - valueToString: (default: String) a potentially asynchronous function converting a Stream element to a string - ifEmpty: (optional) a string to return instead of the start and end tag if the stream is empty |
await AsyncStream.of(1, 2, 3).join({ start: '<', sep: ', ', end: '>' })
// => '<1, 2, 3>'
O(N)
last
Returns the last element of the AsyncStream, or a fallback value (default undefined) if the stream is empty.
lastDefinitions
last(): Promise<T | undefined>;
last<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>;
await AsyncStream.of(1, 2, 3).last() // => 3
await AsyncStream.empty<number>().last() // => undefined
await AsyncStream.empty<number>().last(0) // => 0
await AsyncStream.empty<number>().last(async () => 0) // => 0
O(N)
map
Returns an AsyncStream where mapFun is applied to each element.
mapmapFun is applied to each element.Definition
map<T2>(mapFun: (value: T, index: number) => MaybePromise<T2>): AsyncStream<T2>;
Type parameters
| Name | Description |
|---|---|
| T2 | the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
mapFun | (value: T, index: number) => MaybePromise<T2> | a potentially asynchronous function taking an element and its index, and returning some new element |
await AsyncStream.of(1, 2, 3).map(async (v, i) => `[${i}]: ${v}`).toArray()
// => ['[0]: 1', '[1]: 2', '[2]: 3']
O(1)
mapPure
Returns an AsyncStream where the given mapFun is applied to each value in the stream, with optionally as extra arguments the given args.
mapPuremapFun is applied to each value in the stream, with optionally as extra arguments the given args.Definition
mapPure<T2, A extends readonly unknown[]>(mapFun: (value: T, ...args: A) => MaybePromise<T2>, ...args: A): AsyncStream<T2>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| T2 | the result value type | |
| A | readonly unknown[] | the type of arguments to be supplied to the mapFun after each element |
Parameters
| Name | Type | Description |
|---|---|---|
mapFun | (value: T, ...args: A) => MaybePromise<T2> | a potentially asynchronous function taking an element and the given args, and returning the resulting stream value |
args | A | (optional) the extra arguments to pass to the given mapFun when needed |
is mostly aimed to increase performance so that an extra function is not required @note can be used on function that really expect 1 argument, since the normal map will also pass more arguments
const s = AsyncStream.of({ a: 1 }, { a: 2, c: { d: true } })
const s2 = s.mapPure(JSON.stringify, ['a'], 5)
// when stream is evaluated, will call JSON.stringify on each stream element with the given extra arguments
console.log(await s2.toArray())
// => ["{\n \"a\": 1\n}", "{\n \"a\": 2\n}"]
max
Returns the maximum element of the AsyncStream according to a default compare function, or the provided otherwise fallback value if the stream is empty.
maxotherwise fallback value if the stream is empty.Definitions
max(): Promise<T | undefined>;
max<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>;
await AsyncStream.of(5, 1, 3).max() // => 5
await AsyncStream.empty<number>().max() // => undefined
await AsyncStream.empty<number>().max('a') // => 'a'
O(N)
maxBy
Returns the maximum element of the AsyncStream according to the provided compare function, or the provided otherwise fallback value if the stream is empty.
maxBycompare function, or the provided otherwise fallback value if the stream is empty.Definitions
maxBy(compare: (v1: T, v2: T) => number): Promise<T | undefined>;
maxBy<O>(compare: (v1: T, v2: T) => number, otherwise: AsyncOptLazy<O>): Promise<T | O>;
Parameters
| Name | Type | Description |
|---|---|---|
compare | (v1: T, v2: T) => number |
function compareLength(a: string, b: string): number { return b.length - a.length };
await AsyncStream.of('abc', 'a', 'ab').maxBy(compareLength) // => 'abc'
await AsyncStream.empty<string>().maxBy(compareLength) // => undefined
await AsyncStream.empty<string>().maxBy(compareLength, 'a') // => 'a'
O(N)
min
Returns the mimimum element of the AsyncStream according to a default compare function, or the provided otherwise fallback value if the stream is empty.
minotherwise fallback value if the stream is empty.Definitions
min(): Promise<T | undefined>;
min<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>;
await AsyncStream.of(5, 1, 3).min() // => 1
await AsyncStream.empty<number>().min() // => undefined
await AsyncStream.empty<number>().min('a') // => 'a'
await AsyncStream.empty<number>().min(async () => 'a') // => 'a'
O(N)
minBy
Returns the mimimum element of the AsyncStream according to the provided compare function, or the provided otherwise fallback value if the stream is empty.
minBycompare function, or the provided otherwise fallback value if the stream is empty.Definitions
minBy(compare: (v1: T, v2: T) => number): Promise<T | undefined>;
minBy<O>(compare: (v1: T, v2: T) => number, otherwise: AsyncOptLazy<O>): Promise<T | O>;
Parameters
| Name | Type | Description |
|---|---|---|
compare | (v1: T, v2: T) => number |
function compareLength(a: string, b: string): number { return b.length - a.length };
await AsyncStream.of('abc', 'a', 'ab').minBy(compareLength) // => 'a'
await AsyncStream.empty<string>().minBy(compareLength) // => undefined
await AsyncStream.empty<string>().minBy(compareLength, 'a') // => 'a'
O(N)
mkGroup
Returns an AsyncStream starting with options.sep, then returning the elements of this Stream interspersed with options.sep, and ending with options.end.
mkGroupoptions.sep, then returning the elements of this Stream interspersed with options.sep, and ending with options.end.Definition
mkGroup(options: {
sep?: AsyncStreamSource<T> | undefined;
start?: AsyncStreamSource<T> | undefined;
end?: AsyncStreamSource<T> | undefined;
}): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
options | {sep?: AsyncStreamSource<T> | undefined;start?: AsyncStreamSource<T> | undefined;end?: AsyncStreamSource<T> | undefined;} | object specifying the following properties - sep: (optional) a seperator StreamSource to insert between each Stream element - start: (optional) a start StreamSource to prepend - end: (optional) an end StreamSource to append |
await AsyncStream.of(1, 2, 3).mkGroup({ start: '<<', sep: '-', end: '>>' }).toArray()
// => ['<', '<', 1, '-', 2, '-', 3, '>', '>']
O(N)
partition
Returns a promise resolving to a tuple of which the first element is the result of collecting the elements for which the given predicate is true, and the second one the result of collecting the other elements. Own reducers can be provided as collectors, by default the values are collected into an array.
partitionpredicate is true, and the second one the result of collecting the other elements. Own reducers can be provided as collectors, by default the values are collected into an array.Definitions
partition<T2 extends T, RT, RF = RT>(pred: (value: T, index: number) => value is T2, options: {
collectorTrue: AsyncReducer.Accept<T2, RT>;
collectorFalse: AsyncReducer.Accept<Exclude<T, T2>, RF>;
}): Promise<[true: RT, false: RF]>;
partition<T2 extends T>(pred: (value: T, index: number) => value is T2, options?: {
collectorTrue?: undefined;
collectorFalse?: undefined;
}): Promise<[true: T2[], false: Exclude<T, T2>[]]>;
partition<RT, RF = RT, T2 extends T = T>(pred: (value: T, index: number) => MaybePromise<boolean>, options: {
collectorTrue: AsyncReducer.Accept<T | T2, RT>;
collectorFalse: AsyncReducer.Accept<T | T2, RF>;
}): Promise<[true: RT, false: RF]>;
partition(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
collectorTrue?: undefined;
collectorFalse?: undefined;
}): Promise<[true: T[], false: T[]]>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| T2 | T | ||
| RT | the reducer result type for the collectorTrue value | ||
| RF | RT | the reducer result type for the collectorFalse value |
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => value is T2 | a potentially async predicate receiving the value and its index |
options | {collectorTrue: AsyncReducer.Accept<T2, RT>;collectorFalse: AsyncReducer.Accept<Exclude<T, T2>, RF>;} | (optional) an object containing the following properties: - collectorTrue: (default: Reducer.toArray()) a reducer that collects the values for which the predicate is true - collectorFalse: (default: Reducer.toArray()) a reducer that collects the values for which the predicate is false |
if the predicate is a type guard, the return type is automatically inferred
prepend
Returns the current stream preceded by the given value
prependvalueDefinition
prepend(value: AsyncOptLazy<T>): AsyncStream.NonEmpty<T>;
Parameters
| Name | Type | Description |
|---|---|---|
value | AsyncOptLazy<T> | the value to prepend |
await AsyncStream.of(1, 2, 3).prepend(0).toArray()
// => [0, 1, 2, 3]
O(1)
reduce
Applies the given (Async)Reducer to each element in the AsyncStream, and returns the final result.
reduce(Async)Reducer to each element in the AsyncStream, and returns the final result.Definitions
reduce<R, T2 extends T = T>(reducer: AsyncReducer.Accept<T | T2, R>): Promise<R>;
reduce<const S extends AsyncReducer.CombineShape<T>>(shape: S & AsyncReducer.CombineShape<T>): Promise<AsyncReducer.CombineResult<S>>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the resulting type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
reducer | AsyncReducer.Accept<T | T2, R> | the (Async)Reducer instance to use to apply to all stream elements. |
console.log(await AsyncStream.of(1, 2, 4).reduce(Reducer.sum))
// => 7
console.log(await AsyncStream.of(1, 2, 4).reduce(Reducer.product))
// => 8
reduceStream
Returns an AsyncStream where the given AsyncReducer is applied to each element in the stream.
reduceStreamAsyncReducer is applied to each element in the stream.Definitions
reduceStream<R, T2 extends T = T>(reducer: AsyncReducer.Accept<T |T2, R>):AsyncStream<R>;
reduceStream<const S extends AsyncReducer.CombineShape<T>>(shape: S & AsyncReducer.CombineShape<T>): AsyncStream<AsyncReducer.CombineResult<S>>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the resulting element type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
reducer | AsyncReducer.Accept<T | T2, R> | the (Async)Reducer instance to use to apply to all stream elements. |
console.log(
await AsyncStream.of(1, 2, 4)
.reduceStream(Reducer.sum)
.toArray()
)
// => [1, 3, 7]
console.log(
await AsyncStream.of(1, 2, 4)
.reduce(Reducer.product)
.toArray()
)
// => [1, 2, 8]
repeat
Returns an AsyncStream that returns the elements from this stream given amount of times.
repeatamount of times.Definition
repeat(amount?: number |undefined):AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
amount | number | undefined | (default: undefined) the amount of times to return this Stream |
const source = AsyncStream.of(1, 2, 3)
source.repeat() // => AsyncStream(1, 2, 3, 1, 2, 3, 1, 2, ...)
await source.repeat(1).toArray() // => [1, 2, 3]
await source.repeat(3).toArray() // => [1, 2, 3, 1, 2, 3, 1, 2, 3]
await source.repeat(-3).toArray() // => [1, 2, 3]
amount = undefined means that the AsyncStream is repeated indefintely @note amount = 1 means that the Stream is not repeated @note amount < 1 will be normalized to amount = 1 @note O(1)
single
Returns the first element of the Stream if it only has one element, or a fallback value if the Stream does not have exactly one value.
singleDefinitions
single(): Promise<T | undefined>;
single<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>;
await AsyncStream.empty<number>().single() // => undefined
await AsyncStream.of(1, 2, 3).single() // => undefined
await AsyncStream.of(1).single() // => 1
await AsyncStream.of(1, 2, 3).single(0) // => 0
some
Returns true if any element of the AsyncStream satifies given pred function.
somepred function.Definition
some(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): Promise<boolean>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchonous predicate function taking an element and its index |
options | {negate?: boolean | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).some((v, i) => v + i > 10) // => false
await AsyncStream.of(1, 2, 3).some(async (v, i) => v + i > 1) // => true
O(N)
splitOn
Returns an AsyncStream of collections of stream elements, where each array is filled with elements of this stream up to the next element that equals given sepElem according to the given eq function.
splitOnsepElem according to the given eq function.Definitions
splitOn<R, T2 extends T = T>(sepElem: T, options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
collector: AsyncReducer.Accept<T | T2, R>;
}): AsyncStream<R>;
splitOn(sepElem: T, options?: {
eq?: Eq<T> | undefined;
negate?: boolean | undefined;
collector?: undefined;
}): AsyncStream<T[]>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the result type of the collector and the resulting stream element type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
sepElem | T | the separator element to look for |
options | {eq?: Eq<T> | undefined;negate?: boolean | undefined;collector: AsyncReducer.Accept<T | T2, R>;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- negate: (default: false) when true will negate the given Eq function - collector: (default: AsyncArray.toArray()) the async reducer to use to collect the resulting values |
await AsyncStream.from('marmot').splitOn('m').toArray() // => [[], ['a', 'r'], ['o', 't']]
O(1)
splitOnSlice
Returns an AsyncStream of collections of stream elements, where each array is filled with elements of this stream up to the next sequence of elements that matches given sepSeq ordered elements with the given eq function.
splitOnSlicesepSeq ordered elements with the given eq function.Definitions
splitOnSlice<R, T2 extends T = T>(sepSlice: AsyncStreamSource<T>, options: {
eq?: Eq<T> | undefined;
collector: AsyncReducer.Accept<T | T2, R>;
}): AsyncStream<R>;
splitOnSlice(sepSlice: AsyncStreamSource<T>, options?: {
eq?: Eq<T> | undefined;
collector?: undefined;
}): AsyncStream<T[]>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the result type of the collector and the resulting stream element type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
sepSlice | AsyncStreamSource<T> | an AsyncStreamSource contaning the sequence to find |
options | {eq?: Eq<T> | undefined;collector: AsyncReducer.Accept<T | T2, R>;} | (optional) object specifying the following properties - eq: (default: Eq.objectIs) the Eq instance to use to test equality of elements- collector: (default: AsyncArray.toArray()) the async reducer to use to collect the resulting values |
await AsyncStream.from('marmalade').splitSeq('ma').toArray() // => [[], ['r'], ['l', 'a', 'd', 'e']]
O(1)
splitWhere
Returns an AsyncStream of collections of stream elements, where each array is filled with elements of this stream up to the next element that satisfies give function pred.
splitWherepred.Definitions
splitWhere<R, T2 extends T = T>(pred: (value: T, index: number) => MaybePromise<boolean>, options: {
negate?: boolean | undefined;
collector: AsyncReducer.Accept<T | T2, R>;
}): AsyncStream<R>;
splitWhere(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
collector?: undefined;
}): AsyncStream<T[]>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the result type of the collector and the resulting stream element type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element and its index |
options | {negate?: boolean | undefined;collector: AsyncReducer.Accept<T | T2, R>;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate - collector: (default: AsyncArray.toArray()) the async reducer to use to collect the resulting values |
await AsyncStream.of(1, 2, 3, 4).splitWhere(async v => v == 3).toArray()
// => [[1, 2], [4]]
O(1)
take
Returns an AsyncStream that contains the elements of this stream up to a maximum of amount elements.
takeamount elements.Definition
take(amount: number): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
amount | number | the maximum amount of elements to return from the resulting Stream |
await AsyncStream.of(1, 2, 3).take(2).toArray() // => [1, 2]
O(N)
takeWhile
Returns an AsyncStream that contains the elements of this stream up to the first element that does not satisfy given pred function.
takeWhilepred function.Definition
takeWhile(pred: (value: T, index: number) => MaybePromise<boolean>, options?: {
negate?: boolean | undefined;
}): AsyncStream<T>;
Parameters
| Name | Type | Description |
|---|---|---|
pred | (value: T, index: number) => MaybePromise<boolean> | a potentially asynchronous predicate function taking an element and its index |
options | {negate?: boolean | undefined;} | (optional) object specifying the following properties - negate: (default: false) when true will negate the given predicate |
await AsyncStream.of(1, 2, 3).takeWhile(async v => v < 3).toArray()
// => [1, 2]
O(N)
toArray
Returns an Array containing all elements in the AsyncStream.
toArraytoJSON
Returns a JSON representation of the AsyncStream.
toJSONtoString
Returns a string representation of the AsyncStream.
toStringDefinition
toString(): string;
to avoid issues with potentially infinite stream, this method does not list the stream elements. To do this, use join.
AsyncStream.of(1, 2, 3).toString() // => 'AsyncStream(...<potentially empty>)'
transform
Returns an AsyncStream consisting of the concatenation of AsyncStreamSource elements resulting from applying the given reducer to each element.
transformreducer to each element.Definition
transform<R, T2 extends T = T>(transformer: AsyncTransformer.Accept<T |T2, R>):AsyncStream<R>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the resulting element type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
transformer | AsyncTransformer.Accept<T | T2, R> | an async reducer taking elements ot type T as input, and returing an AsyncStreamSource of element type R |
O(1)
await AsyncStream.of(1, 2, 3, 4, 5, 6).transform(AsyncTransformer.window(3)).toArray()
// => [[1, 2, 3], [4, 5, 6]]
window
Returns an AsyncStream containing windows of windowSize consecutive elements of the source stream, with each window starting skipAmount elements after the previous one.
windowwindows of windowSize consecutive elements of the source stream, with each window starting skipAmount elements after the previous one.Definitions
window<R, T2 extends T = T>(windowSize: number, options: {
skipAmount?: number | undefined;
collector: AsyncReducer.Accept<T | T2, R>;
}): AsyncStream<R>;
window(windowSize: number, options?: {
skipAmount?: number | undefined;
collector?: undefined;
}): AsyncStream<T[]>;
Type parameters
| Name | Constraints | Default | Description |
|---|---|---|---|
| R | the collector reducer result type | ||
| T2 | T | T |
Parameters
| Name | Type | Description |
|---|---|---|
windowSize | number | the size in elements of the windows |
options | {skipAmount?: number | undefined;collector: AsyncReducer.Accept<T | T2, R>;} | (optional) object specifying the following properties - skipAmount: (default: windowSize) the amount of elements to skip to start the next window - collector: (default: AsyncArray.toArray()) the async reducer to use to collect the window values |
await Stream.of(1, 2, 3, 4, 5, 6, 7).window(3).toArray()
// => [[1, 2, 3], [4, 5, 6]]
await Stream.of(1, 2, 3, 4, 5).window(3, 1).toArray()
// => [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
await Stream.of(1, 2, 3, 4).window(2, 2, AsyncReducer.toJSSet()).toArray()
// => [Set(1, 2), Set(3, 4)]
withOnly
Returns an AsyncStream containing only those elements that are in the given values array.
withOnlyvalues array.Definition
withOnly<F extends T>(values: F[]): AsyncStream<F>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| F | T | a subtype of T to indicate the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
values | F[] | an array of values to include |
without
Returns an AsyncStream containing all elements except the elements in the given values array.
withoutvalues array.Definition
without<F extends T>(values: F[]): AsyncStream<T extends Exclude<T, F> ? T : Exclude<T, F>>;
Type parameters
| Name | Constraints | Description |
|---|---|---|
| F | T | a subtype of T to indicate the resulting element type |
Parameters
| Name | Type | Description |
|---|---|---|
values | F[] | an array of values to exclude |