semantic-typescript 0.5.3 → 0.7.0

package/dist/{collector.js → synchronous/collector.js}

@@ -1,15 +1,14 @@
-import { Collectable } from "./semantic";
-import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
-import { useCompare, useToBigInt, useToNumber } from "./hook";
-import { Optional } from "./optional";
-import { CollectableSymbol } from "./symbol";
-import { validate, invalidate } from "./utility";
-export class Collector {
+import { isFunction, isNumber, isBigInt, isBoolean, isString, isObject, isAsyncFunction, isIterable } from "../guard";
+import { useCompare, useToBigInt, useToNumber } from "../hook";
+import { Optional } from "../optional";
+import { SynchronousCollectorSymbol } from "../symbol";
+import { invalidate, validate } from "../utility";
+export class SynchronousCollector {
     identity;
     interrupt;
     accumulator;
     finisher;
-    Collector = CollectableSymbol;
+    SynchronousCollector = SynchronousCollectorSymbol;
     constructor(identity, interrupt, accumulator, finisher) {
         if (isFunction(identity) && isFunction(interrupt) && isFunction(accumulator) && isFunction(finisher)) {
             this.identity = identity;
@@ -41,8 +40,8 @@ export class Collector {
                     enumerable: true,
                     configurable: false
                 },
-                "Collector": {
-                    value: CollectableSymbol,
+                "SynchronousCollector": {
+                    value: SynchronousCollectorSymbol,
                     writable: false,
                     enumerable: false,
                     configurable: false
@@ -55,124 +54,140 @@ export class Collector {
         }
     }
     collect(argument1, argument2) {
-        let accumulator = this.identity();
-        let count = 0n;
-        if (isFunction(argument1)) {
-            let generator = argument1;
-            generator((element, index) => {
-                accumulator = this.accumulator(accumulator, element, index);
-                count++;
-            }, (element, index) => this.interrupt(element, index, accumulator));
-        }
-        else if (isIterable(argument1)) {
-            let iterable = argument1;
-            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 (isSemantic(argument1)) {
-            let semantic = argument1;
-            let generator = Reflect.get(semantic, "generator");
-            if (isFunction(generator)) {
+        if (isAsyncFunction(argument1) || isFunction(argument1)) {
+            try {
+                let generator = argument1;
+                let accumulator = this.identity();
+                let count = 0n;
                 generator((element, index) => {
                     accumulator = this.accumulator(accumulator, element, index);
                     count++;
                 }, (element, index) => this.interrupt(element, index, accumulator));
+                return this.finisher(accumulator);
             }
-            else {
-                throw new TypeError("Invalid arguments");
+            catch (error) {
+                throw error;
             }
         }
-        else if (isCollectable(argument1)) {
-            let collectable = argument1;
-            let source = collectable.source();
-            if (isFunction(source)) {
-                let generator = source;
-                generator((element, index) => {
-                    accumulator = this.accumulator(accumulator, element, index);
+        else if (isIterable(argument1)) {
+            try {
+                let iterable = argument1;
+                let accumulator = this.identity();
+                let count = 0n;
+                for (let element of iterable) {
+                    if (this.interrupt(element, count, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, element, count);
                     count++;
-                }, (element, index) => this.interrupt(element, index, accumulator));
+                }
+                return this.finisher(accumulator);
+            }
+            catch (error) {
+                throw error;
             }
         }
         else if (isNumber(argument1) && isNumber(argument2)) {
-            let start = argument1 < argument2 ? argument1 : argument2;
-            let end = argument1 > argument2 ? argument1 : argument2;
-            for (let i = start; i < end; i++) {
-                if (this.interrupt(i, count, accumulator)) {
-                    break;
+            try {
+                let start = argument1 < argument2 ? argument1 : argument2;
+                let end = argument1 > argument2 ? argument1 : argument2;
+                let accumulator = this.identity();
+                let count = 0n;
+                for (let i = start; i < end; i++) {
+                    if (this.interrupt(i, count, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, i, count);
+                    count++;
                 }
-                accumulator = this.accumulator(accumulator, i, count);
-                count++;
+                return this.finisher(accumulator);
+            }
+            catch (error) {
+                throw error;
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
-            let start = argument1 < argument2 ? argument1 : argument2;
-            let end = argument1 > argument2 ? argument1 : argument2;
-            for (let i = start; i < end; i++) {
-                if (this.interrupt(i, count, accumulator)) {
-                    break;
+            try {
+                let start = argument1 < argument2 ? argument1 : argument2;
+                let end = argument1 > argument2 ? argument1 : argument2;
+                let accumulator = this.identity();
+                let count = 0n;
+                for (let i = start; i < end; i++) {
+                    if (this.interrupt(i, count, accumulator)) {
+                        break;
+                    }
+                    accumulator = this.accumulator(accumulator, i, count);
+                    count++;
                 }
-                accumulator = this.accumulator(accumulator, i, count);
-                count++;
+                return this.finisher(accumulator);
+            }
+            catch (error) {
+                throw error;
             }
         }
-        return this.finisher(accumulator);
+        throw new Error("Invalid arguments.");
+    }
+    getIdentity() {
+        return this.identity;
+    }
+    getInterrupt() {
+        return this.interrupt;
+    }
+    getAccumulator() {
+        return this.accumulator;
+    }
+    getFinisher() {
+        return this.finisher;
     }
     static full(identity, accumulator, finisher) {
-        return new Collector(identity, () => false, accumulator, finisher);
+        return new SynchronousCollector(identity, () => false, accumulator, finisher);
     }
     static shortable(identity, interrupt, accumulator, finisher) {
-        return new Collector(identity, interrupt, accumulator, finisher);
+        return new SynchronousCollector(identity, interrupt, accumulator, finisher);
     }
 }
 ;
 ;
-export let useAnyMatch = (predicate) => {
+export let useSynchronousAnyMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element, index) => accumulator || predicate(element, index), (accumulator) => accumulator);
+        return SynchronousCollector.shortable(() => false, (_element, _index, accumulator) => isBoolean(accumulator) && accumulator, (accumulator, element, index) => accumulator || predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
 ;
-export let useAllMatch = (predicate) => {
+export let useSynchronousAllMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element, index) => accumulator && predicate(element, index), (accumulator) => accumulator);
+        return SynchronousCollector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element, index) => accumulator && predicate(element, index), (accumulator) => accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
 ;
-export let useCollect = (argument1, argument2, argument3, argument4) => {
+export let useSynchronousCollect = (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);
+        return SynchronousCollector.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);
+        return SynchronousCollector.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 useSynchronousCount = () => {
+    return SynchronousCollector.full(() => 0n, (count) => isBigInt(count) ? (count + 1n) : 1n, (count) => isBigInt(count) ? count : 0n);
 };
 ;
-export let useError = (argument1, argument2, argument3) => {
+export let useSynchronousError = (argument1, argument2, argument3) => {
     if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
         let prefix = argument1;
         let accumulator = argument2;
         let suffix = argument3;
-        return Collector.full(() => prefix, accumulator, (text) => {
+        return SynchronousCollector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.error(result);
             return result;
@@ -182,14 +197,14 @@ export let useError = (argument1, argument2, argument3) => {
         let prefix = "[";
         let accumulator = argument2;
         let suffix = "]";
-        return Collector.full(() => prefix, accumulator, (text) => {
+        return SynchronousCollector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.error(result);
             return result;
         });
     }
     else {
-        return Collector.full(() => "[", (accumulator, element) => {
+        return SynchronousCollector.full(() => "[", (accumulator, element) => {
             if (isString(accumulator) && isString(element)) {
                 return accumulator + element + ",";
             }
@@ -202,74 +217,87 @@ export let useError = (argument1, argument2, argument3) => {
     }
 };
 ;
-export let useFindAt = (index) => {
+export let useSynchronousFindAt = (index) => {
     let target = useToBigInt(index);
     if (target < 0n) {
-        return Collector.full(() => [], (accumulator, element) => {
-            accumulator.push(element);
-            return accumulator;
-        }, (accumulator) => {
-            if (accumulator.length === 0) {
-                return Optional.empty();
+        return SynchronousCollector.full(() => [], (accumulator, element) => {
+            let accumulated = Array.isArray(accumulator) ? accumulator : [];
+            accumulated.push(element);
+            return accumulated;
+        }, (result) => {
+            if (Array.isArray(result) && result.length > 0) {
+                let index = ((Number(target) % result.length) + result.length) % result.length;
+                return Optional.of(result[index]);
             }
-            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
-            return Optional.ofNullable(accumulator[Number(limited)]);
+            return Optional.empty();
         });
     }
-    return Collector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
-        accumulator.push(element);
-        return accumulator;
-    }, (accumulator) => {
-        if (accumulator.length === 0) {
-            return Optional.empty();
+    return SynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
+        let accumulated = Array.isArray(accumulator) ? accumulator : [];
+        accumulated.push(element);
+        return accumulated;
+    }, (result) => {
+        let index = ((Number(target) % result.length) + result.length) % result.length;
+        if (Array.isArray(result) && result.length > 0) {
+            return Optional.of(result[index]);
         }
-        return Optional.ofNullable(accumulator[Number(target)]);
+        return Optional.empty();
     });
 };
-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);
+export let useSynchronousFindFirst = () => {
+    return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
         return accumulator;
-    }, (accumulator) => accumulator);
+    }, (result) => result);
 };
-export let useFindMaximum = (comparator = (useCompare)) => {
-    return Collector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) > 0 ? accumulator : Optional.ofNullable(element);
+export let useSynchronousFindAny = () => {
+    return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent() && validate(element) && Math.random() < 0.5) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
+        return accumulator;
     }, (result) => result);
 };
-export let useFindMinimum = (comparator = (useCompare)) => {
-    return Collector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) < 0 ? accumulator : Optional.ofNullable(element);
+export let useSynchronousFindLast = () => {
+    return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
+        return accumulator;
     }, (result) => result);
 };
+export let useSynchronousFindMaximum = (comparator = (useCompare)) => {
+    if (isFunction(comparator)) {
+        return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
+            if (validate(accumulator) && accumulator.isPresent()) {
+                return accumulator.map((previous) => {
+                    return comparator(previous, element) > 0 ? previous : element;
+                });
+            }
+            return accumulator;
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
+};
+export let useSynchronousFindMinimum = (comparator = (useCompare)) => {
+    if (isFunction(comparator)) {
+        return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
+            if (validate(accumulator) && accumulator.isPresent()) {
+                return accumulator.map((previous) => {
+                    return comparator(previous, element) < 0 ? previous : element;
+                });
+            }
+            return accumulator;
+        }, (result) => result);
+    }
+    throw new TypeError("Invalid argument.");
+};
 ;
-export let useForEach = (action) => {
+export let useSynchronousForEach = (action) => {
     if (isFunction(action)) {
-        return Collector.full(() => 0n, (accumulator, element, index) => {
+        return SynchronousCollector.full(() => 0n, (accumulator, element, index) => {
             action(element, index);
             return accumulator + 1n;
         }, (accumulator) => accumulator);
@@ -277,16 +305,16 @@ export let useForEach = (action) => {
     throw new TypeError("Action must be a function.");
 };
 ;
-export let useNoneMatch = (predicate) => {
+export let useSynchronousNoneMatch = (predicate) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element, index) => accumulator && !predicate(element, index), (accumulator) => !accumulator);
+        return SynchronousCollector.shortable(() => true, (_element, _index, accumulator) => !accumulator, (accumulator, element, index) => accumulator && !predicate(element, index), (accumulator) => !accumulator);
     }
     throw new TypeError("Predicate must be a function.");
 };
 ;
-export let useGroup = (classifier) => {
+export let useSynchronousGroup = (classifier) => {
     if (isFunction(classifier)) {
-        return Collector.full(() => new Map(), (accumulator, element, index) => {
+        return SynchronousCollector.full(() => new Map(), (accumulator, element, index) => {
             let key = classifier(element, index);
             let group = accumulator.get(key) || [];
             group.push(element);
@@ -296,9 +324,9 @@ export let useGroup = (classifier) => {
     }
     throw new TypeError("Classifier must be a function.");
 };
-export let useGroupBy = (keyExtractor, valueExtractor = (element) => element) => {
+export let useSynchronousGroupBy = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (accumulator, element, index) => {
+        return SynchronousCollector.full(() => new Map(), (accumulator, element, index) => {
             let key = keyExtractor(element, index);
             let group = accumulator.get(key) || [];
             group.push(valueExtractor(element, index));
@@ -309,35 +337,35 @@ export let useGroupBy = (keyExtractor, valueExtractor = (element) => element) =>
     throw new TypeError("Key extractor and value extractor must be functions.");
 };
 ;
-export let useJoin = (argument1, argument2, argument3) => {
+export let useSynchronousJoin = (argument1, argument2, argument3) => {
     if (invalidate(argument1) && invalidate(argument2) && invalidate(argument3)) {
-        return Collector.full(() => "[", (text, element) => text + element + ",", (text) => text.substring(0, text.length - 1) + "]");
+        return SynchronousCollector.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) + "]");
+        return SynchronousCollector.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);
+        return SynchronousCollector.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);
+        return SynchronousCollector.full(() => prefix, (text, element) => text + element + delimiter, (text) => text + suffix);
     }
     throw new TypeError("Invalid arguments.");
 };
 ;
-export let useLog = (argument1, argument2, argument3) => {
+export let useSynchronousLog = (argument1, argument2, argument3) => {
     if (isString(argument1) && isFunction(argument2) && isString(argument3)) {
         let prefix = argument1;
         let accumulator = argument2;
         let suffix = argument3;
-        return Collector.full(() => prefix, accumulator, (text) => {
+        return SynchronousCollector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.log(result);
             return result;
@@ -347,15 +375,14 @@ export let useLog = (argument1, argument2, argument3) => {
         let prefix = "[";
         let accumulator = argument2;
         let suffix = "]";
-        return Collector.full(() => prefix, accumulator, (text) => {
+        return SynchronousCollector.full(() => prefix, accumulator, (text) => {
             let result = text + suffix;
             console.log(result);
             return result;
         });
     }
     else {
-        return Collector.full(() => "[", (accumulator, element) => {
-            console.log(element);
+        return SynchronousCollector.full(() => "[", (accumulator, element) => {
             if (isString(accumulator) && isString(element)) {
                 return accumulator + element + ",";
             }
@@ -367,10 +394,10 @@ export let useLog = (argument1, argument2, argument3) => {
         });
     }
 };
-export let usePartition = (count) => {
+export let useSynchronousPartition = (count) => {
     if (isBigInt(count)) {
         let limited = count > 1n ? count : 1n;
-        return Collector.full(() => {
+        return SynchronousCollector.full(() => {
             return [];
         }, (array, element) => {
             let index = limited % BigInt(array.length);
@@ -386,9 +413,9 @@ export let usePartition = (count) => {
     throw new TypeError("Count must be a BigInt.");
 };
 ;
-export let usePartitionBy = (classifier) => {
+export let useSynchronousPartitionBy = (classifier) => {
     if (isFunction(classifier)) {
-        return Collector.full(() => {
+        return SynchronousCollector.full(() => {
             return [];
         }, (array, element, index) => {
             let resolved = classifier(element, index);
@@ -404,44 +431,41 @@ export let usePartitionBy = (classifier) => {
     throw new TypeError("Classifier must be a function.");
 };
 ;
-export let useReduce = (argument1, argument2, argument3) => {
+export let useSynchronousReduce = (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));
+        return SynchronousCollector.full(() => Optional.empty(), (result, element, index) => {
+            if (validate(result) && result.isPresent()) {
+                return result.map((previous) => accumulator(previous, element, index));
             }
+            return result;
         }, (result) => result);
     }
     else if (validate(argument1) && isFunction(argument2) && invalidate(argument3)) {
         let identity = argument1;
         let accumulator = argument2;
-        return Collector.full(() => identity, accumulator, (result) => result);
+        return SynchronousCollector.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);
+        return SynchronousCollector.full(() => identity, accumulator, finisher);
     }
     else {
         throw new TypeError("Invalid arguments.");
     }
 };
-export let useToArray = () => {
-    return Collector.full(() => [], (array, element) => {
+export let useSynchronousToArray = () => {
+    return SynchronousCollector.full(() => [], (array, element) => {
         array.push(element);
         return array;
     }, (array) => array);
 };
 ;
-export let useToMap = (keyExtractor, valueExtractor = (element) => element) => {
+export let useSynchronousToMap = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (map, element, index) => {
+        return SynchronousCollector.full(() => new Map(), (map, element, index) => {
             let key = keyExtractor(element, index);
             let value = valueExtractor(element, index);
             map.set(key, value);
@@ -450,19 +474,19 @@ export let useToMap = (keyExtractor, valueExtractor = (element) => element) => {
     }
     throw new TypeError("Key extractor and value extractor must be functions.");
 };
-export let useToSet = () => {
-    return Collector.full(() => new Set(), (set, element) => {
+export let useSynchronousToSet = () => {
+    return SynchronousCollector.full(() => new Set(), (set, element) => {
         set.add(element);
         return set;
     }, (set) => set);
 };
 ;
-export let useWrite = (argument1, argument2) => {
+export let useSynchronousWrite = (argument1, argument2) => {
     if (isObject(argument1)) {
         if (isFunction(argument2)) {
             let stream = argument1;
             let accumulator = argument2;
-            return Collector.full(() => Promise.resolve(stream), (promise, element, index) => {
+            return SynchronousCollector.full(() => Promise.resolve(stream), (promise, element, index) => {
                 return new Promise((resolve, reject) => {
                     promise.then((stream) => {
                         try {
@@ -477,7 +501,7 @@ export let useWrite = (argument1, argument2) => {
         }
         else {
             let stream = argument1;
-            return Collector.full(() => Promise.resolve(stream), (promise, element) => {
+            return SynchronousCollector.full(() => Promise.resolve(stream), (promise, element) => {
                 return new Promise((resolve, reject) => {
                     promise.then((stream) => {
                         try {
@@ -496,23 +520,23 @@ export let useWrite = (argument1, argument2) => {
     throw new TypeError("Invalid arguments.");
 };
 ;
-export let useNumericSummate = (mapper = useToNumber) => {
-    return Collector.full(() => 0, (accumulator, element) => {
+export let useSynchronousNumericSummate = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => 0, (accumulator, element) => {
         let resolved = isNumber(element) ? element : mapper(element);
         return accumulator + (isNumber(resolved) ? resolved : 0);
     }, (result) => result);
 };
 ;
-export let useBigIntSummate = (mapper = useToBigInt) => {
-    return Collector.full(() => 0n, (accumulator, element) => {
+export let useSynchronousBigIntSummate = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => 0n, (accumulator, element) => {
         let resolved = isBigInt(element) ? element : mapper(element);
         return accumulator + (isBigInt(resolved) ? resolved : 0n);
     }, (result) => result);
 };
 ;
 ;
-export let useNumericAverage = (mapper = useToNumber) => {
-    return Collector.full(() => {
+export let useSynchronousNumericAverage = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0,
             count: 0
@@ -532,8 +556,8 @@ export let useNumericAverage = (mapper = useToNumber) => {
 };
 ;
 ;
-export let useBigIntAverage = (mapper = useToBigInt) => {
-    return Collector.full(() => {
+export let useSynchronousBigIntAverage = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0n,
             count: 0n
@@ -551,16 +575,16 @@ export let useBigIntAverage = (mapper = useToBigInt) => {
         return result.summate / result.count;
     });
 };
-export let useFrequency = () => {
-    return Collector.full(() => new Map(), (map, element) => {
+export let useSynchronousFrequency = () => {
+    return SynchronousCollector.full(() => new Map(), (map, element) => {
         let count = map.get(element) || 0n;
         map.set(element, count + 1n);
         return map;
     }, (map) => map);
 };
 ;
-export let useNumericMode = (mapper = useToNumber) => {
-    return Collector.full(() => new Map(), (map, element) => {
+export let useSynchronousNumericMode = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => new Map(), (map, element) => {
         let resolved = isNumber(element) ? element : mapper(element);
         let count = map.get(resolved) || 0n;
         map.set(resolved, count + 1n);
@@ -578,8 +602,8 @@ export let useNumericMode = (mapper = useToNumber) => {
     });
 };
 ;
-export let useBigIntMode = (mapper = useToBigInt) => {
-    return Collector.full(() => new Map(), (map, element) => {
+export let useSynchronousBigIntMode = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => new Map(), (map, element) => {
         let resolved = isBigInt(element) ? element : mapper(element);
         let count = map.get(resolved) || 0n;
         map.set(resolved, count + 1n);
@@ -598,8 +622,8 @@ export let useBigIntMode = (mapper = useToBigInt) => {
 };
 ;
 ;
-export let useNumericVariance = (mapper = useToNumber) => {
-    return Collector.full(() => {
+export let useSynchronousNumericVariance = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0,
             summateOfSquares: 0,
@@ -623,8 +647,8 @@ export let useNumericVariance = (mapper = useToNumber) => {
 };
 ;
 ;
-export let useBigIntVariance = (mapper = useToBigInt) => {
-    return Collector.full(() => {
+export let useSynchronousBigIntVariance = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0n,
             summateOfSquares: 0n,
@@ -648,8 +672,8 @@ export let useBigIntVariance = (mapper = useToBigInt) => {
 };
 ;
 ;
-export let useNumericStandardDeviation = (mapper = useToNumber) => {
-    return Collector.full(() => {
+export let useSynchronousNumericStandardDeviation = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0,
             summateOfSquares: 0,
@@ -674,8 +698,8 @@ export let useNumericStandardDeviation = (mapper = useToNumber) => {
 };
 ;
 ;
-export let useBigIntStandardDeviation = (mapper = useToBigInt) => {
-    return Collector.full(() => {
+export let useSynchronousBigIntStandardDeviation = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => {
         return {
             summate: 0n,
             summateOfSquares: 0n,
@@ -699,8 +723,8 @@ export let useBigIntStandardDeviation = (mapper = useToBigInt) => {
     });
 };
 ;
-export let useNumericMedian = (mapper = useToNumber) => {
-    return Collector.full(() => [], (array, element) => {
+export let useSynchronousNumericMedian = (mapper = useToNumber) => {
+    return SynchronousCollector.full(() => [], (array, element) => {
         let resolved = isNumber(element) ? element : mapper(element);
         array.push(resolved);
         array.sort((a, b) => a - b);
@@ -718,8 +742,8 @@ export let useNumericMedian = (mapper = useToNumber) => {
     });
 };
 ;
-export let useBigIntMedian = (mapper = useToBigInt) => {
-    return Collector.full(() => [], (array, element) => {
+export let useSynchronousBigIntMedian = (mapper = useToBigInt) => {
+    return SynchronousCollector.full(() => [], (array, element) => {
         let resolved = isBigInt(element) ? element : mapper(element);
         array.push(resolved);
         array.sort((a, b) => Number(a - b));
@@ -736,8 +760,8 @@ export let useBigIntMedian = (mapper = useToBigInt) => {
         }
     });
 };
-export let useToGeneratorFunction = () => {
-    return Collector.full(() => [], (array, element) => {
+export let useSynchronousToGeneratorFunction = () => {
+    return SynchronousCollector.full(() => [], (array, element) => {
         array.push(element);
         return array;
     }, (array) => {
@@ -748,8 +772,8 @@ export let useToGeneratorFunction = () => {
         })();
     });
 };
-export let useToAsyncGeneratorFunction = () => {
-    return Collector.full(() => [], (array, element) => {
+export let useSynchronousToAsyncGeneratorFunction = () => {
+    return SynchronousCollector.full(() => [], (array, element) => {
         array.push(element);
         return array;
     }, (array) => {