Class ASeq<T>`Abstract`

The ASeq class, which wraps an async iterable.

Type Parameters

Implements

AsyncIterable<T>

Index

Properties

flatMap

flatMap: <S>(
projection: (element: T, index: number) => MaybePromised<SimpleInput<S>>,
) => ASeq<Get_Concat_Element_Type<T, S>> = ...

concatMap

Type declaration

- <S>(
 projection: (element: T, index: number) => MaybePromised<SimpleInput<S>>,
 ): ASeq<Get_Concat_Element_Type<T, S>>
- Applies a sequence projection on each element of this sequence and concatenates the resulting sequences.
 Type Parameters
 - S
 Parameters
 - projection: (element: T, index: number) => MaybePromised<SimpleInput<S>>
 The sequence projection to apply to each element.
 Returns ASeq<Get_Concat_Element_Type<T, S>>
 A new sequence with the flattened results.

Methods

after

after(action: () => unknown): ASeq<T>
Calls a side-effect function after all elements have been yielded, but before iteration finishes.

⚠️ If the client stops iterating early, the function won't be called.
Parameters
- action: () => unknown
 A function to invoke after iteration completes.
Returns ASeq<T>
A new sequence that acts like this but invokes action before it finishes.
- Defined in src/seqs/aseq.class.ts:60

as

as<S>(): ASeq<S>
Reinterprets the declared element type of this as another, arbitrary type.

ℹ️ This is only useful in TypeScript and has no runtime effects.
Type Parameters
- S
 The new element type.
Returns ASeq<S>
The same sequence, but with a different declared type.
- Defined in src/seqs/aseq.class.ts:75

at

at(index: number): DoddleAsync<undefined | T>
🦥Lazily gets the element at the given index in this sequence, or undefined if the index is out of bounds.

ℹ️ Negative indexes count from the end of the sequence.
⚠️ Requires iterating over the sequence up to the given index.
Parameters
- index: number
 The index of the item to retrieve.
Returns DoddleAsync<undefined | T>
A 🦥DoddleAsync that resolves to the item at the given index.
- Defined in src/seqs/aseq.class.ts:89

before

before(action: () => unknown): ASeq<T>
Executes a side effect action once before any elements are yielded, but after iteration has begun.
Parameters
- action: () => unknown
 Invokes before any elements are yielded.
Returns ASeq<T>
A new async sequence that performs action before yielding elements.
- Defined in src/seqs/aseq.class.ts:106

cache

cache(): ASeq<T>
Caches the elements of this sequence as they're iterated over, so that it's evaluated only once.

Returns ASeq<T>
A new sequence with the same elements as the original sequence.
- Defined in src/seqs/aseq.class.ts:120

catch

catch<S = T>(
 handler: (
 element: unknown,
 index: number,
 ) => MaybePromised<void | ASeq.Input<S>>,
): ASeq<T | S>
Handles errors thrown while iterating over this sequence.
Type Parameters
- S = T
Parameters
- handler: (element: unknown, index: number) => MaybePromised<void | ASeq.Input<S>>
 A handler that will be called with the error and the index of the element that caused it. Should return a new sequence or undefined, which stops iteration.
Returns ASeq<T | S>
A new sequence that handles errors.
- Defined in src/seqs/aseq.class.ts:162

chunk

chunk<L extends number, S>(
size: L,
projection: (...window: getWindowArgsType<T, L>) => MaybePromised<S>,
): ASeq<S>
Splits this sequence into chunks of the given size, optionally applying a projection to each chunk.

ℹ️ The last chunk may be smaller than the given size.
Type Parameters
- L extends number
- S
Parameters
- size: L
 The size of each chunk.
- projection: (...window: getWindowArgsType<T, L>) => MaybePromised<S>
 Optionally, an N-ary projection to apply to each chunk. Defaults to collecting the elements into an array.
Returns ASeq<S>
A new sequence.
- Defined in src/seqs/aseq.class.ts:205
chunk<L extends number>(size: L): ASeq<getWindowOutputType<T, L>>
Splits this sequence into chunks of the given size,.

ℹ️ The last chunk may be smaller than the given size.
Type Parameters
- L extends number
Parameters
- size: L
 The size of each chunk.
Returns ASeq<getWindowOutputType<T, L>>
A new sequence.
- Defined in src/seqs/aseq.class.ts:217

collect

collect(): ASeq<T>
Returns a new sequence. When iterated, before yielding its first element, it will iterate over all the elements of this and store them in memory. Then it will yield all of them one by one.

ℹ️ Used to control side-effects. Makes sure all side-effects execute before continuing to apply other operators.

Returns ASeq<T>
A new sequence with the same elements as this one, but where iteration has already completed.
- Defined in src/seqs/aseq.class.ts:261

concat

concat<ASeqs extends SimpleInput<any>[]>(..._inputs: ASeqs): ASeq<T | {}>
Concatenates one or more sequences to the end of this, so that their elements appear in order.
Type Parameters
- ASeqs extends SimpleInput<any>[]
Parameters
- ..._inputs: ASeqs
 The sequential inputs to concatenate to the end of this.
Returns ASeq<T | {}>
A new sequence with the concatenated elements.
- Defined in src/seqs/aseq.class.ts:278

concatMap

concatMap<S>(
projection: (element: T, index: number) => MaybePromised<SimpleInput<S>>,
): ASeq<Get_Concat_Element_Type<T, S>>
Applies a sequence projection on each element of this sequence and concatenates the resulting sequences.
Type Parameters
- S
Parameters
- projection: (element: T, index: number) => MaybePromised<SimpleInput<S>>
 The sequence projection to apply to each element.
Returns ASeq<Get_Concat_Element_Type<T, S>>
A new sequence with the flattened results.
- Defined in src/seqs/aseq.class.ts:301

concatTo

concatTo<Seqs extends ASeq.Input<any>[]>(...others: Seqs): ASeq<T | {}>
Concatenates this sequence to the end of one or more other sequences.

ℹ️ Input sequences are concatenated in the order that they appear.
Type Parameters
- Seqs extends ASeq.Input<any>[]
Parameters
- ...others: Seqs
Returns ASeq<T | {}>
A new sequence with the concatenated elements.

See
ASeq.concat
- Defined in src/seqs/aseq.class.ts:324

count

count(): DoddleAsync<number>
🦥Lazily counts the number of elements in this sequence.

⚠️ Requires iterating over the entire sequence.

Returns DoddleAsync<number>
A 🦥DoddleAsync that resolves to the number of elements in this.
- Defined in src/seqs/aseq.class.ts:337
count(
predicate: (element: T, index: number) => MaybePromised<boolean>,
): DoddleAsync<number>
🦥Lazily counts the number of elements in this sequence that match the given predicate.

⚠️ Requires iterating over the entire sequence.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate used to test each element.
Returns DoddleAsync<number>
A 🦥DoddleAsync that resolves to the number of matching elements.
- Defined in src/seqs/aseq.class.ts:346

each

each(
 action: (
 element: T,
 index: number,
 stage: "before" | "after",
 ) => unknown,
 stage?: undefined | "before" | "after" | "both",
): ASeq<Awaited<T>>
Calls an action function as each element in this is iterated over. Calls the function before or after yielding the element, or both.
Parameters
- action: (element: T, index: number, stage: "before" | "after") => unknown
 The action function to invoke for each element.
- stage: undefined | "before" | "after" | "both" = "before"
 The stage at which to invoke the function. Can be "before", "after", or "both".
Returns ASeq<Awaited<T>>
A new sequence that invokes the action function while being iterated.
- Defined in src/seqs/aseq.class.ts:371

every

every(
predicate: (element: T, index: number) => MaybePromised<boolean>,
): DoddleAsync<boolean>
🦥Lazily checks if all elements in this sequence match the given predicate.

⚠️ May iterate over the entire sequence.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that yields true if all elements match, or false otherwise.
- Defined in src/seqs/aseq.class.ts:399

filter

filter<S>(predicate: (element: T, index: number) => element is S): ASeq<S>
Filters the elements of this sequence based on the given type predicate, narrowing the type of the elements in the resulting sequence.
Type Parameters
- S
Parameters
- predicate: (element: T, index: number) => element is S
 The predicate to filter elements.
Returns ASeq<S>
A new sequence with the filtered elements, its type narrowed based on the predicate.
- Defined in src/seqs/aseq.class.ts:419
filter(
predicate: (element: T, index: number) => MaybePromised<boolean>,
): ASeq<T>
Filters the elements of this sequence based on the given predicate.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate to filter elements.
Returns ASeq<T>
A new sequence with the filtered elements.
- Defined in src/seqs/aseq.class.ts:426

first

first(): DoddleAsync<undefined | T>
🦥Lazily finds the first element in this sequence, or undefined if it's empty.

Returns DoddleAsync<undefined | T>
A 🦥DoddleAsync that resolves to the first element or the alternative value.
- Defined in src/seqs/aseq.class.ts:445
first<const Alt = undefined>(
predicate: (element: T, index: number) => MaybePromised<boolean>,
alt?: Alt,
): DoddleAsync<T | Alt>
🦥Lazily finds the first element in this sequence that matches the given predicate.

⚠️ May iterate over the entire sequence.
Type Parameters
- const Alt = undefined
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate used to find the element.
- Optionalalt: Alt
 The value to return if no element matches the predicate. Defaults to undefined.
Returns DoddleAsync<T | Alt>
- Defined in src/seqs/aseq.class.ts:454

groupBy

groupBy<K>(
 keyProjection: (element: T) => MaybePromised<K>,
): ASeq<
 {
 "[unscopables]": {
 "[iterator]"?: boolean;
 "[unscopables]"?: boolean;
 at?: boolean;
 concat?: boolean;
 entries?: boolean;
 every?: boolean;
 filter?: boolean;
 find?: boolean;
 findIndex?: boolean;
 flat?: boolean;
 flatMap?: boolean;
 forEach?: boolean;
 includes?: boolean;
 indexOf?: boolean;
 join?: boolean;
 keys?: boolean;
 lastIndexOf?: boolean;
 length?: boolean;
 map?: boolean;
 reduce?: boolean;
 reduceRight?: boolean;
 slice?: boolean;
 some?: boolean;
 toLocaleString?: boolean;
 toString?: boolean;
 values?: boolean;
 readonly [key: number]: undefined
 | boolean;
 };
 "0": K;
 "1": ASeq<T>;
 length: 2;
 "[iterator]"(): IterableIterator<ASeq<T> | K>;
 at(index: number): undefined | ASeq<T> | K;
 concat(...items: ConcatArray<ASeq<T> | K>[]): (ASeq<T> | K)[];
 concat(
 ...items: (ASeq<T> | K | ConcatArray<ASeq<T> | K>)[],
 ): (ASeq<T> | K)[];
 entries(): IterableIterator<[number, ASeq<T> | K]>;
 every<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): this is readonly S[];
 every(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): boolean;
 filter<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): S[];
 filter(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): (ASeq<T> | K)[];
 find<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): undefined | S;
 find(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): undefined | ASeq<T> | K;
 findIndex(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): number;
 flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
 flatMap<U, This = undefined>(
 callback: (
 this: This,
 value: ASeq<T> | K,
 index: number,
 array: (ASeq<T> | K)[],
 ) => U | readonly U[],
 thisArg?: This,
 ): U[];
 forEach(
 callbackfn: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => void,
 thisArg?: any,
 ): void;
 includes(searchElement: ASeq<T> | K, fromIndex?: number): boolean;
 indexOf(searchElement: ASeq<T> | K, fromIndex?: number): number;
 join(separator?: string): string;
 keys(): IterableIterator<number>;
 lastIndexOf(searchElement: ASeq<T> | K, fromIndex?: number): number;
 map(
 callbackfn: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 thisArg?: any,
 ): U[];
 reduce(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 ): ASeq<T> | K;
 reduce(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 initialValue: ASeq<T> | K,
 ): ASeq<T> | K;
 reduce(
 callbackfn: (
 previousValue: U,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 initialValue: U,
 ): U;
 reduceRight(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 ): ASeq<T> | K;
 reduceRight(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 initialValue: ASeq<T> | K,
 ): ASeq<T> | K;
 reduceRight(
 callbackfn: (
 previousValue: U,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 initialValue: U,
 ): U;
 slice(start?: number, end?: number): (ASeq<T> | K)[];
 some(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): boolean;
 toLocaleString(): string;
 toLocaleString(
 locales: string | string[],
 options?: NumberFormatOptions & DateTimeFormatOptions,
 ): string;
 toString(): string;
 values(): IterableIterator<ASeq<T> | K>;
 },
>
Groups the elements of this sequence by key, resulting in a sequence of pairs where the first element is the key and the second is a sequence of values.
Type Parameters
- K
Parameters
- keyProjection: (element: T) => MaybePromised<K>
 The projection used to determine the key for each element.
Returns ASeq<
 {
 "[unscopables]": {
 "[iterator]"?: boolean;
 "[unscopables]"?: boolean;
 at?: boolean;
 concat?: boolean;
 entries?: boolean;
 every?: boolean;
 filter?: boolean;
 find?: boolean;
 findIndex?: boolean;
 flat?: boolean;
 flatMap?: boolean;
 forEach?: boolean;
 includes?: boolean;
 indexOf?: boolean;
 join?: boolean;
 keys?: boolean;
 lastIndexOf?: boolean;
 length?: boolean;
 map?: boolean;
 reduce?: boolean;
 reduceRight?: boolean;
 slice?: boolean;
 some?: boolean;
 toLocaleString?: boolean;
 toString?: boolean;
 values?: boolean;
 readonly [key: number]: undefined
 | boolean;
 };
 "0": K;
 "1": ASeq<T>;
 length: 2;
 "[iterator]"(): IterableIterator<ASeq<T> | K>;
 at(index: number): undefined | ASeq<T> | K;
 concat(...items: ConcatArray<ASeq<T> | K>[]): (ASeq<T> | K)[];
 concat(
 ...items: (ASeq<T> | K | ConcatArray<ASeq<T> | K>)[],
 ): (ASeq<T> | K)[];
 entries(): IterableIterator<[number, ASeq<T> | K]>;
 every<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): this is readonly S[];
 every(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): boolean;
 filter<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): S[];
 filter(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): (ASeq<T> | K)[];
 find<S>(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => value is S,
 thisArg?: any,
 ): undefined | S;
 find(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): undefined | ASeq<T> | K;
 findIndex(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 obj: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): number;
 flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
 flatMap<U, This = undefined>(
 callback: (
 this: This,
 value: ASeq<T> | K,
 index: number,
 array: (ASeq<T> | K)[],
 ) => U | readonly U[],
 thisArg?: This,
 ): U[];
 forEach(
 callbackfn: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => void,
 thisArg?: any,
 ): void;
 includes(searchElement: ASeq<T> | K, fromIndex?: number): boolean;
 indexOf(searchElement: ASeq<T> | K, fromIndex?: number): number;
 join(separator?: string): string;
 keys(): IterableIterator<number>;
 lastIndexOf(searchElement: ASeq<T> | K, fromIndex?: number): number;
 map(
 callbackfn: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 thisArg?: any,
 ): U[];
 reduce(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 ): ASeq<T> | K;
 reduce(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 initialValue: ASeq<T> | K,
 ): ASeq<T> | K;
 reduce(
 callbackfn: (
 previousValue: U,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 initialValue: U,
 ): U;
 reduceRight(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 ): ASeq<T> | K;
 reduceRight(
 callbackfn: (
 previousValue: ASeq<T> | K,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => ASeq<T> | K,
 initialValue: ASeq<T> | K,
 ): ASeq<T> | K;
 reduceRight(
 callbackfn: (
 previousValue: U,
 currentValue: ASeq<T> | K,
 currentIndex: number,
 array: readonly (ASeq<T> | K)[],
 ) => U,
 initialValue: U,
 ): U;
 slice(start?: number, end?: number): (ASeq<T> | K)[];
 some(
 predicate: (
 value: ASeq<T> | K,
 index: number,
 array: readonly (ASeq<T> | K)[],
 ) => unknown,
 thisArg?: any,
 ): boolean;
 toLocaleString(): string;
 toLocaleString(
 locales: string | string[],
 options?: NumberFormatOptions & DateTimeFormatOptions,
 ): string;
 toString(): string;
 values(): IterableIterator<ASeq<T> | K>;
 },
>
A sequence of pairs.
- Defined in src/seqs/aseq.class.ts:477

includes

includes<T, S>(this: ASeq<T>, ...values: S[]): DoddleAsync<boolean>
🦥Lazily checks if this sequence includes one or more values by iterating over it.

⚠️ May iterate over the entire sequence.
Type Parameters
- T
- S
Parameters
- this: ASeq<T>
- ...values: S[]
 The values to check for inclusion.
Returns DoddleAsync<boolean>
- Defined in src/seqs/aseq.class.ts:532
includes<S>(...values: S[]): DoddleAsync<boolean>
🦥Lazily checks if this sequence includes one or more values.

⚠️ May iterate over the entire sequence.
Type Parameters
- S
Parameters
- ...values: S[]
 The values to check for inclusion.
Returns DoddleAsync<boolean>
- Defined in src/seqs/aseq.class.ts:540

join

join(separator?: string): DoddleAsync<string>
🦥Lazily joins the elements of this sequence into a single string, separated by the given separator.

⚠️ Requires iterating over the entire sequence.
Parameters
- separator: string = ","
 The string to use as a separator between elements.
Returns DoddleAsync<string>
A 🦥DoddleAsync that resolves to the joined string.
- Defined in src/seqs/aseq.class.ts:563

last

last(): DoddleAsync<undefined | T>
🦥Lazily gets the last element in this sequence, or undefined.

Returns DoddleAsync<undefined | T>
A 🦥DoddleAsync that resolves to the last element in this sequence, or undefined.
- Defined in src/seqs/aseq.class.ts:580
last<const Alt = undefined>(
predicate: (element: T, index: number) => MaybePromised<boolean>,
alt?: Alt,
): DoddleAsync<T | Alt>
🦥Lazily finds the last element in this sequence that matches the given predicate.

⚠️ Requires iterating over the entire sequence.
Type Parameters
- const Alt = undefined
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate for testing each element.
- Optionalalt: Alt
 Optionally, the value to return if no matching value is found. Defaults to undefined.
Returns DoddleAsync<T | Alt>
A 🦥DoddleAsync that resolves to the last matching element or the alternative value.
- Defined in src/seqs/aseq.class.ts:592

map

map<S>(projection: (element: T, index: number) => MaybePromised<S>): ASeq<S>
Applies a projection to each element of this sequence.
Type Parameters
- S
Parameters
- projection: (element: T, index: number) => MaybePromised<S>
 The projection to apply to each element.
Returns ASeq<S>
A new sequence with the projected elements.
- Defined in src/seqs/aseq.class.ts:615

maxBy

maxBy<K, const Alt = undefined>(
projection: (element: T, index: number) => MaybePromised<K>,
alt?: Alt,
): DoddleAsync<T | Alt>
🦥Lazily finds the maximum element in this sequence by key, or the given alternative value if the sequence is empty.
Type Parameters
- K
- const Alt = undefined
Parameters
- projection: (element: T, index: number) => MaybePromised<K>
 Projects each element into a key so it can be compared.
- Optionalalt: Alt
 The value to return if the sequence is empty. Defaults to undefined.
Returns DoddleAsync<T | Alt>
- Defined in src/seqs/aseq.class.ts:632

minBy

minBy<K, const Alt = undefined>(
projection: (element: T, index: number) => MaybePromised<K>,
alt?: Alt,
): DoddleAsync<T | Alt>
🦥Lazily finds the minimum element in this sequence by key, or the given alternative value if the sequence is empty.
Type Parameters
- K
- const Alt = undefined
Parameters
- projection: (element: T, index: number) => MaybePromised<K>
 Projects each element into a key so it can be compared.
- Optionalalt: Alt
 The value to return if the sequence is empty. Defaults to undefined.
Returns DoddleAsync<T | Alt>
A 🦥DoddleAsync that resolves to the element with the minimum key, or alt if the sequence is empty.
- Defined in src/seqs/aseq.class.ts:662

orderBy

orderBy<S>(
projection: (element: T) => MaybePromised<S>,
descending?: boolean,
): ASeq<T>
Orders the elements of this sequence by key, using the given key projection.

⚠️ Has to iterate over the entire sequence.
Type Parameters
- S
Parameters
- projection: (element: T) => MaybePromised<S>
 A projection that returns a key to order by.
- Optionaldescending: boolean
 Whether to use descending order.
Returns ASeq<T>
A new sequence with the elements ordered by the given key.
- Defined in src/seqs/aseq.class.ts:693
orderBy<K extends [unknown, ...unknown[]]>(
projection: (element: T) => MaybePromised<K>,
descending?: boolean,
): ASeq<T>
Orders the elements of this using the given mutli-key tuple projection.

ℹ️ The keys are compared in the order they appear.
⚠️ Has to iterate over the entire sequence.
Type Parameters
- K extends [unknown, ...unknown[]]
Parameters
- projection: (element: T) => MaybePromised<K>
 A projection function that returns a tuple of keys to order by.
- Optionaldescending: boolean
 Whether to use descending order.
Returns ASeq<T>
A new sequence with the elements ordered by the given keys.
- Defined in src/seqs/aseq.class.ts:705

product

product<Xs extends any[], R = [T, ...Xs[]]>(
_others: { [K in string | number | symbol]: ASeq.Input<Xs[K<K>]> },
projection?: (...args: [T, ...Xs[]]) => R,
): ASeq<R>
Returns a cartesian product of this sequence with one or more other sequences, optionally applying an N-ary projection to each combination of elements.

The product of N sequences is the collection of all possible sets of elements from each sequence.

For example, the product of [1, 2] and [3, 4] is:
```
;[
 [1, 3],
 [1, 4],
 [2, 3],
 [2, 4]
]
```
Type Parameters
- Xs extends any[]
- R = [T, ...Xs[]]
Parameters
- _others: { [K in string | number | symbol]: ASeq.Input<Xs[K<K>]> }
- Optionalprojection: (...args: [T, ...Xs[]]) => R
 Optionally, an N-ary projection to apply to each combination of elements. If not given, each combination is yielded as an array.
Returns ASeq<R>
A new sequence.
Example
```
aseq([1, 2]).product([3, 4])
 // => [[1, 3], [1, 4], [2, 3], [2, 4]]
 aseq([]).product([3, 4])
 // => []
 aseq([1, 2]).product([3, 4], (a, b) => a + b)
 // => [4, 5, 5, 6]
```
- Defined in src/seqs/aseq.class.ts:760

reduce

reduce(
reducer: (acc: T, element: T, index: number) => MaybePromised<T>,
): DoddleAsync<T>
🦥Lazily reduces this sequence to a single value by applying the given reduction.

ℹ️ Uses the first element as the initial value.
Parameters
- reducer: (acc: T, element: T, index: number) => MaybePromised<T>
Returns DoddleAsync<T>
A 🦥DoddleAsync that resolves to the reduced value.
- Defined in src/seqs/aseq.class.ts:792
reduce<Acc>(
reducer: (acc: Acc, element: T, index: number) => MaybePromised<Acc>,
initial: Acc,
): DoddleAsync<Acc>
🦥Lazily reduces this sequence to a single value by applying the given reduction.

ℹ️ You need to supply an initial value.
Type Parameters
- Acc
Parameters
- reducer: (acc: Acc, element: T, index: number) => MaybePromised<Acc>
 The reduction to apply to each element.
- initial: Acc
 The initial value to start the reduction with.
Returns DoddleAsync<Acc>
- Defined in src/seqs/aseq.class.ts:801

reverse

reverse(): ASeq<T>
Reverses this sequence.

⚠️ Requires iterating over the entire sequence.

Returns ASeq<T>
A new sequence with the elements in reverse order.
- Defined in src/seqs/aseq.class.ts:828

scan

scan(reducer: (acc: T, element: T, index: number) => MaybePromised<T>): ASeq<T>
Applies a reduction to each element of this sequence. Returns a new sequence that yields the accumulated value at each step.

ℹ️ The first element is used as the initial value.
Parameters
- reducer: (acc: T, element: T, index: number) => MaybePromised<T>
Returns ASeq<T>
A new sequence with the accumulated values.

Throws
If this is empty.
- Defined in src/seqs/aseq.class.ts:848
scan<Acc>(
reducer: (acc: Acc, element: T, index: number) => MaybePromised<Acc>,
initial: Acc,
): ASeq<Acc>
Applies a reduction to each element of this sequence. Returns a new sequence that yields the accumulated value at each step.

ℹ️ You need to supply an initial value.
Type Parameters
- Acc
Parameters
- reducer: (acc: Acc, element: T, index: number) => MaybePromised<Acc>
- initial: Acc
 The initial value to start the reduction with.
Returns ASeq<Acc>
- Defined in src/seqs/aseq.class.ts:858

seqEquals

seqEquals<T, S>(
this: AsyncIterable<T>,
input: ASeq.Input<S>,
): DoddleAsync<boolean>
🦥Lazily checks if this sequence is equal to the input sequence.

ℹ️ For two sequences to be equal, their elements must be equal and be in the same order.
Type Parameters
- T
- S
Parameters
- this: AsyncIterable<T>
- input: ASeq.Input<S>
 The sequence-like input to compare with.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if all elements are equal, or false
- Defined in src/seqs/aseq.class.ts:889
seqEquals<S>(input: ASeq.Input<S>): DoddleAsync<boolean>
🦥Lazily checks if this sequence is equal to the input sequence.

ℹ️ For two sequences to be equal, their elements must be equal and be in the same order.
Type Parameters
- S
Parameters
- input: ASeq.Input<S>
 The sequence-like input to compare with.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if all elements are equal, or false
- Defined in src/seqs/aseq.class.ts:899
seqEquals<K, S = T>(
input: ASeq.Input<S>,
projection: (element: T | S) => MaybePromised<K>,
): DoddleAsync<boolean>
🦥Lazily checks if this sequence is equal to the input sequence.

The elements are compared by key, using the given key projection.
Type Parameters
- K
- S = T
Parameters
- input: ASeq.Input<S>
 The sequential input to compare with.
- projection: (element: T | S) => MaybePromised<K>
 The projection function that determines the key for comparison.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if all elements are equal, or false otherwise.
- Defined in src/seqs/aseq.class.ts:910

setEquals

setEquals<S>(input: ASeq.Input<S>): DoddleAsync<boolean>
🦥Lazily checks if this sequence contains the same elements as the input sequence, without regard to order.

⚠️ Requires iterating over the entire sequence.
Type Parameters
- S
Parameters
- input: ASeq.Input<S>
 The sequence-like input to compare with.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if this is set-equal to the input, or false otherwise.
- Defined in src/seqs/aseq.class.ts:950
setEquals<T, S>(
this: AsyncIterable<T>,
input: ASeq.Input<S>,
): DoddleAsync<boolean>
🦥Lazily checks if this sequence contains the same elements as the input sequence, without regard to order.

⚠️ Requires iterating over the entire sequence.
Type Parameters
- T
- S
Parameters
- this: AsyncIterable<T>
- input: ASeq.Input<S>
 The sequence-like input to compare with.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if this is set-equal to the input, or false otherwise.
- Defined in src/seqs/aseq.class.ts:962
setEquals<K, S = T>(
input: ASeq.Input<NoInfer<S>>,
projection?: (element: T | S) => MaybePromised<K>,
): DoddleAsync<boolean>
🦥Lazily checks if this sequence contains the same elements as the input sequence, without regard to order.

ℹ️ The elements are compared by key, using the given key projection.
Type Parameters
- K
- S = T
Parameters
- input: ASeq.Input<NoInfer<S>>
 The sequence-like input to compare with.
- Optionalprojection: (element: T | S) => MaybePromised<K>
 The projection function that determines the key for comparison.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if this is set-equal to the input, or false otherwise.
- Defined in src/seqs/aseq.class.ts:974

share(): ASeq<T>
Returns a new sequence that shares its iterator state. This allows different loops to iterate over it, sharing progress.

⚠️ Can be iterated over exactly once, and will be empty afterwards.

Returns ASeq<T>
A new, shared iterable sequence that can be iterated over exactly once.
- Defined in src/seqs/aseq.class.ts:1006

shuffle

shuffle(): ASeq<T>
Shuffles the elements of this sequence randomly.

⚠️ Requires iterating over the entire sequence.

Returns ASeq<T>
A new sequence with the shuffled elements.
- Defined in src/seqs/aseq.class.ts:1026

skip

skip(count: number): ASeq<T>
Skips the first count elements of this sequence, yielding the rest.

ℹ️ If count is negative, skips the final elements instead (e.g. skipLast)
Parameters
- count: number
 The number of elements to skip.
Returns ASeq<T>
A new sequence without the skipped elements.
- Defined in src/seqs/aseq.class.ts:1041

skipWhile

skipWhile(
predicate: (element: T, index: number) => MaybePromised<boolean>,
options?: { skipFinal?: boolean },
): ASeq<T>
Skips elements from this sequence while the given predicate is true, and yields the rest.

ℹ️ You can use the options argument to skip the first element that returns false.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate to determine whether to continue skipping.
- Optionaloptions: { skipFinal?: boolean }
 Options for skipping behavior.
 - OptionalskipFinal?: boolean
 Whether to skip the boundary element for which the predicate returns false.
Returns ASeq<T>
A new sequence without the skipped elements.
- Defined in src/seqs/aseq.class.ts:1076

some

some(
predicate: (element: T, index: number) => MaybePromised<boolean>,
): DoddleAsync<boolean>
🦥Lazily checks if any element in this sequence matches the given predicate, by iterating over it until a match is found.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate to match the element.
Returns DoddleAsync<boolean>
A 🦥DoddleAsync that resolves to true if any element matches, or false otherwise.
- Defined in src/seqs/aseq.class.ts:1105

sumBy

sumBy(
projection: (element: T, index: number) => MaybePromised<number>,
): DoddleAsync<number>
🦥Lazily sums the elements of this sequence by iterating over it, applying the given projection to each element.
Parameters
- projection: (element: T, index: number) => MaybePromised<number>
 The projection function to apply to each element.
Returns DoddleAsync<number>
A 🦥DoddleAsync that resolves to the sum of the projected elements.
- Defined in src/seqs/aseq.class.ts:1125

take

take(count: number): ASeq<T>
Yields the first count elements of this sequence.

ℹ️ If count is negative, yields the last -count elements instead.
ℹ️ If the sequence is smaller than count, it yields all elements.
Parameters
- count: number
 The number of elements to yield.
Returns ASeq<T>
A new sequence with the yielded elements.
- Defined in src/seqs/aseq.class.ts:1146

takeWhile

takeWhile(
predicate: (element: T, index: number) => MaybePromised<boolean>,
specifier?: { takeFinal?: boolean },
): ASeq<T>
Yields the first elements of this sequence while the given predicate is true and skips the rest.

ℹ️ If the sequence is too small, the result will be empty.
ℹ️ The options argument lets you keep the first element for which the predicate returns false.
Parameters
- predicate: (element: T, index: number) => MaybePromised<boolean>
 The predicate to determine whether to continue yielding.
- Optionalspecifier: { takeFinal?: boolean }
Returns ASeq<T>
A new sequence with the yielded elements.
- Defined in src/seqs/aseq.class.ts:1192

toArray

toArray(): DoddleAsync<T[]>
🦥Lazily converts this sequence into an array.

⚠️ Has to iterate over the entire sequence.

Returns DoddleAsync<T[]>
A 🦥DoddleAsync that resolves to an array of the elements in the sequence.
- Defined in src/seqs/aseq.class.ts:1216

toMap

toMap<K, V>(
 kvpProjection: (
 element: T,
 index: number,
 ) => MaybePromised<readonly [K, V]>,
): DoddleAsync<Map<K, V>>
🦥Lazily converts this sequence into a Map.

⚠️ Has to iterate over the entire sequence.
Type Parameters
- K
- V
Parameters
- kvpProjection: (element: T, index: number) => MaybePromised<readonly [K, V]>
 A function that takes an element and returns a key-value pair.
Returns DoddleAsync<Map<K, V>>
A 🦥DoddleAsync that resolves to a Map of the elements in the sequence.
- Defined in src/seqs/aseq.class.ts:1234

toRecord

toRecord<const Key extends PropertyKey, Value>(
 kvpProjection: (
 element: T,
 index: number,
 ) => MaybePromised<readonly [Key, Value]>,
): DoddleAsync<Record<Key, Value>>
🦥Lazily converts this sequence into a plain JS object. Uses the given kvpProjection to determine each key-value pair.
Type Parameters
- const Key extends PropertyKey
- Value
Parameters
- kvpProjection: (element: T, index: number) => MaybePromised<readonly [Key, Value]>
 A function that takes an element and returns a key-value pair. Each key must be a valid PropertyKey.
Returns DoddleAsync<Record<Key, Value>>
A 🦥DoddleAsync that resolves to a plain JS object.
- Defined in src/seqs/aseq.class.ts:1258

toSeq

toSeq(): DoddleAsync<Seq<T>>
Lazily converts this async sequence into a synchronous Seq sequence.

⚠️ Has to iterate over the entire sequence.

Returns DoddleAsync<Seq<T>>
A 🦥DoddleAsync that resolves to a synchronous Seq sequence.
- Defined in src/seqs/aseq.class.ts:1283

toSet

toSet(): DoddleAsync<Set<T>>
🦥Lazily converts this sequence into a Set.

⚠️ Has to iterate over the entire sequence.

Returns DoddleAsync<Set<T>>
A 🦥DoddleAsync that resolves to a Set of the elements in the sequence.
- Defined in src/seqs/aseq.class.ts:1296

uniq

uniq(keyProjection?: (element: T) => any): ASeq<T>
Filters out duplicate elements from this sequence, optionally using a key projection.

ℹ️ Doesn't need to iterate over the entire sequence.
⚠️ Needs to cache the sequence as it's iterated over.
Parameters
- keyProjection: (element: T) => any = ...
 A function that takes an element and returns a key used to check for uniqueness.
Returns ASeq<T>
A sequence of unique elements.
- Defined in src/seqs/aseq.class.ts:1316

window

window<L extends number, S>(
size: L,
projection: (...window: getWindowArgsType<T, L>) => MaybePromised<S>,
): ASeq<S>
Splits this async sequence into overlapping windows of fixed size, applying a projection to each window.

ℹ️ If the sequence is smaller than the window size, one smaller window will yielded.
Type Parameters
- L extends number
- S
Parameters
- size: L
 The size of each window.
- projection: (...window: getWindowArgsType<T, L>) => MaybePromised<S>
 A function to project each window to a value.
Returns ASeq<S>
A new sequence of windows or projected results.
- Defined in src/seqs/aseq.class.ts:1340
window<L extends number>(size: L): ASeq<getWindowOutputType<T, L>>
Splits this async sequence into overlapping windows of fixed size.

ℹ️ If the sequence is smaller than the window size, one smaller window will yielded.
Type Parameters
- L extends number
Parameters
- size: L
 The size of each window.
Returns ASeq<getWindowOutputType<T, L>>
A new sequence of windows.
- Defined in src/seqs/aseq.class.ts:1352

zip

zip<Xs extends [any, ...any[]]>(
others: { [K in string | number | symbol]: Seq.Input<Xs[K<K>]> },
): ASeq<[undefined | neverToUndefined<T>, ...getZipValuesType<Xs>[]]>
Zips this sequence with other sequences, yielding tuples of elements that appear in the same position in each sequence.

ℹ️ Sequences that are exhausted will yield undefined for their elements.
ℹ️ The resulting sequence will be as long as the longest input sequence.
Type Parameters
- Xs extends [any, ...any[]]
Parameters
- others: { [K in string | number | symbol]: Seq.Input<Xs[K<K>]> }
 An array of other sequence inputs to zip with.
Returns ASeq<[undefined | neverToUndefined<T>, ...getZipValuesType<Xs>[]]>
A new async sequence of tuples containing parallel elements.
- Defined in src/seqs/aseq.class.ts:1398
zip<Xs extends [any, ...any[]], R>(
 _others: { [K in string | number | symbol]: ASeq.Input<Xs[K<K>]> },
 projection: (
 ...args: [undefined | neverToUndefined<T>, ...getZipValuesType<Xs>[]],
 ) => MaybePromised<R>,
): ASeq<R>
Zips this sequence with other sequences, applying a projection to each set of elements and yielding the results.

ℹ️ Sequences that are exhausted will yield undefined for their elements.
ℹ️ The resulting sequence will be as long as the longest input sequence.
Type Parameters
- Xs extends [any, ...any[]]
- R
Parameters
- _others: { [K in string | number | symbol]: ASeq.Input<Xs[K<K>]> }
- projection: (
 ...args: [undefined | neverToUndefined<T>, ...getZipValuesType<Xs>[]],
 ) => MaybePromised<R>
Returns ASeq<R>
A new sequence of elements generated from the zipped values.
- Defined in src/seqs/aseq.class.ts:1411

Class ASeq<T>Abstract

Type Parameters

Implements

Index

Properties

Methods

Properties

flatMap

Type declaration

Type Parameters

Parameters

Returns ASeq<Get_Concat_Element_Type<T, S>>

Methods

after

Parameters

Returns ASeq<T>

as

Type Parameters

Returns ASeq<S>

at

Parameters

Returns DoddleAsync<undefined | T>

before

Parameters

Returns ASeq<T>

cache

Returns ASeq<T>

catch

Type Parameters

Parameters

Returns ASeq<T | S>

chunk

Type Parameters

Parameters

Returns ASeq<S>

Type Parameters

Parameters

Returns ASeq<getWindowOutputType<T, L>>

collect

Returns ASeq<T>

concat

Type Parameters

Parameters

Returns ASeq<T | {}>

concatMap

Type Parameters

Parameters

Returns ASeq<Get_Concat_Element_Type<T, S>>

concatTo

Type Parameters

Parameters

Returns ASeq<T | {}>

See

count

Returns DoddleAsync<number>

Parameters

Returns DoddleAsync<number>

each

Parameters

Returns ASeq<Awaited<T>>

every

Parameters

Returns DoddleAsync<boolean>

filter

Type Parameters

Parameters

Returns ASeq<S>

Parameters

Returns ASeq<T>

first

Returns DoddleAsync<undefined | T>

Type Parameters

Parameters

Returns DoddleAsync<T | Alt>

groupBy

Type Parameters

Parameters

includes

Type Parameters

Parameters

Class ASeq<T>`Abstract`