scats 1.4.0-dev → 1.4.1-dev

package/dist/abstract-map.d.ts

@@ -1,7 +1,7 @@
-import { ArrayIterable } from './array-iterable';
-import { Option } from './option';
-import { HashSet } from './hashset';
-import { Collection } from './collection';
+import { ArrayIterable } from './array-iterable.js';
+import { Option } from './option.js';
+import { HashSet } from './hashset.js';
+import { Collection } from './collection.js';
 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>;

package/dist/abstract-map.js

@@ -1,11 +1,9 @@
-"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 {
+import { ArrayIterable } from './array-iterable.js';
+import { option } from './option.js';
+import { HashSet } from './hashset.js';
+import { Collection } from './collection.js';
+export class AbstractMap extends ArrayIterable {
+    map;
     constructor(map) {
         super();
         this.map = map;
@@ -17,7 +15,7 @@ class AbstractMap extends array_iterable_1.ArrayIterable {
         return this.map.size <= 0;
     }
     get(key) {
-        return (0, option_1.option)(this.map.get(key));
+        return option(this.map.get(key));
     }
     getOrElse(key, defaultValue) {
         return this.get(key).getOrElse(defaultValue);
@@ -26,22 +24,22 @@ class AbstractMap extends array_iterable_1.ArrayIterable {
         return this.get(key).getOrElseValue(defaultValue);
     }
     get keySet() {
-        return hashset_1.HashSet.of(...Array.from(this.map.keys()));
+        return 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()));
+        return new Collection(Array.from(this.map.keys()));
     }
     get values() {
-        return new collection_1.Collection(Array.from(this.map.values()));
+        return new Collection(Array.from(this.map.values()));
     }
     get valueIterator() {
         return this.map.values();
     }
     get entries() {
-        return new collection_1.Collection(Array.from(this.map.entries()));
+        return new Collection(Array.from(this.map.entries()));
     }
     get entriesIterator() {
         return this.map.entries();
@@ -50,7 +48,7 @@ class AbstractMap extends array_iterable_1.ArrayIterable {
         return this.map.has(key);
     }
     get toCollection() {
-        return new collection_1.Collection(Array.from(this.map.entries()));
+        return new Collection(Array.from(this.map.entries()));
     }
     get toMap() {
         return this.map;
@@ -59,4 +57,3 @@ class AbstractMap extends array_iterable_1.ArrayIterable {
         return Array.from(this.map.entries());
     }
 }
-exports.AbstractMap = AbstractMap;

package/dist/abstract-set.d.ts

@@ -1,5 +1,5 @@
-import { ArrayIterable } from './array-iterable';
-import { ArrayBuffer, Collection } from './collection';
+import { ArrayIterable } from './array-iterable.js';
+import { ArrayBuffer, Collection } from './collection.js';
 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>);

package/dist/abstract-set.js

@@ -1,9 +1,7 @@
-"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 {
+import { ArrayIterable } from './array-iterable.js';
+import { ArrayBuffer, Collection } from './collection.js';
+export class AbstractSet extends ArrayIterable {
+    items;
     constructor(items) {
         super();
         this.items = items;
@@ -15,7 +13,7 @@ class AbstractSet extends array_iterable_1.ArrayIterable {
         return Array.from(this.items.keys());
     }
     get toCollection() {
-        return new collection_1.Collection(Array.from(this.items.keys()));
+        return new Collection(Array.from(this.items.keys()));
     }
     get toSet() {
         return new Set(this.items);
@@ -27,7 +25,6 @@ class AbstractSet extends array_iterable_1.ArrayIterable {
         return this.items.size;
     }
     get toBuffer() {
-        return new collection_1.ArrayBuffer(Array.from(this.items.keys()));
+        return new ArrayBuffer(Array.from(this.items.keys()));
     }
 }
-exports.AbstractSet = AbstractSet;

package/dist/array-iterable.d.ts

@@ -1,4 +1,4 @@
-import { Collection, HashMap, Option } from './index';
+import { Collection, HashMap, Option } from './index.js';
 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,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayIterable = void 0;
-const index_1 = require("./index");
-class ArrayIterable {
+import { Collection, HashMap, none, option, some } from './index.js';
+export class ArrayIterable {
     [Symbol.iterator]() {
         let i = 0;
         const items = this.toArray;
@@ -38,7 +35,7 @@ class ArrayIterable {
         return this.toArray.find(i => p(i)) !== undefined;
     }
     find(p) {
-        return (0, index_1.option)(this.toArray.find(i => p(i)));
+        return option(this.toArray.find(i => p(i)));
     }
     count(p) {
         let res = 0;
@@ -65,7 +62,7 @@ class ArrayIterable {
         return this.reduceLeftOption(op);
     }
     get headOption() {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.head);
+        return this.isEmpty ? none : some(this.head);
     }
     get head() {
         if (this.isEmpty) {
@@ -76,7 +73,7 @@ class ArrayIterable {
         }
     }
     get lastOption() {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.last);
+        return this.isEmpty ? none : some(this.last);
     }
     get last() {
         if (this.isEmpty) {
@@ -100,11 +97,11 @@ class ArrayIterable {
         return acc;
     }
     reduceLeftOption(op) {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.reduceLeft(op));
+        return this.isEmpty ? none : some(this.reduceLeft(op));
     }
     foldRight(initial) {
         return (op) => {
-            return new index_1.Collection(this.toArray)
+            return new Collection(this.toArray)
                 .reverse
                 .foldLeft(initial)((a, n) => op(n, a));
         };
@@ -123,7 +120,7 @@ class ArrayIterable {
         return acc;
     }
     reduceRightOption(op) {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.reduceRight(op));
+        return this.isEmpty ? none : some(this.reduceRight(op));
     }
     foldLeft(initial) {
         return (op) => {
@@ -134,10 +131,10 @@ class ArrayIterable {
         return this.foldLeft(initial);
     }
     groupBy(field) {
-        return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
+        return this.foldLeft(HashMap.empty)((acc, next) => {
             const key = field(next);
-            const existing = acc.get(key).getOrElseValue(index_1.Collection.empty);
-            return acc.set(key, new index_1.Collection(existing.toArray.concat(next)));
+            const existing = acc.get(key).getOrElseValue(Collection.empty);
+            return acc.set(key, new Collection(existing.toArray.concat(next)));
         });
     }
     minBy(toNumber) {
@@ -158,7 +155,7 @@ class ArrayIterable {
         }
     }
     minByOption(toNumber) {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.minBy(toNumber));
+        return this.isEmpty ? none : some(this.minBy(toNumber));
     }
     maxBy(toNumber) {
         if (this.isEmpty) {
@@ -178,7 +175,7 @@ class ArrayIterable {
         }
     }
     maxByOption(toNumber) {
-        return this.isEmpty ? index_1.none : (0, index_1.some)(this.maxBy(toNumber));
+        return this.isEmpty ? none : some(this.maxBy(toNumber));
     }
     partition(p) {
         const array = this.toArray;
@@ -248,12 +245,12 @@ class ArrayIterable {
     }
     sliding(length, step = 1) {
         if (this.isEmpty) {
-            return index_1.Collection.empty;
+            return Collection.empty;
         }
         else {
             const itemsSize = this.size;
             if (itemsSize <= length) {
-                return index_1.Collection.of(this);
+                return Collection.of(this);
             }
             else {
                 const result = [];
@@ -267,7 +264,7 @@ class ArrayIterable {
                     left += step;
                     right = left + length;
                 }
-                return new index_1.Collection(result);
+                return new Collection(result);
             }
         }
     }
@@ -309,9 +306,9 @@ class ArrayIterable {
     }
     groupMap(key) {
         return (value) => {
-            return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
+            return this.foldLeft(HashMap.empty)((acc, next) => {
                 const nextKey = key(next);
-                const existingColl = acc.getOrElse(nextKey, () => index_1.Collection.empty);
+                const existingColl = acc.getOrElse(nextKey, () => Collection.empty);
                 const updatedColl = existingColl.appended(value(next));
                 return acc.updated(nextKey, updatedColl);
             });
@@ -320,7 +317,7 @@ class ArrayIterable {
     groupMapReduce(key) {
         return (value) => {
             return (reduce) => {
-                return this.foldLeft(index_1.HashMap.empty)((acc, next) => {
+                return this.foldLeft(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));
@@ -359,7 +356,7 @@ class ArrayIterable {
         for (let i = 0; i < array.length; i++) {
             res.push([array[i], i]);
         }
-        return new index_1.Collection(res);
+        return new Collection(res);
     }
     get tails() {
         const array = this.toArray;
@@ -367,7 +364,7 @@ class ArrayIterable {
         for (let i = 0; i <= array.length; i++) {
             res.push(this.takeRight(array.length - i));
         }
-        return new index_1.Collection(res);
+        return new Collection(res);
     }
     get inits() {
         const array = this.toArray;
@@ -375,7 +372,6 @@ class ArrayIterable {
         for (let i = 0; i <= array.length; i++) {
             res.push(this.take(array.length - i));
         }
-        return new index_1.Collection(res);
+        return new Collection(res);
     }
 }
-exports.ArrayIterable = ArrayIterable;

package/dist/collection.d.ts

@@ -1,7 +1,7 @@
-import { Mappable } from './mappable';
-import { HashMap, HashSet, Option } from './index';
-import { Filterable } from './util';
-import { ArrayIterable } from './array-iterable';
+import { Mappable } from './mappable.js';
+import { HashMap, HashSet, Option } from './index.js';
+import { Filterable } from './util.js';
+import { ArrayIterable } from './array-iterable.js';
 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;

package/dist/collection.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayBuffer = exports.Nil = exports.Collection = exports.ArrayBackedCollection = void 0;
-const tslib_1 = require("tslib");
-const index_1 = require("./index");
-const array_iterable_1 = require("./array-iterable");
-class ArrayBackedCollection extends array_iterable_1.ArrayIterable {
+import { HashMap, HashSet } from './index.js';
+import { ArrayIterable } from './array-iterable.js';
+export class ArrayBackedCollection extends ArrayIterable {
     checkWithinBounds(lo, hi) {
         if (lo < 0)
             throw new Error(`$lo is out of bounds (min 0, max ${this.items.length - 1})`);
@@ -22,7 +18,7 @@ class ArrayBackedCollection extends array_iterable_1.ArrayIterable {
         return this.items[index];
     }
     get toSet() {
-        return index_1.HashSet.of(...this.items);
+        return HashSet.of(...this.items);
     }
     indexOf(item) {
         return this.items.indexOf(item);
@@ -70,15 +66,16 @@ class ArrayBackedCollection extends array_iterable_1.ArrayIterable {
         return this.size;
     }
 }
-exports.ArrayBackedCollection = ArrayBackedCollection;
-class Collection extends ArrayBackedCollection {
+export class Collection extends ArrayBackedCollection {
+    items;
     constructor(items) {
         super();
         this.items = items;
     }
+    static empty = new Collection([]);
     fromArray(array) {
         if (!array || array.length <= 0) {
-            return exports.Nil;
+            return Nil;
         }
         else {
             return new Collection(array);
@@ -118,34 +115,26 @@ class Collection extends ArrayBackedCollection {
         });
         return new Collection(res);
     }
-    mapPromise(f) {
-        return (0, 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 Collection(res);
-        });
+    async mapPromise(f) {
+        const res = [];
+        for (let i = 0; i < this.items.length; i++) {
+            res.push(await f(this.items[i]));
+        }
+        return new Collection(res);
     }
-    mapPromiseAll(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return new Collection(yield Promise.all(this.items.map(i => f(i))));
-        });
+    async mapPromiseAll(f) {
+        return new Collection(await Promise.all(this.items.map(i => f(i))));
     }
-    flatMapPromise(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            let res = [];
-            for (let i = 0; i < this.items.length; i++) {
-                const item = this.items[i];
-                res = res.concat((yield f(item)).items);
-            }
-            return new Collection(res);
-        });
+    async flatMapPromise(f) {
+        let res = [];
+        for (let i = 0; i < this.items.length; i++) {
+            const item = this.items[i];
+            res = res.concat((await f(item)).items);
+        }
+        return new Collection(res);
     }
-    flatMapPromiseAll(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return (yield this.mapPromiseAll(f)).flatten();
-        });
+    async flatMapPromiseAll(f) {
+        return (await this.mapPromiseAll(f)).flatten();
     }
     flatten() {
         const res = [];
@@ -163,7 +152,7 @@ class Collection extends ArrayBackedCollection {
         return new ArrayBuffer(this.items);
     }
     toMap(mapper) {
-        return index_1.HashMap.of(...this.map(mapper).toArray);
+        return HashMap.of(...this.map(mapper).toArray);
     }
     zip(that) {
         const res = [];
@@ -183,17 +172,16 @@ class Collection extends ArrayBackedCollection {
         return new Collection(res);
     }
 }
-exports.Collection = Collection;
-Collection.empty = new Collection([]);
-exports.Nil = Collection.empty;
-class ArrayBuffer extends ArrayBackedCollection {
+export const Nil = Collection.empty;
+export class ArrayBuffer extends ArrayBackedCollection {
+    items;
+    static get empty() {
+        return new ArrayBuffer([]);
+    }
     constructor(items = []) {
         super();
         this.items = items;
     }
-    static get empty() {
-        return new ArrayBuffer([]);
-    }
     static of(...elements) {
         return new ArrayBuffer(elements);
     }
@@ -344,37 +332,29 @@ class ArrayBuffer extends ArrayBackedCollection {
         });
         return new ArrayBuffer(res);
     }
-    flatMapPromise(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            let res = [];
-            for (let i = 0; i < this.items.length; i++) {
-                const item = this.items[i];
-                res = res.concat((yield f(item)).items);
-            }
-            return new ArrayBuffer(res);
-        });
+    async flatMapPromise(f) {
+        let res = [];
+        for (let i = 0; i < this.items.length; i++) {
+            const item = this.items[i];
+            res = res.concat((await f(item)).items);
+        }
+        return new ArrayBuffer(res);
     }
     map(f) {
         return new ArrayBuffer(this.items.map(i => f(i)));
     }
-    mapPromise(f) {
-        return (0, 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);
-        });
+    async mapPromise(f) {
+        const res = [];
+        for (let i = 0; i < this.items.length; i++) {
+            res.push(await f(this.items[i]));
+        }
+        return new ArrayBuffer(res);
     }
-    mapPromiseAll(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return new ArrayBuffer(yield Promise.all(this.items.map(i => f(i))));
-        });
+    async mapPromiseAll(f) {
+        return new ArrayBuffer(await Promise.all(this.items.map(i => f(i))));
     }
-    flatMapPromiseAll(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return (yield this.mapPromiseAll(f)).flatten();
-        });
+    async flatMapPromiseAll(f) {
+        return (await this.mapPromiseAll(f)).flatten();
     }
     flatten() {
         const res = [];
@@ -389,7 +369,6 @@ class ArrayBuffer extends ArrayBackedCollection {
         return new ArrayBuffer(res);
     }
     toMap(mapper) {
-        return index_1.HashMap.of(...this.map(mapper).toArray);
+        return HashMap.of(...this.map(mapper).toArray);
     }
 }
-exports.ArrayBuffer = ArrayBuffer;

package/dist/either.d.ts

@@ -1,7 +1,7 @@
-import { Option } from './option';
-import { Collection } from './collection';
-import { TryLike } from './try';
-import { Mappable } from './mappable';
+import { Option } from './option.js';
+import { Collection } from './collection.js';
+import { TryLike } from './try.js';
+import { Mappable } from './mappable.js';
 export interface EitherMatch<LEFT, RIGHT, T> {
     right: (right: RIGHT) => T;
     left: (left: LEFT) => T;

package/dist/either.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.left = exports.right = exports.Right = exports.Left = exports.Either = void 0;
-const tslib_1 = require("tslib");
-const option_1 = require("./option");
-const collection_1 = require("./collection");
-const try_1 = require("./try");
-const util_1 = require("./util");
-class Either {
+import { none, some } from './option.js';
+import { Collection, Nil } from './collection.js';
+import { failure, success } from './try.js';
+import { toErrorConversion } from './util.js';
+export class Either {
     get isRight() {
         return !this.isLeft;
     }
@@ -92,12 +88,10 @@ class Either {
             left: () => this
         });
     }
-    mapPromise(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return this.match({
-                right: (v) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () { return right(yield f(v)); }),
-                left: () => Promise.resolve(this)
-            });
+    async mapPromise(f) {
+        return this.match({
+            right: async (v) => right(await f(v)),
+            left: () => Promise.resolve(this)
         });
     }
     filterOrElse(p, zero) {
@@ -114,25 +108,25 @@ class Either {
     }
     get toCollection() {
         return this.match({
-            right: v => collection_1.Collection.of(v),
-            left: () => collection_1.Collection.empty
+            right: v => Collection.of(v),
+            left: () => Collection.empty
         });
     }
     get toOption() {
         return this.match({
-            right: v => (0, option_1.some)(v),
-            left: () => option_1.none
+            right: v => some(v),
+            left: () => none
         });
     }
-    toTry(toError = util_1.toErrorConversion) {
+    toTry(toError = toErrorConversion) {
         return this.match({
-            right: (b) => (0, try_1.success)(b),
-            left: (e) => (0, try_1.failure)(toError(e))
+            right: (b) => success(b),
+            left: (e) => failure(toError(e))
         });
     }
 }
-exports.Either = Either;
-class Left extends Either {
+export class Left extends Either {
+    error;
     constructor(error) {
         super();
         this.error = error;
@@ -147,8 +141,8 @@ class Left extends Either {
         return this;
     }
 }
-exports.Left = Left;
-class Right extends Either {
+export class Right extends Either {
+    value;
     constructor(value) {
         super();
         this.value = value;
@@ -163,15 +157,15 @@ class Right extends Either {
         return this;
     }
 }
-exports.Right = Right;
 (function (Either) {
     class LeftProjection {
+        e;
         constructor(e) {
             this.e = e;
         }
         mapPromise(f) {
             return this.e.match({
-                left: (v) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () { return left(yield f(v)); }),
+                left: async (v) => left(await f(v)),
                 right: () => Promise.resolve(this.e)
             });
         }
@@ -226,30 +220,28 @@ exports.Right = Right;
         }
         filterToOption(p) {
             return this.e.match({
-                left: l => p(l) ? (0, option_1.some)(this.e) : option_1.none,
-                right: () => option_1.none
+                left: l => p(l) ? some(this.e) : none,
+                right: () => none
             });
         }
         get toCollection() {
             return this.e.match({
-                left: l => collection_1.Collection.of(l),
-                right: () => collection_1.Nil
+                left: l => Collection.of(l),
+                right: () => Nil
             });
         }
         get toOption() {
             return this.e.match({
-                left: l => (0, option_1.some)(l),
-                right: () => option_1.none
+                left: l => some(l),
+                right: () => none
             });
         }
     }
     Either.LeftProjection = LeftProjection;
-})(Either = exports.Either || (exports.Either = {}));
-function right(value) {
+})(Either || (Either = {}));
+export function right(value) {
     return new Right(value);
 }
-exports.right = right;
-function left(value) {
+export function left(value) {
     return new Left(value);
 }
-exports.left = left;

package/dist/hashmap.d.ts

@@ -1,5 +1,5 @@
-import { mutable, Option } from './index';
-import { AbstractMap, Tuple2 } from './abstract-map';
+import { mutable, Option } from './index.js';
+import { AbstractMap, Tuple2 } from './abstract-map.js';
 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>;