scats 1.0.32 → 1.2.0

package/src/hashmap.ts

@@ -1,76 +1,73 @@
-import {option, Option} from './option';
-import {Collection} from './collection';
-import {HashSet} from './hashset';
-import {ArrayIterable} from './array-iterable';
+import {mutable, Option} from './index';
+import {AbstractMap, Tuple2} from './abstract-map';
 
-export type Tuple2<K, V> = [K, V];
 
-export class HashMap<K, V> extends ArrayIterable<Tuple2<K, V>, HashMap<K, V>> {
+
+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);
     }
 
-    constructor(private readonly map: Map<K, V>) {
-        super();
+    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 empty = new HashMap(new Map());
-
-    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);
+    static from<K, V>(values: Iterable<Tuple2<K, V>>): HashMap<K, V> {
+        return HashMap.of(...Array.from(values));
     }
 
-    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()));
-    }
+    static empty = new HashMap(new Map());
 
-    get values(): Collection<V> {
-        return new Collection(Array.from(this.map.values()));
+    appendedAll(map: HashMap<K, V>): HashMap<K, V> {
+        return this.concat(map);
     }
 
-    get valueIterator(): IterableIterator<V> {
-        return this.map.values();
+    appended(key: K, value: V): HashMap<K, V> {
+        return this.set(key, value);
     }
 
-    get entries(): Collection<Tuple2<K, V>> {
-        return new Collection(Array.from(this.map.entries()));
+    /**
+     * 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);
     }
 
-    get entriesIterator(): IterableIterator<Tuple2<K, V>> {
-        return this.map.entries();
+    /**
+     * 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);
     }
 
-    appendedAll(map: HashMap<K, V>): HashMap<K, V> {
-        return this.concat(map);
+    /**
+     * 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> {
@@ -87,29 +84,33 @@ export class HashMap<K, V> extends ArrayIterable<Tuple2<K, V>, HashMap<K, V>> {
         return new HashMap<K, V>(new Map(next));
     }
 
-    remove(key: K): HashMap<K, V> {
-        const next = new Map(this.map);
-        next.delete(key);
-        return new HashMap<K, V>(next);
-    }
-
-    containsKey(key: K): boolean {
-        return this.map.has(key);
-    }
-
-    updated(key: K, value: V): HashMap<K, V> {
-        return this.set(key, value);
-    }
-
-    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());
+    /**
+     * 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,15 +1,11 @@
-import {Collection} from './collection';
-import {ArrayIterable} from './array-iterable';
 import {HashMap} from './hashmap';
+import {AbstractSet} from './abstract-set';
+import * as mutable from './mutable/hashset';
 
-export class HashSet<T> extends ArrayIterable<T, HashSet<T>>{
+export class HashSet<T> extends AbstractSet<T, HashSet<T>> {
 
-    protected fromArray(array: T[]): HashSet<T> {
-        return HashSet.of(...array);
-    }
-
-    constructor(private readonly items: Set<T>) {
-        super();
+    protected constructor(items: Set<T>) {
+        super(items);
     }
 
     static empty = new HashSet<any>(new Set());
@@ -18,56 +14,88 @@ export class HashSet<T> extends ArrayIterable<T, HashSet<T>>{
         return new HashSet<T>(new Set(items));
     }
 
-    get toCollection(): Collection<T> {
-        return new Collection(Array.from(this.items.keys()));
+    static from<T>(elements: Iterable<T>): HashSet<T> {
+        return new HashSet<T>(new Set(elements));
     }
 
-    get toSet(): Set<T> {
-        return this.items;
+    protected fromArray(array: T[]): HashSet<T> {
+        return HashSet.of(...array);
     }
 
-    contains(item: T): boolean {
-        return this.items.has(item);
+
+    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)));
     }
 
-    flatMap<B>(f: (item: T) => HashSet<B>): HashSet<B> {
-        let res = HashSet.empty ;
-        this.items.forEach(i => {
-            res = res.union(f(i));
-        });
-        return res;
-    }
 
-    get toArray(): Array<T> {
-        return Array.from(this.items.keys());
-    }
-
-    get isEmpty(): boolean {
-        return this.items.size <= 0;
+    /** 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);
     }
 
-    get size(): number {
-        return this.items.size;
-    }
 
-    concat(other: ArrayIterable<T, any>): HashSet<T> {
-        return this.appendedAll(other);
+    /** 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: ArrayIterable<T, any>): HashSet<T> {
+    union(other: Iterable<T>): HashSet<T> {
         return this.concat(other);
     }
 
     appended(item: T): HashSet<T> {
-        return HashSet.of(...this.toArray.concat([item]));
+        return this.fromArray(this.toArray.concat([item]));
     }
 
-    appendedAll(other: ArrayIterable<T, any>): HashSet<T> {
-        return HashSet.of(...this.toArray.concat(other.toArray));
+    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> {
@@ -76,19 +104,31 @@ export class HashSet<T> extends ArrayIterable<T, HashSet<T>>{
         return new HashSet(res);
     }
 
-    removedAll(other: HashSet<T>): HashSet<T> {
+    removedAll(other: Iterable<T>): HashSet<T> {
         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);
     }
 
+    /**
+     * 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));
     }
 
-    toMap<K, V>(mapper: (item: T) => [K, V]): HashMap<K, V> {
-        return HashMap.of(...this.map(mapper).toArray);
+    /**
+     * 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

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

package/src/mutable/hashmap.ts

@@ -0,0 +1,247 @@
+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());
+    }
+
+}