semantic-typescript 0.3.8 → 0.5.0

package/dist/collector.d.ts

@@ -1,12 +1,14 @@
 import type { Collectable } from "./collectable";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
 import type { Semantic } from "./semantic";
+import { HashSet } from "./set";
 import { type BiFunctional, type BiPredicate, type Functional, type Predicate, type Supplier, type TriFunctional, type Generator, type TriPredicate, type Consumer, type BiConsumer, type Comparator } from "./utility";
 export declare class Collector<E, A, R> {
-    protected readonly identity: Supplier<A>;
-    protected readonly interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
-    protected readonly accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
-    protected readonly finisher: Functional<A, R>;
+    protected identity: Supplier<A>;
+    protected interrupt: Predicate<E> | BiPredicate<E, bigint> | TriPredicate<E, bigint, A>;
+    protected accumulator: BiFunctional<A, E, A> | TriFunctional<A, E, bigint, A>;
+    protected finisher: Functional<A, R>;
     protected readonly Collector: symbol;
     protected constructor(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
     protected constructor(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>);
@@ -20,29 +22,37 @@ export declare class Collector<E, A, 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>;
     static full<E, A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
-    static shortable<E, A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): 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>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    static shortable<E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+}
+interface UseAnyMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useAnyMatch: UseAnyMatch;
+interface UseAllMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useAllMatch: UseAllMatch;
 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>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: BiPredicate<E, bigint>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): Collector<E, A, R>;
+    <E, A, R>(identity: Supplier<A>, interrupt: 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 {
+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>;
@@ -50,28 +60,46 @@ export interface UseError {
     <E = unknown>(prefix: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
 }
 export declare let useError: UseError;
+interface UseFindAt {
+    <E>(index: number): Collector<E, Array<E>, Optional<E>>;
+    <E>(index: bigint): Collector<E, Array<E>, Optional<E>>;
+}
+export declare let useFindAt: UseFindAt;
 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 UseFindMaximum {
+interface UseFindMaximum {
     <E>(): Collector<E, Optional<E>, Optional<E>>;
     <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
 }
 export declare let useFindMaximum: UseFindMaximum;
-export interface UseFindMinimum {
+interface UseFindMinimum {
     <E>(): Collector<E, Optional<E>, Optional<E>>;
     <E>(comparator: Comparator<E>): Collector<E, Optional<E>, Optional<E>>;
 }
 export declare let useFindMinimum: UseFindMinimum;
-export interface UseForEach {
+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 {
+interface UseNonMatch {
+    <E>(predicate: Predicate<E>): Collector<E, boolean, boolean>;
+    <E>(predicate: BiPredicate<E, bigint>): Collector<E, boolean, boolean>;
+}
+export declare let useNoneMatch: UseNonMatch;
+interface UseGroup {
+    <E, K>(classifier: Functional<E, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K>(classifier: BiFunctional<E, bigint, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
+}
+export declare let useGroup: UseGroup;
+interface UseGroupBy {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E[]>, Map<K, E[]>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V[]>, Map<K, V[]>>;
+}
+export declare let useGroupBy: UseGroupBy;
+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>;
@@ -79,7 +107,7 @@ export interface UseJoin {
     <E = unknown>(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): Collector<E, string, string>;
 }
 export declare let useJoin: UseJoin;
-export interface UseLog {
+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>;
@@ -88,8 +116,12 @@ export interface UseLog {
 }
 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 {
+interface UsePartitionBy {
+    <E>(classifier: Functional<E, bigint>): Collector<E, Array<E[]>, Array<E[]>>;
+    <E>(classifier: BiFunctional<E, bigint, bigint>): Collector<E, Array<E[]>, Array<E[]>>;
+}
+export declare let usePartitionBy: UsePartitionBy;
+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>;
@@ -99,99 +131,111 @@ export interface UseReduce {
 }
 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>>;
+interface UseToMap {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, Map<K, E>, Map<K, E>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, Map<K, V>, Map<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, Map<K, V>, Map<K, V>>;
+}
+export declare let useToMap: UseToMap;
+interface UseToHashMap {
+    <E, K>(keyExtractor: Functional<E, K>): Collector<E, HashMap<K, E>, HashMap<K, E>>;
+    <E, K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
+    <E, K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Collector<E, HashMap<K, V>, HashMap<K, V>>;
+}
+export declare let useToHashMap: UseToHashMap;
 export declare let useToSet: <E>() => Collector<E, Set<E>, Set<E>>;
-export interface UseWrite {
+export declare let useToHashSet: <E>() => Collector<E, HashSet<E>, HashSet<E>>;
+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 interface UseNumericSummate {
+interface UseNumericSummate {
     <E>(): Collector<E, number, number>;
     <E>(mapper: Functional<E, number>): Collector<E, number, number>;
 }
 export declare let useNumericSummate: UseNumericSummate;
-export interface UseBigIntSummate {
+interface UseBigIntSummate {
     <E>(): Collector<E, bigint, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, bigint, bigint>;
 }
 export declare let useBigIntSummate: UseBigIntSummate;
-export interface UseNumericAverage {
+interface UseNumericAverage {
     <E>(): Collector<E, NumericAverageAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, NumericAverageAccumulator, number>;
 }
-export interface NumericAverageAccumulator {
+interface NumericAverageAccumulator {
     summate: number;
     count: number;
 }
 export declare let useNumericAverage: UseNumericAverage;
-export interface UseBigIntAverage {
+interface UseBigIntAverage {
     <E>(): Collector<E, BigIntAverageAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntAverageAccumulator, bigint>;
 }
-export interface BigIntAverageAccumulator {
+interface BigIntAverageAccumulator {
     summate: bigint;
     count: bigint;
 }
 export declare let useBigIntAverage: UseBigIntAverage;
 export declare let useFrequency: <E>() => Collector<E, Map<E, bigint>, Map<E, bigint>>;
-export interface UseNumericMode {
+interface UseNumericMode {
     <E>(): Collector<E, Map<number, bigint>, number>;
     <E>(mapper: Functional<E, number>): Collector<E, Map<number, bigint>, number>;
 }
 export declare let useNumericMode: UseNumericMode;
-export interface UseBigIntMode {
+interface UseBigIntMode {
     <E>(): Collector<E, Map<bigint, bigint>, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, Map<bigint, bigint>, bigint>;
 }
 export declare let useBigIntMode: UseBigIntMode;
-export interface UseNumericVariance {
+interface UseNumericVariance {
     <E>(): Collector<E, VarianceAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, VarianceAccumulator, number>;
 }
-export interface VarianceAccumulator {
+interface VarianceAccumulator {
     summate: number;
     summateOfSquares: number;
     count: number;
 }
 export declare let useNumericVariance: UseNumericVariance;
-export interface UseBigIntVariance {
+interface UseBigIntVariance {
     <E>(): Collector<E, BigIntVarianceAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntVarianceAccumulator, bigint>;
 }
-export interface BigIntVarianceAccumulator {
+interface BigIntVarianceAccumulator {
     summate: bigint;
     summateOfSquares: bigint;
     count: bigint;
 }
 export declare let useBigIntVariance: UseBigIntVariance;
-export interface UseNumericStandardDeviation {
+interface UseNumericStandardDeviation {
     <E>(): Collector<E, StandardDeviationAccumulator, number>;
     <E>(mapper: Functional<E, number>): Collector<E, StandardDeviationAccumulator, number>;
 }
-export interface StandardDeviationAccumulator {
+interface StandardDeviationAccumulator {
     summate: number;
     summateOfSquares: number;
     count: number;
 }
 export declare let useNumericStandardDeviation: UseNumericStandardDeviation;
-export interface UseBigIntStandardDeviation {
+interface UseBigIntStandardDeviation {
     <E>(): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, BigIntStandardDeviationAccumulator, bigint>;
 }
-export interface BigIntStandardDeviationAccumulator {
+interface BigIntStandardDeviationAccumulator {
     summate: bigint;
     summateOfSquares: bigint;
     count: bigint;
 }
 export declare let useBigIntStandardDeviation: UseBigIntStandardDeviation;
-export interface UseNumericMedian {
+interface UseNumericMedian {
     <E>(): Collector<E, number[], number>;
     <E>(mapper: Functional<E, number>): Collector<E, number[], number>;
 }
 export declare let useNumericMedian: UseNumericMedian;
-export interface UseBigIntMedian {
+interface UseBigIntMedian {
     <E>(): Collector<E, bigint[], bigint>;
     <E>(mapper: Functional<E, bigint>): Collector<E, bigint[], bigint>;
 }

package/dist/collector.js

@@ -1,6 +1,8 @@
 import { isBigInt, isBoolean, isCollectable, isFunction, isIterable, isNumber, isObject, isSemantic, isString } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
+import { HashSet } from "./set";
 import { CollectableSymbol } from "./symbol";
 import { validate, invalidate } from "./utility";
 export class Collector {
@@ -17,34 +19,34 @@ export class Collector {
             this.finisher = finisher;
             Object.defineProperties(this, {
                 "identity": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: identity,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "interrupt": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: interrupt,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "accumulator": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: accumulator,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "finisher": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: finisher,
+                    writable: false,
+                    enumerable: true,
+                    configurable: false
                 },
                 "Collector": {
-                    enumerable: false,
-                    writable: false,
-                    configurable: false,
                     value: CollectableSymbol,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
                 }
             });
             Object.freeze(this);
@@ -57,98 +59,68 @@ export class Collector {
         let accumulator = this.identity();
         let count = 0n;
         if (isFunction(argument1)) {
-            try {
-                let generator = argument1;
-                generator((element, index) => {
-                    accumulator = this.accumulator(accumulator, element, index);
-                    count++;
-                }, (element, index) => this.interrupt(element, index, accumulator));
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
-            }
+            let generator = argument1;
+            generator((element, index) => {
+                accumulator = this.accumulator(accumulator, element, index);
+                count++;
+            }, (element, index) => this.interrupt(element, index, accumulator));
         }
         else if (isIterable(argument1)) {
-            try {
-                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++;
+            let iterable = argument1;
+            let index = 0n;
+            for (let element of iterable) {
+                if (this.interrupt(element, index, accumulator)) {
+                    break;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, element, count);
+                count++;
+                index++;
             }
         }
         else if (isSemantic(argument1)) {
-            try {
-                let semantic = argument1;
-                let generator = Reflect.get(semantic, "generator");
-                if (isFunction(generator)) {
-                    generator((element, index) => {
-                        accumulator = this.accumulator(accumulator, element, index);
-                        count++;
-                    }, (element, index) => this.interrupt(element, index, accumulator));
-                }
-                else {
-                    throw new TypeError("Invalid arguments");
-                }
+            let semantic = argument1;
+            let generator = Reflect.get(semantic, "generator");
+            if (isFunction(generator)) {
+                generator((element, index) => {
+                    accumulator = this.accumulator(accumulator, element, index);
+                    count++;
+                }, (element, index) => this.interrupt(element, index, accumulator));
             }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+            else {
+                throw new TypeError("Invalid arguments");
             }
         }
         else if (isCollectable(argument1)) {
-            try {
-                let collectable = argument1;
-                let source = collectable.source();
-                if (isFunction(source)) {
-                    let generator = source;
-                    generator((element, index) => {
-                        accumulator = this.accumulator(accumulator, element, index);
-                        count++;
-                    }, (element, index) => this.interrupt(element, index, accumulator));
-                }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+            let collectable = argument1;
+            let source = collectable.source();
+            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)) {
-            try {
-                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;
-                    }
-                    accumulator = this.accumulator(accumulator, i, count);
-                    count++;
+            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;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
-            try {
-                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;
-                    }
-                    accumulator = this.accumulator(accumulator, i, count);
-                    count++;
+            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;
                 }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on collect.");
+                accumulator = this.accumulator(accumulator, i, count);
+                count++;
             }
         }
         return this.finisher(accumulator);
@@ -156,23 +128,22 @@ export class Collector {
     static full(identity, accumulator, finisher) {
         return new Collector(identity, () => false, accumulator, finisher);
     }
-    static shortable(identity, interruptor, accumulator, finisher) {
-        return new Collector(identity, interruptor, accumulator, finisher);
+    static shortable(identity, interrupt, accumulator, finisher) {
+        return new Collector(identity, interrupt, accumulator, finisher);
     }
 }
 ;
-Object.freeze(Collector);
-Object.freeze(Collector.prototype);
-Object.freeze(Object.getPrototypeOf(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);
+        return Collector.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) => {
     if (isFunction(predicate)) {
-        return Collector.shortable(() => true, (_element, _index, accumulator) => isBoolean(accumulator) && !accumulator, (accumulator, element) => accumulator && predicate(element), (accumulator) => accumulator);
+        return Collector.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.");
 };
@@ -231,6 +202,31 @@ export let useError = (argument1, argument2, argument3) => {
         });
     }
 };
+;
+export let useFindAt = (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();
+            }
+            let limited = (((BigInt(accumulator.length)) % target) + target) % target;
+            return Optional.ofNullable(accumulator[Number(limited)]);
+        });
+    }
+    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 Optional.ofNullable(accumulator[Number(target)]);
+    });
+};
 export let useFindFirst = () => {
     return Collector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
         if (validate(accumulator) && accumulator.isPresent()) {
@@ -281,16 +277,18 @@ export let useForEach = (action) => {
     }
     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);
+        return Collector.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) => {
     if (isFunction(classifier)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = classifier(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = classifier(element, index);
             let group = accumulator.get(key) || [];
             group.push(element);
             accumulator.set(key, group);
@@ -299,12 +297,12 @@ export let useGroup = (classifier) => {
     }
     throw new TypeError("Classifier must be a function.");
 };
-export let useGroupBy = (keyExtractor, valueExtractor) => {
+export let useGroupBy = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (accumulator, element) => {
-            let key = keyExtractor(element);
+        return Collector.full(() => new Map(), (accumulator, element, index) => {
+            let key = keyExtractor(element, index);
             let group = accumulator.get(key) || [];
-            group.push(valueExtractor(element));
+            group.push(valueExtractor(element, index));
             accumulator.set(key, group);
             return accumulator;
         }, (accumulator) => accumulator);
@@ -388,13 +386,14 @@ export let usePartition = (count) => {
     }
     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, element, index) => {
+            let resolved = classifier(element, index);
+            while (resolved > BigInt(array.length) - 1n) {
                 array.push([]);
             }
             array[Number(index)].push(element);
@@ -440,11 +439,24 @@ export let useToArray = () => {
         return array;
     }, (array) => array);
 };
-export let useToMap = (keyExtractor, valueExtractor) => {
+;
+export let useToMap = (keyExtractor, valueExtractor = (element) => element) => {
     if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
-        return Collector.full(() => new Map(), (map, element) => {
-            let key = keyExtractor(element);
-            let value = valueExtractor(element);
+        return Collector.full(() => new Map(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
+            map.set(key, value);
+            return map;
+        }, (map) => map);
+    }
+    throw new TypeError("Key extractor and value extractor must be functions.");
+};
+;
+export let useToHashMap = (keyExtractor, valueExtractor = (element) => element) => {
+    if (isFunction(keyExtractor) && isFunction(valueExtractor)) {
+        return Collector.full(() => new HashMap(), (map, element, index) => {
+            let key = keyExtractor(element, index);
+            let value = valueExtractor(element, index);
             map.set(key, value);
             return map;
         }, (map) => map);
@@ -457,6 +469,12 @@ export let useToSet = () => {
         return set;
     }, (set) => set);
 };
+export let useToHashSet = () => {
+    return Collector.full(() => new HashSet(), (set, element) => {
+        set.add(element);
+        return set;
+    }, (set) => set);
+};
 ;
 export let useWrite = (argument1, argument2) => {
     if (isObject(argument1)) {