scats 1.0.32 → 1.2.0

package/dist/collection.js

@@ -1,11 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Nil = exports.Collection = void 0;
+exports.ArrayBuffer = exports.Nil = exports.Collection = exports.ArrayBackedCollection = void 0;
 const tslib_1 = require("tslib");
-const hashmap_1 = require("./hashmap");
-const hashset_1 = require("./hashset");
+const index_1 = require("./index");
 const array_iterable_1 = require("./array-iterable");
-class Collection extends array_iterable_1.ArrayIterable {
+class ArrayBackedCollection extends array_iterable_1.ArrayIterable {
+    checkWithinBounds(lo, hi) {
+        if (lo < 0)
+            throw new Error(`$lo is out of bounds (min 0, max ${this.items.length - 1})`);
+        if (hi > this.size)
+            throw new Error(`$lo is out of bounds (min 0, max ${this.items.length - 1})`);
+    }
+    get reverse() {
+        return this.fromArray(this.items.reverse());
+    }
+    get toArray() {
+        return this.items;
+    }
+    get(index) {
+        this.checkWithinBounds(index, index + 1);
+        return this.items[index];
+    }
+    get toSet() {
+        return index_1.HashSet.of(...this.items);
+    }
+    indexOf(item) {
+        return this.items.indexOf(item);
+    }
+    get distinct() {
+        return this.fromArray(Array.from(new Set(this.items)));
+    }
+    distinctBy(key) {
+        const keys = new Set();
+        const res = [];
+        this.foreach(item => {
+            const currentKey = key(item);
+            if (!keys.has(currentKey)) {
+                keys.add(currentKey);
+                res.push(item);
+            }
+        });
+        return this.fromArray(res);
+    }
+    appended(item) {
+        return this.fromArray(this.items.concat([item]));
+    }
+    appendedAll(other) {
+        return this.fromArray(this.items.concat(...other));
+    }
+    prepended(item) {
+        return this.fromArray([item].concat(this.items));
+    }
+    prependedAll(other) {
+        return this.fromArray(Array.from(other).concat(this.items));
+    }
+    concat(other) {
+        return this.appendedAll(other);
+    }
+    slice(from, until) {
+        return this.fromArray(this.items.slice(from, until));
+    }
+    sort(param) {
+        return this.fromArray(this.items.slice(0).sort(param));
+    }
+    sortBy(fieldToNumber) {
+        return this.sort(((a, b) => fieldToNumber(a) - fieldToNumber(b)));
+    }
+    get length() {
+        return this.size;
+    }
+}
+exports.ArrayBackedCollection = ArrayBackedCollection;
+class Collection extends ArrayBackedCollection {
     constructor(items) {
         super();
         this.items = items;
@@ -21,6 +87,9 @@ class Collection extends array_iterable_1.ArrayIterable {
     static of(...items) {
         return new Collection(items);
     }
+    static from(elements) {
+        return new Collection(Array.from(elements));
+    }
     static fill(len) {
         return function (elem) {
             const res = new Array(len);
@@ -30,16 +99,22 @@ class Collection extends array_iterable_1.ArrayIterable {
             return new Collection(res);
         };
     }
-    slice(from, until) {
-        return new Collection(this.items.slice(from, until));
-    }
     map(f) {
         return new Collection(this.items.map(i => f(i)));
     }
     flatMap(f) {
-        let res = [];
+        const res = [];
+        this.items.forEach(i => {
+            res.push(...f(i).items);
+        });
+        return new Collection(res);
+    }
+    flatMapOption(f) {
+        const res = [];
         this.items.forEach(i => {
-            res = res.concat(f(i).items);
+            f(i).foreach(v => {
+                res.push(v);
+            });
         });
         return new Collection(res);
     }
@@ -59,10 +134,10 @@ class Collection extends array_iterable_1.ArrayIterable {
     }
     flatMapPromise(f) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let res = [];
+            const res = [];
             for (let i = 0; i < this.items.length; i++) {
                 const item = this.items[i];
-                res = res.concat((yield f(item)).items);
+                res.push(...(yield f(item)).items);
             }
             return new Collection(res);
         });
@@ -84,59 +159,11 @@ class Collection extends array_iterable_1.ArrayIterable {
         });
         return new Collection(res);
     }
-    get(idx) {
-        return this.items[idx];
-    }
-    get toArray() {
-        return this.items;
-    }
-    get reverse() {
-        return new Collection(this.items.reverse());
-    }
-    sort(param) {
-        return new Collection(this.items.sort(param));
-    }
-    sortBy(fieldToNumber) {
-        return this.sort((a, b) => fieldToNumber(a) - fieldToNumber(b));
-    }
-    appended(item) {
-        return new Collection(this.items.concat([item]));
-    }
-    appendedAll(other) {
-        return new Collection(this.items.concat(other.items));
-    }
-    prepended(item) {
-        return new Collection([item].concat(this.items));
-    }
-    prependedAll(other) {
-        return new Collection(other.items.concat(this.items));
-    }
-    concat(other) {
-        return this.appendedAll(other);
-    }
-    get toSet() {
-        return hashset_1.HashSet.of(...this.items);
-    }
-    get distinct() {
-        return hashset_1.HashSet.of(...this.items).toCollection;
-    }
-    distinctBy(key) {
-        const keys = new Set();
-        const res = [];
-        this.foreach(item => {
-            const currentKey = key(item);
-            if (!keys.has(currentKey)) {
-                keys.add(currentKey);
-                res.push(item);
-            }
-        });
-        return new Collection(res);
+    get toBuffer() {
+        return new ArrayBuffer(this.items);
     }
     toMap(mapper) {
-        return hashmap_1.HashMap.of(...this.map(mapper).toArray);
-    }
-    indexOf(item) {
-        return this.items.indexOf(item);
+        return index_1.HashMap.of(...this.map(mapper).toArray);
     }
     zip(that) {
         const res = [];
@@ -159,3 +186,168 @@ class Collection extends array_iterable_1.ArrayIterable {
 exports.Collection = Collection;
 Collection.empty = new Collection([]);
 exports.Nil = Collection.empty;
+class ArrayBuffer extends ArrayBackedCollection {
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    static get empty() {
+        return new ArrayBuffer([]);
+    }
+    static of(...elements) {
+        return new ArrayBuffer(elements);
+    }
+    static from(elements) {
+        return new ArrayBuffer(Array.from(elements));
+    }
+    static fill(len) {
+        return function (elem) {
+            const res = new Array(len);
+            for (let i = 0; i < len; i++) {
+                res[i] = elem(i);
+            }
+            return new ArrayBuffer(res);
+        };
+    }
+    fromArray(array) {
+        if (!array || array.length <= 0) {
+            return new ArrayBuffer([]);
+        }
+        else {
+            return new ArrayBuffer(array);
+        }
+    }
+    update(index, element) {
+        this.checkWithinBounds(index, index + 1);
+        this.items[index] = element;
+    }
+    set(index, element) {
+        this.update(index, element);
+    }
+    clear() {
+        this.items.length = 0;
+    }
+    append(element) {
+        this.items.push(element);
+        return this;
+    }
+    appendAll(elements) {
+        this.items.push(...elements);
+        return this;
+    }
+    prepend(element) {
+        this.items.unshift(element);
+        return this;
+    }
+    prependAll(elements) {
+        this.items.unshift(...elements);
+        return this;
+    }
+    insert(idx, element) {
+        this.checkWithinBounds(idx, idx);
+        this.items.splice(idx, 0, element);
+    }
+    insertAll(idx, elements) {
+        this.checkWithinBounds(idx, idx);
+        this.items.splice(idx, 0, ...elements);
+    }
+    remove(index, count = 1) {
+        if (count > 0) {
+            this.checkWithinBounds(index, index + 1);
+            this.items.splice(index, count);
+        }
+        else if (count < 0) {
+            throw new Error('removing negative number of elements: ' + count);
+        }
+    }
+    subtractOne(element) {
+        const i = this.items.indexOf(element);
+        if (i != -1) {
+            this.remove(i);
+        }
+        return this;
+    }
+    subtractAll(elements) {
+        if (elements === this || elements === this.items) {
+            const buf = new ArrayBuffer(Array.from(elements));
+            buf.foreach(e => this.subtractOne(e));
+        }
+        else {
+            for (const element of elements) {
+                this.subtractOne(element);
+            }
+        }
+        return this;
+    }
+    sort(compareFn) {
+        this.items.sort(compareFn);
+        return this;
+    }
+    get toCollection() {
+        return new Collection(this.items.slice(0));
+    }
+    flatMap(f) {
+        const res = [];
+        this.items.forEach(i => {
+            res.push(...f(i).items);
+        });
+        return new ArrayBuffer(res);
+    }
+    flatMapOption(f) {
+        const res = [];
+        this.items.forEach(i => {
+            f(i).foreach(v => {
+                res.push(v);
+            });
+        });
+        return new ArrayBuffer(res);
+    }
+    flatMapPromise(f) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const res = [];
+            for (let i = 0; i < this.items.length; i++) {
+                const item = this.items[i];
+                res.push(...(yield f(item)).items);
+            }
+            return new ArrayBuffer(res);
+        });
+    }
+    map(f) {
+        return new ArrayBuffer(this.items.map(i => f(i)));
+    }
+    mapPromise(f) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const res = [];
+            for (let i = 0; i < this.items.length; i++) {
+                res.push(yield f(this.items[i]));
+            }
+            return new ArrayBuffer(res);
+        });
+    }
+    mapPromiseAll(f) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new ArrayBuffer(yield Promise.all(this.items.map(i => f(i))));
+        });
+    }
+    flatMapPromiseAll(f) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield this.mapPromiseAll(f)).flatten();
+        });
+    }
+    flatten() {
+        const res = [];
+        this.items.forEach(i => {
+            if (i instanceof ArrayBuffer) {
+                res.push(...i.items);
+            }
+            else {
+                res.push(i);
+            }
+        });
+        return new ArrayBuffer(res);
+    }
+    toMap(mapper) {
+        return index_1.HashMap.of(...this.map(mapper).toArray);
+    }
+}
+exports.ArrayBuffer = ArrayBuffer;

package/dist/hashmap.d.ts

@@ -1,33 +1,19 @@
-import { Option } from './option';
-import { Collection } from './collection';
-import { HashSet } from './hashset';
-import { ArrayIterable } from './array-iterable';
-export declare type Tuple2<K, V> = [K, V];
-export declare class HashMap<K, V> extends ArrayIterable<Tuple2<K, V>, HashMap<K, V>> {
-    private readonly map;
+import { mutable, Option } from './index';
+import { AbstractMap, Tuple2 } from './abstract-map';
+export declare class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> {
+    protected readonly map: Map<K, V>;
     protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V>;
-    constructor(map: Map<K, V>);
+    protected constructor(map: Map<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>;
     static empty: HashMap<any, any>;
-    get size(): number;
-    get isEmpty(): boolean;
-    get(key: K): Option<V>;
-    getOrElse(key: K, defaultValue: () => V): V;
-    getOrElseValue(key: K, defaultValue: V): V;
-    get keySet(): HashSet<K>;
-    get keyIterator(): IterableIterator<K>;
-    get keys(): Collection<K>;
-    get values(): Collection<V>;
-    get valueIterator(): IterableIterator<V>;
-    get entries(): Collection<Tuple2<K, V>>;
-    get entriesIterator(): IterableIterator<Tuple2<K, V>>;
     appendedAll(map: HashMap<K, V>): HashMap<K, V>;
+    appended(key: K, value: V): HashMap<K, V>;
+    updated(key: K, value: V): HashMap<K, V>;
+    removed(key: K): HashMap<K, V>;
+    removedAll(keys: Iterable<K>): HashMap<K, V>;
     concat(map: HashMap<K, V>): HashMap<K, V>;
     set(key: K, value: V): HashMap<K, V>;
-    remove(key: K): HashMap<K, V>;
-    containsKey(key: K): boolean;
-    updated(key: K, value: V): HashMap<K, V>;
-    get toCollection(): Collection<Tuple2<K, V>>;
-    get toMap(): Map<K, V>;
-    get toArray(): Array<Tuple2<K, V>>;
+    updatedWith(key: K): (remappingFunction: (maybeValue: Option<V>) => Option<V>) => HashMap<K, V>;
+    get toMutable(): mutable.HashMap<K, V>;
 }

package/dist/hashmap.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashMap = void 0;
-const option_1 = require("./option");
-const collection_1 = require("./collection");
-const hashset_1 = require("./hashset");
-const array_iterable_1 = require("./array-iterable");
-class HashMap extends array_iterable_1.ArrayIterable {
+const index_1 = require("./index");
+const abstract_map_1 = require("./abstract-map");
+class HashMap extends abstract_map_1.AbstractMap {
     constructor(map) {
-        super();
+        super(map);
         this.map = map;
     }
     fromArray(array) {
@@ -16,44 +14,29 @@ class HashMap extends array_iterable_1.ArrayIterable {
     static of(...values) {
         return new HashMap(new Map(values));
     }
-    get size() {
-        return this.map.size;
+    static from(values) {
+        return HashMap.of(...Array.from(values));
     }
-    get isEmpty() {
-        return this.map.size <= 0;
-    }
-    get(key) {
-        return option_1.option(this.map.get(key));
-    }
-    getOrElse(key, defaultValue) {
-        return this.get(key).getOrElse(defaultValue);
-    }
-    getOrElseValue(key, defaultValue) {
-        return this.get(key).getOrElseValue(defaultValue);
-    }
-    get keySet() {
-        return hashset_1.HashSet.of(...Array.from(this.map.keys()));
-    }
-    get keyIterator() {
-        return this.map.keys();
-    }
-    get keys() {
-        return new collection_1.Collection(Array.from(this.map.keys()));
-    }
-    get values() {
-        return new collection_1.Collection(Array.from(this.map.values()));
+    appendedAll(map) {
+        return this.concat(map);
     }
-    get valueIterator() {
-        return this.map.values();
+    appended(key, value) {
+        return this.set(key, value);
     }
-    get entries() {
-        return new collection_1.Collection(Array.from(this.map.entries()));
+    updated(key, value) {
+        return this.set(key, value);
     }
-    get entriesIterator() {
-        return this.map.entries();
+    removed(key) {
+        const next = new Map(this.map);
+        next.delete(key);
+        return new HashMap(next);
     }
-    appendedAll(map) {
-        return this.concat(map);
+    removedAll(keys) {
+        const next = new Map(this.map);
+        for (const key of keys) {
+            next.delete(key);
+        }
+        return new HashMap(next);
     }
     concat(map) {
         const mergedMap = new Map([
@@ -67,25 +50,23 @@ class HashMap extends array_iterable_1.ArrayIterable {
         next.set(key, value);
         return new HashMap(new Map(next));
     }
-    remove(key) {
-        const next = new Map(this.map);
-        next.delete(key);
-        return new HashMap(next);
-    }
-    containsKey(key) {
-        return this.map.has(key);
-    }
-    updated(key, value) {
-        return this.set(key, value);
-    }
-    get toCollection() {
-        return new collection_1.Collection(Array.from(this.map.entries()));
-    }
-    get toMap() {
-        return this.map;
-    }
-    get toArray() {
-        return Array.from(this.map.entries());
+    updatedWith(key) {
+        const previousValue = this.get(key);
+        return (remappingFunction) => {
+            const nextValue = remappingFunction(previousValue);
+            if (previousValue.isEmpty && nextValue.isEmpty) {
+                return this;
+            }
+            else if (previousValue.isDefined && nextValue.isEmpty) {
+                return this.removed(key);
+            }
+            else {
+                return this.updated(key, nextValue.get);
+            }
+        };
+    }
+    get toMutable() {
+        return index_1.mutable.HashMap.of(...Array.from(this.map.entries()));
     }
 }
 exports.HashMap = HashMap;

package/dist/hashset.d.ts

@@ -1,26 +1,21 @@
-import { Collection } from './collection';
-import { ArrayIterable } from './array-iterable';
 import { HashMap } from './hashmap';
-export declare class HashSet<T> extends ArrayIterable<T, HashSet<T>> {
-    private readonly items;
-    protected fromArray(array: T[]): HashSet<T>;
-    constructor(items: Set<T>);
+import { AbstractSet } from './abstract-set';
+import * as mutable from './mutable/hashset';
+export declare class HashSet<T> extends AbstractSet<T, HashSet<T>> {
+    protected constructor(items: Set<T>);
     static empty: HashSet<any>;
     static of<T>(...items: T[]): HashSet<T>;
-    get toCollection(): Collection<T>;
-    get toSet(): Set<T>;
-    contains(item: T): boolean;
+    static from<T>(elements: Iterable<T>): HashSet<T>;
+    protected fromArray(array: T[]): HashSet<T>;
+    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
     map<B>(f: (item: T) => B): HashSet<B>;
     flatMap<B>(f: (item: T) => HashSet<B>): HashSet<B>;
-    get toArray(): Array<T>;
-    get isEmpty(): boolean;
-    get size(): number;
-    concat(other: ArrayIterable<T, any>): HashSet<T>;
-    union(other: ArrayIterable<T, any>): HashSet<T>;
+    concat(that: Iterable<T>): HashSet<T>;
+    union(other: Iterable<T>): HashSet<T>;
     appended(item: T): HashSet<T>;
-    appendedAll(other: ArrayIterable<T, any>): HashSet<T>;
+    appendedAll(other: Iterable<T>): HashSet<T>;
     removed(item: T): HashSet<T>;
-    removedAll(other: HashSet<T>): HashSet<T>;
+    removedAll(other: Iterable<T>): HashSet<T>;
     intersect(other: HashSet<T>): HashSet<T>;
-    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
+    get toMutable(): mutable.HashSet<T>;
 }

package/dist/hashset.js

@@ -1,59 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HashSet = void 0;
-const collection_1 = require("./collection");
-const array_iterable_1 = require("./array-iterable");
+const tslib_1 = require("tslib");
 const hashmap_1 = require("./hashmap");
-class HashSet extends array_iterable_1.ArrayIterable {
+const abstract_set_1 = require("./abstract-set");
+const mutable = tslib_1.__importStar(require("./mutable/hashset"));
+class HashSet extends abstract_set_1.AbstractSet {
     constructor(items) {
-        super();
-        this.items = items;
-    }
-    fromArray(array) {
-        return HashSet.of(...array);
+        super(items);
     }
     static of(...items) {
         return new HashSet(new Set(items));
     }
-    get toCollection() {
-        return new collection_1.Collection(Array.from(this.items.keys()));
+    static from(elements) {
+        return new HashSet(new Set(elements));
     }
-    get toSet() {
-        return this.items;
+    fromArray(array) {
+        return HashSet.of(...array);
     }
-    contains(item) {
-        return this.items.has(item);
+    toMap(mapper) {
+        return hashmap_1.HashMap.of(...this.map(mapper).toArray);
     }
     map(f) {
         return HashSet.of(...Array.from(this.items).map(i => f(i)));
     }
     flatMap(f) {
-        let res = HashSet.empty;
-        this.items.forEach(i => {
-            res = res.union(f(i));
-        });
-        return res;
-    }
-    get toArray() {
-        return Array.from(this.items.keys());
-    }
-    get isEmpty() {
-        return this.items.size <= 0;
-    }
-    get size() {
-        return this.items.size;
+        const res = new Set();
+        this.items.forEach(i => f(i).foreach(e => res.add(e)));
+        return new HashSet(res);
     }
-    concat(other) {
-        return this.appendedAll(other);
+    concat(that) {
+        return this.appendedAll(that);
     }
     union(other) {
         return this.concat(other);
     }
     appended(item) {
-        return HashSet.of(...this.toArray.concat([item]));
+        return this.fromArray(this.toArray.concat([item]));
     }
     appendedAll(other) {
-        return HashSet.of(...this.toArray.concat(other.toArray));
+        const res = Array.from(this.items);
+        res.push(...Array.from(other));
+        return this.fromArray(res);
     }
     removed(item) {
         const res = new Set(Array.from(this.items));
@@ -62,14 +50,16 @@ class HashSet extends array_iterable_1.ArrayIterable {
     }
     removedAll(other) {
         const res = new Set(Array.from(this.items));
-        other.foreach(i => res.delete(i));
+        for (const element of other) {
+            res.delete(element);
+        }
         return new HashSet(res);
     }
     intersect(other) {
         return this.filter(x => other.contains(x));
     }
-    toMap(mapper) {
-        return hashmap_1.HashMap.of(...this.map(mapper).toArray);
+    get toMutable() {
+        return mutable.HashSet.of(...this.items);
     }
 }
 exports.HashSet = HashSet;

package/dist/index.d.ts

@@ -5,3 +5,5 @@ export * from './hashset';
 export * from './option';
 export * from './try';
 export * from './util';
+import * as mutable from './mutable';
+export { mutable };

package/dist/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutable = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./collection"), exports);
 tslib_1.__exportStar(require("./either"), exports);
@@ -8,3 +9,5 @@ tslib_1.__exportStar(require("./hashset"), exports);
 tslib_1.__exportStar(require("./option"), exports);
 tslib_1.__exportStar(require("./try"), exports);
 tslib_1.__exportStar(require("./util"), exports);
+const mutable = tslib_1.__importStar(require("./mutable"));
+exports.mutable = mutable;