semantic-typescript 0.2.7 → 0.3.0

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 {};

package/dist/collector.js

@@ -1,5 +1,7 @@
-import { isBigInt, isFunction, isIterable, isNumber, isSemantic } from "./guard";
+import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
+import { Optional } from "./optional";
 import { CollectableSymbol } from "./symbol";
+import { validate, invalidate } from "./utility";
 export class Collector {
     identity;
     interrupt;
@@ -52,6 +54,29 @@ export class Collector {
                 throw new TypeError("Invalid arguments");
             }
         }
+        else if (isCollectable(argument1)) {
+            let collectable = argument1;
+            let source = collectable.source();
+            if (isIterable(source)) {
+                let iterable = source;
+                let index = 0n;
+                for (let element of iterable) {
+                    if (this.interrupt(element, index, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, element, count);
+                    count++;
+                    index++;
+                }
+            }
+            else if (isFunction(source)) {
+                let generator = source;
+                generator((element, index) => {
+                    accumulator = this.accumulator(accumulator, element, index);
+                    count++;
+                }, (element, index) => this.interrupt(element, index, accumulator));
+            }
+        }
         else if (isNumber(argument1) && isNumber(argument2)) {
             let start = argument1 < argument2 ? argument1 : argument2;
             let end = argument1 > argument2 ? argument1 : argument2;
@@ -84,3 +109,399 @@ export class Collector {
     }
 }
 ;
+export let useAnyMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element) => accumulator || predicate(element), (accumulator) => accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+export let useAllMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element) => accumulator && predicate(element), (accumulator) => accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+;
+export let useCollect = (argument1, argument2, argument3, argument4) => {
+    if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3) && isFunction(argument4)) {
+        let identity = argument1;
+        let interrupt = argument2;
+        let accumulator = argument3;
+        let finisher = argument4;
+        return Collector.shortable(identity, interrupt, accumulator, finisher);
+    }
+    if (isFunction(argument1) && isFunction(argument2) && isFunction(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        let finisher = argument3;
+        return Collector.full(identity, accumulator, finisher);
+    }
+    throw new TypeError("Identity, accumulator, and finisher must be functions.");
+};
+export let useCount = () => {
+    return Collector.full(() => 0n, (count) => count + 1n, (count) => count);
+};
+;
+export let useError = (argument1, argument2, argument3) => {
+    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        return Collector.full(() => "[", (accumulator, element) => {
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, text.length - 1) + "]";
+            console.error(result);
+            return result;
+        });
+    }
+    else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let accumulator = argument1;
+        return Collector.full(() => "[", accumulator, (text) => {
+            let result = text.substring(0, text.length - 1) + "]";
+            console.error(result);
+            return result;
+        });
+    }
+    else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.error(result);
+            return result;
+        });
+    }
+    else {
+        throw new TypeError("Invalid arguments.");
+    }
+};
+export let useFindFirst = () => {
+    return Collector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent()) {
+            return accumulator;
+        }
+        return Optional.ofNullable(element);
+    }, (accumulator) => accumulator);
+};
+export let useFindAny = () => {
+    return Collector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent() && Math.random() < 0.5) {
+            return accumulator;
+        }
+        return Optional.ofNullable(element);
+    }, (accumulator) => accumulator);
+};
+export let useFindLast = () => {
+    return Collector.full(() => Optional.empty(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent()) {
+            return Optional.ofNullable(element);
+        }
+        return accumulator;
+    }, (accumulator) => accumulator);
+};
+;
+export let useForEach = (action) => {
+    if (isFunction(action)) {
+        return Collector.full(() => 0n, (accumulator, element, index) => {
+            action(element, index);
+            return accumulator + 1n;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Action must be a function.");
+};
+export let useNoneMatch = (predicate) => {
+    if (isFunction(predicate)) {
+        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element) => accumulator && !predicate(element), (accumulator) => !accumulator);
+    }
+    throw new TypeError("Predicate must be a function.");
+};
+export let useGroup = (classifier) => {
+    if (isFunction(classifier)) {
+        return Collector.full(() => new Map(), (accumulator, element) => {
+            let key = classifier(element);
+            let group = accumulator.get(key) || [];
+            group.push(element);
+            accumulator.set(key, group);
+            return accumulator;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Classifier must be a function.");
+};
+export let useGroupBy = (keyExtractor, valueExtractor) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return Collector.full(() => new Map(), (accumulator, element) => {
+            let key = keyExtractor(element);
+            let group = accumulator.get(key) || [];
+            group.push(valueExtractor(element));
+            accumulator.set(key, group);
+            return accumulator;
+        }, (accumulator) => accumulator);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+;
+export let useJoin = (argument1, argument2, argument3) => {
+    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        return Collector.full(() => "[", (text, element) => text + element + ",", (text) => text.substring(0, text.length - 1) + "]");
+    }
+    if (isString(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let delimiter = argument1;
+        return Collector.full(() => "[", (text, element) => text + element + delimiter, (text) => text.substring(0, text.length - delimiter.length) + "]");
+    }
+    if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, accumulator, (text) => text + suffix);
+    }
+    if (isString(argument1) && isString(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let delimiter = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, (text, element) => text + element + delimiter, (text) => text + suffix);
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useLog = (argument1, argument2, argument3) => {
+    if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        return Collector.full(() => "[", (accumulator, element) => {
+            if (isString(accumulator) && isString(element)) {
+                return accumulator + element + ",";
+            }
+            return String(accumulator) + String(element) + ",";
+        }, (text) => {
+            let result = text.substring(0, text.length - 1) + "]";
+            console.log(result);
+            return result;
+        });
+    }
+    else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let accumulator = argument1;
+        return Collector.full(() => "[", accumulator, (text) => {
+            let result = text.substring(0, text.length - 1) + "]";
+            console.log(result);
+            return result;
+        });
+    }
+    else if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
+        let prefix = argument1;
+        let accumulator = argument2;
+        let suffix = argument3;
+        return Collector.full(() => prefix, accumulator, (text) => {
+            let result = text + suffix;
+            console.log(result);
+            return result;
+        });
+    }
+    else {
+        throw new TypeError("Invalid arguments.");
+    }
+};
+export let usePartition = (count) => {
+    if (isBigInt(count)) {
+        let limited = count > 1n ? count : 1n;
+        return Collector.full(() => {
+            return [];
+        }, (array, element) => {
+            let index = limited % BigInt(array.length);
+            if (index === 0n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    throw new TypeError("Count must be a BigInt.");
+};
+export let usePartitionBy = (classifier) => {
+    if (isFunction(classifier)) {
+        return Collector.full(() => {
+            return [];
+        }, (array, element) => {
+            let index = classifier(element);
+            while (index > BigInt(array.length) - 1n) {
+                array.push([]);
+            }
+            array[Number(index)].push(element);
+            return array;
+        }, (result) => {
+            return result;
+        });
+    }
+    throw new TypeError("Classifier must be a function.");
+};
+;
+export let useReduce = (argument1, argument2, argument3) => {
+    if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+        let accumulator = argument1;
+        return Collector.full(() => 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);
+    }
+    else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        return Collector.full(() => identity, accumulator, (result) => result);
+    }
+    else if (validate(argument1) && isFunction(argument2) && isFunction(argument3)) {
+        let identity = argument1;
+        let accumulator = argument2;
+        let finisher = argument3;
+        return Collector.full(() => identity, accumulator, finisher);
+    }
+    else {
+        throw new TypeError("Invalid arguments.");
+    }
+};
+export let useToArray = () => {
+    return Collector.full(() => [], (array, element) => {
+        array.push(element);
+        return array;
+    }, (array) => array);
+};
+export let useToMap = (keyExtractor, valueExtractor) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return Collector.full(() => new Map(), (map, element) => {
+            let key = keyExtractor(element);
+            let value = valueExtractor(element);
+            map.set(key, value);
+            return map;
+        }, (map) => map);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+export let useToSet = () => {
+    return Collector.full(() => new Set(), (set, element) => {
+        set.add(element);
+        return set;
+    }, (set) => set);
+};
+;
+export let useWrite = (argument1, argument2) => {
+    if (isObject(argument1)) {
+        if (isFunction(argument2)) {
+            let stream = argument1;
+            let accumulator = argument2;
+            return Collector.full(() => Promise.resolve(stream), (promise, element, index) => {
+                return new Promise((resolve, reject) => {
+                    promise.then((stream) => {
+                        try {
+                            resolve(accumulator(stream, element, index));
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }).catch(reject);
+                });
+            }, (promise) => promise);
+        }
+        else {
+            let stream = argument1;
+            return Collector.full(() => Promise.resolve(stream), (promise, element) => {
+                return new Promise((resolve, reject) => {
+                    promise.then((stream) => {
+                        try {
+                            let writer = stream.getWriter();
+                            writer.write(String(element));
+                            resolve(stream);
+                        }
+                        catch (error) {
+                            reject(error);
+                        }
+                    }).catch(reject);
+                });
+            }, (promise) => promise);
+        }
+    }
+    throw new TypeError("Invalid arguments.");
+};
+;
+export let useNumericAverage = (mapper) => {
+    if (isFunction(mapper)) {
+        return Collector.full(() => {
+            return {
+                summate: 0,
+                count: 0
+            };
+        }, (information, element) => {
+            let value = mapper(element);
+            information.summate += value;
+            information.count++;
+            return information;
+        }, (information) => {
+            return information.summate / information.count;
+        });
+    }
+    return Collector.full(() => {
+        return {
+            summate: 0,
+            count: 0
+        };
+    }, (information, element) => {
+        information.summate += element;
+        information.count++;
+        return information;
+    }, (information) => {
+        return information.summate / information.count;
+    });
+};
+;
+export let useBigIntAverage = (mapper) => {
+    if (isFunction(mapper)) {
+        return Collector.full(() => {
+            return {
+                summate: 0n,
+                count: 0n
+            };
+        }, (information, element) => {
+            let value = mapper(element);
+            information.summate += value;
+            information.count++;
+            return information;
+        }, (information) => {
+            return information.summate / information.count;
+        });
+    }
+    return Collector.full(() => {
+        return {
+            summate: 0n,
+            count: 0n
+        };
+    }, (information, element) => {
+        information.summate += element;
+        information.count++;
+        return information;
+    }, (information) => {
+        return information.summate / information.count;
+    });
+};
+export let useFrequency = () => {
+    return Collector.full(() => new Map(), (map, element) => {
+        let count = map.get(element) || 0n;
+        map.set(element, count + 1n);
+        return map;
+    }, (map) => map);
+};
+;
+export let useSummate = (mapper) => {
+    if (isFunction(mapper)) {
+        return Collector.full(() => 0, (summate, element) => {
+            let value = mapper(element);
+            return summate + value;
+        }, (summate) => summate);
+    }
+    return Collector.full(() => 0, (summate, element) => {
+        return summate + element;
+    }, (summate) => summate);
+};

package/dist/hook.d.ts

@@ -1,2 +1,4 @@
+import { type BiConsumer, type DeepPropertyKey, type DeepPropertyValue } from "./utility";
 export declare let useCompare: <T>(t1: T, t2: T) => number;
 export declare let useRandom: <T = number | bigint>(index: T) => T;
+export declare let useTraverse: <T extends object>(t: T, callback: BiConsumer<DeepPropertyKey<T>, DeepPropertyValue<T>>) => void;

package/dist/hook.js

@@ -1,4 +1,5 @@
-import { isFunction, isNumber, isPrimitive } from "./guard";
+import { isFunction, isIterable, isNumber, isObject, isPrimitive } from "./guard";
+import { validate } from "./utility";
 export let useCompare = (t1, t2) => {
     if (t1 === t2 || Object.is(t1, t2)) {
         return 0;
@@ -62,3 +63,37 @@ export let useRandom = (index) => {
     }
     throw new TypeError("Invalid input type");
 };
+export let useTraverse = (t, callback) => {
+    if (isObject(t)) {
+        let seen = new WeakSet();
+        let traverse = (target) => {
+            if (!seen.has(target)) {
+                seen.add(target);
+                let properties = Reflect.ownKeys(target);
+                for (let property of properties) {
+                    let value = target[property];
+                    if (validate(value)) {
+                        if (isObject(value)) {
+                            if (isIterable(value)) {
+                                for (let item of value) {
+                                    if (validate(item)) {
+                                        if (isObject(item)) {
+                                            traverse(item);
+                                        }
+                                        else {
+                                            callback(property, item);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            callback(property, value);
+                        }
+                    }
+                }
+            }
+        };
+        traverse(t);
+    }
+};

package/dist/optional.d.ts

@@ -1,3 +1,4 @@
+import type { Semantic } from "./semantic";
 import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
@@ -11,6 +12,7 @@ export declare class Optional<T> {
     isEmpty(): boolean;
     isPresent(): boolean;
     map<R>(mapper: Functional<T, R>): Optional<R>;
+    semantic(): Semantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;
     static ofNullable<T>(value?: MaybeInvalid<T>): Optional<T>;

package/dist/optional.js

@@ -1,3 +1,4 @@
+import { empty, generate } from "./factory";
 import { isFunction } from "./guard";
 import { OptionalSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
@@ -46,6 +47,16 @@ export class Optional {
         }
         return new Optional(null);
     }
+    semantic() {
+        if (this.isPresent()) {
+            return generate(() => {
+                return this.value;
+            }, () => {
+                return this.isEmpty();
+            });
+        }
+        return empty();
+    }
     static empty() {
         return new Optional(null);
     }

package/dist/semantic.d.ts

@@ -40,3 +40,8 @@ export declare class Semantic<E> {
     translate(offset: bigint): Semantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
 }
+export interface UseTransform {
+    <E, R>(generator: Generator<E>, mapper: Functional<E, R>): Generator<R>;
+    <E, R>(generator: Generator<E>, mapper: BiFunctional<E, bigint, R>): Generator<R>;
+}
+export declare let useTransform: UseTransform;

package/dist/semantic.js

@@ -18,7 +18,8 @@ export class Semantic {
                     accept(element, index);
                     count++;
                 }, interrupt);
-                other.generator((element, index) => {
+                let otherGenerator = Reflect.has(other, "generator") ? Reflect.get(other, "generator") : () => { };
+                otherGenerator((element, index) => {
                     accept(element, index + count);
                 }, interrupt);
             });
@@ -337,3 +338,14 @@ export class Semantic {
     }
 }
 ;
+;
+export let useTransform = (generator, mapper) => {
+    return (accept, interrupt) => {
+        generator((element, index) => {
+            let resolved = mapper(element, index);
+            accept(resolved, index);
+        }, (element, index) => {
+            return interrupt(mapper(element, index), index);
+        });
+    };
+};

package/dist/utility.d.ts

@@ -6,6 +6,12 @@ export declare let invalidate: <T>(t: MaybeInvalid<T>) => t is (null | undefined
 export type Primitive = string | number | boolean | symbol | bigint | Function | ((...args: any[]) => any);
 export type MaybePrimitive<T> = T | Primitive;
 export type AsyncFunction = (...args: any[]) => Promise<unknown>;
+export type DeepPropertyKey<T extends object> = {
+    [K in keyof T]: T[K] extends object ? DeepPropertyKey<T[K]> : K;
+};
+export type DeepPropertyValue<T extends object> = {
+    [K in keyof T]: T[K] extends object ? DeepPropertyValue<T[K]> : T[K];
+};
 export interface Runnable {
     (): void;
 }

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",
@@ -52,12 +52,10 @@
   },
   "scripts": {
     "build": "tsc",
+    "dev": "vite",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "typescript": "~5.9.3"
-  },
-  "peerDependencies": {},
-  "dependencies": {
   }
-}
+}

package/readme.md

@@ -148,6 +148,42 @@ console.log(empty.get(100)); // Outputs 100
 |------|------|------------|------------|
 | `Collector.full(identity, accumulator, finisher)` | Create a full collector | O(1) | O(1) |
 | `Collector.shortable(identity, interruptor, accumulator, finisher)` | Create an interruptible collector | O(1) | O(1) |
+| `useAnyMatch<E>(predicate)` | Create a shortable collector returning true if any element matches the predicate | O(n) | O(1) |
+| `useAllMatch<E>(predicate)` | Create a shortable collector returning true if all elements match the predicate | O(n) | O(1) |
+| `useCollect<E, A, R>(identity, accumulator, finisher)` | Create a full collector with identity, accumulator, finisher | O(1) | O(1) |
+| `useCollect<E, A, R>(identity, interruptor, accumulator, finisher)` | Create a shortable collector with identity, interruptor, accumulator, finisher | O(1) | O(1) |
+| `useCount<E>()` | Create a full collector counting elements | O(n) | O(1) |
+| `useFindFirst<E>()` | Create a shortable collector returning the first element | O(n) | O(1) |
+| `useFindAny<E>()` | Create a shortable collector returning any element | O(n) | O(1) |
+| `useFindLast<E>()` | Create a full collector returning the last element | O(n) | O(1) |
+| `useForEach<E>(action)` | Create a full collector executing an action for each element | O(n) | O(1) |
+| `useNoneMatch<E>(predicate)` | Create a shortable collector returning true if no element matches the predicate | O(n) | O(1) |
+| `useGroup<E, K>(classifier)` | Create a full collector grouping elements by classifier key | O(n) | O(n) |
+| `useGroupBy<E, K, V>(keyExtractor, valueExtractor)` | Create a full collector grouping elements by key with extracted values | O(n) | O(n) |
+| `useJoin<E>()` | Create a full collector joining elements into a string with default format | O(n) | O(1) |
+| `useJoin<E>(delimiter)` | Create a full collector joining elements with delimiter | O(n) | O(1) |
+| `useJoin<E>(prefix, delimiter, suffix)` | Create a full collector joining elements with prefix, delimiter, suffix | O(n) | O(1) |
+| `useJoin<E>(prefix, accumulator, suffix)` | Create a full collector joining elements via custom accumulator | O(n) | O(1) |
+| `useLog<E>()` | Create a full collector logging elements to console with default format | O(n) | O(1) |
+| `useLog<E>(accumulator)` | Create a full collector logging elements via custom accumulator | O(n) | O(1) |
+| `useLog<E>(prefix, accumulator, suffix)` | Create a full collector logging elements with prefix/suffix via accumulator | O(n) | O(1) |
+| `usePartition<E>(count)` | Create a full collector partitioning elements into chunks of specified size | O(n) | O(n) |
+| `usePartitionBy<E>(classifier)` | Create a full collector partitioning elements by classifier result | O(n) | O(n) |
+| `useReduce<E>(accumulator)` | Create a full collector reducing elements without identity | O(n) | O(1) |
+| `useReduce<E>(identity, accumulator)` | Create a full collector reducing elements with identity | O(n) | O(1) |
+| `useReduce<E, R>(identity, accumulator, finisher)` | Create a full collector reducing elements with identity, accumulator, finisher | O(n) | O(1) |
+| `useToArray<E>()` | Create a full collector gathering elements into an array | O(n) | O(n) |
+| `useToMap<E, K, V>(keyExtractor, valueExtractor)` | Create a full collector gathering elements into a Map | O(n) | O(n) |
+| `useToSet<E>()` | Create a full collector gathering elements into a Set | O(n) | O(n) |
+| `useWrite<E, S>(stream)` | Create a full collector writing elements to a stream | O(n) | O(1) |
+| `useWrite<E, S>(stream, accumulator)` | Create a full collector writing elements via custom accumulator | O(n) | O(1) |
+| `useNumericAverage<E>(mapper)` | Create a full collector computing numeric average with mapper | O(n) | O(1) |
+| `useNumericAverage<E>()` | Create a full collector computing numeric average | O(n) | O(1) |
+| `useBigIntAverage<E>(mapper)` | Create a full collector computing bigint average with mapper | O(n) | O(1) |
+| `useBigIntAverage<E>()` | Create a full collector computing bigint average | O(n) | O(1) |
+| `useFrequency<E>()` | Create a full collector counting element frequencies | O(n) | O(n) |
+| `useSummate<E>(mapper)` | Create a full collector summing mapped numeric values | O(n) | O(1) |
+| `useSummate<E>()` | Create a full collector summing numeric elements | O(n) | O(1) |
 
 ```typescript
 // Collector conversion examples
@@ -163,22 +199,24 @@ let ordered: OrderedCollectable<number> = from([3, 1, 4, 1, 5, 9, 2, 6, 5])
     .sorted();
 
 // Counts the number of elements
-let count: Collector<number, number, number> = Collector.full(
-    (): number => 0, // Initial value
-    (accumulator: number, element: number): number => accumulator + element, // Accumulate
-    (accumulator: number): number => accumulator // Finish
-);
+let count: Collector<number, number, number> = useCount();
 count.collect(from([1,2,3,4,5])); // Counts from a stream
 count.collect([1,2,3,4,5]); // Counts from an iterable object
 
-let find: Optional<number> = Collector.shortable(
-    (): Optional<number> => Optional.empty(), // Initial value
-    (element: number, index: bigint, accumulator: Optional<number>): Optional<number> => accumulator.isPresent(), // Interrupt
-    (accumulator: Optional<number>, element: number, index: bigint): Optional<number> => Optional.of(element), // Accumulate
-    (accumulator: Optional<number>): Optional<number> => accumulator // Finish
-);
+// Finds the first element
+let findFirst: Collector<number, number, number> = useFindFirst();
 find.collect(from([1,2,3,4,5])); // Finds the first element
 find.collect([1,2,3,4,5]); // Finds the first element
+
+// Calculates the sum of elements
+let sum: Collector<number, number, number> = useSummate();
+sum.collect(from([1,2,3,4,5])); // Sums from a stream
+sum.collect([1,2,3,4,5]); // Sums from an iterable object
+
+// Calculates the average of elements
+let average: Collector<number, number, number> = useNumericAverage();
+average.collect(from([1,2,3,4,5])); // Averages from a stream
+average.collect([1,2,3,4,5]); // Averages from an iterable object
 ```
 
 ### Semantic Factory Methods