Skip to main content

abstract class AsyncStreamBase<T>

undocumented

Extended by: AsyncOfStream<T>, FromResource<T,R>, FromSource<T>, AsyncFromStream<T>

Type parameters

NameDescription
Tundocumented

Methods

[Symbol.asyncIterator]

undocumented

Definition

abstract [Symbol.asyncIterator](): AsyncFastIterator<T>;

append

undocumented

Definition

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

Parameters

NameTypeDescription
valueAsyncOptLazy<T>

asNormal

undocumented

Definition

asNormal(): AsyncStream<T>;

assumeNonEmpty

undocumented

Definition

assumeNonEmpty(): AsyncStream.NonEmpty<T>;

asyncStream

undocumented

Definition

asyncStream(): this;

collect

undocumented

Definition

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

Type parameters

NameDescription
R

Parameters

NameTypeDescription
collectFunAsyncCollectFun<T, R>

concat

undocumented

Definition

concat(...others: ArrayNonEmpty<AsyncStreamSource<T>>): any;

Parameters

NameTypeDescription
othersArrayNonEmpty<AsyncStreamSource<T>>

contains

undocumented

Definition

contains(searchValue: T, amount?: number, eq?: Eq<T>): Promise<boolean>;

Parameters

NameTypeDescription
searchValueT
amountnumber
eqEq<T>

containsSlice

undocumented

Definition

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

Parameters

NameTypeDescription
sourceAsyncStreamSource.NonEmpty<T>
eqEq<any>

count

undocumented

Definition

count(): Promise<number>;

countElement

undocumented

Definition

countElement(value: T, eq?: Eq<any>): Promise<number>;

Parameters

NameTypeDescription
valueT
eqEq<any>

countNotElement

undocumented

Definition

countNotElement(value: T, eq?: Eq<any>): Promise<number>;

Parameters

NameTypeDescription
valueT
eqEq<any>

distinctPrevious

undocumented

Definition

distinctPrevious(eq?: Eq<T>): AsyncStream<T>;

Parameters

NameTypeDescription
eqEq<T>

drop

undocumented

Definition

drop(amount: number): AsyncStream<T>;

Parameters

NameTypeDescription
amountnumber

dropWhile

undocumented

Definition

dropWhile(pred: (value: T, index: number) => MaybePromise<boolean>): AsyncStream<T>;

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>

elementAt

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
indexnumber
otherwiseAsyncOptLazy<O>

equals

undocumented

Definition

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

Parameters

NameTypeDescription
otherAsyncStreamSource<T>
eqEq<T>

every

undocumented

Definition

every(pred: (value: T, index: number) => MaybePromise<boolean>): Promise<boolean>;

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>

filter

undocumented

Definition

filter(pred: (value: T, index: number, halt: () => void) => MaybePromise<boolean>): AsyncStream<T>;

Parameters

NameTypeDescription
pred(value: T, index: number, halt: () => void) => MaybePromise<boolean>

filterNot

undocumented

Definition

filterNot(pred: (value: T, index: number, halt: () => void) => MaybePromise<boolean>): AsyncStream<T>;

Parameters

NameTypeDescription
pred(value: T, index: number, halt: () => void) => MaybePromise<boolean>

filterNotPure

undocumented

Definition

filterNotPure<A extends readonly unknown[]>(pred: (value: T, ...args: A) => MaybePromise<boolean>, ...args: A): AsyncStream<T>;

Type parameters

NameConstraintsDescription
Areadonly unknown[]

Parameters

NameTypeDescription
pred(value: T, ...args: A) => MaybePromise<boolean>
argsA

filterPure

undocumented

Definition

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

Type parameters

NameConstraintsDescription
Areadonly unknown[]

Parameters

NameTypeDescription
pred(value: T, ...args: A) => MaybePromise<boolean>
argsA

find

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>
occurrancenumber
otherwiseAsyncOptLazy<O>

first

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
otherwiseAsyncOptLazy<O>

flatMap

undocumented

Definition

flatMap<T2>(flatMapFun: (value: T, index: number, halt: () => void) => AsyncStreamSource<T2>): AsyncStream<T2>;

Type parameters

NameDescription
T2

Parameters

NameTypeDescription
flatMapFun(value: T, index: number, halt: () => void) => AsyncStreamSource<T2>

flatZip

undocumented

Definition

flatZip<T2>(flatMapFun: (value: T, index: number, halt: () => void) => AsyncStreamSource<T2>): AsyncStream<[T, T2]>;

Type parameters

NameDescription
T2

Parameters

NameTypeDescription
flatMapFun(value: T, index: number, halt: () => void) => AsyncStreamSource<T2>

fold

undocumented

Definition

fold<R>(init: AsyncOptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => MaybePromise<R>): Promise<R>;

Type parameters

NameDescription
R

Parameters

NameTypeDescription
initAsyncOptLazy<R>
next(current: R, value: T, index: number, halt: () => void) => MaybePromise<R>

foldStream

undocumented

Definition

foldStream<R>(init: AsyncOptLazy<R>, next: (current: R, value: T, index: number, halt: () => void) => MaybePromise<R>): AsyncStream<R>;

Type parameters

NameDescription
R

Parameters

NameTypeDescription
initAsyncOptLazy<R>
next(current: R, value: T, index: number, halt: () => void) => MaybePromise<R>

forEach

undocumented

Definition

forEach(f: (value: T, index: number, halt: () => void) => MaybePromise<void>, state?: TraverseState): Promise<void>;

Parameters

NameTypeDescription
f(value: T, index: number, halt: () => void) => MaybePromise<void>
stateTraverseState

forEachPure

undocumented

Definition

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

Type parameters

NameConstraintsDescription
Areadonly unknown[]

Parameters

NameTypeDescription
f(value: T, ...args: A) => MaybePromise<void>
argsA

indexed

undocumented

Definition

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

Parameters

NameTypeDescription
startIndexnumber

indexOf

undocumented

Definition

indexOf(searchValue: T, occurrance?: number, eq?: Eq<T>): Promise<number | undefined>;

Parameters

NameTypeDescription
searchValueT
occurrancenumber
eqEq<T>

indexWhere

undocumented

Definition

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

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>
occurrancenumber

indicesOf

undocumented

Definition

indicesOf(searchValue: T, eq?: Eq<T>): AsyncStream<number>;

Parameters

NameTypeDescription
searchValueT
eqEq<T>

indicesWhere

undocumented

Definition

indicesWhere(pred: (value: T) => MaybePromise<boolean>): AsyncStream<number>;

Parameters

NameTypeDescription
pred(value: T) => MaybePromise<boolean>

intersperse

undocumented

Definition

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

Parameters

NameTypeDescription
sepAsyncStreamSource<T>

join

undocumented

Definition

join({ sep, start, end, valueToString, ifEmpty, }?: {
    sep?: string | undefined;
    start?: string | undefined;
    end?: string | undefined;
    valueToString?: StringConstructor | undefined;
    ifEmpty?: undefined;
  }): Promise<string>;

Parameters

NameTypeDescription
{ sep, start, end, valueToString, ifEmpty, }{
    sep?: string | undefined;
    start?: string | undefined;
    end?: string | undefined;
    valueToString?: StringConstructor | undefined;
    ifEmpty?: undefined;
  }

last

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
otherwiseAsyncOptLazy<O>

map

undocumented

Definition

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

Type parameters

NameDescription
T2

Parameters

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

mapPure

undocumented

Definition

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

Type parameters

NameConstraintsDescription
T2
Areadonly unknown[]

Parameters

NameTypeDescription
mapFun(value: T, ...args: A) => MaybePromise<T2>
argsA

max

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
otherwiseAsyncOptLazy<O>

maxBy

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
compare(v1: T, v2: T) => number
otherwiseAsyncOptLazy<O>

min

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
otherwiseAsyncOptLazy<O>

minBy

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
compare(v1: T, v2: T) => number
otherwiseAsyncOptLazy<O>

mkGroup

undocumented

Definition

mkGroup({ sep, start, end, }?: {
    sep?: AsyncStreamSource<T>;
    start?: AsyncStreamSource<T>;
    end?: AsyncStreamSource<T>;
  }): any;

Parameters

NameTypeDescription
{ sep, start, end, }{
    sep?: AsyncStreamSource<T>;
    start?: AsyncStreamSource<T>;
    end?: AsyncStreamSource<T>;
  }

prepend

undocumented

Definition

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

Parameters

NameTypeDescription
valueAsyncOptLazy<T>

reduce

undocumented

Definition

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

Type parameters

NameDescription
R

Parameters

NameTypeDescription
reducerAsyncReducer<T, R>

reduceAll

undocumented

Definition

reduceAll<R extends [unknown, unknown, ...unknown[]]>(...reducers: {
    [K in keyof R]: AsyncReducer<T, R[K]>;
  }): Promise<any>;

Type parameters

NameConstraintsDescription
R[unknown, unknown, ...unknown[]]

Parameters

NameTypeDescription
reducers{
    [K in keyof R]: AsyncReducer<T, R[K]>;
  }

reduceAllStream

undocumented

Definition

reduceAllStream<R extends [unknown, unknown, ...unknown[]]>(...reducers: {
    [K in keyof R]: AsyncReducer<T, R[K]>;
  }): any;

Type parameters

NameConstraintsDescription
R[unknown, unknown, ...unknown[]]

Parameters

NameTypeDescription
reducers{
    [K in keyof R]: AsyncReducer<T, R[K]>;
  }

reduceStream

undocumented

Definition

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

Type parameters

NameDescription
R

Parameters

NameTypeDescription
reducerAsyncReducer<T, R>

repeat

undocumented

Definition

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

Parameters

NameTypeDescription
amountnumber

single

undocumented

Definition

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

Type parameters

NameDescription
O

Parameters

NameTypeDescription
otherwiseAsyncOptLazy<O>

some

undocumented

Definition

some(pred: (value: T, index: number) => MaybePromise<boolean>): Promise<boolean>;

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>

splitOn

undocumented

Definition

splitOn(sepElem: T, eq?: Eq<T>): AsyncStream<T[]>;

Parameters

NameTypeDescription
sepElemT
eqEq<T>

splitWhere

undocumented

Definition

splitWhere(pred: (value: T, index: number) => MaybePromise<boolean>): AsyncStream<T[]>;

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>

take

undocumented

Definition

take(amount: number): AsyncStream<T>;

Parameters

NameTypeDescription
amountnumber

takeWhile

undocumented

Definition

takeWhile(pred: (value: T, index: number) => MaybePromise<boolean>): AsyncStream<T>;

Parameters

NameTypeDescription
pred(value: T, index: number) => MaybePromise<boolean>

toArray

undocumented

Definition

toArray(): Promise<T[]>;

toJSON

undocumented

Definition

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

toString

undocumented

Definition

toString(): string;

transform

undocumented

Definition

transform<R>(transformer: AsyncReducer<T, AsyncStreamSource<R>>): AsyncStream<R>;

Type parameters

NameDescription
R

Parameters

NameTypeDescription
transformerAsyncReducer<T, AsyncStreamSource<R>>

window

undocumented

Definition

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

Type parameters

NameDescription
R

Parameters

NameTypeDescription
windowSizenumber
skipAmountnumber
collectorAsyncReducer<T, R>