semantic-typescript 0.6.0 → 0.7.0

package/dist/synchronous/collector.js

@@ -1,8 +1,8 @@
-import { isFunction, isIterable, isNumber, isBigInt, isBoolean, isString, isObject } from "../guard";
+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 { validate, invalidate } from "../utility";
+import { invalidate, validate } from "../utility";
 export class SynchronousCollector {
     identity;
     interrupt;
@@ -54,7 +54,7 @@ export class SynchronousCollector {
         }
     }
     collect(argument1, argument2) {
-        if (isFunction(argument1)) {
+        if (isAsyncFunction(argument1) || isFunction(argument1)) {
             try {
                 let generator = argument1;
                 let accumulator = this.identity();
@@ -66,29 +66,25 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         else if (isIterable(argument1)) {
             try {
                 let iterable = argument1;
-                let index = 0n;
                 let accumulator = this.identity();
                 let count = 0n;
                 for (let element of iterable) {
-                    if (this.interrupt(element, index, accumulator)) {
+                    if (this.interrupt(element, count, accumulator)) {
                         break;
                     }
                     accumulator = this.accumulator(accumulator, element, count);
                     count++;
-                    index++;
                 }
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error n collect.");
+                throw error;
             }
         }
         else if (isNumber(argument1) && isNumber(argument2)) {
@@ -107,8 +103,7 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         else if (isBigInt(argument1) && isBigInt(argument2)) {
@@ -127,12 +122,23 @@ export class SynchronousCollector {
                 return this.finisher(accumulator);
             }
             catch (error) {
-                console.error(error);
-                throw new Error("Uncaught error on collect.");
+                throw error;
             }
         }
         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 SynchronousCollector(identity, () => false, accumulator, finisher);
     }
@@ -173,7 +179,7 @@ export let useSynchronousCollect = (argument1, argument2, argument3, argument4)
     throw new TypeError("Identity, accumulator, and finisher must be functions.");
 };
 export let useSynchronousCount = () => {
-    return SynchronousCollector.full(() => 0n, (count) => count + 1n, (count) => count);
+    return SynchronousCollector.full(() => 0n, (count) => isBigInt(count) ? (count + 1n) : 1n, (count) => isBigInt(count) ? count : 0n);
 };
 ;
 export let useSynchronousError = (argument1, argument2, argument3) => {
@@ -215,65 +221,78 @@ export let useSynchronousFindAt = (index) => {
     let target = useToBigInt(index);
     if (target < 0n) {
         return SynchronousCollector.full(() => [], (accumulator, element) => {
-            accumulator.push(element);
-            return accumulator;
-        }, (accumulator) => {
-            if (accumulator.length === 0) {
-                return Optional.empty();
+            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 SynchronousCollector.shortable(() => [], (_element, _index, accumulator) => BigInt(accumulator.length) - 1n === target, (accumulator, element) => {
-        accumulator.push(element);
-        return accumulator;
-    }, (accumulator) => {
-        if (accumulator.length === 0) {
-            return Optional.empty();
+        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 useSynchronousFindFirst = () => {
     return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent()) {
-            return accumulator;
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
-    }, (accumulator) => accumulator);
+        return accumulator;
+    }, (result) => result);
 };
 export let useSynchronousFindAny = () => {
     return SynchronousCollector.shortable(() => Optional.empty(), (_element, _index, accumulator) => validate(accumulator) && accumulator.isPresent(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent() && Math.random() < 0.5) {
-            return accumulator;
+        if (validate(accumulator) && accumulator.isPresent() && validate(element) && Math.random() < 0.5) {
+            return Optional.of(element);
         }
-        return Optional.ofNullable(element);
-    }, (accumulator) => accumulator);
+        return accumulator;
+    }, (result) => result);
 };
 export let useSynchronousFindLast = () => {
     return SynchronousCollector.full(() => Optional.empty(), (accumulator, element) => {
-        if (validate(accumulator) && accumulator.isPresent()) {
-            return Optional.ofNullable(element);
+        if (validate(accumulator) && accumulator.isPresent() && validate(element)) {
+            return Optional.of(element);
         }
         return accumulator;
-    }, (accumulator) => accumulator);
+    }, (result) => result);
 };
 export let useSynchronousFindMaximum = (comparator = (useCompare)) => {
-    return SynchronousCollector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) > 0 ? accumulator : Optional.ofNullable(element);
-        }
-        return Optional.ofNullable(element);
-    }, (result) => result);
+    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)) => {
-    return SynchronousCollector.full(() => Optional.ofNullable(), (accumulator, element) => {
-        if (accumulator.isPresent()) {
-            return comparator(accumulator.get(), element) < 0 ? accumulator : Optional.ofNullable(element);
-        }
-        return Optional.ofNullable(element);
-    }, (result) => result);
+    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 useSynchronousForEach = (action) => {
@@ -364,7 +383,6 @@ export let useSynchronousLog = (argument1, argument2, argument3) => {
     }
     else {
         return SynchronousCollector.full(() => "[", (accumulator, element) => {
-            console.log(element);
             if (isString(accumulator) && isString(element)) {
                 return accumulator + element + ",";
             }
@@ -416,14 +434,11 @@ export let useSynchronousPartitionBy = (classifier) => {
 export let useSynchronousReduce = (argument1, argument2, argument3) => {
     if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
         let accumulator = argument1;
-        return SynchronousCollector.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)) {

package/dist/synchronous/semantic.d.ts

@@ -1,9 +1,10 @@
+import { type BiConsumer, type BiFunctional, type BiPredicate, type Comparator, type Consumer, type Functional, type Indexed, type Predicate, type Supplier, type SynchronousGenerator, type TriFunctional, type TriPredicate } from "../utility";
 import { SynchronousCollector } from "./collector";
 import type { Optional } from "../optional";
-import type { BiConsumer, BiFunctional, BiPredicate, Comparator, Consumer, Functional, Indexed, Predicate, Supplier, SynchronousGenerator, TriFunctional, TriPredicate } from "../utility";
 export declare class SynchronousSemantic<E> {
     protected generator: SynchronousGenerator<E>;
     protected readonly SynchronousSemantic: Symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     concat(other: SynchronousSemantic<E>): SynchronousSemantic<E>;
     concat(other: Iterable<E>): SynchronousSemantic<E>;
@@ -22,8 +23,8 @@ export declare class SynchronousSemantic<E> {
     flatMap<R>(mapper: BiFunctional<E, bigint, Iterable<R>>): SynchronousSemantic<R>;
     flatMap<R>(mapper: Functional<E, SynchronousSemantic<R>>): SynchronousSemantic<R>;
     flatMap<R>(mapper: BiFunctional<E, bigint, SynchronousSemantic<R>>): SynchronousSemantic<R>;
-    limit(n: number): SynchronousSemantic<E>;
-    limit(n: bigint): SynchronousSemantic<E>;
+    limit(count: number): SynchronousSemantic<E>;
+    limit(count: bigint): SynchronousSemantic<E>;
     map<R>(mapper: Functional<E, R>): SynchronousSemantic<R>;
     map<R>(mapper: BiFunctional<E, bigint, R>): SynchronousSemantic<R>;
     peek(consumer: Consumer<E>): SynchronousSemantic<E>;
@@ -32,16 +33,15 @@ export declare class SynchronousSemantic<E> {
     reverse(): SynchronousSemantic<E>;
     shuffle(): SynchronousSemantic<E>;
     shuffle(mapper: BiFunctional<E, bigint, bigint>): SynchronousSemantic<E>;
-    skip(n: number): SynchronousSemantic<E>;
-    skip(n: bigint): SynchronousSemantic<E>;
+    skip(count: number): SynchronousSemantic<E>;
+    skip(count: bigint): SynchronousSemantic<E>;
     source(): SynchronousGenerator<E>;
-    sorted(): SynchronousOrderedCollectable<E>;
-    sorted(comparator: Comparator<E>): SynchronousOrderedCollectable<E>;
+    sub(start: number, end: number): SynchronousSemantic<E>;
     sub(start: bigint, end: bigint): SynchronousSemantic<E>;
     takeWhile(predicate: Predicate<E>): SynchronousSemantic<E>;
     takeWhile(predicate: BiPredicate<E, bigint>): SynchronousSemantic<E>;
-    toSynchronousCollectable(): SynchronousCollectable<E>;
-    toSynchronousCollectable<C extends SynchronousCollectable<E>>(mapper: Functional<SynchronousGenerator<E>, C>): C;
+    toCollectable(): SynchronousCollectable<E>;
+    toCollectable<C extends SynchronousCollectable<E>>(mapper: Functional<SynchronousGenerator<E>, C>): C;
     toBigintStatistics(): SynchronousBigIntStatistics<E>;
     toNumericStatistics(): SynchronousNumericStatistics<E>;
     toOrdered(): SynchronousOrderedCollectable<E>;
@@ -51,13 +51,15 @@ export declare class SynchronousSemantic<E> {
     translate(offset: bigint): SynchronousSemantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): SynchronousSemantic<E>;
 }
-export declare abstract class SynchronousCollectable<E> {
+export declare abstract class SynchronousCollectable<E> implements Iterable<E> {
     protected readonly SynchronousCollectable: symbol;
+    [Symbol.toStringTag]: string;
     constructor();
-    abstract [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    abstract [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
     anyMatch(predicate: Predicate<E>): boolean;
+    anyMatch(predicate: BiPredicate<E, bigint>): boolean;
     allMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: BiPredicate<E, bigint>): boolean;
     collect<A, R>(collector: SynchronousCollector<E, A, R>): R;
     collect<A, R>(identity: Supplier<A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
     collect<A, R>(identity: Supplier<A>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
@@ -104,8 +106,8 @@ export declare abstract class SynchronousCollectable<E> {
     partition(count: bigint): Array<Array<E>>;
     partitionBy(classifier: Functional<E, bigint>): Array<Array<E>>;
     partitionBy(classifier: BiFunctional<E, bigint, bigint>): Array<Array<E>>;
-    reduce(accumulator: BiFunctional<E, E, E>): Optional<E>;
-    reduce(accumulator: TriFunctional<E, E, bigint, E>): Optional<E>;
+    reduce(accumulator: BiFunctional<E, E, E>): E;
+    reduce(accumulator: TriFunctional<E, E, bigint, E>): 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: Functional<R, R>): R;
@@ -122,30 +124,32 @@ export declare abstract class SynchronousCollectable<E> {
     write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;
 }
 export declare class SynchronousOrderedCollectable<E> extends SynchronousCollectable<E> {
-    protected readonly SynchronousOrderedCollectable: symbol;
+    protected readonly OrderedCollectable: symbol;
     protected buffer: Array<Indexed<E>>;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    allMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: BiPredicate<E, bigint>): boolean;
     source(): SynchronousGenerator<E>;
     isEmpty(): boolean;
+    count(): bigint;
 }
 export declare class SynchronousUnorderedCollectable<E> extends SynchronousCollectable<E> {
     protected readonly SynchronousUnorderedCollectable: symbol;
+    [Symbol.toStringTag]: string;
     protected buffer: Map<bigint, E>;
     constructor(generator: SynchronousGenerator<E>);
-    source(): SynchronousGenerator<E>;
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    source(): SynchronousGenerator<E>;
 }
 export declare abstract class SynchronousStatistics<E, D extends number | bigint> extends SynchronousOrderedCollectable<E> {
     protected readonly SynchronousStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
-    count(): bigint;
     abstract average(): D;
     abstract average(mapper: Functional<E, D>): D;
     abstract range(): D;
@@ -174,10 +178,10 @@ export declare abstract class SynchronousStatistics<E, D extends number | bigint
 }
 export declare class SynchronousBigIntStatistics<E> extends SynchronousStatistics<E, bigint> {
     protected readonly BigIntStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
     average(): bigint;
     average(mapper: Functional<E, bigint>): bigint;
     range(): bigint;
@@ -205,10 +209,10 @@ export declare class SynchronousBigIntStatistics<E> extends SynchronousStatistic
 }
 export declare class SynchronousNumericStatistics<E> extends SynchronousStatistics<E, number> {
     protected readonly SynchronousNumericStatistics: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
     average(): number;
     average(mapper: Functional<E, number>): number;
     range(): number;
@@ -236,10 +240,10 @@ export declare class SynchronousNumericStatistics<E> extends SynchronousStatisti
 }
 export declare class SynchronousWindowCollectable<E> extends SynchronousOrderedCollectable<E> {
     protected readonly WindowCollectable: symbol;
+    [Symbol.toStringTag]: string;
     constructor(generator: SynchronousGenerator<E>);
     constructor(generator: SynchronousGenerator<E>, comparator: Comparator<E>);
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
-    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
     slide(size: bigint, step?: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
     tumble(size: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
 }