semantic-typescript 0.5.3 → 0.7.0

package/dist/asynchronous/collector.d.ts

@@ -0,0 +1,235 @@
+import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, TriPredicate, Consumer, BiConsumer, Comparator, AsynchronousGenerator } from "../utility";
+export declare class AsynchronousCollector<E, A, R> {
+    protected identity: Supplier<A>;
+    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    protected finisher: Functional<A, R>;
+    protected readonly AsynchronousCollector: symbol;
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>);
+    collect(generator: AsynchronousGenerator<E>): Promise<R>;
+    collect(iterable: AsyncIterable<E>): Promise<R>;
+    collect(start: number, end: number): Promise<R>;
+    collect(start: bigint, end: bigint): Promise<R>;
+    getIdentity(): Supplier<A>;
+    getInterrupt(): Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    getAccumulator(): BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    getFinisher(): Functional<A, R>;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+}
+interface UseAsynchronousAnyMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousAnyMatch: UseAsynchronousAnyMatch;
+interface UseAsynchronousAllMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousAllMatch: UseAsynchronousAllMatch;
+interface UseAsynchronousCollect {
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): AsynchronousCollector<E, A, R>;
+}
+export declare let useAsynchronousCollect: UseAsynchronousCollect;
+export declare let useAsynchronousCount: <E = unknown>() => AsynchronousCollector<E, bigint, bigint>;
+interface UseAsynchronousError {
+    <E = unknown>(): AsynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): AsynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
+}
+export declare let useAsynchronousError: UseAsynchronousError;
+interface UseAsynchronousFindAt {
+    <E>(index: number): AsynchronousCollector<E, Array<E>, Promise<E>>;
+    <E>(index: bigint): AsynchronousCollector<E, Array<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindAt: UseAsynchronousFindAt;
+export declare let useAsynchronousFindFirst: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;
+export declare let useAsynchronousFindAny: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;
+export declare let useAsynchronousFindLast: <E>() => AsynchronousCollector<E, Array<E>, Promise<E>>;
+interface UseAsynchronousFindMaximum {
+    <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindMaximum: UseAsynchronousFindMaximum;
+interface UseAsynchronousFindMinimum {
+    <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindMinimum: UseAsynchronousFindMinimum;
+interface UseAsynchronousForEach {
+    <E>(action: Consumer<E>): AsynchronousCollector<E, bigint, bigint>;
+    <E>(action: BiConsumer<E, bigint>): AsynchronousCollector<E, bigint, bigint>;
+}
+export declare let useAsynchronousForEach: UseAsynchronousForEach;
+interface UseAsynchronousNonMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousNoneMatch: UseAsynchronousNonMatch;
+interface UseAsynchronousGroup {
+    <E, K>(classifier: Functional<E, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K>(classifier: BiFunctional<E, bigint, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+}
+export declare let useAsynchronousGroup: UseAsynchronousGroup;
+interface UseAsynchronousGroupBy {
+    <E, K>(keyExtractor: Functional<E, K>): AsynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): AsynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): AsynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+}
+export declare let useAsynchronousGroupBy: UseAsynchronousGroupBy;
+interface UseAsynchronousJoin {
+    <E = unknown>(): AsynchronousCollector<E, string, string>;
+    <E = unknown>(delimiter: string): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, delimiter: string, suffix: string): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
+}
+export declare let useAsynchronousJoin: UseAsynchronousJoin;
+interface UseAsynchronousLog {
+    <E = unknown>(): AsynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): AsynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): AsynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): AsynchronousCollector<E, string, string>;
+}
+export declare let useAsynchronousLog: UseAsynchronousLog;
+export declare let useAsynchronousPartition: <E>(count: bigint) => AsynchronousCollector<E, Array<Array<E>>, Array<Array<E>>>;
+interface UseAsynchronousPartitionBy {
+    <E>(classifier: Functional<E, bigint>): AsynchronousCollector<E, Array<E[]>, Array<E[]>>;
+    <E>(classifier: BiFunctional<E, bigint, bigint>): AsynchronousCollector<E, Array<E[]>, Array<E[]>>;
+}
+export declare let useAsynchronousPartitionBy: UseAsynchronousPartitionBy;
+interface UseAsynchronousReduce {
+    <E>(accumulator: BiFunctional<E, E, E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(accumulator: TriFunctional<E, E, bigint, E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(identity: E, accumulator: BiFunctional<E, E, E>): AsynchronousCollector<E, E, E>;
+    <E>(identity: E, accumulator: TriFunctional<E, E, bigint, E>): AsynchronousCollector<E, E, E>;
+    <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): AsynchronousCollector<E, R, R>;
+    <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): AsynchronousCollector<E, R, R>;
+}
+export declare let useAsynchronousReduce: UseAsynchronousReduce;
+export declare let useAsynchronousToArray: <E>() => AsynchronousCollector<E, E[], E[]>;
+interface UseAsynchronousToMap {
+    <E, K>(keyExtractor: Functional<E, K>): AsynchronousCollector<E, Map<K, E>, Map<K, E>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): AsynchronousCollector<E, Map<K, V>, Map<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): AsynchronousCollector<E, Map<K, V>, Map<K, V>>;
+}
+export declare let useAsynchronousToMap: UseAsynchronousToMap;
+export declare let useAsynchronousToSet: <E>() => AsynchronousCollector<E, Set<E>, Set<E>>;
+interface UseAsynchronousWrite {
+    <E, S = string>(stream: WritableStream<S>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): AsynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+}
+export declare let useAsynchronousWrite: UseAsynchronousWrite;
+interface UseAsynchronousNumericSummate {
+    <E>(): AsynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<number, number, number>;
+}
+export declare let useAsynchronousNumericSummate: UseAsynchronousNumericSummate;
+interface UseAsynchronousBigIntSummate {
+    <E>(): AsynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<bigint, bigint, bigint>;
+}
+export declare let useAsynchronousBigIntSummate: UseAsynchronousBigIntSummate;
+interface UseAsynchronousNumericAverage {
+    <E>(): AsynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<number, NumericAverageAccumulator, number>;
+}
+interface NumericAverageAccumulator {
+    summate: number;
+    count: number;
+}
+export declare let useAsynchronousNumericAverage: UseAsynchronousNumericAverage;
+interface UseAsynchronousBigIntAverage {
+    <E>(): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+}
+interface BigIntAverageAccumulator {
+    summate: bigint;
+    count: bigint;
+}
+export declare let useAsynchronousBigIntAverage: UseAsynchronousBigIntAverage;
+export declare let useAsynchronousFrequency: <E>() => AsynchronousCollector<E, Map<E, bigint>, Map<E, bigint>>;
+interface UseAsynchronousNumericMode {
+    <E>(): AsynchronousCollector<E, Map<number, bigint>, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, Map<number, bigint>, number>;
+}
+export declare let useAsynchronousNumericMode: UseAsynchronousNumericMode;
+interface UseAsynchronousBigIntMode {
+    <E>(): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
+}
+export declare let useAsynchronousBigIntMode: UseAsynchronousBigIntMode;
+interface UseAsynchronousNumericVariance {
+    <E>(): AsynchronousCollector<E, VarianceAccumulator, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, VarianceAccumulator, number>;
+}
+interface VarianceAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useAsynchronousNumericVariance: UseAsynchronousNumericVariance;
+interface UseAsynchronousBigIntVariance {
+    <E>(): AsynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+}
+interface BigIntVarianceAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useAsynchronousBigIntVariance: UseAsynchronousBigIntVariance;
+interface UseAsynchronousNumericStandardDeviation {
+    <E>(): AsynchronousCollector<E, StandardDeviationAccumulator, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, StandardDeviationAccumulator, number>;
+}
+interface StandardDeviationAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useAsynchronousNumericStandardDeviation: UseAsynchronousNumericStandardDeviation;
+interface UseAsynchronousBigIntStandardDeviation {
+    <E>(): AsynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+}
+interface BigIntStandardDeviationAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useAsynchronousBigIntStandardDeviation: UseAsynchronousBigIntStandardDeviation;
+interface UseAsynchronousNumericMedian {
+    <E>(): AsynchronousCollector<E, number[], number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, number[], number>;
+}
+export declare let useAsynchronousNumericMedian: UseAsynchronousNumericMedian;
+interface UseAsynchronousBigIntMedian {
+    <E>(): AsynchronousCollector<E, bigint[], bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, bigint[], bigint>;
+}
+export declare let useAsynchronousBigIntMedian: UseAsynchronousBigIntMedian;
+export declare let useAsynchronousToGeneratorFunction: <E>() => AsynchronousCollector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
+export declare let useAsynchronousToAsyncGeneratorFunction: <E>() => AsynchronousCollector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
+export {};