semantic-typescript 0.3.7 → 0.4.1

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

@@ -7,6 +7,21 @@ export class Optional {
     Optional = OptionalSymbol;
     constructor(value) {
         this.value = value;
+        Object.defineProperties(this, {
+            "Optional": {
+                value: OptionalSymbol,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            },
+            "value": {
+                value: value,
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     filter(predicate) {
         if (this.isPresent() && isFunction(predicate) && predicate(this.value)) {
@@ -74,3 +89,6 @@ export class Optional {
     }
 }
 ;
+Object.freeze(Optional);
+Object.freeze(Optional.prototype);
+Object.freeze(Object.getPrototypeOf(Optional));

package/dist/semantic.d.ts

@@ -1,7 +1,7 @@
 import { Collectable, OrderedCollectable, UnorderedCollectable } from "./collectable";
 import { BigIntStatistics, NumericStatistics } from "./statistics";
 import { type Predicate } from "./utility";
-import type { Generator, Functional, BiFunctional, Consumer, BiConsumer, Comparator } 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>;
@@ -10,14 +10,24 @@ export declare class Semantic<E> {
     concat(other: Semantic<E>): Semantic<E>;
     concat(other: Iterable<E>): Semantic<E>;
     distinct(): Semantic<E>;
-    distinct(comparator: Comparator<E>): 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>;
-    flat(mapper: Functional<E, Iterable<E> | Semantic<E>>): Semantic<E>;
-    flatMap<R>(mapper: Functional<E, Iterable<R> | Semantic<R>>): Semantic<R>;
+    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>;
@@ -30,6 +40,7 @@ export declare class Semantic<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>;

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";
@@ -10,6 +11,21 @@ export class Semantic {
     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)) {
@@ -50,29 +66,15 @@ export class Semantic {
         }
         throw new TypeError("Invalid arguments.");
     }
-    distinct(comparator) {
-        if (validate(comparator)) {
-            return new Semantic((accept, interrupt) => {
-                try {
-                    let array = [];
-                    this.generator((element, index) => {
-                        if (!array.some((e) => comparator(e, element))) {
-                            array.push(element);
-                            accept(element, index);
-                        }
-                    }, interrupt);
-                }
-                catch (error) {
-                    throw new Error("Uncaught error on distinct.");
-                }
-            });
-        }
+    distinct(argument1) {
+        let keyExtractor = validate(argument1) ? argument1 : (element) => element;
         return new Semantic((accept, interrupt) => {
             try {
                 let set = new Set();
                 this.generator((element, index) => {
-                    if (!set.has(element)) {
-                        set.add(element);
+                    let key = keyExtractor(element, index);
+                    if (!set.has(key)) {
+                        set.add(key);
                         accept(element, index);
                     }
                 }, interrupt);
@@ -89,7 +91,7 @@ export class Semantic {
                     let dropping = true;
                     this.generator((element, index) => {
                         if (dropping) {
-                            if (!predicate(element)) {
+                            if (!predicate(element, index)) {
                                 dropping = false;
                                 accept(element, index);
                             }
@@ -110,7 +112,7 @@ export class Semantic {
             return new Semantic((accept, interrupt) => {
                 try {
                     this.generator((element, index) => {
-                        if (predicate(element)) {
+                        if (predicate(element, index)) {
                             accept(element, index);
                         }
                     }, interrupt);
@@ -128,8 +130,8 @@ export class Semantic {
                 try {
                     let count = 0n;
                     let stop = false;
-                    this.generator((element) => {
-                        let result = mapper(element);
+                    this.generator((element, index) => {
+                        let result = mapper(element, index);
                         if (isIterable(result)) {
                             for (let subElement of result) {
                                 accept(subElement, count);
@@ -159,8 +161,8 @@ export class Semantic {
                 try {
                     let count = 0n;
                     let stop = false;
-                    this.generator((element) => {
-                        let result = mapper(element);
+                    this.generator((element, index) => {
+                        let result = mapper(element, index);
                         if (isIterable(result)) {
                             for (let subElement of result) {
                                 accept(subElement, count);
@@ -227,7 +229,7 @@ export class Semantic {
                 try {
                     let stop = false;
                     this.generator((element, index) => {
-                        let resolved = mapper(element);
+                        let resolved = mapper(element, index);
                         accept(resolved, index);
                         stop = stop || interrupt(resolved, index);
                     }, () => stop);
@@ -298,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) {
@@ -384,7 +386,7 @@ export class Semantic {
         return new Semantic((accept, interrupt) => {
             try {
                 this.generator((element, index) => {
-                    if (!predicate(element)) {
+                    if (!predicate(element, index)) {
                         interrupt(element, index);
                         return;
                     }
@@ -499,3 +501,6 @@ export class Semantic {
     }
 }
 ;
+Object.freeze(Semantic);
+Object.freeze(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));

package/dist/statistics.js

@@ -1,5 +1,5 @@
 import { OrderedCollectable } from "./collectable";
-import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToAsyncGeneratorFunction, useToGeneratorFunction } from "./collector";
+import { Collector, useBigIntAverage, useBigIntMedian, useBigIntMode, useBigIntSummate, useBigIntVariance, useFrequency, useNumericAverage, useNumericMedian, useNumericMode, useNumericStandardDeviation, useNumericSummate, useNumericVariance, useToArray } from "./collector";
 import { isFunction } from "./guard";
 import { useCompare, useToBigInt, useToNumber } from "./hook";
 import { StatisticsSymbol, NumericStatisticsSymbol, BigIntStatisticsSymbol } from "./symbol";
@@ -7,10 +7,19 @@ export class Statistics extends OrderedCollectable {
     Statistics = StatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "Statistics": {
+                value: StatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -19,7 +28,7 @@ export class Statistics extends OrderedCollectable {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToAsyncGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -34,14 +43,26 @@ export class Statistics extends OrderedCollectable {
     }
 }
 ;
+Object.freeze(Statistics);
+Object.freeze(Statistics.prototype);
+Object.freeze(Object.getPrototypeOf(Statistics));
 export class NumericStatistics extends Statistics {
     NumericStatistics = NumericStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "NumericStatistics": {
+                value: NumericStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -50,7 +71,7 @@ export class NumericStatistics extends Statistics {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToAsyncGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -241,14 +262,26 @@ export class NumericStatistics extends Statistics {
     }
 }
 ;
+Object.freeze(NumericStatistics);
+Object.freeze(NumericStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(NumericStatistics));
 export class BigIntStatistics extends Statistics {
     BigIntStatistics = BigIntStatisticsSymbol;
     constructor(parameter, comparator) {
         super(parameter, comparator || useCompare);
+        Object.defineProperties(this, {
+            "BigIntStatistics": {
+                value: BigIntStatisticsSymbol,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            }
+        });
+        Object.freeze(this);
     }
     *[Symbol.iterator]() {
         try {
-            let collector = useToGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -257,7 +290,7 @@ export class BigIntStatistics extends Statistics {
     }
     async *[Symbol.asyncIterator]() {
         try {
-            let collector = useToAsyncGeneratorFunction();
+            let collector = useToArray();
             yield* collector.collect(this.source());
         }
         catch (error) {
@@ -445,3 +478,6 @@ export class BigIntStatistics extends Statistics {
     }
 }
 ;
+Object.freeze(BigIntStatistics);
+Object.freeze(BigIntStatistics.prototype);
+Object.freeze(Object.getPrototypeOf(BigIntStatistics));

package/dist/symbol.d.ts

@@ -8,3 +8,11 @@ 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 BinaryNodeSymbol: symbol;
+export declare let ReadBlackNodeSymbol: symbol;
+export declare let HashableSymbol: symbol;

package/dist/symbol.js

@@ -8,3 +8,11 @@ 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 BinaryNodeSymbol = Symbol.for("BinaryNode");
+export let ReadBlackNodeSymbol = Symbol.for("BlackAndRedNode");
+export let HashableSymbol = Symbol.for("hashable");