scats 1.4.0-dev → 1.4.1-dev

package/src/hashmap.ts

@@ -1,116 +0,0 @@
-import {mutable, Option} from './index';
-import {AbstractMap, Tuple2} from './abstract-map';
-
-
-
-export class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> {
-
-    protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V> {
-        return HashMap.of(...array);
-    }
-
-    protected constructor(protected readonly map: Map<K, V>) {
-        super(map);
-    }
-
-    static of<K, V>(...values: Tuple2<K, V>[]): HashMap<K, V> {
-        return new HashMap<K, V>(new Map(values));
-    }
-
-    static from<K, V>(values: Iterable<Tuple2<K, V>>): HashMap<K, V> {
-        return HashMap.of(...Array.from(values));
-    }
-
-    static empty = new HashMap(new Map());
-
-    appendedAll(map: HashMap<K, V>): HashMap<K, V> {
-        return this.concat(map);
-    }
-
-    appended(key: K, value: V): HashMap<K, V> {
-        return this.set(key, value);
-    }
-
-    /**
-     * Creates a new map obtained by updating this map with a given key/value pair.
-     * @param  key the key
-     * @param  value the value
-     * @tparam V1 the type of the added value
-     * @return A new map with the new key/value mapping added to this map.
-     */
-    updated(key: K, value: V): HashMap<K, V> {
-        return this.set(key, value);
-    }
-
-    /**
-     * Removes a key from this map, returning a new map.
-     *
-     * @param key the key to be removed
-     * @return a new map without a binding for ''key''
-     */
-    removed(key: K): HashMap<K, V> {
-        const next = new Map(this.map);
-        next.delete(key);
-        return new HashMap<K, V>(next);
-    }
-
-    /**
-     * Creates a new map from this map by removing all elements of another
-     * collection.
-     *
-     * @param keys   the collection containing the removed elements.
-     * @return a new map that contains all elements of the current map
-     * except one less occurrence of each of the elements of `elems`.
-     */
-    removedAll(keys: Iterable<K>): HashMap<K, V> {
-        const next = new Map(this.map);
-        for (const key of keys) {
-            next.delete(key);
-        }
-        return new HashMap<K, V>(next);
-    }
-
-    concat(map: HashMap<K, V>): HashMap<K, V> {
-        const mergedMap = new Map<K, V>([
-            ...this.entries.toArray,
-            ...map.entries.toArray
-        ]);
-        return new HashMap<K, V>(mergedMap);
-    }
-
-    set(key: K, value: V): HashMap<K, V> {
-        const next = new Map(this.map);
-        next.set(key, value);
-        return new HashMap<K, V>(new Map(next));
-    }
-
-    /**
-     * Update a mapping for the specified key and its current optionally-mapped value
-     * (`Some` if there is current mapping, `None` if not).
-     *
-     * If the remapping function returns `Some(v)`, the mapping is updated with the new value `v`.
-     * If the remapping function returns `None`, the mapping is removed (or remains absent if initially absent).
-     * If the function itself throws an exception, the exception is rethrown, and the current mapping is left unchanged.
-     *
-     * @param key the key value
-     * @param remappingFunction a partial function that receives current optionally-mapped value and return a new mapping
-     * @return A new map with the updated mapping with the key
-     */
-    updatedWith(key: K): (remappingFunction: (maybeValue: Option<V>) => Option<V>) => HashMap<K, V> {
-        const previousValue = this.get(key);
-        return (remappingFunction: (maybeValue: Option<V>) => Option<V>) => {
-            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(): mutable.HashMap<K, V> {
-        return mutable.HashMap.of(...Array.from(this.map.entries()));
-    }
-}

package/src/hashset.ts

@@ -1,134 +0,0 @@
-import {HashMap} from './hashmap';
-import {AbstractSet} from './abstract-set';
-import * as mutable from './mutable/hashset';
-
-export class HashSet<T> extends AbstractSet<T, HashSet<T>> {
-
-    protected constructor(items: Set<T>) {
-        super(items);
-    }
-
-    static empty = new HashSet<any>(new Set());
-
-    static of<T>(...items: T[]): HashSet<T> {
-        return new HashSet<T>(new Set(items));
-    }
-
-    static from<T>(elements: Iterable<T>): HashSet<T> {
-        return new HashSet<T>(new Set(elements));
-    }
-
-    protected fromArray(array: T[]): HashSet<T> {
-        return HashSet.of(...array);
-    }
-
-
-    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V> {
-        return HashMap.of(...this.map(mapper).toArray);
-    }
-
-
-    /**
-     * Builds a new HashSet by applying a function to all elements of this $coll.
-     *
-     * @param f      the function to apply to each element.
-     * @tparam B     the element type of the returned $coll.
-     * @return       a new HashSet resulting from applying the given function
-     *               `f` to each element of this HashSet and collecting the results.
-     */
-    map<B>(f: (item: T) => B): HashSet<B> {
-        return HashSet.of(...Array.from(this.items).map(i => f(i)));
-    }
-
-
-    /** Builds a new HashSet by applying a function to all elements of this HashSet
-     *  and using the elements of the resulting collections.
-     *
-     *    For example:
-     *
-     *    ```
-     *      getWords(lines: HashSet<string>): HashSet<string> {
-     *          return lines.flatMap(line => HashSet.from(line.split("\\W+")))
-     *      }
-     *    ```
-     *
-     *
-     *  @param f  the function to apply to each element.
-     *  @tparam B the element type of the returned collection.
-     *  @return   a new HashSet resulting from applying the given collection-valued function
-     *            `f` to each element of this HashSet and concatenating the results.
-     */
-    flatMap<B>(f: (item: T) => HashSet<B>): HashSet<B> {
-        const res = new Set<B>();
-        this.items.forEach(i =>
-            f(i).foreach(e => res.add(e))
-        );
-        return new HashSet(res);
-    }
-
-
-    /** Creates a new $coll by adding all elements contained in another collection to this $coll, omitting duplicates.
-     *
-     * This method takes a collection of elements and adds all elements, omitting duplicates, into $coll.
-     *
-     * Example:
-     *  {{{
-     *    scala> val a = Set(1, 2) concat Set(2, 3)
-     *    a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
-     *  }}}
-     *
-     *  @param that     the collection containing the elements to add.
-     *  @return a new $coll with the given elements added, omitting duplicates.
-     */
-    concat(that: Iterable<T>): HashSet<T> {
-        return this.appendedAll(that);
-    }
-
-    union(other: Iterable<T>): HashSet<T> {
-        return this.concat(other);
-    }
-
-    appended(item: T): HashSet<T> {
-        return this.fromArray(this.toArray.concat([item]));
-    }
-
-    appendedAll(other: Iterable<T>): HashSet<T> {
-        const res = Array.from(this.items);
-        res.push(...Array.from(other));
-        return this.fromArray(res);
-    }
-
-    removed(item: T): HashSet<T> {
-        const res = new Set(Array.from(this.items));
-        res.delete(item);
-        return new HashSet(res);
-    }
-
-    removedAll(other: Iterable<T>): HashSet<T> {
-        const res = new Set(Array.from(this.items));
-        for (const element of other) {
-            res.delete(element);
-        }
-        return new HashSet(res);
-    }
-
-    /**
-     * Computes the intersection between this set and another set.
-     *
-     * @param   other  the set to intersect with.
-     * @return  a new set consisting of all elements that are both in this
-     * set and in the given set `that`.
-     */
-    intersect(other: HashSet<T>): HashSet<T> {
-        return this.filter(x => other.contains(x));
-    }
-
-    /**
-     * Creates the immutable HashMap with the contents from this HashMap.
-     * @return immutable HashMap
-     */
-    get toMutable(): mutable.HashSet<T> {
-        return mutable.HashSet.of(...this.items);
-    }
-
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './collection';
-export * from './either';
-export * from './hashmap';
-export * from './hashset';
-export * from './option';
-export * from './try';
-export * from './util';
-
-import * as mutable from './mutable';
-export {mutable};

package/src/mappable.ts

@@ -1,8 +0,0 @@
-export interface Mappable<C> {
-
-    map<B>(f: (item: C) => B): Mappable<B>;
-    flatMap<B>(f: (item: C) => Mappable<B>): Mappable<B>;
-
-    mapPromise<B>(f: (v: C) => Promise<B>): Promise<Mappable<B>>;
-    flatMapPromise<B>(f: (item: C) => Promise<Mappable<B>>): Promise<Mappable<B>>;
-}

package/src/mutable/hashmap.ts

@@ -1,247 +0,0 @@
-import {Option} from '../option';
-import {AbstractMap, Tuple2} from '../abstract-map';
-import * as immutable from '../hashmap';
-
-export class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> {
-
-    constructor(map: Map<K, V> = new Map()) {
-        super(map);
-    }
-
-    protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V> {
-        return HashMap.of(...array);
-    }
-
-    static of<K, V>(...values: Tuple2<K, V>[]): HashMap<K, V> {
-        return new HashMap<K, V>(new Map(values));
-    }
-
-    static from<K, V>(values: Iterable<Tuple2<K, V>>): HashMap<K, V> {
-        return HashMap.of(...Array.from(values));
-    }
-
-    /** Adds all elements produced by an Iterable to this HashMap.
-     *
-     *  @param values   the Iterable producing the elements to HashMap.
-     *  @return  the HashMap itself.
-     */
-    addAll(values: Iterable<Tuple2<K, V>>): this {
-        for (const [key, value] of values) {
-            this.map.set(key, value);
-        }
-        return this;
-    }
-
-
-    /**
-     * Update a mapping for the specified key and its current optionally-mapped value
-     * (`Some` if there is current mapping, `None` if not).
-     *
-     * If the remapping function returns `Some(v)`, the mapping is updated with the new value `v`.
-     * If the remapping function returns `None`, the mapping is removed (or remains absent if initially absent).
-     * If the function itself throws an exception, the exception is rethrown, and the current mapping is left unchanged.
-     *
-     * @param key the key value
-     * @param remappingFunction a partial function that receives current optionally-mapped value and return a new mapping
-     * @return the new value associated with the specified key
-     */
-    updateWith(key: K): (remappingFunction: (maybeValue: Option<V>) => Option<V>) => Option<V> {
-        const previousValue = this.get(key);
-
-        return (remappingFunction: (maybeValue: Option<V>) => Option<V>) => {
-            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;
-            }
-
-        };
-    }
-
-    /**
-     * Removes all elements produced by an iterator from this $coll.
-     *
-     * @param values   the iterator producing the elements to remove.
-     * @return the hashmap itself
-     */
-    subtractAll(values: Iterable<K>): this {
-        if (this.isEmpty) {
-            return this;
-        }
-
-        for (const key of values) {
-            this.map.delete(key);
-            if (this.isEmpty) {
-                return this;
-            }
-        }
-
-        return this;
-    }
-
-
-    /** Clears the map's contents. After this operation, the
-     *  map is empty.
-     */
-    clear(): void {
-        this.map.clear();
-    }
-
-    /**
-     * Creates new Hashmap with the values from this HashMap
-     * @return new Hashmap
-     */
-    clone(): HashMap<K, V> {
-        const contentClone = new Map(this.map);
-        return new HashMap<K, V>(contentClone);
-    }
-
-    /**
-     * Retains only those mappings for which the predicate
-     * `p` returns `true`.
-     *
-     * @param p  The test predicate
-     */
-    filterInPlace(p: (entry: Tuple2<K, V>) => boolean): this {
-        if (this.nonEmpty) {
-            const entries = this.entries;
-            entries.foreach(e => {
-                if (!p(e)) {
-                    this.remove(e[0]);
-                }
-            });
-        }
-        return this;
-    }
-
-    /**
-     * Applies a transformation function to all values contained in this map.
-     * The transformation function produces new values from existing keys
-     * associated values.
-     *
-     * @param f  the transformation to apply
-     * @return   the map itself.
-     */
-    mapValuesInPlace(f: (entry: Tuple2<K, V>) => V): this {
-        if (this.nonEmpty) {
-            const entries = this.entries;
-            entries.foreach(e => {
-                this.update(e[0], f(e));
-            });
-        }
-        return this;
-    }
-
-    /**
-     * If given key is already in this map, returns associated value.
-     *
-     * Otherwise, computes value from given expression `op`, stores with key
-     * in map and returns that value.
-     *
-     * Concurrent map implementations may evaluate the expression `op`
-     * multiple times, or may evaluate `op` without inserting the result.
-     *
-     * @param  key          the key to test
-     * @param  defaultValue the computation yielding the value to associate with `key`, if
-     *                      `key` is previously unbound.
-     * @return              the value associated with key (either previously or as a result
-     *                      of executing the method).
-     */
-    getOrElseUpdate(key: K, defaultValue: () => V): V {
-        return this.get(key).getOrElse(() => {
-            const newValue = defaultValue();
-            this.map.set(key, newValue);
-            return newValue;
-        });
-    }
-
-    /**
-     * Adds a single element to this map.
-     *
-     * @param key  the element to add.
-     * @param value  the element's value.
-     * @return the map itself
-     */
-    set(key: K, value: V): this {
-        this.map.set(key, value);
-        return this;
-    }
-
-    /**
-     * Adds a new key/value pair to this map and optionally returns previously bound value.
-     * If the map already contains a
-     * mapping for the key, it will be overridden by the new value.
-     *
-     * @param key    the key to update
-     * @param value  the new value
-     * @return an option value containing the value associated with the key
-     *         before the `put` operation was executed, or `None` if `key`
-     *         was not defined in the map before.
-     */
-    put(key: K, value: V): Option<V> {
-        const res = this.get(key);
-        this.map.set(key, value);
-        return res;
-    }
-
-    /**
-     * Removes a key from this map, returning the value associated previously
-     * with that key as an option.
-     * @param  key the key to be removed
-     * @return an option value containing the value associated previously with `key`,
-     *         or `None` if `key` was not defined in the map before.
-     */
-    remove(key: K): Option<V> {
-        const res = this.get(key);
-        this.subtractOne(key);
-        return res;
-    }
-
-    /**
-     * Adds a new key/value pair to this map.
-     * If the map already contains a
-     * mapping for the key, it will be overridden by the new value.
-     *
-     * @param key    The key to update
-     * @param value  The new value
-     */
-    update(key: K, value: V): void {
-        this.map.set(key, value);
-    }
-
-    /**
-     * Adds a single element to this map.
-     *
-     * @param elem  the element to $=add.
-     * @return the map itself
-     */
-    addOne(elem: Tuple2<K, V>): this {
-        this.map.set(elem[0], elem[1]);
-        return this;
-    }
-
-    /**
-     * Removes a single element from this $coll.
-     *
-     * @param key  the element to remove.
-     * @return the map itself
-     */
-    subtractOne(key: K): this {
-        this.map.delete(key);
-        return this;
-    }
-
-    /**
-     * Creates the immutable HashMap with the contents from this HashMap.
-     * @return immutable HashMap
-     */
-    get toImmutable(): immutable.HashMap<K, V> {
-        return immutable.HashMap.of(...this.map.entries());
-    }
-
-}

package/src/mutable/hashset.ts

@@ -1,177 +0,0 @@
-import {AbstractSet} from '../abstract-set';
-import * as immutable from '../hashset';
-
-export class HashSet<T> extends AbstractSet<T, HashSet<T>> {
-
-    constructor(items: Set<T> = new Set()) {
-        super(items);
-    }
-
-    static of<T>(...items: T[]): HashSet<T> {
-        return new HashSet<T>(new Set(items));
-    }
-
-    static from<T>(values: Iterable<T>): HashSet<T> {
-        return HashSet.of(...Array.from(values));
-    }
-
-    protected fromArray(array: T[]): HashSet<T> {
-        return HashSet.of(...array);
-    }
-
-    /**
-     * Adds an element to this set
-     * @param elem element to add
-     * @return true if the element wasn't already contained in the set
-     */
-    add(elem: T): boolean {
-        const res = this.items.has(elem);
-        if (!res) {
-            this.items.add(elem);
-            return true;
-        } else {
-            return !res;
-        }
-    }
-
-    /**
-     * Adds all elements produced by an Iterable to this set.
-     *
-     *  @param xs   the Iterable producing the elements to add.
-     *  @return  the set itself.
-     */
-    addAll(xs: Iterable<T>): this {
-        for (const x of xs) {
-            this.items.add(x);
-        }
-        return this;
-    }
-
-    /**
-     * Removes all elements produced by an iterator from this set.
-     *
-     *  @param xs   the iterator producing the elements to remove.
-     *  @return the set itself
-     */
-    subtractAll(xs: Iterable<T>): this {
-        for (const x of xs) {
-            this.items.delete(x);
-        }
-        return this;
-    }
-
-    /**
-     * Removes an element from this set.
-     *
-     *  @param elem     the element to be removed
-     *  @return true if this set contained the element before it was removed
-     */
-    remove(elem: T) : boolean {
-        const res = this.items.has(elem);
-        if (res) {
-            this.items.delete(elem);
-            return true;
-        } else {
-            return res;
-        }
-
-    }
-
-
-    /**
-     * Removes all elements from the set for which do not satisfy a predicate.
-     * @param  p  the predicate used to test elements. Only elements for
-     *            which `p` returns `true` are retained in the set; all others
-     *            are removed.
-     */
-    filterInPlace(p: (item: T) => boolean): this {
-        if (this.nonEmpty) {
-            const arr = this.toArray;
-            for (const t of arr) {
-                if (!p(t)) {
-                    this.remove(t);
-                }
-            }
-        }
-        return this;
-    }
-
-
-    /** Clears the set's contents. After this operation, the
-     *  set is empty.
-     */
-    clear(): void {
-        this.items.clear();
-    }
-
-    /**
-     * Adds a single element to this set.
-     *
-     * @param elem  the element to add.
-     * @return the $coll itself
-     */
-    addOne(elem: T): this {
-        this.add(elem);
-        return this;
-    }
-
-
-    /** Removes a single element from this set.
-     *
-     *  @param elem  the element to remove.
-     *  @return the set itself
-     */
-    subtractOne(elem: T): this {
-        this.remove(elem);
-        return this;
-    }
-
-    /**
-     * Creates a new $coll by adding all elements contained in another collection to this $coll, omitting duplicates.
-     *
-     * This method takes a collection of elements and adds all elements, omitting duplicates, into $coll.
-     *
-     * Example:
-     *  {{{
-     *    scala> val a = Set(1, 2) concat Set(2, 3)
-     *    a: scala.collection.immutable.Set[Int] = Set(1, 2, 3)
-     *  }}}
-     *
-     *  @param that     the collection containing the elements to add.
-     *  @return a new $coll with the given elements added, omitting duplicates.
-     */
-    concat(that: Iterable<T>): HashSet<T> {
-        const newSet = new Set<T>([...this.items, ...that]);
-        return new HashSet<T>(newSet);
-    }
-
-    /**
-     * Computes the intersection between this set and another set.
-     *
-     * @param   that  the set to intersect with.
-     * @return  a new set consisting of all elements that are both in this
-     * set and in the given set `that`.
-     */
-    intersect(that: AbstractSet<T, any>): HashSet<T> {
-        return this.filter(x => that.contains(x));
-    }
-
-    /** Computes the union between of set and another set.
-     *
-     *  @param   that  the set to form the union with.
-     *  @return  a new set consisting of all elements that are in this
-     *  set or in the given set `that`.
-     */
-    union(that: AbstractSet<T, any>): HashSet<T> {
-        return this.concat(that);
-    }
-
-    /**
-     * Creates the immutable HashMap with the contents from this HashMap.
-     * @return immutable HashMap
-     */
-    get toImmutable(): immutable.HashSet<T> {
-        return immutable.HashSet.of(...this.items);
-    }
-
-}

package/src/mutable.ts

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