semantic-typescript 0.2.9 → 0.3.1

package/dist/collectable.d.ts

@@ -17,6 +17,11 @@ export declare abstract class Collectable<E> {
     collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
     collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
     count(): bigint;
+    error(): void;
+    error(accumulator: BiFunctional<string, E, string>): void;
+    error(accumulator: TriFunctional<string, E, bigint, string>): void;
+    error(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
+    error(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
     isEmpty(): boolean;
     findAny(): Optional<E>;
     findFirst(): Optional<E>;
@@ -32,7 +37,7 @@ export declare abstract class Collectable<E> {
     join(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): string;
     log(): void;
     log(accumulator: BiFunctional<string, E, string>): void;
-    log(accumulator: BiFunctional<string, E, string> | TriFunctional<string, E, bigint, string>): void;
+    log(accumulator: TriFunctional<string, E, bigint, string>): void;
     log(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): void;
     log(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): void;
     nonMatch(predicate: Predicate<E>): boolean;
@@ -42,16 +47,16 @@ export declare abstract class Collectable<E> {
     reduce(accumulator: TriFunctional<E, E, bigint, E>): Optional<E>;
     reduce(identity: E, accumulator: BiFunctional<E, E, E>): E;
     reduce(identity: E, accumulator: TriFunctional<E, E, bigint, E>): E;
-    reduce<R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: BiFunctional<R, R, R>): R;
-    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: BiFunctional<R, R, R>): R;
+    reduce<R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): R;
+    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): R;
     semantic(): Semantic<E>;
-    protected abstract source(): Generator<E> | Iterable<E>;
+    abstract source(): Generator<E> | Iterable<E>;
     toArray(): Array<E>;
     toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
     toSet(): Set<E>;
-    write(stream: WritableStream<string>): Promise<WritableStream<string>>;
-    write(stream: WritableStream<string>, accumulator: BiFunctional<E, bigint, string>): Promise<WritableStream<string>>;
-    write(stream: WritableStream<Uint8Array>, accumulator: BiFunctional<E, bigint, Uint8Array>): Promise<WritableStream<Uint8Array>>;
+    write<S = string>(stream: WritableStream<S>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
 }
 export declare class UnorderedCollectable<E> extends Collectable<E> {
     protected readonly UnorderedCollectable: symbol;

package/dist/collectable.js

@@ -1,6 +1,6 @@
-import { Collector } from "./collector";
+import { Collector, useAllMatch, useAnyMatch, useCollect, useCount, useError, useFindAny, useFindFirst, useFindLast, useForEach, useGroup, useGroupBy, useJoin, useLog, useNoneMatch, usePartition, useReduce, useToArray, useToMap, useToSet, useWrite } from "./collector";
 import { from } from "./factory";
-import { isCollector, isFunction, isIterable, isObject, isString } from "./guard";
+import { isBigInt, isCollector, isFunction, isIterable, isObject, isString } from "./guard";
 import { useCompare } from "./hook";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
@@ -11,226 +11,138 @@ export class Collectable {
     constructor() {
     }
     anyMatch(predicate) {
-        return this.collect(() => {
-            return false;
-        }, (_element, _index, accumulator) => {
-            return accumulator;
-        }, (result, element) => {
-            return result || predicate(element);
-        }, (result) => {
-            return result;
-        });
+        if (isFunction(predicate)) {
+            return useAnyMatch(predicate).collect(this);
+        }
+        throw new TypeError("Predicate must be a function.");
     }
     allMatch(predicate) {
-        return this.collect(() => {
-            return true;
-        }, (_element, _index, accumulator) => {
-            return !accumulator;
-        }, (result, element) => {
-            return result && predicate(element);
-        }, (result) => {
-            return result;
-        });
+        return useAllMatch(predicate).collect(this);
     }
     collect(argument1, argument2, argument3, argument4) {
-        let source = this.source();
         if (isCollector(argument1)) {
             let collector = argument1;
-            return collector.collect(source);
+            return collector.collect(this);
         }
         if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
             let identity = argument1;
             let accumulator = argument2;
             let finisher = argument3;
-            let collector = Collector.full(identity, accumulator, finisher);
-            return collector.collect(source);
+            return useCollect(identity, accumulator, finisher).collect(this);
         }
         if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
             let identity = argument1;
             let interrupt = argument2;
             let accumulator = argument3;
             let finisher = argument4;
-            let collector = Collector.shortable(identity, interrupt, accumulator, finisher);
-            return collector.collect(source);
+            return useCollect(identity, interrupt, accumulator, finisher).collect(this);
         }
         throw new TypeError("Invalid arguments.");
     }
     count() {
-        return this.collect(() => {
-            return 0n;
-        }, (count) => {
-            return count + 1n;
-        }, (count) => {
-            return count;
-        });
+        return useCount().collect(this);
+    }
+    error(argument1, argument2, argument3) {
+        if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            useError().collect(this);
+        }
+        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            let accumulator = argument1;
+            useError(accumulator).collect(this);
+        }
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            let prefix = argument1;
+            let accumulator = argument2;
+            let suffix = argument3;
+            useError(prefix, accumulator, suffix).collect(this);
+        }
+        {
+            throw new TypeError("Invalid arguments.");
+        }
     }
     isEmpty() {
         return this.count() === 0n;
     }
     findAny() {
-        return this.collect(() => {
-            return Optional.empty();
-        }, (_element, _index, accumulator) => {
-            return accumulator.isPresent();
-        }, (result, element) => {
-            if (Math.random() < 0.5) {
-                return Optional.of(element);
-            }
-            return result;
-        }, (result) => {
-            return result;
-        });
+        return useFindAny().collect(this);
     }
     findFirst() {
-        return this.collect(() => {
-            return Optional.empty();
-        }, (_element, _index, accumulator) => {
-            return accumulator.isPresent();
-        }, (result, element) => {
-            return result.isPresent() ? result : Optional.of(element);
-        }, (result) => {
-            return result;
-        });
+        return useFindFirst().collect(this);
     }
     findLast() {
-        return this.collect(() => {
-            return Optional.empty();
-        }, () => {
-            return false;
-        }, (result, element) => {
-            return result.isPresent() ? result : Optional.of(element);
-        }, (result) => {
-            return result;
-        });
+        return useFindLast().collect(this);
     }
     forEach(action) {
         if (isFunction(action)) {
-            this.collect(() => {
-                return 0n;
-            }, (count, element) => {
-                action(element, count);
-                return count + 1n;
-            }, (count) => {
-                return count;
-            });
+            useForEach(action).collect(this);
+        }
+        else {
+            throw new TypeError("Action must be a function.");
         }
     }
     group(classifier) {
         if (isFunction(classifier)) {
-            return this.collect(() => {
-                return new Map();
-            }, (map, element) => {
-                let key = classifier(element);
-                let raw = map.get(key);
-                let array = validate(raw) ? raw : [];
-                array.push(element);
-                map.set(key, array);
-                return map;
-            }, (map) => {
-                return map;
-            });
+            return useGroup(classifier).collect(this);
         }
-        throw new TypeError("Invalid arguments.");
+        throw new TypeError("Classifier must be a function.");
     }
     groupBy(keyExtractor, valueExtractor) {
-        return this.collect(() => {
-            return new Map();
-        }, (map, element) => {
-            let key = keyExtractor(element);
-            let value = valueExtractor(element);
-            let group = (validate(map.get(key)) ? map.get(key) : []);
-            group.push(value);
-            map.set(key, group);
-            return map;
-        }, (map) => {
-            return map;
-        });
+        if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+            return useGroupBy(keyExtractor, valueExtractor).collect(this);
+        }
+        throw new TypeError("Key and value extractors must be functions.");
     }
     join(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            return this.collect(() => {
-                return "[";
-            }, (text, element) => {
-                return text + element + ",";
-            }, (text) => {
-                return text.substring(0, text.length - 1) + "]";
-            });
+            return useJoin().collect(this);
         }
         if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
             let delimiter = argument1;
-            return this.collect(() => {
-                return "[";
-            }, (text, element) => {
-                return text + element + delimiter;
-            }, (text) => {
-                return text.substring(0, text.length - 1) + "]";
-            });
+            return useJoin(delimiter).collect(this);
         }
         if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
             let prefix = argument1;
             let accumulator = argument2;
             let suffix = argument3;
-            return this.collect(() => {
-                return prefix;
-            }, (text, element, index) => {
-                return text + accumulator(text, element, index);
-            }, (text) => {
-                return text + suffix;
-            });
+            return useJoin(prefix, accumulator, suffix).collect(this);
         }
         if (isString(argument1) && isString(argument2) && isString(argument3)) {
             let prefix = argument1;
             let delimiter = argument2;
             let suffix = argument3;
-            return this.collect(() => {
-                return prefix;
-            }, (text, element) => {
-                return text + element + delimiter;
-            }, (text) => {
-                return text + suffix;
-            });
+            return useJoin(prefix, delimiter, suffix).collect(this);
         }
         throw new TypeError("Invalid arguments.");
     }
     log(argument1, argument2, argument3) {
         if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-            let text = this.join();
-            console.log(text);
+            useLog().collect(this);
         }
         else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
             let accumulator = argument1;
-            let text = this.join("[", accumulator, "]");
-            console.log(text);
+            useLog(accumulator).collect(this);
         }
-        else {
+        else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+            let prefix = argument1;
+            let accumulator = argument2;
+            let suffix = argument3;
+            useLog(prefix, accumulator, suffix).collect(this);
+        }
+        {
             throw new TypeError("Invalid arguments.");
         }
     }
     nonMatch(predicate) {
-        return this.collect(() => {
-            return true;
-        }, (_element, _index, accumulator) => {
-            return !accumulator;
-        }, (result, element) => {
-            return result || !predicate(element);
-        }, (result) => {
-            return result;
-        });
+        if (isFunction(predicate)) {
+            return useNoneMatch(predicate).collect(this);
+        }
+        throw new TypeError("Predicate must be a function.");
     }
     partition(count) {
-        let limited = count > 1n ? count : 1n;
-        return this.collect(() => {
-            return [];
-        }, (array, element) => {
-            let index = limited % BigInt(array.length);
-            if (index === 0n) {
-                array.push([]);
-            }
-            array[Number(index)].push(element);
-            return array;
-        }, (result) => {
-            return result;
-        });
+        if (isBigInt(count)) {
+            return usePartition(count).collect(this);
+        }
+        throw new TypeError("Count must be a BigInt.");
     }
     partitionBy(classifier) {
         return this.collect(() => {
@@ -249,30 +161,18 @@ export class Collectable {
     reduce(argument1, argument2, argument3) {
         if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
             let accumulator = argument1;
-            return this.collect(() => Optional.ofNullable(), (result, element, index) => {
-                if (result.isEmpty()) {
-                    return Optional.of(element);
-                }
-                else {
-                    let current = result.get();
-                    return Optional.of(accumulator(current, element, index));
-                }
-            }, (result) => result);
+            return useReduce(accumulator).collect(this);
         }
         else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
             let identity = argument1;
             let accumulator = argument2;
-            return this.collect(() => identity, (result, element, index) => {
-                return accumulator(result, element, index);
-            }, (result) => result);
+            return useReduce(identity, accumulator).collect(this);
         }
         else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
             let identity = argument1;
             let accumulator = argument2;
             let finisher = argument3;
-            return this.collect(() => identity, (result, element, index) => {
-                return accumulator(result, element, index);
-            }, (result) => finisher(result, result));
+            return useReduce(identity, accumulator, finisher).collect(this);
         }
         else {
             throw new TypeError("Invalid arguments.");
@@ -291,83 +191,26 @@ export class Collectable {
         }
     }
     toArray() {
-        return this.collect(() => {
-            return [];
-        }, (array, element) => {
-            array.push(element);
-            return array;
-        }, (result) => {
-            return result;
-        });
+        return useToArray().collect(this);
     }
     toMap(keyExtractor, valueExtractor) {
-        return this.collect(() => {
-            return new Map();
-        }, (map, element) => {
-            let key = keyExtractor(element);
-            let value = valueExtractor(element);
-            map.set(key, value);
-            return map;
-        }, (map) => {
-            return map;
-        });
+        return useToMap(keyExtractor, valueExtractor).collect(this);
     }
     toSet() {
-        return this.collect(() => {
-            return new Set();
-        }, (set, element) => {
-            set.add(element);
-            return set;
-        }, (result) => {
-            return result;
-        });
+        return useToSet().collect(this);
     }
-    write(stream, accumulator) {
-        if (isObject(stream) && invalidate(accumulator)) {
-            let optional = this.collect(() => {
-                return Optional.ofNonNull(stream);
-            }, (result, element) => {
-                try {
-                    return result.map((stream) => {
-                        let writer = stream.getWriter();
-                        writer.write(String(element));
-                        return stream;
-                    });
-                }
-                catch (reason) {
-                    return Optional.empty();
-                }
-            }, (a) => {
-                return a;
-            });
-            return new Promise((resolve, reject) => {
-                optional.ifPresent(resolve, reject);
-            });
-        }
-        else if (isObject(stream) && isFunction(accumulator)) {
-            let optional = this.collect(() => {
-                return Optional.ofNonNull(stream);
-            }, (result, element, index) => {
-                try {
-                    return result.map((stream) => {
-                        let writer = stream.getWriter();
-                        writer.write(accumulator(element, index));
-                        return stream;
-                    });
-                }
-                catch (reason) {
-                    return Optional.empty();
-                }
-            }, (a) => {
-                return a;
-            });
-            return new Promise((resolve, reject) => {
-                optional.ifPresent(resolve, reject);
-            });
-        }
-        else {
-            throw new TypeError("Invalid arguments.");
+    write(argument1, argument2) {
+        if (isObject(argument1)) {
+            let stream = argument1;
+            if (isFunction(argument2)) {
+                let accumulator = argument2;
+                return useWrite(stream, accumulator);
+            }
+            else {
+                return useWrite(stream);
+            }
         }
+        throw new TypeError("Invalid arguments.");
     }
 }
 ;

package/dist/collector.d.ts

@@ -1,5 +1,7 @@
+import type { Collectable } from "./collectable";
+import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
-import type { BiFunctional, BiPredicate, Functional, Predicate, Supplier, TriFunctional, Generator, TriPredicate } from "./utility";
+import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer } from "./utility";
 export declare class Collector<E, A, R> {
     protected identity: Supplier<A>;
     protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
@@ -13,6 +15,7 @@ export declare class Collector<E, A, R> {
     collect(generator: Generator<E>): R;
     collect(iterable: Iterable<E>): R;
     collect(semantic: Semantic<E>): R;
+    collect(collectable: Collectable<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>): Collector<E, A, R>;
@@ -24,3 +27,98 @@ export declare class Collector<E, A, R> {
     static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
     static shortable<E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
 }
+export declare let useAnyMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
+export declare let useAllMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
+interface UseCollect {
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+}
+export declare let useCollect: UseCollect;
+export declare let useCount: <E = unknown>() => Collector<E, bigint, bigint>;
+export interface UseError {
+    <E = unknown>(): Collector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): Collector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): Collector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
+}
+export declare let useError: UseLog;
+export declare let useFindFirst: <E>() => Collector<E, Optional<E>, Optional<E>>;
+export declare let useFindAny: <E>() => Collector<E, Optional<E>, Optional<E>>;
+export declare let useFindLast: <E>() => Collector<E, Optional<E>, Optional<E>>;
+export interface UseForEach {
+    <E>(action: Consumer<E>): Collector<E, bigint, bigint>;
+    <E>(action: BiConsumer<E, bigint>): Collector<E, bigint, bigint>;
+}
+export declare let useForEach: UseForEach;
+export declare let useNoneMatch: <E>(predicate: Predicate<E>) => Collector<E, boolean, boolean>;
+export declare let useGroup: <E, K>(classifier: Functional<E, K>) => Collector<E, Map<K, E[]>, Map<K, E[]>>;
+export declare let useGroupBy: <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>) => Collector<E, Map<K, V[]>, Map<K, V[]>>;
+export interface UseJoin {
+    <E = unknown>(): Collector<E, string, string>;
+    <E = unknown>(delimiter: string): Collector<E, string, string>;
+    <E = unknown>(prefix: string, delimiter: string, suffix: string): Collector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
+    <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
+}
+export declare let useJoin: UseJoin;
+export interface UseLog {
+    <E = unknown>(): Collector<E, string, string>;
+    <E = unknown>(accumulator: BiFunctional<string, E, string>): Collector<E, string, string>;
+    <E = unknown>(accumulator: TriFunctional<string, E, bigint, string>): Collector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: BiFunctional<string, E, string>, suffix: string): Collector<E, string, string>;
+    <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
+}
+export declare let useLog: UseLog;
+export declare let usePartition: <E>(count: bigint) => Collector<E, Array<Array<E>>, Array<Array<E>>>;
+export declare let usePartitionBy: <E>(classifier: Functional<E, bigint>) => Collector<E, Array<E[]>, Array<E[]>>;
+export interface UseReduce {
+    <E>(accumulator: BiFunctional<E, E, E>): Collector<E, Optional<E>, Optional<E>>;
+    <E>(accumulator: TriFunctional<E, E, bigint, E>): Collector<E, Optional<E>, Optional<E>>;
+    <E>(identity: E, accumulator: BiFunctional<E, E, E>): Collector<E, E, E>;
+    <E>(identity: E, accumulator: TriFunctional<E, E, bigint, E>): Collector<E, E, E>;
+    <E, R>(identity: R, accumulator: BiFunctional<R, E, R>, finisher: Functional<R, R>): Collector<E, R, R>;
+    <E, R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): Collector<E, R, R>;
+}
+export declare let useReduce: UseReduce;
+export declare let useToArray: <E>() => Collector<E, E[], E[]>;
+export declare let useToMap: <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>) => Collector<E, Map<K, V>, Map<K, V>>;
+export declare let useToSet: <E>() => Collector<E, Set<E>, Set<E>>;
+export interface UseWrite {
+    <E, S = string>(stream: WritableStream<S>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+    <E, S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Collector<E, Promise<WritableStream<S>>, Promise<WritableStream<S>>>;
+}
+export declare let useWrite: UseWrite;
+export type NumericAverageInformation = {
+    summate: number;
+    count: number;
+};
+export interface UseNumericAverage {
+    (): Collector<number, NumericAverageInformation, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, NumericAverageInformation, number>;
+}
+export declare let useNumericAverage: UseNumericAverage;
+export type BigIntAverageInformation = {
+    summate: bigint;
+    count: bigint;
+};
+export interface UseBigIntAverage {
+    (): Collector<bigint, BigIntAverageInformation, bigint>;
+    <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageInformation, bigint>;
+}
+export declare let useBigIntAverage: UseBigIntAverage;
+export declare let useFrequency: <E>() => Collector<E, Map<E, bigint>, Map<E, bigint>>;
+export interface UseNumericSummate {
+    (): Collector<number, number, number>;
+    <E>(mapper: Functional<E, number>): Collector<E, number, number>;
+}
+export declare let useSummate: UseNumericSummate;
+export {};