semantic-typescript 0.4.1 → 0.5.3

package/dist/optional.d.ts

@@ -1,17 +1,20 @@
 import type { Semantic } from "./semantic";
-import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable } from "./utility";
+import { type Consumer, type Functional, type MaybeInvalid, type Predicate, type Runnable, type Valid } from "./utility";
 export declare class Optional<T> {
     protected value: MaybeInvalid<T>;
     protected readonly Optional: Symbol;
     protected constructor(value: MaybeInvalid<T>);
     filter(predicate: Predicate<T>): Optional<T>;
-    get(): T;
-    get(defaultValue: T): T;
+    get(): Valid<T>;
+    get(defaultValue: T): Valid<T>;
     ifPresent(action: Consumer<T>): void;
     ifPresent(action: Consumer<T>, elseAction: Runnable): void;
     isEmpty(): boolean;
     isPresent(): boolean;
     map<R>(mapper: Functional<T, R>): Optional<R>;
+    flat(mapper: Functional<T, Optional<T>>): Optional<T>;
+    flatMap<R>(mapper: Functional<T, Optional<R>>): Optional<R>;
+    orElse(other: MaybeInvalid<T>): MaybeInvalid<T>;
     semantic(): Semantic<T>;
     static empty<T>(): Optional<T>;
     static of<T>(value: MaybeInvalid<T>): Optional<T>;

package/dist/optional.js

@@ -1,5 +1,5 @@
-import { empty, generate } from "./factory";
-import { isFunction } from "./guard";
+import { useEmpty, useOf } from "./factory";
+import { isFunction, isOptional } from "./guard";
 import { OptionalSymbol } from "./symbol";
 import { invalidate, validate } from "./utility";
 export class Optional {
@@ -62,15 +62,37 @@ export class Optional {
         }
         return new Optional(null);
     }
+    flat(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            let result = mapper(this.value);
+            if (isOptional(result)) {
+                return result;
+            }
+            throw new TypeError("Must return an Optional.");
+        }
+        return new Optional(null);
+    }
+    flatMap(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            let result = mapper(this.value);
+            if (isOptional(result)) {
+                return result;
+            }
+            throw new TypeError("Must return an Optional.");
+        }
+        return new Optional(null);
+    }
+    orElse(other) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        return other;
+    }
     semantic() {
         if (this.isPresent()) {
-            return generate(() => {
-                return this.value;
-            }, () => {
-                return this.isEmpty();
-            });
+            return useOf(this.value);
         }
-        return empty();
+        return useEmpty();
     }
     static empty() {
         return new Optional(null);

package/dist/semantic.d.ts

@@ -1,8 +1,7 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
-import { BigIntStatistics, NumericStatistics } from "./statistics";
+import { Collector } from "./collector";
+import type { Optional } from "./optional";
 import { type Predicate } from "./utility";
-import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate } from "./utility";
-import { WindowCollectable } from "./window";
+import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate, Indexed, Supplier, TriFunctional, TriPredicate } from "./utility";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;
@@ -44,6 +43,7 @@ export declare class Semantic<E> {
     toCollectable(): Collectable<E>;
     toCollectable<C extends Collectable<E>>(mapper: Functional<Generator<E>, C>): C;
     toBigintStatistics(): BigIntStatistics<E>;
+    toEvent(): EventCollectable<E>;
     toNumericStatistics(): NumericStatistics<E>;
     toOrdered(): OrderedCollectable<E>;
     toUnordered(): UnorderedCollectable<E>;
@@ -52,3 +52,203 @@ export declare class Semantic<E> {
     translate(offset: bigint): Semantic<E>;
     translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
 }
+export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterable<E> {
+    protected readonly Collectable: symbol;
+    constructor();
+    abstract [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    abstract [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    anyMatch(predicate: Predicate<E>): boolean;
+    allMatch(predicate: Predicate<E>): boolean;
+    collect<A, R>(collector: Collector<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;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: BiPredicate<E, bigint>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: TriPredicate<E, bigint, A>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
+    collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: TriFunctional<A, E, bigint, A>, finisher: Functional<A, R>): R;
+    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>;
+    findAt(index: number): Optional<E>;
+    findAt(index: bigint): Optional<E>;
+    findFirst(): Optional<E>;
+    findLast(): Optional<E>;
+    findMaximum(): Optional<E>;
+    findMaximum(comparator: Comparator<E>): Optional<E>;
+    findMinimum(): Optional<E>;
+    findMinimum(comparator: Comparator<E>): Optional<E>;
+    forEach(action: Consumer<E>): void;
+    forEach(action: BiConsumer<E, bigint>): void;
+    group<K>(classifier: Functional<E, K>): Map<K, Array<E>>;
+    group<K>(classifier: BiFunctional<E, bigint, K>): Map<K, Array<E>>;
+    groupBy<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, Array<V>>;
+    groupBy<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, K>): Map<K, Array<V>>;
+    join(): string;
+    join(delimiter: string): string;
+    join(prefix: string, delimiter: string, suffix: string): string;
+    join(prefiex: string, accumulator: BiFunctional<string, E, string>, suffix: string): string;
+    join(prefiex: string, accumulator: TriFunctional<string, E, bigint, string>, suffix: string): string;
+    log(): void;
+    log(accumulator: BiFunctional<string, E, 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;
+    nonMatch(predicate: BiPredicate<E, bigint>): boolean;
+    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(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;
+    reduce<R>(identity: R, accumulator: TriFunctional<R, E, bigint, R>, finisher: Functional<R, R>): R;
+    semantic(): Semantic<E>;
+    abstract source(): Generator<E>;
+    toArray(): Array<E>;
+    toMap<K, E>(keyExtractor: Functional<E, K>): Map<K, E>;
+    toMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): Map<K, V>;
+    toMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): Map<K, V>;
+    toSet(): Set<E>;
+    write<S = string>(stream: WritableStream<S>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: BiFunctional<WritableStream<S>, E, WritableStream<S>>): Promise<WritableStream<S>>;
+    write<S = string>(stream: WritableStream<S>, accumulator: TriFunctional<WritableStream<S>, E, bigint, WritableStream<S>>): Promise<WritableStream<S>>;
+}
+export declare class EventCollectable<E> extends Collectable<E> {
+    protected readonly AsyncCollectable: symbol;
+    protected generator: Generator<E>;
+    constructor(generator: Generator<E>);
+    source(): Generator<E>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+}
+export declare class UnorderedCollectable<E> extends Collectable<E> {
+    protected readonly UnorderedCollectable: symbol;
+    protected buffer: Map<bigint, E>;
+    constructor(generator: Generator<E>);
+    source(): Generator<E>;
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+}
+export declare class OrderedCollectable<E> extends Collectable<E> {
+    protected readonly OrderedCollectable: symbol;
+    protected buffer: Array<Indexed<E>>;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    source(): Generator<E>;
+    isEmpty(): boolean;
+}
+export declare abstract class Statistics<E, D extends number | bigint> extends OrderedCollectable<E> {
+    protected readonly Statistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<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;
+    abstract range(mapper: Functional<E, D>): D;
+    abstract variance(): D;
+    abstract variance(mapper: Functional<E, D>): D;
+    abstract standardDeviation(): D;
+    abstract standardDeviation(mapper: Functional<E, D>): D;
+    abstract mean(): D;
+    abstract mean(mapper: Functional<E, D>): D;
+    abstract median(): D;
+    abstract median(mapper: Functional<E, D>): D;
+    abstract mode(): D;
+    abstract mode(mapper: Functional<E, D>): D;
+    frequency(): Map<E, bigint>;
+    abstract summate(): D;
+    abstract summate(mapper: Functional<E, D>): D;
+    abstract quantile(quantile: number): D;
+    abstract quantile(quantile: number, mapper: Functional<E, D>): D;
+    abstract interquartileRange(): D;
+    abstract interquartileRange(mapper: Functional<E, D>): D;
+    abstract skewness(): D;
+    abstract skewness(mapper: Functional<E, D>): D;
+    abstract kurtosis(): D;
+    abstract kurtosis(mapper: Functional<E, D>): D;
+}
+export declare class NumericStatistics<E> extends Statistics<E, number> {
+    protected readonly NumericStatistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<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;
+    range(mapper: Functional<E, number>): number;
+    variance(): number;
+    variance(mapper: Functional<E, number>): number;
+    standardDeviation(): number;
+    standardDeviation(mapper: Functional<E, number>): number;
+    mean(): number;
+    mean(mapper: Functional<E, number>): number;
+    median(): number;
+    median(mapper: Functional<E, number>): number;
+    mode(): number;
+    mode(mapper: Functional<E, number>): number;
+    summate(): number;
+    summate(mapper: Functional<E, number>): number;
+    quantile(quantile: number): number;
+    quantile(quantile: number, mapper: Functional<E, number>): number;
+    interquartileRange(): number;
+    interquartileRange(mapper: Functional<E, number>): number;
+    skewness(): number;
+    skewness(mapper: Functional<E, number>): number;
+    kurtosis(): number;
+    kurtosis(mapper: Functional<E, number>): number;
+}
+export declare class BigIntStatistics<E> extends Statistics<E, bigint> {
+    protected readonly BigIntStatistics: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<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;
+    range(mapper: Functional<E, bigint>): bigint;
+    variance(): bigint;
+    variance(mapper: Functional<E, bigint>): bigint;
+    standardDeviation(): bigint;
+    standardDeviation(mapper: Functional<E, bigint>): bigint;
+    mean(): bigint;
+    mean(mapper: Functional<E, bigint>): bigint;
+    median(): bigint;
+    median(mapper: Functional<E, bigint>): bigint;
+    mode(): bigint;
+    mode(mapper: Functional<E, bigint>): bigint;
+    summate(): bigint;
+    summate(mapper: Functional<E, bigint>): bigint;
+    quantile(quantile: number): bigint;
+    quantile(quantile: number, mapper: Functional<E, bigint>): bigint;
+    interquartileRange(): bigint;
+    interquartileRange(mapper: Functional<E, bigint>): bigint;
+    skewness(): bigint;
+    skewness(mapper: Functional<E, bigint>): bigint;
+    kurtosis(): bigint;
+    kurtosis(mapper: Functional<E, bigint>): bigint;
+}
+export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+    protected readonly WindowCollectable: symbol;
+    constructor(generator: Generator<E>);
+    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
+    [Symbol.asyncIterator](): globalThis.AsyncGenerator<E, void, undefined>;
+    slide(size: bigint, step?: bigint): Semantic<Semantic<E>>;
+    tumble(size: bigint): Semantic<Semantic<E>>;
+}