semantic-typescript 0.3.8 → 0.5.0

package/dist/optional.d.ts

@@ -12,6 +12,9 @@ export declare class Optional<T> {
     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

@@ -8,14 +8,14 @@ export class Optional {
     constructor(value) {
         this.value = value;
         Object.defineProperties(this, {
-            "value": {
-                value: this.value,
+            "Optional": {
+                value: OptionalSymbol,
                 writable: false,
-                enumerable: true,
+                enumerable: false,
                 configurable: false
             },
-            "Optional": {
-                value: this.Optional,
+            "value": {
+                value: value,
                 writable: false,
                 enumerable: false,
                 configurable: false
@@ -44,20 +44,10 @@ export class Optional {
     }
     ifPresent(action, elseAction) {
         if (this.isPresent() && isFunction(action)) {
-            try {
-                action(this.value);
-            }
-            catch (error) {
-                throw new Error("Uncaught error on ifPresent.");
-            }
+            action(this.value);
         }
         else if (isFunction(elseAction)) {
-            try {
-                elseAction();
-            }
-            catch (error) {
-                throw new Error("Uncaught error on ifPresent elseAction.");
-            }
+            elseAction();
         }
     }
     isEmpty() {
@@ -68,15 +58,28 @@ export class Optional {
     }
     map(mapper) {
         if (this.isPresent() && isFunction(mapper)) {
-            try {
-                return new Optional(mapper(this.value));
-            }
-            catch (error) {
-                throw new Error("Uncaught error on map.");
-            }
+            return new Optional(mapper(this.value));
         }
         return new Optional(null);
     }
+    flat(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            return mapper(this.value);
+        }
+        return new Optional(null);
+    }
+    flatMap(mapper) {
+        if (this.isPresent() && isFunction(mapper)) {
+            return mapper(this.value);
+        }
+        return new Optional(null);
+    }
+    orElse(other) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        return other;
+    }
     semantic() {
         if (this.isPresent()) {
             return generate(() => {

package/dist/semantic.d.ts

@@ -1,8 +1,6 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
-import { BigIntStatistics, NumericStatistics } from "./statistics";
+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";
-import { WindowCollectable } from "./window";
 export declare class Semantic<E> {
     protected generator: Generator<E>;
     protected readonly Semantic: Symbol;

package/dist/semantic.js

@@ -1,24 +1,23 @@
-import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
+import { BigIntStatistics, Collectable, NumericStatistics, OrderedCollectable, UnorderedCollectable, WindowCollectable } from "./collectable";
 import { isBigInt, isCollectable, isFunction, isIterable, isNumber, isSemantic } from "./guard";
-import { useCompare, useRandom } from "./hook";
-import { BigIntStatistics, NumericStatistics } from "./statistics";
+import { useHash } from "./hash";
+import { useCompare } from "./hook";
 import { SemanticSymbol } from "./symbol";
 import { validate } from "./utility";
-import { WindowCollectable } from "./window";
 export class Semantic {
     generator;
     Semantic = SemanticSymbol;
     constructor(generator) {
         this.generator = generator;
         Object.defineProperties(this, {
-            "generator": {
-                value: generator,
+            "Semantic": {
+                value: SemanticSymbol,
                 writable: false,
-                enumerable: true,
+                enumerable: false,
                 configurable: false
             },
-            "Semantic": {
-                value: SemanticSymbol,
+            "generator": {
+                value: generator,
                 writable: false,
                 enumerable: false,
                 configurable: false
@@ -269,7 +268,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments on redirect.");
+        throw new TypeError("Invalid arguments.");
     }
     reverse() {
         return new Semantic((accept, interrupt) => {
@@ -299,7 +298,7 @@ export class Semantic {
         return new Semantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
-                    accept(element, useRandom(index));
+                    accept(element, useHash(element, index));
                 }, interrupt);
             }
             catch (error) {
@@ -345,7 +344,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments on skip.");
+        throw new TypeError("Invalid arguments.");
     }
     sorted(comparator) {
         if (isFunction(comparator)) {
@@ -364,44 +363,38 @@ export class Semantic {
         }
     }
     sub(start, end) {
-        if (isBigInt(start) && isBigInt(end)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let count = 0n;
-                    this.generator((element, index) => {
-                        if (count < end) {
-                            count++;
-                            if (count >= start) {
-                                accept(element, index);
-                            }
+        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.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments on sub.");
+                    }
+                }, interrupt);
+            }
+            catch (error) {
+                throw new Error("Uncaught error on sub.");
+            }
+        });
     }
     takeWhile(predicate) {
-        if (isFunction(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.");
-                }
-            });
-        }
-        throw new TypeError("Invalid arguments.");
+        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)) {
@@ -476,7 +469,7 @@ export class Semantic {
                 }
             });
         }
-        if (isBigInt(argument1)) {
+        else if (isBigInt(argument1)) {
             let offset = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -489,7 +482,7 @@ export class Semantic {
                 }
             });
         }
-        if (isFunction(argument1)) {
+        else if (isFunction(argument1)) {
             let translator = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -508,4 +501,4 @@ export class Semantic {
 ;
 Object.freeze(Semantic);
 Object.freeze(Semantic.prototype);
-Object.freeze(Object.getPrototypeOf(Semantic.prototype));
+Object.freeze(Object.getPrototypeOf(Semantic));

package/dist/set.d.ts

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,65 @@
+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));

package/dist/statistics.js

@@ -7,11 +7,13 @@ export class Statistics extends OrderedCollectable {
     Statistics = StatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
-        Object.defineProperty(this, "Statistics", {
-            value: StatisticsSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
+        Object.defineProperties(this, {
+            "Statistics": {
+                value: StatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
         });
         Object.freeze(this);
     }
@@ -48,11 +50,13 @@ export class NumericStatistics extends Statistics {
     NumericStatistics = NumericStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
-        Object.defineProperty(this, "NumericStatistics", {
-            value: NumericStatisticsSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
+        Object.defineProperties(this, {
+            "NumericStatistics": {
+                value: NumericStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
         });
         Object.freeze(this);
     }
@@ -265,11 +269,13 @@ export class BigIntStatistics extends Statistics {
     BigIntStatistics = BigIntStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
-        Object.defineProperty(this, "BigIntStatistics", {
-            value: BigIntStatisticsSymbol,
-            enumerable: false,
-            writable: false,
-            configurable: false
+        Object.defineProperties(this, {
+            "BigIntStatistics": {
+                value: BigIntStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
         });
         Object.freeze(this);
     }

package/dist/symbol.d.ts

@@ -8,3 +8,17 @@ export declare let StatisticsSymbol: symbol;
 export declare let NumericStatisticsSymbol: symbol;
 export declare let BigIntStatisticsSymbol: symbol;
 export declare let UnorderedCollectableSymbol: symbol;
+export declare let SemanticMapSymbol: symbol;
+export declare let HashMapSymbol: symbol;
+export declare let HashSetSymbol: symbol;
+export declare let TreeMapSymbol: symbol;
+export declare let TreeSetSymbol: symbol;
+export declare let NodeSymbol: symbol;
+export declare let LinearNodeSymbol: symbol;
+export declare let BinaryNodeSymbol: symbol;
+export declare let RedBlackNodeSymbol: symbol;
+export declare let AverageLevelNodeSymbol: symbol;
+export declare let TreeSymbol: symbol;
+export declare let BinaryTreeSymbol: symbol;
+export declare let RedBlackTreeSymbol: symbol;
+export declare let AVLTreeSymbol: symbol;

package/dist/symbol.js

@@ -8,3 +8,17 @@ export let StatisticsSymbol = Symbol.for("Statistics");
 export let NumericStatisticsSymbol = Symbol.for("NumericStatistics");
 export let BigIntStatisticsSymbol = Symbol.for("BigIntStatistics");
 export let UnorderedCollectableSymbol = Symbol.for("UnorderedCollectable");
+export let SemanticMapSymbol = Symbol.for("SemanticMap");
+export let HashMapSymbol = Symbol.for("HashMap");
+export let HashSetSymbol = Symbol.for("HashSet");
+export let TreeMapSymbol = Symbol.for("TreeMap");
+export let TreeSetSymbol = Symbol.for("TreeSet");
+export let NodeSymbol = Symbol.for("Node");
+export let LinearNodeSymbol = Symbol.for("LinearNode");
+export let BinaryNodeSymbol = Symbol.for("BinaryNode");
+export let RedBlackNodeSymbol = Symbol.for("RedBlackNode");
+export let AverageLevelNodeSymbol = Symbol.for("AverageLevelNode");
+export let TreeSymbol = Symbol.for("Tree");
+export let BinaryTreeSymbol = Symbol.for("BinaryTree");
+export let RedBlackTreeSymbol = Symbol.for("RedBlackTree");
+export let AVLTreeSymbol = Symbol.for("AVLTree");

package/dist/tree.d.ts

@@ -0,0 +1,82 @@
+import { BinaryNode, RedBlackNode, type Node } from './node';
+import { Optional } from './optional';
+import { type Comparator } from './utility';
+export interface Tree<E, N extends Node<E, N>, T extends Tree<E, N, T>> extends Iterable<E> {
+    root(): Optional<N>;
+    isEmpty(): boolean;
+    size(): bigint;
+    height(): bigint;
+    depth(): bigint;
+    width(): bigint;
+    level(): bigint;
+    add(value: E): void;
+    remove(value: E): void;
+    contains(value: E): boolean;
+    find(value: E): Optional<N>;
+    preorder(): Generator<E>;
+    inorder(): Generator<E>;
+    postorder(): Generator<E>;
+    breadth(): Generator<E>;
+    toArray(): Array<E>;
+    toSet(): Set<E>;
+    sub(node: N): T;
+    prune(node: Node<E, N>): T;
+    merge(other: T): T;
+    [Symbol.iterator](): Iterator<E>;
+}
+export declare abstract class AbstractTree<E, N extends Node<E, N>, T extends Tree<E, N, T>> implements Tree<E, N, T> {
+    protected readonly Tree: symbol;
+    protected internal: bigint;
+    constructor();
+    abstract root(): Optional<N>;
+    isEmpty(): boolean;
+    size(): bigint;
+    abstract add(value: E): void;
+    abstract remove(value: E): void;
+    contains(value: E): boolean;
+    abstract find(value: E): Optional<N>;
+    abstract preorder(): Generator<E>;
+    abstract inorder(): Generator<E>;
+    abstract postorder(): Generator<E>;
+    abstract breadth(): Generator<E>;
+    toArray(): Array<E>;
+    toSet(): Set<E>;
+    abstract sub(node: N): T;
+    abstract prune(node: Node<E, N>): T;
+    abstract merge(other: T): T;
+    height(): bigint;
+    width(): bigint;
+    depth(): bigint;
+    level(): bigint;
+    abstract [Symbol.iterator](): Iterator<E>;
+}
+export declare abstract class BinaryTree<E, N extends BinaryNode<E, N>, T extends BinaryTree<E, N, T>> extends AbstractTree<E, N, T> {
+    protected readonly BinaryTree: symbol;
+    protected first: Optional<N>;
+    constructor();
+    constructor(root: Optional<N>);
+    root(): Optional<N>;
+    find(value: E): Optional<N>;
+    preorder(): Generator<E>;
+    inorder(): Generator<E>;
+    postorder(): Generator<E>;
+    isBalanced(): boolean;
+    isComplete(): boolean;
+    isFull(): boolean;
+    isPerfect(): boolean;
+    [Symbol.iterator](): Iterator<E>;
+}
+export declare class RedBlackTree<E> extends BinaryTree<E, RedBlackNode<E>, RedBlackTree<E>> {
+    protected readonly RedBlackTree: symbol;
+    protected comparator: Comparator<E>;
+    constructor();
+    constructor(root: Optional<RedBlackNode<E>>);
+    constructor(comparator: Comparator<E>);
+    constructor(root: Optional<RedBlackNode<E>>, comparator: Comparator<E>);
+    add(value: E): void;
+    remove(value: E): void;
+    breadth(): Generator<E>;
+    sub(node: RedBlackNode<E>): RedBlackTree<E>;
+    prune(node: Node<E, RedBlackNode<E>>): RedBlackTree<E>;
+    merge(other: RedBlackTree<E>): RedBlackTree<E>;
+}