doddle
Version:
Tiny yet feature-packed (async) iteration toolkit.
724 lines • 30.7 kB
TypeScript
import type { Doddle } from "../doddle/index.js";
import { type EachCallStage, type Get_Concat_Element_Type, type getWindowArgsType, type getWindowOutputType, type getZipValuesType, type SkipWhileOptions, type TakeWhileOptions } from "./common-types.js";
/**
* The Seq class, which wraps a synchronous iterable.
*
* @category Use
*/
export declare abstract class Seq<T> implements Iterable<T> {
flatMap: <S>(projection: Seq.Iteratee<T, Seq.Input<S>>) => Seq<Get_Concat_Element_Type<T, S>>;
/**
* Calls a side-effect function after all elements have been yielded, but before iteration
* finishes.
*
* ⚠️ If the client stops iterating early, the action won't be executed.
*
* @param action A function to invoke after iteration completes.
* @returns A new sequence that acts like `this` but invokes `action` before it's finished.
*/
after(action: Seq.NoInputAction): Seq<T>;
/**
* Reinterprets the declared element type of `this` as another, arbitrary type.
*
* ℹ️ This is only useful in TypeScript and has no runtime effects.
*
* @template S The new element type.
* @returns The same sequence, but with a different declared type.
*/
as<S>(): Seq<S>;
/**
* 🦥**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.
*
* @param index The index of the item to retrieve.
* @returns A 🦥{@link Doddle} that resolves to the item at the given index.
*/
at(index: number): Doddle<T | undefined>;
/**
* Executes a side effect action once before any elements are yielded, but after iteration has
* begun.
*
* @param action Invokes before any elements are yielded.
* @returns A new async sequence that performs `action` before yielding elements.
*/
before(action: Seq.NoInputAction): Seq<T>;
/**
* Caches the elements of `this` sequence as they're iterated over, so that it's evaluated only
* once.
*
* @returns A new sequence with the same elements as the original sequence.
*/
cache(): Seq<T>;
/**
* Handles errors thrown while iterating over `this` sequence.
*
* @param handler 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 A new sequence that handles errors.
*/
catch<S = T>(handler: Seq.Iteratee<unknown, Seq.Input<S> | void>): Seq<T | 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.
*
* @param size The size of each chunk.
* @param projection Optionally, an N-ary projection to apply to each chunk. Defaults to
* collecting the elements into an array.
* @returns A new sequence.
*/
chunk<L extends number, S = getWindowOutputType<T, L>>(size: L, projection?: (...window: getWindowArgsType<T, L>) => S | Doddle<S>): Seq<S>;
/**
* 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 A new sequence with the same elements as this one, but where iteration has already
* completed.
*/
collect(): Seq<T>;
/**
* Concatenates one or more sequences to the end of `this`, so that their elements appear in
* order.
*
* @param inputs The sequential inputs to concatenate to the end of `this`.
* @returns A new sequence with the concatenated elements.
*/
concat<Seqs extends Seq.Input<any>[]>(...inputs: Seqs): Seq<T | Seq.ElementOfInput<Seqs[number]>>;
/**
* Applies a sequence projection on each element of `this` sequence and concatenates the
* resulting sequences.
*
* @param projection The sequence projection to apply to each element.
* @returns A new sequence with the flattened results.
*/
concatMap<S>(projection: Seq.Iteratee<T, Seq.Input<S>>): Seq<Get_Concat_Element_Type<T, S>>;
/**
* Concatenates `this` sequence to the end of one or more other sequences.
*
* ℹ️ Input sequences are concatenated in the order that they appear.
*
* @param inputs One or more other sequences.
* @returns A new sequence with the concatenated elements.
* @see {@link Seq.concat}
*/
concatTo<Seqs extends Seq.Input<any>[]>(...inputs: Seqs): Seq<T | Seq.ElementOfInput<Seqs[number]>>;
/**
* 🦥**Lazily** counts the number of elements in `this` sequence.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @returns A 🦥{@link Doddle} that resolves to the number of elements in `this`.
*/
count(): Doddle<number>;
/**
* 🦥**Lazily** counts the number of elements in `this` sequence that match the given predicate.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @param predicate The predicate used to test each element.
* @returns A 🦥{@link Doddle} that resolves to the number of matching elements.
*/
count(predicate: Seq.Predicate<T>): Doddle<number>;
/**
* Calls an action function as each element in `this` is iterated over. Calls the function
* before or after yielding the element, or both.
*
* @param action The action function to invoke for each element.
* @param stage The **stage** at which to invoke the function. Can be `"before"`, `"after"`, or
* `"both"`.
* @returns A new sequence that invokes the action function while being iterated.
*/
each(action: Seq.StageIteratee<T, void>, stage?: EachCallStage | undefined): Seq<T>;
/**
* 🦥**Lazily** checks if all elements in `this` sequence match the given predicate.
*
* ⚠️ May iterate over the entire sequence.
*
* @param predicate The predicate.
* @returns A 🦥{@link Doddle} that yields `true` if all elements match, or `false` otherwise.
*/
every(predicate: Seq.Predicate<T>): Doddle<boolean>;
/**
* Filters the elements of `this` sequence based on the given type predicate, narrowing the type
* of the elements in the resulting sequence.
*
* @param predicate The predicate to filter elements.
* @returns A new sequence with the filtered elements, its type narrowed based on the predicate.
*/
filter<S extends T>(predicate: Seq.TypePredicate<T, S>): Seq<S>;
/**
* Filters the elements of `this` sequence based on the given predicate.
*
* @param predicate The predicate to filter elements.
* @returns A new sequence with the filtered elements.
*/
filter(predicate: Seq.Predicate<T>): Seq<T>;
/**
* 🦥**Lazily** finds the first element in `this` sequence, or `undefined` if it's empty.
*
* @returns A 🦥{@link Doddle} that resolves to the first element or the alternative value.
*/
first(): Doddle<T | undefined>;
/**
* 🦥**Lazily** finds the first element in `this` sequence that matches the given predicate.
*
* ⚠️ May iterate over the entire sequence.
*
* @param predicate The predicate used to find the element.
* @param alt The value to return if no element matches the predicate. Defaults to `undefined`.
*/
first<const Alt = undefined>(predicate: Seq.Predicate<T>, alt?: Alt): Doddle<T | Alt>;
/**
* 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.
*
* @param keyProjection The projection used to determine the key for each element.
* @returns A sequence of pairs.
*/
groupBy<K>(keyProjection: Seq.NoIndexIteratee<T, K>): Seq<Seq.Group<K, T>>;
/**
* 🦥**Lazily** checks if `this` sequence includes one or more values by iterating over it.
*
* ⚠️ May iterate over the entire sequence.
*
* @param values The values to check for inclusion.
*/
includes<T extends S, S>(this: Seq<T>, ...values: S[]): Doddle<boolean>;
/**
* 🦥**Lazily** checks if `this` sequence includes one or more values.
*
* ⚠️ May iterate over the entire sequence.
*
* @param values The values to check for inclusion.
*/
includes<S extends T>(...value: S[]): Doddle<boolean>;
/**
* 🦥**Lazily** joins the elements of `this` sequence into a single string, separated by the
* given separator.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @param separator The string to use as a separator between elements.
* @returns A 🦥{@link Doddle} that resolves to the joined string.
*/
join(separator?: string): Doddle<string>;
/**
* 🦥**Lazily** gets the last element in `this` sequence, or `undefined`.
*
* @returns A 🦥{@link Doddle} that resolves to the last element in `this` sequence, or
* `undefined`.
*/
last(): Doddle<T | undefined>;
/**
* 🦥**Lazily** finds the last element in `this` sequence that matches the given predicate.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @param predicate The predicate for testing each element.
* @param alt Optionally, the value to return if no matching value is found. Defaults to
* `undefined`.
* @returns A 🦥{@link Doddle} that resolves to the last matching element or the alternative
* value.
*/
last<const Alt = undefined>(predicate: Seq.Predicate<T>, alt?: Alt): Doddle<T | Alt>;
/**
* Applies a projection to each element of `this` sequence.
*
* @param projection The projection to apply to each element.
* @returns A new sequence with the projected elements.
*/
map<S>(projection: Seq.Iteratee<T, S>): Seq<S>;
/**
* 🦥**Lazily** finds the maximum element in `this` sequence by key, or the given alternative
* value if the sequence is empty.
*
* @param projection Projects each element into a key so it can be compared.
* @param alt The value to return if the sequence is empty. Defaults to `undefined`.
*/
maxBy<K, const Alt = undefined>(projection: Seq.Iteratee<T, K>, alt?: Alt): Doddle<T | Alt>;
/**
* 🦥**Lazily** finds the minimum element in `this` sequence by key, or the given alternative
* value if the sequence is empty.
*
* @param projection Projects each element into a key so it can be compared.
* @param alt The value to return if the sequence is empty. Defaults to `undefined`.
* @returns A 🦥{@link Doddle} that resolves to the element with the minimum key, or `alt` if the
* sequence is empty.
*/
minBy<K, const Alt = undefined>(projection: Seq.Iteratee<T, K>, alt?: Alt): Doddle<T | Alt>;
/**
* Orders the elements of `this` sequence by key, using the given key projection.
*
* ⚠️ Has to iterate over the entire sequence.
*
* @param projection A projection that returns a key to order by.
* @param descending Whether to use descending order.
* @returns A new sequence with the elements ordered by the given key.
*/
orderBy<K>(projection: Seq.NoIndexIteratee<T, K>, descending?: boolean): Seq<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.
*
* @param projection A projection function that returns a tuple of keys to order by.
* @param descending Whether to use descending order.
* @returns A new sequence with the elements ordered by the given keys.
*/
orderBy<K extends [unknown, ...unknown[]]>(projection: Seq.NoIndexIteratee<T, K>, descending?: boolean): Seq<T>;
/**
* 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:
*
* ```ts
* ;[
* [1, 3],
* [1, 4],
* [2, 3],
* [2, 4]
* ]
* ```
*
* @example
* seq([1, 2]).product([3, 4])
* // => [[1, 3], [1, 4], [2, 3], [2, 4]]
* seq([]).product([3, 4])
* // => []
* seq([1, 2]).product([3, 4], (a, b) => a + b)
* // => [4, 5, 5, 6]
*
* @param others One or more sequence-like inputs for the product.
* @param projection Optionally, an N-ary projection to apply to each combination of elements.
* If not given, each combination is yielded as an array.
* @returns A new sequence.
*/
product<Xs extends any[], R = [T, ...Xs]>(_others: {
[K in keyof Xs]: Seq.Input<Xs[K]>;
}, projection?: (...args: [T, ...Xs]) => R): Seq<R>;
/**
* 🦥**Lazily** reduces `this` sequence to a single value by applying the given reduction.
*
* ℹ️ Uses the first element as the initial value.
*
* @param reduction The reduction function to apply to each element.
* @returns A 🦥{@link Doddle} that resolves to the reduced value.
*/
reduce(reduction: Seq.Reduction<T, T>): Doddle<T>;
/**
* 🦥**Lazily** reduces `this` sequence to a single value by applying the given reduction.
*
* ℹ️ You need to supply an initial value.
*
* @param reducer The reduction to apply to each element.
* @param initial The initial value to start the reduction with.
*/
reduce<Acc>(reducer: Seq.Reduction<T, Acc>, initial: Acc): Doddle<Acc>;
/**
* Reverses `this` sequence.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @returns A new sequence with the elements in reverse order.
*/
reverse(): Seq<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.
*
* @param reduction The reduction function to apply.
* @returns A new sequence with the accumulated values.
* @throws If `this` is empty.
*/
scan(reduction: Seq.Reduction<T, T>): Seq<T>;
/**
* 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.
*
* @param reduction The reduction to apply.
* @param initial The initial value to start the reduction with.
*/
scan<Acc>(reduction: Seq.Reduction<T, Acc>, initial: Acc): Seq<Acc>;
/**
* 🦥**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.
*
* @param input The sequence-like input to compare with.
* @param projection The projection function that determines the key for comparison.
* @returns A 🦥{@link Doddle} that resolves to `true` if all elements are equal, or `false`
*/
seqEquals<T extends S, S>(this: Seq<T>, input: Seq.Input<S>): Doddle<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.
*
* @param input The sequence-like input to compare with.
* @param projection The projection function that determines the key for comparison.
* @returns A 🦥{@link Doddle} that resolves to `true` if all elements are equal, or `false`
*/
seqEquals<S extends T>(input: Seq.Input<S>): Doddle<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.
*
* @param input The sequence-like input to compare with.
* @param projection The projection function that determines the key for comparison.
* @returns A 🦥{@link Doddle} that resolves to `true` if all elements are equal, or `false`
*/
seqEquals<K, S = T>(input: Seq.Input<S>, projection: Seq.NoIndexIteratee<S | T, K>): Doddle<boolean>;
/**
* 🦥**Lazily** checks if `this` sequence contains the same elements as the input sequence,
* without regard to order.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @param input The sequence-like input to compare with.
* @returns A 🦥{@link Doddle} that resolves to `true` if `this` is set-equal to the input, or
* `false` otherwise.
*/
setEquals<T extends S, S>(this: Seq<T>, input: Seq.Input<S>): Doddle<boolean>;
/**
* 🦥**Lazily** checks if `this` sequence contains the same elements as the input sequence,
* without regard to order.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @param input The sequence-like input to compare with.
* @returns A 🦥{@link Doddle} that resolves to `true` if `this` is set-equal to the input, or
* `false` otherwise.
*/
setEquals<S extends T>(input: Seq.Input<S>): Doddle<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.
*
* @param input The sequence-like input to compare with.
* @param projection The projection function that determines the key for comparison.
* @returns A 🦥{@link Doddle} that resolves to `true` if `this` is set-equal to the input, or
* `false` otherwise.
*/
setEquals<K, S = T>(input: Seq.Input<S>, projection: Seq.NoIndexIteratee<S | T, K>): Doddle<boolean>;
/**
* 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 A new, shared iterable sequence that can be iterated over exactly once.
*/
share(): Seq<T>;
/**
* Shuffles the elements of `this` sequence randomly.
*
* ⚠️ Requires iterating over the entire sequence.
*
* @returns A new sequence with the shuffled elements.
*/
shuffle(): Seq<T>;
/**
* Skips the first `count` elements of `this` sequence, yielding the rest.
*
* ℹ️ If `count` is negative, skips the final elements instead (e.g. `skipLast`)
*
* @param count The number of elements to skip.
* @returns A new sequence without the skipped elements.
*/
skip(count: number): Seq<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`.
*
* @param predicate The predicate to determine whether to continue skipping.
* @param options Options for skipping behavior.
* @returns A new sequence without the skipped elements.
*/
skipWhile(predicate: Seq.Predicate<T>, options?: SkipWhileOptions): Seq<T>;
/**
* 🦥**Lazily** checks if any element in `this` sequence matches the given predicate, by
* iterating over it until a match is found.
*
* @param predicate The predicate to match the element.
* @returns A 🦥{@link Doddle} that resolves to `true` if any element matches, or `false`
* otherwise.
*/
some(predicate: Seq.Predicate<T>): Doddle<boolean>;
/**
* 🦥**Lazily** sums the elements of `this` sequence by iterating over it, applying the given
* projection to each element.
*
* @param projection The projection function to apply to each element.
* @returns A 🦥{@link Doddle} that resolves to the sum of the projected elements.
*/
sumBy(projection: Seq.Iteratee<T, number>): Doddle<number>;
/**
* 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.
*
* @param count The number of elements to yield.
* @returns A new sequence with the yielded elements.
*/
take(count: number): Seq<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`.
*
* @param predicate The predicate to determine whether to continue yielding.
* @param options Extra options.
* @returns A new sequence with the yielded elements.
*/
takeWhile(predicate: Seq.Predicate<T>, options?: TakeWhileOptions): Seq<T>;
/**
* 🦥**Lazily** converts `this` sequence into an array.
*
* ⚠️ Has to iterate over the entire sequence.
*
* @returns A 🦥{@link Doddle} that resolves to an array.
*/
toArray(): Doddle<T[]>;
/**
* Returns `this` sequence as an {@link Iterable}.
*
* @returns An {@link Iterable} of the elements in this sequence.
*/
toIterable(): Iterable<T>;
/**
* 🦥**Lazily** converts `this` sequence into a Map.
*
* ⚠️ Has to iterate over the entire sequence.
*
* @param kvpProjection A function that takes an element and returns a key-value pair.
* @returns A 🦥{@link Doddle} that resolves to a Map of the elements in the sequence.
*/
toMap<Pair extends readonly [any, any]>(kvpProjection: Seq.Iteratee<T, Pair>): Doddle<Map<Pair[0], Pair[1]>>;
/**
* 🦥**Lazily** converts `this` sequence into a plain JS object. Uses the given `kvpProjection`
* to determine each key-value pair.
*
* @param kvpProjection A function that takes an element and returns a key-value pair. Each key
* must be a valid PropertyKey.
* @returns A 🦥{@link Doddle} that resolves to a plain JS object.
*/
toRecord<const Key extends PropertyKey, Value>(kvpProjection: Seq.Iteratee<T, readonly [Key, Value]>): Doddle<{
[k in Key]: Value;
}>;
/**
* 🦥**Lazily** converts `this` sequence into a Set.
*
* ⚠️ Has to iterate over the entire sequence.
*
* @returns A 🦥{@link Doddle} that resolves to a Set of the elements in the sequence.
*/
toSet(): Doddle<Set<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.
*
* @param keyProjection A function that takes an element and returns a key used to check for
* uniqueness.
* @returns A sequence of unique elements.
*/
uniq(keyProjection?: Seq.NoIndexIteratee<T, any>): Seq<T>;
/**
* 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.
*
* @param size The size of each window.
* @param projection A function to project each window to a value.
* @returns A new sequence of windows or projected results.
*/
window<L extends number, S>(size: L, projection: (...window: getWindowArgsType<T, L>) => S | Doddle<S>): Seq<S>;
/**
* Splits `this` async sequence into overlapping windows of fixed size.
*
* ℹ️ If the sequence is smaller than the window size, one smaller window will yielded.
*
* @param size The size of each window.
* @returns A new sequence of windows.
*/
window<L extends number>(size: L): Seq<getWindowOutputType<T, L>>;
/**
* 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.
*
* @param others An array of other sequence inputs to zip with.
* @returns A new async sequence of tuples containing parallel elements.
*/
zip<Xs extends [any, ...any[]]>(others: {
[K in keyof Xs]: Seq.Input<Xs[K]>;
}): Seq<getZipValuesType<[T, ...Xs]>>;
/**
* 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.
*
* @param others An array of other sequence inputs to zip with.
* @returns A new sequence of elements generated from the zipped values.
*/
zip<Xs extends [any, ...any[]], R>(others: {
[K in keyof Xs]: Seq.Input<Xs[K]>;
}, projection: (...args: getZipValuesType<[T, ...Xs]>) => R): Seq<R>;
/** @ignore */
abstract [Symbol.iterator](): Iterator<T>;
}
/**
* Types associated with the {@link Seq} class.
*
* @category Types
*/
export declare namespace Seq {
/**
* A type that can be either a value or a {@link Doddle} of that value
*
* @inline
*/
type MaybeDoddle<Value> = Value | Doddle<Value>;
/**
* An iteratee that receives only the index and returns a value or promise of a value.
*
* ℹ️ Useful for operations that depend solely on element position.
*
* @template O The output type.
* @inline
*/
export type ElementOfInput<SeqLike> = SeqLike extends Input<infer Element> ? Element : never;
/**
* An iteratee that receives consecutive indexes, not elements. Used for generating sequences.
*
* @template Out The element type of the sequence.
* @inline
*/
export type IndexIteratee<Out> = (index: number) => MaybeDoddle<Out>;
/**
* A function applied to each element and its index, producing a value or promise of a value.
*
* ℹ️ Used in most transformation and filtering operations.
*
* @template E The input element type.
* @template O The output value type.
* @inline
*/
export type Iteratee<In, Out> = (element: In, index: number) => MaybeDoddle<Out>;
/**
* An iteratee that ignores the index and returns a value or promise.
*
* ℹ️ Used for operations that ignore the index, such as some key projections.
*
* @template E The input element type.
* @template O The output value type.
* @inline
*/
export type NoIndexIteratee<In, Out> = (element: In) => MaybeDoddle<Out>;
/**
* A function called at stages "before" or "after" yielding an element.
*
* ℹ️ Used for operations that call side-effect functions.
*
* @template E The input element type.
* @template O The output type, typically used for side-effects.
* @inline
*/
export type StageIteratee<In, Out> = (element: In, index: number, stage: "before" | "after") => Out;
/**
* A predicate function over elements, returning boolean or promise of boolean.
*
* ℹ️ Used for filtering, counting, or skipping elements based on a condition.
*
* @template E The input element type.
* @inline
*/
export type Predicate<In> = Iteratee<In, boolean>;
/**
* A type predicate {@link Iteratee}. When filtering, narrows the element type.
*
* @template In The input element type.
* @template Narrowed The narrowed element type.
* @inline
*/
export type TypePredicate<In, Narrowed extends In> = (element: In, index: number) => element is Narrowed;
/**
* A reducer function combining an accumulator and element to produce a new accumulator.
*
* ℹ️ Used in operations like `reduce` or `scan` to accumulate results.
*
* @template E The element type.
* @template O The accumulator type.
* @inline
*/
export type Reduction<In, Result> = (acc: Result, element: In, index: number) => MaybeDoddle<Result>;
/**
* A function that returns a sequence or iterator, possibly asynchronously.
*
* ℹ️ Used in conversions to {@link Seq}.
*
* @template E The element type.
*/
export type FunctionInput<Item> = () => MaybeDoddle<ObjectIterable<MaybeDoddle<Item>>>;
/**
* An Iterable, Iterator, or ArrayLike but **not** a `string`.
*
* ℹ️ Used in conversions to {@link Seq}.
*
* @template Item The element type of the iterable.
*/
export type ObjectIterable<Item> = object & (Iterable<Item> | Iterator<Item> | ArrayLike<Item>);
/**
* The general input type for a sequence.s
*
* @template E The element type (may be a promise of something).
*/
export type Input<Item> = MaybeDoddle<ObjectIterable<Item>> | FunctionInput<Item>;
/**
* A zero-argument action for side-effects that may return a doddle-wrapped value.
*
* @inline
*/
export type NoInputAction = () => unknown | Doddle<unknown>;
/**
* A grouped output pairing a key with a sub-sequence of elements.
*
* @template K The group key type.
* @template T The element type within the group.
* @inline
*/
export type Group<Key, Val> = readonly [Key, Seq<Val>];
export {};
}
//# sourceMappingURL=seq.class.d.ts.map