semantic-typescript 0.5.0 → 0.6.0

package/dist/asynchronous/collector.d.ts

@@ -0,0 +1,231 @@
+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>;
+    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 UseSynchronousAnyMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousAnyMatch: UseSynchronousAnyMatch;
+interface UseSynchronousAllMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousAllMatch: UseSynchronousAllMatch;
+interface UseSynchronousCollect {
+    <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: UseSynchronousCollect;
+export declare let useAsynchronousCount: <E = unknown>() => AsynchronousCollector<E, bigint, bigint>;
+interface UseSynchronousError {
+    <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: UseSynchronousError;
+interface UseSynchronousFindAt {
+    <E>(index: number): AsynchronousCollector<E, Array<E>, Promise<E>>;
+    <E>(index: bigint): AsynchronousCollector<E, Array<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindAt: UseSynchronousFindAt;
+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 UseSynchronousFindMaximum {
+    <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindMaximum: UseSynchronousFindMaximum;
+interface UseSynchronousFindMinimum {
+    <E>(): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+    <E>(comparator: Comparator<E>): AsynchronousCollector<E, Promise<E>, Promise<E>>;
+}
+export declare let useAsynchronousFindMinimum: UseSynchronousFindMinimum;
+interface UseSynchronousForEach {
+    <E>(action: Consumer<E>): AsynchronousCollector<E, bigint, bigint>;
+    <E>(action: BiConsumer<E, bigint>): AsynchronousCollector<E, bigint, bigint>;
+}
+export declare let useAsynchronousForEach: UseSynchronousForEach;
+interface UseSynchronousNonMatch {
+    <E>(predicate: Predicate<E>): AsynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): AsynchronousCollector<E, boolean, boolean>;
+}
+export declare let useAsynchronousNoneMatch: UseSynchronousNonMatch;
+interface UseSynchronousGroup {
+    <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: UseSynchronousGroup;
+interface UseSynchronousGroupBy {
+    <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: UseSynchronousGroupBy;
+interface UseSynchronousJoin {
+    <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: UseSynchronousJoin;
+interface UseSynchronousLog {
+    <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: UseSynchronousLog;
+export declare let useAsynchronousPartition: <E>(count: bigint) => AsynchronousCollector<E, Array<Array<E>>, Array<Array<E>>>;
+interface UseSynchronousPartitionBy {
+    <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: UseSynchronousPartitionBy;
+interface UseSynchronousReduce {
+    <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: UseSynchronousReduce;
+export declare let useAsynchronousToArray: <E>() => AsynchronousCollector<E, E[], E[]>;
+interface UseSynchronousToMap {
+    <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: UseSynchronousToMap;
+export declare let useAsynchronousToSet: <E>() => AsynchronousCollector<E, Set<E>, Set<E>>;
+interface UseSynchronousWrite {
+    <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: UseSynchronousWrite;
+interface UseSynchronousNumericSummate {
+    <E>(): AsynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<number, number, number>;
+}
+export declare let useAsynchronousNumericSummate: UseSynchronousNumericSummate;
+interface UseSynchronousBigIntSummate {
+    <E>(): AsynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<bigint, bigint, bigint>;
+}
+export declare let useAsynchronousBigIntSummate: UseSynchronousBigIntSummate;
+interface UseSynchronousNumericAverage {
+    <E>(): AsynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<number, NumericAverageAccumulator, number>;
+}
+interface NumericAverageAccumulator {
+    summate: number;
+    count: number;
+}
+export declare let useAsynchronousNumericAverage: UseSynchronousNumericAverage;
+interface UseSynchronousBigIntAverage {
+    <E>(): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+}
+interface BigIntAverageAccumulator {
+    summate: bigint;
+    count: bigint;
+}
+export declare let useAsynchronousBigIntAverage: UseSynchronousBigIntAverage;
+export declare let useAsynchronousFrequency: <E>() => AsynchronousCollector<E, Map<E, bigint>, Map<E, bigint>>;
+interface UseSynchronousNumericMode {
+    <E>(): AsynchronousCollector<E, Map<number, bigint>, number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, Map<number, bigint>, number>;
+}
+export declare let useAsynchronousNumericMode: UseSynchronousNumericMode;
+interface UseSynchronousBigIntMode {
+    <E>(): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, Map<bigint, bigint>, bigint>;
+}
+export declare let useAsynchronousBigIntMode: UseSynchronousBigIntMode;
+interface UseSynchronousNumericVariance {
+    <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: UseSynchronousNumericVariance;
+interface UseSynchronousBigIntVariance {
+    <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: UseSynchronousBigIntVariance;
+interface UseSynchronousNumericStandardDeviation {
+    <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: UseSynchronousNumericStandardDeviation;
+interface UseSynchronousBigIntStandardDeviation {
+    <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: UseSynchronousBigIntStandardDeviation;
+interface UseSynchronousNumericMedian {
+    <E>(): AsynchronousCollector<E, number[], number>;
+    <E>(mapper: Functional<E, number>): AsynchronousCollector<E, number[], number>;
+}
+export declare let useAsynchronousNumericMedian: UseSynchronousNumericMedian;
+interface UseSynchronousBigIntMedian {
+    <E>(): AsynchronousCollector<E, bigint[], bigint>;
+    <E>(mapper: Functional<E, bigint>): AsynchronousCollector<E, bigint[], bigint>;
+}
+export declare let useAsynchronousBigIntMedian: UseSynchronousBigIntMedian;
+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 {};