semantic-typescript 0.5.0 → 0.6.0

package/dist/semantic.d.ts

@@ -1,52 +0,0 @@
-import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
-import { type Predicate } from "./utility";
-import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator, BiPredicate } 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>;
-    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>;
-}

package/dist/semantic.js

@@ -1,504 +0,0 @@
-import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
-import { isBigInt, isCollectable, isFunction, isIterable, isNumber, isSemantic } from "./guard";
-import { useHash } from "./hash";
-import { useCompare } from "./hook";
-import { SemanticSymbol } from "./symbol";
-import { validate } from "./utility";
-export class Semantic {
-    generator;
-    Semantic = SemanticSymbol;
-    constructor(generator) {
-        this.generator = generator;
-        Object.defineProperties(this, {
-            "Semantic": {
-                value: SemanticSymbol,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            },
-            "generator": {
-                value: generator,
-                writable: false,
-                enumerable: false,
-                configurable: false
-            }
-        });
-        Object.freeze(this);
-    }
-    concat(other) {
-        if (isSemantic(other)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        accept(element, index);
-                        count++;
-                    }, interrupt);
-                    let otherGenerator = Reflect.has(other, "generator") ? Reflect.get(other, "generator") : () => { };
-                    otherGenerator((element, index) => {
-                        accept(element, index + count);
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on concatenation.");
-                }
-            });
-        }
-        if (isIterable(other)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        accept(element, index);
-                        count++;
-                    }, interrupt);
-                    for (let element of other) {
-                        accept(element, count);
-                        count++;
-                    }
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on concatenation.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    distinct(argument1) {
-        let keyExtractor = validate(argument1) ? argument1 : (element) => element;
-        return new Semantic((accept, interrupt) => {
-            try {
-                let set = new Set();
-                this.generator((element, index) => {
-                    let key = keyExtractor(element, index);
-                    if (!set.has(key)) {
-                        set.add(key);
-                        accept(element, index);
-                    }
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on distinct.");
-            }
-        });
-    }
-    dropWhile(predicate) {
-        if (isFunction(predicate)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let dropping = true;
-                    this.generator((element, index) => {
-                        if (dropping) {
-                            if (!predicate(element, index)) {
-                                dropping = false;
-                                accept(element, index);
-                            }
-                            return;
-                        }
-                        accept(element, index);
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on dropWhile.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    filter(predicate) {
-        if (isFunction(predicate)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        if (predicate(element, index)) {
-                            accept(element, index);
-                        }
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on filter.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    flat(mapper) {
-        if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    let stop = false;
-                    this.generator((element, index) => {
-                        let result = mapper(element, index);
-                        if (isIterable(result)) {
-                            for (let subElement of result) {
-                                accept(subElement, count);
-                                stop = stop || interrupt(subElement, count);
-                                count++;
-                            }
-                        }
-                        else if (isSemantic(result)) {
-                            result.generator((subElement) => {
-                                accept(subElement, count);
-                                stop = stop || interrupt(subElement, count);
-                                count++;
-                            }, (element) => interrupt(element, count) || stop);
-                        }
-                    }, (element) => interrupt(element, count) || stop);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on flat.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    flatMap(mapper) {
-        if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    let stop = false;
-                    this.generator((element, index) => {
-                        let result = mapper(element, index);
-                        if (isIterable(result)) {
-                            for (let subElement of result) {
-                                accept(subElement, count);
-                                stop = stop || interrupt(subElement, count);
-                                count++;
-                            }
-                        }
-                        else if (isSemantic(result)) {
-                            result.generator((subElement) => {
-                                accept(subElement, count);
-                                stop = stop || interrupt(subElement, count);
-                                count++;
-                            }, (element) => interrupt(element, count) || stop);
-                        }
-                    }, () => stop);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on flatMap.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    limit(n) {
-        if (isNumber(n)) {
-            let limit = BigInt(n);
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        if (count < limit) {
-                            accept(element, index);
-                            count++;
-                        }
-                    }, (element) => interrupt(element, count) || count >= limit);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on limit.");
-                }
-            });
-        }
-        if (isBigInt(n)) {
-            let limit = n;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        if (count < limit) {
-                            accept(element, index);
-                            count++;
-                        }
-                    }, (element) => interrupt(element, count) || count >= limit);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on limit.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    map(mapper) {
-        if (isFunction(mapper)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let stop = false;
-                    this.generator((element, index) => {
-                        let resolved = mapper(element, index);
-                        accept(resolved, index);
-                        stop = stop || interrupt(resolved, index);
-                    }, () => stop);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on map.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    peek(consumer) {
-        if (isFunction(consumer)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        accept(element, index);
-                        consumer(element, index);
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on peek.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    redirect(redirector) {
-        if (isFunction(redirector)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        accept(element, redirector(element, index));
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on redirect.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    reverse() {
-        return new Semantic((accept, interrupt) => {
-            try {
-                this.generator((element, index) => {
-                    accept(element, -index);
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on reverse.");
-            }
-        });
-    }
-    shuffle(mapper) {
-        if (isFunction(mapper)) {
-            try {
-                return new Semantic((accept, interrupt) => {
-                    this.generator((element, index) => {
-                        accept(element, mapper(element, index));
-                    }, interrupt);
-                });
-            }
-            catch (error) {
-                throw new Error("Uncaught error on shuffle.");
-            }
-        }
-        return new Semantic((accept, interrupt) => {
-            try {
-                this.generator((element, index) => {
-                    accept(element, useHash(element, index));
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on shuffle.");
-            }
-        });
-    }
-    skip(n) {
-        if (isNumber(n)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    let limit = BigInt(n);
-                    this.generator((element, index) => {
-                        if (count < limit) {
-                            count++;
-                        }
-                        else {
-                            accept(element, index);
-                        }
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on skip.");
-                }
-            });
-        }
-        if (isBigInt(n)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        if (count < n) {
-                            count++;
-                        }
-                        else {
-                            accept(element, index);
-                        }
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on skip.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-    sorted(comparator) {
-        if (isFunction(comparator)) {
-            try {
-                return new OrderedCollectable(this.generator, comparator);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sorted.");
-            }
-        }
-        try {
-            return new OrderedCollectable(this.generator, (a, b) => useCompare(a, b));
-        }
-        catch (error) {
-            throw new Error("Uncaught error on sorted.");
-        }
-    }
-    sub(start, end) {
-        return new Semantic((accept, interrupt) => {
-            try {
-                let count = 0n;
-                this.generator((element, index) => {
-                    if (count < end) {
-                        count++;
-                        if (count >= start) {
-                            accept(element, index);
-                        }
-                    }
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on sub.");
-            }
-        });
-    }
-    takeWhile(predicate) {
-        return new Semantic((accept, interrupt) => {
-            try {
-                this.generator((element, index) => {
-                    if (!predicate(element, index)) {
-                        interrupt(element, index);
-                        return;
-                    }
-                    accept(element, index);
-                }, interrupt);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on takeWhile.");
-            }
-        });
-    }
-    toCollectable(mapper) {
-        if (isFunction(mapper)) {
-            try {
-                let collectable = mapper(this.generator);
-                if (isCollectable(collectable)) {
-                    return collectable;
-                }
-            }
-            catch (error) {
-                throw new Error("Uncaught error on toCollectable.");
-            }
-        }
-        try {
-            return new UnorderedCollectable(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toCollectable.");
-        }
-    }
-    toBigintStatistics() {
-        try {
-            return new BigIntStatistics(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toBigintStatistics.");
-        }
-    }
-    toNumericStatistics() {
-        try {
-            return new NumericStatistics(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toNumericStatistics.");
-        }
-    }
-    toOrdered() {
-        try {
-            return new OrderedCollectable(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toOrdered.");
-        }
-    }
-    toUnordered() {
-        try {
-            return new UnorderedCollectable(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toUnordered.");
-        }
-    }
-    toWindow() {
-        try {
-            return new WindowCollectable(this.generator);
-        }
-        catch (error) {
-            throw new Error("Uncaught error on toWindow.");
-        }
-    }
-    translate(argument1) {
-        if (isNumber(argument1)) {
-            let offset = argument1;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        accept(element, index + BigInt(offset));
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on translate.");
-                }
-            });
-        }
-        else if (isBigInt(argument1)) {
-            let offset = argument1;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        accept(element, index + offset);
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on translate.");
-                }
-            });
-        }
-        else if (isFunction(argument1)) {
-            let translator = argument1;
-            return new Semantic((accept, interrupt) => {
-                try {
-                    this.generator((element, index) => {
-                        accept(element, index + translator(element, index));
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on translate.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
-    }
-}
-;
-Object.freeze(Semantic);
-Object.freeze(Semantic.prototype);
-Object.freeze(Object.getPrototypeOf(Semantic));

package/dist/set.d.ts

@@ -1,19 +0,0 @@
-import { HashMap } from "./map";
-import type { BiConsumer, Consumer, TriConsumer } from "./utility";
-export declare class HashSet<E> implements Set<E> {
-    protected map: HashMap<E, boolean>;
-    size: number;
-    constructor();
-    add(value: E): this;
-    clear(): void;
-    delete(value: E): boolean;
-    entries(): SetIterator<[E, E]>;
-    forEach(consumer: Consumer<E>): void;
-    forEach(consumer: BiConsumer<E, E>): void;
-    forEach(consumer: TriConsumer<E, E, Set<E>>): void;
-    has(value: E): boolean;
-    keys(): IterableIterator<E>;
-    values(): IterableIterator<E>;
-    [Symbol.iterator](): IterableIterator<E>;
-    [Symbol.toStringTag]: string;
-}

package/dist/set.js

@@ -1,65 +0,0 @@
-import { HashMap } from "./map";
-export class HashSet {
-    map = new HashMap();
-    size = 0;
-    constructor() {
-        Object.defineProperty(this, "size", {
-            get: () => this.map.size,
-            set: (value) => {
-                this.map.size = value;
-            },
-            enumerable: true,
-            configurable: true
-        });
-        Object.freeze(this);
-    }
-    add(value) {
-        this.map.set(value, true);
-        return this;
-    }
-    clear() {
-        this.map.clear();
-    }
-    delete(value) {
-        return this.map.delete(value);
-    }
-    *entries() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield [key, key];
-            }
-        }
-    }
-    forEach(consumer) {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                consumer(key, key);
-            }
-        }
-    }
-    has(value) {
-        return this.map.has(value);
-    }
-    *keys() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield key;
-            }
-        }
-    }
-    *values() {
-        for (let [key, value] of this.map.entries()) {
-            if (value) {
-                yield key;
-            }
-        }
-    }
-    [Symbol.iterator]() {
-        return this.values();
-    }
-    [Symbol.toStringTag] = "HashSet";
-}
-;
-Object.freeze(HashSet);
-Object.freeze(HashSet.prototype);
-Object.freeze(Object.getPrototypeOf(HashSet));