semantic-typescript 0.3.8 → 0.4.1

package/dist/map.d.ts

@@ -0,0 +1,72 @@
+import { type BiConsumer, type BiFunctional, type Comparator, type MaybeInvalid, type MaybeUndefined, type Supplier, type TriConsumer } from "./utility";
+export interface Entry<K, V> {
+    key: K;
+    value: V;
+}
+export interface SemanticMap<K, V> extends globalThis.Map<K, V> {
+    clear(): void;
+    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
+    computeIfAbsent(key: K, remapping: Supplier<V>): V;
+    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
+    delete(key: K): boolean;
+    entries(): MapIterator<[K, V]>;
+    forEach(consumer: BiConsumer<V, K>): void;
+    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
+    get(key: K): MaybeUndefined<V>;
+    get(key: K, defaultValue: V): V;
+    has(key: K): boolean;
+    replace(key: K, value: V): MaybeInvalid<V>;
+    replace(key: K, oldValue: V, newValue: V): boolean;
+    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
+    set(key: K, value: V): this;
+    size: number;
+    values(): IterableIterator<V>;
+}
+export declare abstract class AbstractSemanticMap<K, V> implements SemanticMap<K, V> {
+    protected internal: bigint;
+    size: number;
+    protected readonly SemanticMap: symbol;
+    constructor();
+    abstract clear(): void;
+    compute(key: K, remapping: BiFunctional<K, MaybeInvalid<V>, MaybeInvalid<V>>): MaybeInvalid<V>;
+    computeIfAbsent(key: K, remapping: Supplier<V>): V;
+    computeIfPresent(key: K, remapping: BiFunctional<K, V, MaybeInvalid<V>>): MaybeInvalid<V>;
+    abstract delete(key: K): boolean;
+    abstract entries(): MapIterator<[K, V]>;
+    forEach(consumer: BiConsumer<V, K>): void;
+    forEach(consumer: TriConsumer<V, K, Map<K, V>>): void;
+    abstract get(key: K): MaybeUndefined<V>;
+    abstract get(key: K, defaultValue: V): V;
+    abstract keys(): MapIterator<K>;
+    has(key: K): boolean;
+    replace(key: K, value: V): MaybeInvalid<V>;
+    replace(key: K, oldValue: V, newValue: V): boolean;
+    replaceAll(operator: BiFunctional<K, V, MaybeInvalid<V>>): void;
+    abstract set(key: K, value: V): this;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    [Symbol.toStringTag]: string;
+    abstract values(): IterableIterator<V>;
+}
+export declare class HashMap<K, V> extends AbstractSemanticMap<K, V> {
+    protected buckets: Map<bigint, Array<Entry<K, V>>>;
+    protected threashold: number;
+    protected comparator: Comparator<K>;
+    protected capacity: number;
+    protected readonly HashMap: symbol;
+    constructor();
+    constructor(comparator: Comparator<K>);
+    constructor(threashold: number, initialCapacity: number);
+    constructor(comparator: Comparator<K>, threashold: number, capacity: number);
+    clear(): void;
+    delete(key: K): boolean;
+    entries(): MapIterator<[K, V]>;
+    has(key: K): boolean;
+    protected hash(key: K): bigint;
+    protected findEntry(key: K, hash: bigint): MaybeInvalid<Entry<K, V>>;
+    get(key: K): MaybeUndefined<V>;
+    get(key: K, defaultValue: V): V;
+    keys(): MapIterator<K>;
+    protected rehash(): void;
+    set(key: K, value: V): this;
+    values(): IterableIterator<V>;
+}

package/dist/map.js

@@ -0,0 +1,247 @@
+import { isFunction, isNumber } from "./guard";
+import { useHash } from "./hash";
+import { useCompare } from "./hook";
+import { SemanticMapSymbol } from "./symbol";
+import { invalidate, validate } from "./utility";
+;
+;
+export class AbstractSemanticMap {
+    internal = 0n;
+    size = 0;
+    SemanticMap = SemanticMapSymbol;
+    constructor() {
+        Object.defineProperty(this, "SemanticMap", {
+            value: SemanticMapSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+    }
+    compute(key, remapping) {
+        let value = this.get(key);
+        return remapping(key, value);
+    }
+    computeIfAbsent(key, remapping) {
+        let value = this.get(key);
+        if (invalidate(value)) {
+            return remapping();
+        }
+        return value;
+    }
+    computeIfPresent(key, remapping) {
+        let value = this.get(key);
+        if (validate(value)) {
+            return remapping(key, value);
+        }
+        return value;
+    }
+    forEach(consumer) {
+        for (let entry of this.entries()) {
+            consumer(entry[1], entry[0], this);
+        }
+    }
+    has(key) {
+        return this.get(key) !== undefined;
+    }
+    replace(argument1, argument2, argument3) {
+        if (validate(argument1) && validate(argument2) && validate(argument3)) {
+            let key = argument1;
+            let oldValue = argument2;
+            let newValue = argument3;
+            if (this.get(key) === oldValue) {
+                this.set(key, newValue);
+                return true;
+            }
+            return this.get(key);
+        }
+        if (validate(argument1) && validate(argument2) && invalidate(argument3)) {
+            let key = argument1;
+            let value = argument2;
+            if (this.get(key) === value) {
+                this.delete(key);
+                return true;
+            }
+            return this.get(key);
+        }
+    }
+    replaceAll(operator) {
+        for (let entry of this.entries()) {
+            let key = entry[0];
+            let value = entry[1];
+            let newValue = operator(key, value);
+            if (validate(newValue)) {
+                this.set(key, newValue);
+            }
+            else {
+                this.delete(key);
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = "SemanticMap";
+}
+;
+Object.freeze(AbstractSemanticMap);
+Object.freeze(AbstractSemanticMap.prototype);
+Object.freeze(Object.getPrototypeOf(AbstractSemanticMap));
+export class HashMap extends AbstractSemanticMap {
+    buckets = new Map();
+    threashold;
+    comparator;
+    capacity;
+    HashMap = SemanticMapSymbol;
+    constructor(argument1, argument2, argument3) {
+        super();
+        if (isFunction(argument1) && isNumber(argument2) && isNumber(argument3)) {
+            this.comparator = argument1;
+            this.threashold = argument2;
+            this.capacity = argument3;
+        }
+        else if (isFunction(argument1) && isNumber(argument2) && invalidate(argument3)) {
+            this.comparator = argument1;
+            this.threashold = argument2;
+            this.capacity = 16;
+        }
+        else if (isFunction(argument1) && invalidate(argument2) && invalidate(argument3)) {
+            this.comparator = argument1;
+            this.threashold = 0.75;
+            this.capacity = 16;
+        }
+        else {
+            this.comparator = useCompare;
+            this.threashold = 0.75;
+            this.capacity = 16;
+        }
+        this.buckets = new Map();
+        Object.defineProperty(this, "size", {
+            get: () => this.internal,
+            set: (value) => this.internal = isNumber(value) ? BigInt(value) : 0n,
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, "HashMap", {
+            value: SemanticMapSymbol,
+            enumerable: false,
+            writable: false,
+            configurable: false
+        });
+    }
+    clear() {
+        this.buckets.clear();
+        this.size = 0;
+    }
+    delete(key) {
+        let hashCode = this.hash(key);
+        let bucket = this.buckets.get(hashCode) || [];
+        if (bucket.length > 0) {
+            for (let index = 0; index < bucket.length; index++) {
+                let entry = bucket[index];
+                if (this.comparator(entry.key, key) === 0) {
+                    bucket.splice(index, 1);
+                    this.size--;
+                    if (bucket.length === 0) {
+                        this.buckets.delete(hashCode);
+                    }
+                    return true;
+                }
+            }
+        }
+        this.buckets.delete(hashCode);
+        return false;
+    }
+    *entries() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield [entry.key, entry.value];
+            }
+        }
+    }
+    has(key) {
+        let hashCode = this.hash(key);
+        return validate(this.findEntry(key, hashCode));
+    }
+    hash(key) {
+        return useHash(key);
+    }
+    ;
+    findEntry(key, hash) {
+        let candidates = (this.buckets.get(hash) || []);
+        for (let candidate of candidates) {
+            if (this.comparator(candidate.key, key) === 0) {
+                return candidate;
+            }
+        }
+        return (void 0);
+    }
+    get(argument1, argument2) {
+        if (validate(argument1) && validate(argument2)) {
+            let key = argument1;
+            let defaultValue = argument2;
+            let hashCode = this.hash(key);
+            let entry = this.findEntry(key, hashCode);
+            if (validate(entry)) {
+                return entry.value;
+            }
+            return defaultValue;
+        }
+        let key = argument1;
+        let hashCode = this.hash(key);
+        let entry = this.findEntry(key, hashCode);
+        if (validate(entry)) {
+            return entry.value;
+        }
+        return (void 0);
+    }
+    *keys() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield entry.key;
+            }
+        }
+    }
+    rehash() {
+        let oldBuckets = this.buckets;
+        this.buckets = new Map();
+        this.size = 0;
+        for (let bucket of oldBuckets.values()) {
+            for (let entry of bucket) {
+                let hashCode = this.hash(entry.key);
+                let bucket = this.buckets.get(hashCode) || [];
+                bucket.push(entry);
+                this.size++;
+            }
+        }
+    }
+    set(key, value) {
+        let hashCode = this.hash(key);
+        let bucket = this.buckets.get(hashCode) || [];
+        let found = this.findEntry(key, hashCode);
+        if (validate(found)) {
+            found.value = value;
+        }
+        else {
+            bucket.push({
+                key: key,
+                value: value
+            });
+            this.size++;
+            if (this.size > this.capacity * this.threashold) {
+                this.rehash();
+            }
+        }
+        return this;
+    }
+    *values() {
+        for (let bucket of this.buckets.values()) {
+            for (let entry of bucket) {
+                yield entry.value;
+            }
+        }
+    }
+}
+;
+Object.freeze(HashMap);
+Object.freeze(HashMap.prototype);
+Object.freeze(Object.getPrototypeOf(HashMap));

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,12 +58,7 @@ 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);
     }

package/dist/semantic.js

@@ -1,6 +1,7 @@
 import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import { isBigInt, isCollectable, isFunction, isIterable, isNumber, isSemantic } from "./guard";
-import { useCompare, useRandom } from "./hook";
+import { useHash } from "./hash";
+import { useCompare } from "./hook";
 import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { SemanticSymbol } from "./symbol";
 import { validate } from "./utility";
@@ -11,14 +12,14 @@ export class Semantic {
     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 +270,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments on redirect.");
+        throw new TypeError("Invalid arguments.");
     }
     reverse() {
         return new Semantic((accept, interrupt) => {
@@ -299,7 +300,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 +346,7 @@ export class Semantic {
                 }
             });
         }
-        throw new TypeError("Invalid arguments on skip.");
+        throw new TypeError("Invalid arguments.");
     }
     sorted(comparator) {
         if (isFunction(comparator)) {
@@ -364,44 +365,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 +471,7 @@ export class Semantic {
                 }
             });
         }
-        if (isBigInt(argument1)) {
+        else if (isBigInt(argument1)) {
             let offset = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -489,7 +484,7 @@ export class Semantic {
                 }
             });
         }
-        if (isFunction(argument1)) {
+        else if (isFunction(argument1)) {
             let translator = argument1;
             return new Semantic((accept, interrupt) => {
                 try {
@@ -508,4 +503,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,64 @@
+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
+        });
+    }
+    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));