scats 1.0.32 → 1.2.0

package/dist/mutable/hashmap.d.ts

@@ -0,0 +1,24 @@
+import { Option } from '../option';
+import { AbstractMap, Tuple2 } from '../abstract-map';
+import * as immutable from '../hashmap';
+export declare class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> {
+    constructor(map?: Map<K, V>);
+    protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V>;
+    static of<K, V>(...values: Tuple2<K, V>[]): HashMap<K, V>;
+    static from<K, V>(values: Iterable<Tuple2<K, V>>): HashMap<K, V>;
+    addAll(values: Iterable<Tuple2<K, V>>): this;
+    updateWith(key: K): (remappingFunction: (maybeValue: Option<V>) => Option<V>) => Option<V>;
+    subtractAll(values: Iterable<K>): this;
+    clear(): void;
+    clone(): HashMap<K, V>;
+    filterInPlace(p: (entry: Tuple2<K, V>) => boolean): this;
+    mapValuesInPlace(f: (entry: Tuple2<K, V>) => V): this;
+    getOrElseUpdate(key: K, defaultValue: () => V): V;
+    set(key: K, value: V): this;
+    put(key: K, value: V): Option<V>;
+    remove(key: K): Option<V>;
+    update(key: K, value: V): void;
+    addOne(elem: Tuple2<K, V>): this;
+    subtractOne(key: K): this;
+    get toImmutable(): immutable.HashMap<K, V>;
+}

package/dist/mutable/hashmap.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashMap = void 0;
+const tslib_1 = require("tslib");
+const abstract_map_1 = require("../abstract-map");
+const immutable = tslib_1.__importStar(require("../hashmap"));
+class HashMap extends abstract_map_1.AbstractMap {
+    constructor(map = new Map()) {
+        super(map);
+    }
+    fromArray(array) {
+        return HashMap.of(...array);
+    }
+    static of(...values) {
+        return new HashMap(new Map(values));
+    }
+    static from(values) {
+        return HashMap.of(...Array.from(values));
+    }
+    addAll(values) {
+        for (const [key, value] of values) {
+            this.map.set(key, value);
+        }
+        return this;
+    }
+    updateWith(key) {
+        const previousValue = this.get(key);
+        return (remappingFunction) => {
+            const nextValue = remappingFunction(previousValue);
+            if (previousValue.isEmpty && nextValue.isEmpty) {
+                return nextValue;
+            }
+            else if (previousValue.isDefined && nextValue.isEmpty) {
+                this.remove(key);
+                return nextValue;
+            }
+            else {
+                this.update(key, nextValue.get);
+                return nextValue;
+            }
+        };
+    }
+    subtractAll(values) {
+        if (this.isEmpty) {
+            return this;
+        }
+        for (const key of values) {
+            this.map.delete(key);
+            if (this.isEmpty) {
+                return this;
+            }
+        }
+        return this;
+    }
+    clear() {
+        this.map.clear();
+    }
+    clone() {
+        const contentClone = new Map(this.map);
+        return new HashMap(contentClone);
+    }
+    filterInPlace(p) {
+        if (this.nonEmpty) {
+            const entries = this.entries;
+            entries.foreach(e => {
+                if (!p(e)) {
+                    this.remove(e[0]);
+                }
+            });
+        }
+        return this;
+    }
+    mapValuesInPlace(f) {
+        if (this.nonEmpty) {
+            const entries = this.entries;
+            entries.foreach(e => {
+                this.update(e[0], f(e));
+            });
+        }
+        return this;
+    }
+    getOrElseUpdate(key, defaultValue) {
+        return this.get(key).getOrElse(() => {
+            const newValue = defaultValue();
+            this.map.set(key, newValue);
+            return newValue;
+        });
+    }
+    set(key, value) {
+        this.map.set(key, value);
+        return this;
+    }
+    put(key, value) {
+        const res = this.get(key);
+        this.map.set(key, value);
+        return res;
+    }
+    remove(key) {
+        const res = this.get(key);
+        this.subtractOne(key);
+        return res;
+    }
+    update(key, value) {
+        this.map.set(key, value);
+    }
+    addOne(elem) {
+        this.map.set(elem[0], elem[1]);
+        return this;
+    }
+    subtractOne(key) {
+        this.map.delete(key);
+        return this;
+    }
+    get toImmutable() {
+        return immutable.HashMap.of(...this.map.entries());
+    }
+}
+exports.HashMap = HashMap;

package/dist/mutable/hashset.d.ts

@@ -0,0 +1,20 @@
+import { AbstractSet } from '../abstract-set';
+import * as immutable from '../hashset';
+export declare class HashSet<T> extends AbstractSet<T, HashSet<T>> {
+    constructor(items?: Set<T>);
+    static of<T>(...items: T[]): HashSet<T>;
+    static from<T>(values: Iterable<T>): HashSet<T>;
+    protected fromArray(array: T[]): HashSet<T>;
+    add(elem: T): boolean;
+    addAll(xs: Iterable<T>): this;
+    subtractAll(xs: Iterable<T>): this;
+    remove(elem: T): boolean;
+    filterInPlace(p: (item: T) => boolean): this;
+    clear(): void;
+    addOne(elem: T): this;
+    subtractOne(elem: T): this;
+    concat(that: Iterable<T>): HashSet<T>;
+    intersect(that: AbstractSet<T, any>): HashSet<T>;
+    union(that: AbstractSet<T, any>): HashSet<T>;
+    get toImmutable(): immutable.HashSet<T>;
+}

package/dist/mutable/hashset.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashSet = void 0;
+const tslib_1 = require("tslib");
+const abstract_set_1 = require("../abstract-set");
+const immutable = tslib_1.__importStar(require("../hashset"));
+class HashSet extends abstract_set_1.AbstractSet {
+    constructor(items = new Set()) {
+        super(items);
+    }
+    static of(...items) {
+        return new HashSet(new Set(items));
+    }
+    static from(values) {
+        return HashSet.of(...Array.from(values));
+    }
+    fromArray(array) {
+        return HashSet.of(...array);
+    }
+    add(elem) {
+        const res = this.items.has(elem);
+        if (!res) {
+            this.items.add(elem);
+            return true;
+        }
+        else {
+            return !res;
+        }
+    }
+    addAll(xs) {
+        for (const x of xs) {
+            this.items.add(x);
+        }
+        return this;
+    }
+    subtractAll(xs) {
+        for (const x of xs) {
+            this.items.delete(x);
+        }
+        return this;
+    }
+    remove(elem) {
+        const res = this.items.has(elem);
+        if (res) {
+            this.items.delete(elem);
+            return true;
+        }
+        else {
+            return res;
+        }
+    }
+    filterInPlace(p) {
+        if (this.nonEmpty) {
+            const arr = this.toArray;
+            for (const t of arr) {
+                if (!p(t)) {
+                    this.remove(t);
+                }
+            }
+        }
+        return this;
+    }
+    clear() {
+        this.items.clear();
+    }
+    addOne(elem) {
+        this.add(elem);
+        return this;
+    }
+    subtractOne(elem) {
+        this.remove(elem);
+        return this;
+    }
+    concat(that) {
+        const newSet = new Set([...this.items, ...that]);
+        return new HashSet(newSet);
+    }
+    intersect(that) {
+        return this.filter(x => that.contains(x));
+    }
+    union(that) {
+        return this.concat(that);
+    }
+    get toImmutable() {
+        return immutable.HashSet.of(...this.items);
+    }
+}
+exports.HashSet = HashSet;

package/dist/mutable.d.ts

@@ -0,0 +1,3 @@
+export { ArrayBuffer } from './collection';
+export { HashMap } from './mutable/hashmap';
+export { HashSet } from './mutable/hashset';

package/dist/mutable.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashSet = exports.HashMap = exports.ArrayBuffer = void 0;
+var collection_1 = require("./collection");
+Object.defineProperty(exports, "ArrayBuffer", { enumerable: true, get: function () { return collection_1.ArrayBuffer; } });
+var hashmap_1 = require("./mutable/hashmap");
+Object.defineProperty(exports, "HashMap", { enumerable: true, get: function () { return hashmap_1.HashMap; } });
+var hashset_1 = require("./mutable/hashset");
+Object.defineProperty(exports, "HashSet", { enumerable: true, get: function () { return hashset_1.HashSet; } });

package/dist/option.js

@@ -86,7 +86,7 @@ class Option extends array_iterable_1.ArrayIterable {
         }
     }
     forall(p) {
-        return this.isEmpty ? false : p(this.get);
+        return this.isEmpty ? true : p(this.get);
     }
     foreach(f) {
         if (this.nonEmpty) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "scats",
-  "version": "1.0.32",
+  "version": "1.2.0",
   "description": "Useful scala classes in typescript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "clean": "rimraf dist",
     "lint": "eslint \"{src,test}/**/*.ts\" --fix",
-    "prebuild": "npm run clean && npm run lint",
+    "prebuild": "npm run clean && npm run lint && npm run test",
     "test": "jest",
     "compile": "tsc",
     "build": "npm run compile"
@@ -36,17 +36,17 @@
   },
   "homepage": "https://github.com/papirosko/scats#readme",
   "devDependencies": {
-    "@types/jest": "^26.0.20",
-    "@typescript-eslint/eslint-plugin": "4.16.1",
-    "@typescript-eslint/parser": "4.16.1",
-    "eslint": "7.21.0",
-    "eslint-plugin-import": "^2.22.1",
-    "jest": "^26.6.3",
-    "ts-jest": "^26.5.3",
-    "ts-node": "^9.1.1",
-    "typescript": "^4.2.3"
+    "@types/jest": "^27.0.3",
+    "@typescript-eslint/eslint-plugin": "5.6.0",
+    "@typescript-eslint/parser": "5.6.0",
+    "eslint": "7.32.0",
+    "eslint-plugin-import": "^2.25.3",
+    "jest": "^27.4.4",
+    "ts-jest": "^27.1.1",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.3"
   },
   "dependencies": {
-    "tslib": "^2.1.0"
+    "tslib": "^2.3.1"
   }
 }

package/src/abstract-map.ts

@@ -0,0 +1,79 @@
+import {ArrayIterable} from './array-iterable';
+import {option, Option} from './option';
+import {HashSet} from './hashset';
+import {Collection} from './collection';
+
+export type Tuple2<K, V> = [K, V];
+
+export abstract class AbstractMap<K, V, S extends AbstractMap<K, V, any>> extends ArrayIterable<Tuple2<K, V>, S> {
+
+
+    protected constructor(protected readonly map: Map<K, V>) {
+        super();
+    }
+
+    get size(): number {
+        return this.map.size;
+    }
+
+    get isEmpty(): boolean {
+        return this.map.size <= 0;
+    }
+
+    get(key: K): Option<V> {
+        return option(this.map.get(key));
+    }
+
+    getOrElse(key: K, defaultValue: () => V): V {
+        return this.get(key).getOrElse(defaultValue);
+    }
+
+    getOrElseValue(key: K, defaultValue: V): V {
+        return this.get(key).getOrElseValue(defaultValue);
+    }
+
+    get keySet(): HashSet<K> {
+        return HashSet.of(...Array.from(this.map.keys()));
+    }
+
+    get keyIterator(): IterableIterator<K> {
+        return this.map.keys();
+    }
+
+    get keys(): Collection<K> {
+        return new Collection(Array.from(this.map.keys()));
+    }
+
+    get values(): Collection<V> {
+        return new Collection(Array.from(this.map.values()));
+    }
+
+    get valueIterator(): IterableIterator<V> {
+        return this.map.values();
+    }
+
+    get entries(): Collection<Tuple2<K, V>> {
+        return new Collection(Array.from(this.map.entries()));
+    }
+
+    get entriesIterator(): IterableIterator<Tuple2<K, V>> {
+        return this.map.entries();
+    }
+
+    containsKey(key: K): boolean {
+        return this.map.has(key);
+    }
+
+    get toCollection(): Collection<Tuple2<K, V>> {
+        return new Collection<Tuple2<K, V>>(Array.from(this.map.entries()));
+    }
+
+    get toMap(): Map<K, V> {
+        return this.map;
+    }
+
+    get toArray(): Array<Tuple2<K, V>> {
+        return Array.from(this.map.entries());
+    }
+
+}

package/src/abstract-set.ts

@@ -0,0 +1,40 @@
+import {ArrayIterable} from './array-iterable';
+import {ArrayBuffer, Collection} from './collection';
+
+export abstract class AbstractSet<T, S extends AbstractSet<T, any>> extends ArrayIterable<T, S> {
+
+    protected constructor(protected readonly items: Set<T>) {
+        super();
+    }
+
+
+    contains(item: T): boolean {
+        return this.items.has(item);
+    }
+
+    get toArray(): Array<T> {
+        return Array.from(this.items.keys());
+    }
+
+    get toCollection(): Collection<T> {
+        return new Collection(Array.from(this.items.keys()));
+    }
+
+    get toSet(): Set<T> {
+        return new Set(this.items);
+    }
+
+    get isEmpty(): boolean {
+        return this.items.size <= 0;
+    }
+
+    get size(): number {
+        return this.items.size;
+    }
+
+    get toBuffer(): ArrayBuffer<T> {
+        return new ArrayBuffer(Array.from(this.items.keys()));
+    }
+
+
+}

package/src/array-iterable.ts

@@ -1,6 +1,4 @@
-import {none, option, Option, some} from './option';
-import {HashMap} from './hashmap';
-import {Collection} from './collection';
+import {Collection, HashMap, none, option, Option, some} from './index';
 
 export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implements Iterable<T> {
 
@@ -53,20 +51,34 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
     count(p: (item: T) => boolean): number {
         let res = 0;
         this.toArray.forEach(i => {
-            if (p(i)) { res++; }
+            if (p(i)) {
+                res++;
+            }
         });
 
         return res;
     }
 
+    /**
+     * Tests whether the collection is empty.
+     * @return `true` if the collection contains no elements, `false` otherwise.
+     */
     get isEmpty(): boolean {
         return this.size <= 0;
     }
 
+    /**
+     * Tests whether the collection is not empty.
+     * @return `true` if the collection contains at least one element, `false` otherwise.
+     */
     get nonEmpty(): boolean {
         return !this.isEmpty;
     }
 
+    /**
+     * The size of this collection.
+     * @return the number of elements in this collection.
+     */
     get size(): number {
         return this.toArray.length;
     }
@@ -113,7 +125,7 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
         const array = this.toArray;
         let acc = array[0];
         if (array.length > 1) {
-            for (let i = 1; i< array.length; i++) {
+            for (let i = 1; i < array.length; i++) {
                 acc = op(acc, array[i]);
             }
         }
@@ -140,7 +152,7 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
         let acc = this.last;
         const array = this.toArray.reverse();
         if (array.length > 1) {
-            for (let i = 1; i< array.length; i++) {
+            for (let i = 1; i < array.length; i++) {
                 acc = op(acc, array[i]);
             }
         }
@@ -152,7 +164,6 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
     }
 
 
-
     foldLeft<B>(initial: B): (op: (acc: B, next: T) => B) => B {
         return (op: (acc: B, next: T) => B) => {
             return this.toArray.reduce((a, n) => op(a, n), initial);
@@ -254,7 +265,7 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
         } else if (n === 0) {
             return this as unknown as C;
         } else {
-            return this.fromArray(array.slice(n , array.length));
+            return this.fromArray(array.slice(n, array.length));
         }
     }
 
@@ -265,7 +276,7 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
         } else if (n === 0) {
             return this as unknown as C;
         } else {
-            return this.fromArray(array.slice(0 , array.length - n));
+            return this.fromArray(array.slice(0, array.length - n));
         }
 
     }
@@ -322,6 +333,12 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
     }
 
 
+    /**
+     * Sums up the elements of this collection.
+     *
+     * @param   elementToNum  a parameter converting an element to a number.
+     * @return  the sum of all elements produced by elementToNum over the elements of this collection.
+     */
     sum(elementToNum: (element: T) => number): number {
         if (this.isEmpty) {
             return 0;
@@ -367,7 +384,6 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
     }
 
 
-
     /** The rest of the collection without its first element. */
     get tail(): C {
         if (this.isEmpty) throw new Error('empty.tail');
@@ -409,8 +425,6 @@ export abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implemen
     }
 
 
-
-
     /**
      * Partitions this $coll into a map according to a discriminator function `key`. All the values that
      * have the same discriminator are then transformed by the `f` function and then reduced into a