semantic-typescript 0.4.1 → 0.5.0

package/dist/collectable.d.ts

@@ -1,5 +1,5 @@
 import { Collector } from "./collector";
-import type { HashMap } from "./map";
+import { HashMap } from "./map";
 import { Optional } from "./optional";
 import { Semantic } from "./semantic";
 import type { HashSet } from "./set";
@@ -66,8 +66,10 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
     semantic(): Semantic<E>;
     abstract source(): Generator<E>;
     toArray(): Array<E>;
+    toMap<K, V>(keyExtractor: Functional<E, K>): Map<K, V>;
     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>;
+    toHashMap<K, V>(keyExtractor: Functional<E, K>): HashMap<K, V>;
     toHashMap<K, V>(keyExtractor: Functional<E, K>, valueExtractor: Functional<E, V>): HashMap<K, V>;
     toHashMap<K, V>(keyExtractor: BiFunctional<E, bigint, K>, valueExtractor: BiFunctional<E, bigint, V>): HashMap<K, V>;
     toSet(): Set<E>;
@@ -78,7 +80,7 @@ export declare abstract class Collectable<E> implements Iterable<E>, AsyncIterab
 }
 export declare class UnorderedCollectable<E> extends Collectable<E> {
     protected readonly UnorderedCollectable: symbol;
-    protected generator: Generator<E>;
+    protected buffer: HashMap<bigint, E>;
     constructor(generator: Generator<E>);
     source(): Generator<E>;
     [Symbol.iterator](): globalThis.Generator<E, void, undefined>;
@@ -94,3 +96,107 @@ export declare class OrderedCollectable<E> extends Collectable<E> {
     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>>;
+}