semantic-typescript 0.5.0 → 0.6.0

package/dist/synchronous/collector.d.ts

@@ -0,0 +1,232 @@
+import { Optional } from "../optional";
+import type { Supplier, Predicate, BiPredicate, TriPredicate, BiFunctional, TriFunctional, Functional, SynchronousGenerator, Comparator, Consumer, BiConsumer } from "../utility";
+export declare class SynchronousCollector<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 SynchronousCollector: 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: SynchronousGenerator<E>): R;
+    collect(iterable: Iterable<E>): R;
+    collect(start: number, end: number): R;
+    collect(start: bigint, end: bigint): R;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<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>): SynchronousCollector<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>): SynchronousCollector<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>): SynchronousCollector<E, A, R>;
+}
+interface UseSynchronousAnyMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousAnyMatch: UseSynchronousAnyMatch;
+interface UseSynchronousAllMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousAllMatch: UseSynchronousAllMatch;
+interface UseSynchronousCollect {
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): SynchronousCollector<E, A, R>;
+}
+export declare let useSynchronousCollect: UseSynchronousCollect;
+export declare let useSynchronousCount: <E = unknown>() => SynchronousCollector<E, bigint, bigint>;
+interface UseSynchronousError {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousError: UseSynchronousError;
+interface UseSynchronousFindAt {
+    <E>(index: number): SynchronousCollector<E, Array<E>, Optional<E>>;
+    <E>(index: bigint): SynchronousCollector<E, Array<E>, Optional<E>>;
+}
+export declare let useSynchronousFindAt: UseSynchronousFindAt;
+export declare let useSynchronousFindFirst: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+export declare let useSynchronousFindAny: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+export declare let useSynchronousFindLast: <E>() => SynchronousCollector<E, Optional<E>, Optional<E>>;
+interface UseSynchronousFindMaximum {
+    <E>(): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+}
+export declare let useSynchronousFindMaximum: UseSynchronousFindMaximum;
+interface UseSynchronousFindMinimum {
+    <E>(): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(comparator: Comparator<E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+}
+export declare let useSynchronousFindMinimum: UseSynchronousFindMinimum;
+interface UseSynchronousForEach {
+    <E>(action: Consumer<E>): SynchronousCollector<E, bigint, bigint>;
+    <E>(action: BiConsumer<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+}
+export declare let useSynchronousForEach: UseSynchronousForEach;
+interface UseSynchronousNonMatch {
+    <E>(predicate: Predicate<E>): SynchronousCollector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): SynchronousCollector<E, boolean, boolean>;
+}
+export declare let useSynchronousNoneMatch: UseSynchronousNonMatch;
+interface UseSynchronousGroup {
+    <E, K>(classifier: Functional<E, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K>(classifier: BiFunctional<E, bigint, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+}
+export declare let useSynchronousGroup: UseSynchronousGroup;
+interface UseSynchronousGroupBy {
+    <E, K>(keyExtractor: Functional<E, K>): SynchronousCollector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): SynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): SynchronousCollector<E, Map<K, V[]>, Map<K, V[]>>;
+}
+export declare let useSynchronousGroupBy: UseSynchronousGroupBy;
+interface UseSynchronousJoin {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(delimiter: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, delimiter: string, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousJoin: UseSynchronousJoin;
+interface UseSynchronousLog {
+    <E = unknown>(): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): SynchronousCollector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): SynchronousCollector<E, string, string>;
+}
+export declare let useSynchronousLog: UseSynchronousLog;
+export declare let useSynchronousPartition: <E>(count: bigint) => SynchronousCollector<E, Array<Array<E>>, Array<Array<E>>>;
+interface UseSynchronousPartitionBy {
+    <E>(classifier: Functional<E, bigint>): SynchronousCollector<E, Array<E[]>, Array<E[]>>;
+    <E>(classifier: BiFunctional<E, bigint, bigint>): SynchronousCollector<E, Array<E[]>, Array<E[]>>;
+}
+export declare let useSynchronousPartitionBy: UseSynchronousPartitionBy;
+interface UseSynchronousReduce {
+    <E>(accumulator: BiFunctional<E, E, E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(accumulator: TriFunctional<E, E, bigint, E>): SynchronousCollector<E, Optional<E>, Optional<E>>;
+    <E>(identity: E, accumulator: BiFunctional<E, E, E>): SynchronousCollector<E, E, E>;
+    <E>(identity: E, accumulator: TriFunctional<E, E, bigint, E>): SynchronousCollector<E, E, E>;
+    <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): SynchronousCollector<E, R, R>;
+    <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): SynchronousCollector<E, R, R>;
+}
+export declare let useSynchronousReduce: UseSynchronousReduce;
+export declare let useSynchronousToArray: <E>() => SynchronousCollector<E, E[], E[]>;
+interface UseSynchronousToMap {
+    <E, K>(keyExtractor: Functional<E, K>): SynchronousCollector<E, Map<K, E>, Map<K, E>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): SynchronousCollector<E, Map<K, V>, Map<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): SynchronousCollector<E, Map<K, V>, Map<K, V>>;
+}
+export declare let useSynchronousToMap: UseSynchronousToMap;
+export declare let useSynchronousToSet: <E>() => SynchronousCollector<E, Set<E>, Set<E>>;
+interface UseSynchronousWrite {
+    <E, S = string>(stream: WritableStream<S>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): SynchronousCollector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+}
+export declare let useSynchronousWrite: UseSynchronousWrite;
+interface UseSynchronousNumericSummate {
+    <E>(): SynchronousCollector<E, number, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number, number>;
+}
+export declare let useSynchronousNumericSummate: UseSynchronousNumericSummate;
+interface UseSynchronousBigIntSummate {
+    <E>(): SynchronousCollector<E, bigint, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint, bigint>;
+}
+export declare let useSynchronousBigIntSummate: UseSynchronousBigIntSummate;
+interface UseSynchronousNumericAverage {
+    <E>(): SynchronousCollector<E, NumericAverageAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, NumericAverageAccumulator, number>;
+}
+interface NumericAverageAccumulator {
+    summate: number;
+    count: number;
+}
+export declare let useSynchronousNumericAverage: UseSynchronousNumericAverage;
+interface UseSynchronousBigIntAverage {
+    <E>(): SynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntAverageAccumulator, bigint>;
+}
+interface BigIntAverageAccumulator {
+    summate: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntAverage: UseSynchronousBigIntAverage;
+export declare let useSynchronousFrequency: <E>() => SynchronousCollector<E, Map<E, bigint>, Map<E, bigint>>;
+interface UseSynchronousNumericMode {
+    <E>(): SynchronousCollector<E, Map<number, bigint>, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, Map<number, bigint>, number>;
+}
+export declare let useSynchronousNumericMode: UseSynchronousNumericMode;
+interface UseSynchronousBigIntMode {
+    <E>(): SynchronousCollector<E, Map<bigint, bigint>, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, Map<bigint, bigint>, bigint>;
+}
+export declare let useSynchronousBigIntMode: UseSynchronousBigIntMode;
+interface UseSynchronousNumericVariance {
+    <E>(): SynchronousCollector<E, VarianceAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, VarianceAccumulator, number>;
+}
+interface VarianceAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useSynchronousNumericVariance: UseSynchronousNumericVariance;
+interface UseSynchronousBigIntVariance {
+    <E>(): SynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntVarianceAccumulator, bigint>;
+}
+interface BigIntVarianceAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntVariance: UseSynchronousBigIntVariance;
+interface UseSynchronousNumericStandardDeviation {
+    <E>(): SynchronousCollector<E, StandardDeviationAccumulator, number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, StandardDeviationAccumulator, number>;
+}
+interface StandardDeviationAccumulator {
+    summate: number;
+    summateOfSquares: number;
+    count: number;
+}
+export declare let useSynchronousNumericStandardDeviation: UseSynchronousNumericStandardDeviation;
+interface UseSynchronousBigIntStandardDeviation {
+    <E>(): SynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, BigIntStandardDeviationAccumulator, bigint>;
+}
+interface BigIntStandardDeviationAccumulator {
+    summate: bigint;
+    summateOfSquares: bigint;
+    count: bigint;
+}
+export declare let useSynchronousBigIntStandardDeviation: UseSynchronousBigIntStandardDeviation;
+interface UseSynchronousNumericMedian {
+    <E>(): SynchronousCollector<E, number[], number>;
+    <E>(mapper: Functional<E, number>): SynchronousCollector<E, number[], number>;
+}
+export declare let useSynchronousNumericMedian: UseSynchronousNumericMedian;
+interface UseSynchronousBigIntMedian {
+    <E>(): SynchronousCollector<E, bigint[], bigint>;
+    <E>(mapper: Functional<E, bigint>): SynchronousCollector<E, bigint[], bigint>;
+}
+export declare let useSynchronousBigIntMedian: UseSynchronousBigIntMedian;
+export declare let useSynchronousToGeneratorFunction: <E>() => SynchronousCollector<E, Array<E>, globalThis.Generator<E, void, undefined>>;
+export declare let useSynchronousToAsyncGeneratorFunction: <E>() => SynchronousCollector<E, Array<E>, globalThis.AsyncGenerator<E, void, undefined>>;
+export {};