semantic-typescript 0.5.3 → 0.6.0

package/dist/{semantic.d.ts → synchronous/semantic.d.ts}

@@ -1,65 +1,64 @@
-import { Collector } from "./collector";
-import type { Optional } from "./optional";
-import { type Predicate } from "./utility";
-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;
-    constructor(generator: Generator<E>);
-    concat(other: Semantic<E>): Semantic<E>;
-    concat(other: Iterable<E>): Semantic<E>;
-    distinct(): Semantic<E>;
-    distinct<K>(keyExtractor: Functional<E, K>): Semantic<E>;
-    distinct<K>(keyExtractor: BiFunctional<E, bigint, K>): Semantic<E>;
-    dropWhile(predicate: Predicate<E>): Semantic<E>;
-    dropWhile(predicate: BiPredicate<E, bigint>): Semantic<E>;
-    filter(predicate: Predicate<E>): Semantic<E>;
-    filter(predicate: BiPredicate<E, bigint>): Semantic<E>;
-    flat(mapper: Functional<E, Iterable<E>>): Semantic<E>;
-    flat(mapper: BiFunctional<E, bigint, Iterable<E>>): Semantic<E>;
-    flat(mapper: Functional<E, Semantic<E>>): Semantic<E>;
-    flat(mapper: BiFunctional<E, bigint, Semantic<E>>): Semantic<E>;
-    flatMap<R>(mapper: Functional<E, Iterable<R>>): Semantic<R>;
-    flatMap<R>(mapper: BiFunctional<E, bigint, Iterable<R>>): Semantic<R>;
-    flatMap<R>(mapper: Functional<E, Semantic<R>>): Semantic<R>;
-    flatMap<R>(mapper: BiFunctional<E, bigint, Semantic<R>>): Semantic<R>;
-    limit(n: number): Semantic<E>;
-    limit(n: bigint): Semantic<E>;
-    map<R>(mapper: Functional<E, R>): Semantic<R>;
-    map<R>(mapper: BiFunctional<E, bigint, R>): Semantic<R>;
-    peek(consumer: Consumer<E>): Semantic<E>;
-    peek(consumer: BiConsumer<E, bigint>): Semantic<E>;
-    redirect(redirector: BiFunctional<E, bigint, bigint>): Semantic<E>;
-    reverse(): Semantic<E>;
-    shuffle(): Semantic<E>;
-    shuffle(mapper: BiFunctional<E, bigint, bigint>): Semantic<E>;
-    skip(n: number): Semantic<E>;
-    skip(n: bigint): Semantic<E>;
-    sorted(): OrderedCollectable<E>;
-    sorted(comparator: Comparator<E>): OrderedCollectable<E>;
-    sub(start: bigint, end: bigint): Semantic<E>;
-    takeWhile(predicate: Predicate<E>): Semantic<E>;
-    takeWhile(predicate: BiPredicate<E, bigint>): 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>;
-    toWindow(): WindowCollectable<E>;
-    translate(offset: number): Semantic<E>;
-    translate(offset: bigint): Semantic<E>;
-    translate(translator: BiFunctional<E, bigint, bigint>): Semantic<E>;
+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;
+    constructor(generator: SynchronousGenerator<E>);
+    concat(other: SynchronousSemantic<E>): SynchronousSemantic<E>;
+    concat(other: Iterable<E>): SynchronousSemantic<E>;
+    distinct(): SynchronousSemantic<E>;
+    distinct<K>(keyExtractor: Functional<E, K>): SynchronousSemantic<E>;
+    distinct<K>(keyExtractor: BiFunctional<E, bigint, K>): SynchronousSemantic<E>;
+    dropWhile(predicate: Predicate<E>): SynchronousSemantic<E>;
+    dropWhile(predicate: BiPredicate<E, bigint>): SynchronousSemantic<E>;
+    filter(predicate: Predicate<E>): SynchronousSemantic<E>;
+    filter(predicate: BiPredicate<E, bigint>): SynchronousSemantic<E>;
+    flat(mapper: Functional<E, Iterable<E>>): SynchronousSemantic<E>;
+    flat(mapper: BiFunctional<E, bigint, Iterable<E>>): SynchronousSemantic<E>;
+    flat(mapper: Functional<E, SynchronousSemantic<E>>): SynchronousSemantic<E>;
+    flat(mapper: BiFunctional<E, bigint, SynchronousSemantic<E>>): SynchronousSemantic<E>;
+    flatMap<R>(mapper: Functional<E, Iterable<R>>): SynchronousSemantic<R>;
+    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>;
+    map<R>(mapper: Functional<E, R>): SynchronousSemantic<R>;
+    map<R>(mapper: BiFunctional<E, bigint, R>): SynchronousSemantic<R>;
+    peek(consumer: Consumer<E>): SynchronousSemantic<E>;
+    peek(consumer: BiConsumer<E, bigint>): SynchronousSemantic<E>;
+    redirect(redirector: BiFunctional<E, bigint, bigint>): 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>;
+    source(): SynchronousGenerator<E>;
+    sorted(): SynchronousOrderedCollectable<E>;
+    sorted(comparator: Comparator<E>): SynchronousOrderedCollectable<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;
+    toBigintStatistics(): SynchronousBigIntStatistics<E>;
+    toNumericStatistics(): SynchronousNumericStatistics<E>;
+    toOrdered(): SynchronousOrderedCollectable<E>;
+    toUnordered(): SynchronousUnorderedCollectable<E>;
+    toWindow(): SynchronousWindowCollectable<E>;
+    translate(offset: number): SynchronousSemantic<E>;
+    translate(offset: bigint): SynchronousSemantic<E>;
+    translate(translator: BiFunctional<E, bigint, bigint>): SynchronousSemantic<E>;
 }
-export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterable<E> {
-    protected readonly Collectable: symbol;
+export declare abstract class SynchronousCollectable<E> {
+    protected readonly SynchronousCollectable: 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>(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;
     collect<A, R>(identity: Supplier<A>, interruptor: Predicate<E>, accumulator: BiFunctional<A, E, A>, finisher: Functional<A, R>): R;
@@ -111,8 +110,8 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     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>;
+    semantic(): SynchronousSemantic<E>;
+    abstract source(): SynchronousGenerator<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>;
@@ -122,36 +121,28 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     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>;
+export declare class SynchronousOrderedCollectable<E> extends SynchronousCollectable<E> {
+    protected readonly SynchronousOrderedCollectable: symbol;
+    protected buffer: Array<Indexed<E>>;
+    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>;
+    source(): SynchronousGenerator<E>;
+    isEmpty(): boolean;
 }
-export declare class UnorderedCollectable<E> extends Collectable<E> {
-    protected readonly UnorderedCollectable: symbol;
+export declare class SynchronousUnorderedCollectable<E> extends SynchronousCollectable<E> {
+    protected readonly SynchronousUnorderedCollectable: 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>);
+    constructor(generator: SynchronousGenerator<E>);
+    source(): SynchronousGenerator<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>);
+export declare abstract class SynchronousStatistics<E, D extends number | bigint> extends SynchronousOrderedCollectable<E> {
+    protected readonly SynchronousStatistics: symbol;
+    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;
@@ -181,41 +172,10 @@ export declare abstract class Statistics<E, D extends number | bigint> extends O
     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> {
+export declare class SynchronousBigIntStatistics<E> extends SynchronousStatistics<E, bigint> {
     protected readonly BigIntStatistics: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    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;
@@ -243,12 +203,43 @@ export declare class BigIntStatistics<E> extends Statistics<E, bigint> {
     kurtosis(): bigint;
     kurtosis(mapper: Functional<E, bigint>): bigint;
 }
-export declare class WindowCollectable<E> extends OrderedCollectable<E> {
+export declare class SynchronousNumericStatistics<E> extends SynchronousStatistics<E, number> {
+    protected readonly SynchronousNumericStatistics: symbol;
+    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;
+    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 SynchronousWindowCollectable<E> extends SynchronousOrderedCollectable<E> {
     protected readonly WindowCollectable: symbol;
-    constructor(generator: Generator<E>);
-    constructor(generator: Generator<E>, comparator: Comparator<E>);
+    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): Semantic<Semantic<E>>;
-    tumble(size: bigint): Semantic<Semantic<E>>;
+    slide(size: bigint, step?: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
+    tumble(size: bigint): SynchronousSemantic<SynchronousSemantic<E>>;
 }