AsyncStream | /core/mod.ts | rimbu@1.1.0

namespace AsyncStream

Re-export

import { AsyncStream } from "https://deno.land/x/rimbu@1.1.0/core/mod.ts";

Interfaces

AsyncStream.NonEmpty

A non-empty and possibly infinite asynchronous sequence of elements of type T. See the Stream documentation and the AsyncStream API documentation

interface AsyncStream

implements AsyncFastIterable<T>, AsyncStreamable<T>

Re-export

import { type AsyncStream } from "https://deno.land/x/rimbu@1.1.0/core/mod.ts";

A possibly infinite asynchronous sequence of elements of type T. See the Stream documentation and the AsyncStream API documentation

Examples

Example 1

const s1 = AsyncStream.empty<number>()
const s2 = AsyncStream.of(1, 3, 2)
const s3 = AsyncStream.from(Stream.range({ start: 10, amount: 15 }))

Methods

asyncStream(): this

Returns an async stream of elements of type T.

equals(other: AsyncStreamSource<T>, options?: { eq?: Eq<T>; negate?: boolean; }): Promise<boolean>

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.

assumeNonEmpty(): AsyncStream.NonEmpty<T>

Returns the stream as a non-empty instance.

prepend(value: AsyncOptLazy<T>): AsyncStream.NonEmpty<T>

Returns the current stream preceded by the given value

append(value: AsyncOptLazy<T>): AsyncStream.NonEmpty<T>

Returns the current stream succeeded by the given value

forEach(f: (

value: T,

index: number,

halt: () => void,

) => MaybePromise<void>, options?: { state?: TraverseState; }): Promise<void>

Performs given function f for each element of the Stream, using given state as initial traversal state.

forEachPure<A extends readonly unknown[]>(f: (value: T, ...args: A) => MaybePromise<void>, ...args: A): Promise<void>

Performs given function f for each element of the Stream, with the optionally given args as extra arguments.

indexed(options?: { startIndex?: number; }): AsyncStream<[number, T]>

Returns an AsyncStream where each element in this stream is paired with its index

map<T2>(mapFun: (value: T, index: number) => MaybePromise<T2>): AsyncStream<T2>

Returns an AsyncStream where mapFun is applied to each element.

mapPure<T2, A extends readonly unknown[]>(mapFun: (value: T, ...args: A) => MaybePromise<T2>, ...args: A): AsyncStream<T2>

Returns an AsyncStream where the given mapFun is applied to each value in the stream, with optionally as extra arguments the given args.

flatMap<T2>(flatMapFun: (

value: T,

index: number,

halt: () => void,

) => AsyncStreamSource<T2>): AsyncStream<T2>

Returns an AsyncStream consisting of the concatenation of flatMapFun applied to each element.

flatZip<T2>(flatMapFun: (

value: T,

index: number,

halt: () => void,

) => AsyncStreamSource<T2>): AsyncStream<[T, T2]>

Returns an AsyncStream consisting of the concatenation of flatMapFun applied to each element, zipped with the element that was provided to the function.

transform<R>(transformer: AsyncTransformer<T, R>): AsyncStream<R>

Returns an AsyncStream consisting of the concatenation of AsyncStreamSource elements resulting from applying the given reducer to each element.

filter(pred: (

value: T,

index: number,

halt: () => void,

) => MaybePromise<boolean>, options?: { negate?: boolean; }): AsyncStream<T>

Returns an AsyncStream containing only those elements from this stream for which the given pred function returns true.

filterPure<A extends readonly unknown[]>(options: { pred: (value: T, ...args: A) => MaybePromise<boolean>; negate?: boolean; }, ...args: A): AsyncStream<T>

Returns an AsyncStream containing only those elements from this stream for which the given pred function returns true.

collect<R>(collectFun: AsyncCollectFun<T, R>): AsyncStream<R>

Returns an AsyncStream containing the resulting elements from applying the given collectFun to each element in this Stream.

first(): Promise<T | undefined>

Returns the first element of the AsyncStream, or a fallback value (default undefined) if the stream is empty.

first<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>

last(): Promise<T | undefined>

Returns the last element of the AsyncStream, or a fallback value (default undefined) if the stream is empty.

last<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>

single(): Promise<T | undefined>

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.

single<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>

count(): Promise<number>

Returns the amount of elements in the AsyncStream.

countElement(value: T, options?: { eq?: Eq<T>; negate?: boolean; }): Promise<number>

Returns the amount of elements that are equal according to the given eq to the given value in the AsyncStream.

find<O>(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { occurrance?: number; negate?: boolean; otherwise: AsyncOptLazy<O>; }): Promise<T | O>

Returns the first element for which the given pred function returns true, or a fallback value otherwise.

find(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { occurrance?: number; negate?: boolean; otherwise?: undefined; }): Promise<T | undefined>

elementAt(index: number): Promise<T | undefined>

Returns the element in the AsyncStream at the given index, or a fallback value (default undefined) otherwise.

elementAt<O>(index: number, otherwise: AsyncOptLazy<O>): Promise<T | O>

indicesWhere(pred: (value: T) => MaybePromise<boolean>, options?: { negate?: boolean; }): AsyncStream<number>

Returns an AsyncStream containing the indices of the elements for which the given pred function returns true.

indicesOf(searchValue: T, options?: { eq?: Eq<T>; negate?: boolean; }): AsyncStream<number>

Returns an AsyncStream containing the indicies of the occurrance of the given searchValue, according to given eq function.

indexWhere(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { occurrance?: number; negate?: boolean; }): Promise<number | undefined>

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.

indexOf(searchValue: T, options?: { occurrance?: number; eq?: Eq<T>; negate?: boolean; }): Promise<number | undefined>

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.

some(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { negate?: boolean; }): Promise<boolean>

Returns true if any element of the AsyncStream satifies given pred function.

every(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { negate?: boolean; }): Promise<boolean>

Returns true if every element of the AsyncStream satifies given pred function.

contains(value: T, options?: { amount?: number; eq?: Eq<T>; negate?: boolean; }): Promise<boolean>

Returns true if the AsyncStream contains given amount instances of given value, using given eq function.

containsSlice(source: AsyncStreamSource.NonEmpty<T>, options?: { eq?: Eq<T>; }): Promise<boolean>

Returns true if this stream contains the same sequence of elements as the given source, false otherwise.

takeWhile(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { negate?: boolean; }): AsyncStream<T>

Returns an AsyncStream that contains the elements of this stream up to the first element that does not satisfy given pred function.

dropWhile(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { negate?: boolean; }): AsyncStream<T>

Returns an AsyncStream that contains the elements of this stream starting from the first element that does not satisfy given pred function.

take(amount: number): AsyncStream<T>

Returns an AsyncStream that contains the elements of this stream up to a maximum of amount elements.

drop(amount: number): AsyncStream<T>

Returns an AsyncStream that skips the first amount elements of this stream and returns the rest.

repeat(amount?: number): AsyncStream<T>

Returns an AsyncStream that returns the elements from this stream given amount of times.

concat<T2 = T>(...others: ArrayNonEmpty<AsyncStreamSource.NonEmpty<T2>>): AsyncStream.NonEmpty<T | T2>

Returns an AsyncStream containing the elements of this stream followed by all elements produced by the others array of AsyncStreamSources.

concat<T2 = T>(...others: ArrayNonEmpty<AsyncStreamSource<T2>>): AsyncStream<T | T2>

min(): Promise<T | undefined>

Returns the mimimum element of the AsyncStream according to a default compare function, or the provided otherwise fallback value if the stream is empty.

min<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>

minBy(compare: (v1: T, v2: T) => number): Promise<T | undefined>

Returns the mimimum element of the AsyncStream according to the provided compare function, or the provided otherwise fallback value if the stream is empty.

minBy<O>(compare: (v1: T, v2: T) => number, otherwise: AsyncOptLazy<O>): Promise<T | O>

max(): Promise<T | undefined>

Returns the maximum element of the AsyncStream according to a default compare function, or the provided otherwise fallback value if the stream is empty.

max<O>(otherwise: AsyncOptLazy<O>): Promise<T | O>

maxBy(compare: (v1: T, v2: T) => number): Promise<T | undefined>

Returns the maximum element of the AsyncStream according to the provided compare function, or the provided otherwise fallback value if the stream is empty.

maxBy<O>(compare: (v1: T, v2: T) => number, otherwise: AsyncOptLazy<O>): Promise<T | O>

intersperse(sep: AsyncStreamSource<T>): AsyncStream<T>

Returns an AsyncStream with all elements from the given sep AsyncStreamSource between two elements of this stream.

join(options?: { sep?: string | undefined; start?: string | undefined; end?: string | undefined; valueToString?: ((value: T) => MaybePromise<string>) | undefined; ifEmpty?: string | undefined; }): Promise<string>

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.

mkGroup(options: { sep?: AsyncStreamSource<T>; start?: AsyncStreamSource<T>; end?: AsyncStreamSource<T>; }): AsyncStream<T>

Returns an AsyncStream starting with options.sep, then returning the elements of this Stream interspersed with options.sep, and ending with options.end.

splitWhere<R>(pred: (value: T, index: number) => MaybePromise<boolean>, options: { negate?: boolean; collector: AsyncReducer<T, R>; }): AsyncStream<R>

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.

splitWhere(pred: (value: T, index: number) => MaybePromise<boolean>, options?: { negate?: boolean; collector?: undefined; }): AsyncStream<T[]>

splitOn<R, T2 extends T = T>(sepElem: T2, options?: { eq?: Eq<T2>; negate?: boolean; collector: AsyncReducer<T, R>; }): AsyncStream<R>

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.

splitOn(sepElem: T, options?: { eq?: Eq<T>; negate?: boolean; collector?: undefined; }): AsyncStream<T[]>

splitOnSeq<R, T2 extends T = T>(sepSeq: AsyncStreamSource<T2>, options: { eq?: Eq<T2>; collector: AsyncReducer<T, R>; }): AsyncStream<R>

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.

splitOnSeq(sepSeq: AsyncStreamSource<T>, options?: { eq?: Eq<T>; collector?: undefined; }): AsyncStream<T[]>

distinctPrevious(options?: { eq?: Eq<T>; negate?: boolean; }): AsyncStream<T>

Returns an AsyncStream containing non-repetitive elements of the source stream, where repetitive elements are compared using the optionally given eq equality function.

window<R>(windowSize: number, options: { skipAmount?: number; collector: AsyncReducer<T, R>; }): AsyncStream<R>

Returns an AsyncStream containing windows of windowSize consecutive elements of the source stream, with each window starting skipAmount elements after the previous one.

window(windowSize: number, options?: { skipAmount?: number; collector?: undefined; }): AsyncStream<T[]>

fold<R>(init: AsyncOptLazy<R>, next: (

current: R,

value: T,

index: number,

halt: () => void,

) => MaybePromise<R>): Promise<R>

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.

foldStream<R>(init: AsyncOptLazy<R>, next: (

current: R,

value: T,

index: number,

halt: () => void,

) => MaybePromise<R>): AsyncStream<R>

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.

reduce<R>(reducer: AsyncReducer<T, R>): Promise<R>

Applies the given (Async)Reducer to each element in the AsyncStream, and returns the final result.

reduce<S extends AsyncReducer.CombineShape<T>>(shape: S & AsyncReducer.CombineShape<T>): Promise<AsyncReducer.CombineResult<S>>

Applies the given combined (Async)Reducer to each element in the AsyncStream, and returns the final result.

reduceStream<R>(reducer: AsyncReducer<T, R>): AsyncStream<R>

Returns an AsyncStream where the given AsyncReducer is applied to each element in the stream.

reduceStream<S extends AsyncReducer.CombineShape<T>>(shape: S & AsyncReducer.CombineShape<T>): AsyncStream<AsyncReducer.CombineResult<S>>

Returns an AsyncStream where the given shape containing AsyncReducers is applied to each element in the stream.

toArray(): Promise<T[]>

Returns an Array containing all elements in the AsyncStream.

toString(): string

Returns a string representation of the AsyncStream.

toJSON(): Promise<ToJSON<T[], "AsyncStream">>

Returns a JSON representation of the AsyncStream.