scats 1.0.32 → 1.2.0

package/dist/abstract-map.d.ts

@@ -0,0 +1,25 @@
+import { ArrayIterable } from './array-iterable';
+import { Option } from './option';
+import { HashSet } from './hashset';
+import { Collection } from './collection';
+export declare type Tuple2<K, V> = [K, V];
+export declare abstract class AbstractMap<K, V, S extends AbstractMap<K, V, any>> extends ArrayIterable<Tuple2<K, V>, S> {
+    protected readonly map: Map<K, V>;
+    protected constructor(map: Map<K, V>);
+    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>>;
+    containsKey(key: K): boolean;
+    get toCollection(): Collection<Tuple2<K, V>>;
+    get toMap(): Map<K, V>;
+    get toArray(): Array<Tuple2<K, V>>;
+}

package/dist/abstract-map.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractMap = void 0;
+const array_iterable_1 = require("./array-iterable");
+const option_1 = require("./option");
+const hashset_1 = require("./hashset");
+const collection_1 = require("./collection");
+class AbstractMap extends array_iterable_1.ArrayIterable {
+    constructor(map) {
+        super();
+        this.map = map;
+    }
+    get size() {
+        return this.map.size;
+    }
+    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()));
+    }
+    get valueIterator() {
+        return this.map.values();
+    }
+    get entries() {
+        return new collection_1.Collection(Array.from(this.map.entries()));
+    }
+    get entriesIterator() {
+        return this.map.entries();
+    }
+    containsKey(key) {
+        return this.map.has(key);
+    }
+    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());
+    }
+}
+exports.AbstractMap = AbstractMap;

package/dist/abstract-set.d.ts

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

package/dist/abstract-set.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSet = void 0;
+const array_iterable_1 = require("./array-iterable");
+const collection_1 = require("./collection");
+class AbstractSet extends array_iterable_1.ArrayIterable {
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    contains(item) {
+        return this.items.has(item);
+    }
+    get toArray() {
+        return Array.from(this.items.keys());
+    }
+    get toCollection() {
+        return new collection_1.Collection(Array.from(this.items.keys()));
+    }
+    get toSet() {
+        return new Set(this.items);
+    }
+    get isEmpty() {
+        return this.items.size <= 0;
+    }
+    get size() {
+        return this.items.size;
+    }
+    get toBuffer() {
+        return new collection_1.ArrayBuffer(Array.from(this.items.keys()));
+    }
+}
+exports.AbstractSet = AbstractSet;

package/dist/array-iterable.d.ts

@@ -1,6 +1,4 @@
-import { Option } from './option';
-import { HashMap } from './hashmap';
-import { Collection } from './collection';
+import { Collection, HashMap, Option } from './index';
 export declare abstract class ArrayIterable<T, C extends ArrayIterable<T, any>> implements Iterable<T> {
     [Symbol.iterator](): Iterator<T, T | undefined, undefined>;
     abstract get toArray(): Array<T>;

package/dist/array-iterable.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayIterable = void 0;
-const option_1 = require("./option");
-const hashmap_1 = require("./hashmap");
-const collection_1 = require("./collection");
+const index_1 = require("./index");
 class ArrayIterable {
     [Symbol.iterator]() {
         let i = 0;
@@ -40,7 +38,7 @@ class ArrayIterable {
         return this.toArray.find(i => p(i)) !== undefined;
     }
     find(p) {
-        return option_1.option(this.toArray.find(i => p(i)));
+        return index_1.option(this.toArray.find(i => p(i)));
     }
     count(p) {
         let res = 0;
@@ -67,7 +65,7 @@ class ArrayIterable {
         return this.reduceLeftOption(op);
     }
     get headOption() {
-        return this.isEmpty ? option_1.none : option_1.some(this.head);
+        return this.isEmpty ? index_1.none : index_1.some(this.head);
     }
     get head() {
         if (this.isEmpty) {
@@ -78,7 +76,7 @@ class ArrayIterable {
         }
     }
     get lastOption() {
-        return this.isEmpty ? option_1.none : option_1.some(this.last);
+        return this.isEmpty ? index_1.none : index_1.some(this.last);
     }
     get last() {
         if (this.isEmpty) {
@@ -102,11 +100,11 @@ class ArrayIterable {
         return acc;
     }
     reduceLeftOption(op) {
-        return this.isEmpty ? option_1.none : option_1.some(this.reduceLeft(op));
+        return this.isEmpty ? index_1.none : index_1.some(this.reduceLeft(op));
     }
     foldRight(initial) {
         return (op) => {
-            return new collection_1.Collection(this.toArray)
+            return new index_1.Collection(this.toArray)
                 .reverse
                 .foldLeft(initial)((a, n) => op(n, a));
         };
@@ -125,7 +123,7 @@ class ArrayIterable {
         return acc;
     }
     reduceRightOption(op) {
-        return this.isEmpty ? option_1.none : option_1.some(this.reduceRight(op));
+        return this.isEmpty ? index_1.none : index_1.some(this.reduceRight(op));
     }
     foldLeft(initial) {
         return (op) => {
@@ -136,10 +134,10 @@ class ArrayIterable {
         return this.foldLeft(initial);
     }
     groupBy(field) {
-        return this.foldLeft(hashmap_1.HashMap.empty)((acc, next) => {
+        return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
             const key = field(next);
-            const existing = acc.get(key).getOrElseValue(collection_1.Collection.empty);
-            return acc.set(key, new collection_1.Collection(existing.toArray.concat(next)));
+            const existing = acc.get(key).getOrElseValue(index_1.Collection.empty);
+            return acc.set(key, new index_1.Collection(existing.toArray.concat(next)));
         });
     }
     minBy(toNumber) {
@@ -160,7 +158,7 @@ class ArrayIterable {
         }
     }
     minByOption(toNumber) {
-        return this.isEmpty ? option_1.none : option_1.some(this.minBy(toNumber));
+        return this.isEmpty ? index_1.none : index_1.some(this.minBy(toNumber));
     }
     maxBy(toNumber) {
         if (this.isEmpty) {
@@ -180,7 +178,7 @@ class ArrayIterable {
         }
     }
     maxByOption(toNumber) {
-        return this.isEmpty ? option_1.none : option_1.some(this.maxBy(toNumber));
+        return this.isEmpty ? index_1.none : index_1.some(this.maxBy(toNumber));
     }
     partition(p) {
         const array = this.toArray;
@@ -250,12 +248,12 @@ class ArrayIterable {
     }
     sliding(length, step = 1) {
         if (this.isEmpty) {
-            return collection_1.Collection.empty;
+            return index_1.Collection.empty;
         }
         else {
             const itemsSize = this.size;
             if (itemsSize <= length) {
-                return collection_1.Collection.of(this);
+                return index_1.Collection.of(this);
             }
             else {
                 const result = [];
@@ -269,7 +267,7 @@ class ArrayIterable {
                     left += step;
                     right = left + length;
                 }
-                return new collection_1.Collection(result);
+                return new index_1.Collection(result);
             }
         }
     }
@@ -311,9 +309,9 @@ class ArrayIterable {
     }
     groupMap(key) {
         return (value) => {
-            return this.foldLeft(hashmap_1.HashMap.empty)((acc, next) => {
+            return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
                 const nextKey = key(next);
-                const existingColl = acc.getOrElse(nextKey, () => collection_1.Collection.empty);
+                const existingColl = acc.getOrElse(nextKey, () => index_1.Collection.empty);
                 const updatedColl = existingColl.appended(value(next));
                 return acc.updated(nextKey, updatedColl);
             });
@@ -322,7 +320,7 @@ class ArrayIterable {
     groupMapReduce(key) {
         return (value) => {
             return (reduce) => {
-                return this.foldLeft(hashmap_1.HashMap.empty)((acc, next) => {
+                return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
                     const nextKey = key(next);
                     const nextValue = value(next);
                     return acc.updated(nextKey, acc.get(nextKey).map(e => reduce(e, nextValue)).getOrElseValue(nextValue));
@@ -361,7 +359,7 @@ class ArrayIterable {
         for (let i = 0; i < array.length; i++) {
             res.push([array[i], i]);
         }
-        return new collection_1.Collection(res);
+        return new index_1.Collection(res);
     }
     get tails() {
         const array = this.toArray;
@@ -369,7 +367,7 @@ class ArrayIterable {
         for (let i = 0; i <= array.length; i++) {
             res.push(this.takeRight(array.length - i));
         }
-        return new collection_1.Collection(res);
+        return new index_1.Collection(res);
     }
     get inits() {
         const array = this.toArray;
@@ -377,7 +375,7 @@ class ArrayIterable {
         for (let i = 0; i <= array.length; i++) {
             res.push(this.take(array.length - i));
         }
-        return new collection_1.Collection(res);
+        return new index_1.Collection(res);
     }
 }
 exports.ArrayIterable = ArrayIterable;

package/dist/collection.d.ts

@@ -1,39 +1,78 @@
-import { HashMap } from './hashmap';
-import { HashSet } from './hashset';
-import { ArrayIterable } from './array-iterable';
 import { Mappable } from './mappable';
+import { HashMap, HashSet, Option } from './index';
 import { Filterable } from './util';
-export declare class Collection<T> extends ArrayIterable<T, Collection<T>> implements Mappable<T>, Filterable<T, Collection<T>> {
-    private readonly items;
+import { ArrayIterable } from './array-iterable';
+export declare abstract class ArrayBackedCollection<T, C extends ArrayIterable<T, any>> extends ArrayIterable<T, C> {
+    protected abstract readonly items: T[];
+    protected checkWithinBounds(lo: number, hi: number): void;
+    get reverse(): C;
+    get toArray(): T[];
+    get(index: number): T;
+    get toSet(): HashSet<T>;
+    indexOf(item: T): number;
+    get distinct(): C;
+    distinctBy(key: (item: T) => string | number): C;
+    appended(item: T): C;
+    appendedAll(other: Iterable<T>): C;
+    prepended(item: T): C;
+    prependedAll(other: Iterable<T>): C;
+    concat(other: Iterable<T>): C;
+    slice(from: number, until: number): C;
+    sort(param: (a: T, b: T) => number): C;
+    sortBy(fieldToNumber: (a: T) => number): C;
+    get length(): number;
+}
+export declare class Collection<T> extends ArrayBackedCollection<T, Collection<T>> implements Mappable<T>, Filterable<T, Collection<T>> {
+    protected readonly items: T[];
     constructor(items: T[]);
     static empty: Collection<any>;
     protected fromArray(array: T[]): Collection<T>;
     static of<T>(...items: T[]): Collection<T>;
+    static from<T>(elements: Iterable<T>): Collection<T>;
     static fill<A>(len: number): (elem: (idx: number) => A) => Collection<A>;
-    slice(from: number, until: number): Collection<T>;
     map<B>(f: (item: T) => B): Collection<B>;
     flatMap<B>(f: (item: T) => Collection<B>): Collection<B>;
+    flatMapOption<B>(f: (item: T) => Option<B>): Collection<B>;
     mapPromise<B>(f: (v: T) => Promise<B>): Promise<Collection<B>>;
     mapPromiseAll<B>(f: (v: T) => Promise<B>): Promise<Collection<B>>;
     flatMapPromise<B>(f: (item: T) => Promise<Collection<B>>): Promise<Collection<B>>;
     flatMapPromiseAll<B>(f: (v: T) => Promise<Collection<B>>): Promise<Collection<B>>;
     flatten<B>(): Collection<B>;
-    get(idx: number): T;
-    get toArray(): T[];
-    get reverse(): Collection<T>;
-    sort(param: (a: T, b: T) => number): Collection<T>;
-    sortBy(fieldToNumber: (a: T) => number): Collection<T>;
-    appended(item: T): Collection<T>;
-    appendedAll(other: Collection<T>): Collection<T>;
-    prepended(item: T): Collection<T>;
-    prependedAll(other: Collection<T>): Collection<T>;
-    concat(other: Collection<T>): Collection<T>;
-    get toSet(): HashSet<T>;
-    get distinct(): Collection<T>;
-    distinctBy(key: (item: T) => string | number): Collection<T>;
+    get toBuffer(): ArrayBuffer<T>;
     toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
-    indexOf(item: T): number;
     zip<B>(that: Collection<B>): Collection<[T, B]>;
     zipAll<B>(that: Collection<B>, thisElem: T, thatElem: B): Collection<[T, B]>;
 }
 export declare const Nil: Collection<any>;
+export declare class ArrayBuffer<T> extends ArrayBackedCollection<T, ArrayBuffer<T>> implements Mappable<T>, Filterable<T, ArrayBuffer<T>> {
+    protected readonly items: T[];
+    static get empty(): ArrayBuffer<any>;
+    constructor(items: T[]);
+    static of<T>(...elements: T[]): ArrayBuffer<T>;
+    static from<T>(elements: Iterable<T>): ArrayBuffer<T>;
+    static fill<A>(len: number): (elem: (idx: number) => A) => ArrayBuffer<A>;
+    protected fromArray(array: T[]): ArrayBuffer<T>;
+    update(index: number, element: T): void;
+    set(index: number, element: T): void;
+    clear(): void;
+    append(element: T): this;
+    appendAll(elements: Iterable<T>): this;
+    prepend(element: T): this;
+    prependAll(elements: Iterable<T>): this;
+    insert(idx: number, element: T): void;
+    insertAll(idx: number, elements: Iterable<T>): void;
+    remove(index: number, count?: number): void;
+    subtractOne(element: T): this;
+    subtractAll(elements: Iterable<T>): this;
+    sort(compareFn?: (a: T, b: T) => number): this;
+    get toCollection(): Collection<T>;
+    flatMap<B>(f: (item: T) => ArrayBuffer<B>): ArrayBuffer<B>;
+    flatMapOption<B>(f: (item: T) => Option<B>): ArrayBuffer<B>;
+    flatMapPromise<B>(f: (item: T) => Promise<ArrayBuffer<B>>): Promise<ArrayBuffer<B>>;
+    map<B>(f: (item: T) => B): ArrayBuffer<B>;
+    mapPromise<B>(f: (v: T) => Promise<B>): Promise<ArrayBuffer<B>>;
+    mapPromiseAll<B>(f: (v: T) => Promise<B>): Promise<ArrayBuffer<B>>;
+    flatMapPromiseAll<B>(f: (v: T) => Promise<ArrayBuffer<B>>): Promise<ArrayBuffer<B>>;
+    flatten<B>(): ArrayBuffer<B>;
+    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V>;
+}