scats 1.0.32 → 1.2.0

package/src/mutable/hashset.ts

@@ -0,0 +1,177 @@
+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

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

package/src/option.ts

@@ -79,7 +79,7 @@ export abstract class Option<A> extends ArrayIterable<A, Option<A>> implements M
         if (this.isEmpty) {
             return Promise.resolve(none);
         } else {
-            return option(await f(this.get));
+            return option<B>(await f(this.get));
         }
     }
 
@@ -102,7 +102,7 @@ export abstract class Option<A> extends ArrayIterable<A, Option<A>> implements M
     }
 
     forall(p: (_: A) => boolean): boolean {
-        return this.isEmpty ? false : p(this.get);
+        return this.isEmpty ? true : p(this.get);
     }
 
 

package/src/try.ts

@@ -57,7 +57,7 @@ export abstract class TryLike<T> implements Mappable<T>{
                     f(e);
                     return this;
                 } catch (ex) {
-                    return failure(ex);
+                    return failure(ex as Error);
                 }
             }
         });
@@ -120,7 +120,7 @@ export class Success<T> extends TryLike<T> {
         try {
             return f(this.result);
         } catch (e) {
-            return failure(e);
+            return failure(e as Error);
         }
     }
 
@@ -132,7 +132,7 @@ export class Success<T> extends TryLike<T> {
                 return failure(new Error('Predicate does not hold for ' + this.result));
             }
         } catch (e) {
-            return failure(e);
+            return failure(e as Error);
         }
     }
 
@@ -144,7 +144,7 @@ export class Success<T> extends TryLike<T> {
         try {
             return fb(this.result);
         } catch (e) {
-            return fa(e);
+            return fa(e as Error);
         }
     }
 
@@ -202,7 +202,7 @@ export class Failure extends TryLike<any> {
         try {
             return value();
         } catch (e) {
-            return failure(e);
+            return failure(e as Error);
         }
     }
 
@@ -230,7 +230,7 @@ export class Failure extends TryLike<any> {
         try {
             return success(f(this.error));
         } catch (ex) {
-            return failure(ex);
+            return failure(ex as Error);
         }
     }
 
@@ -242,7 +242,7 @@ export class Failure extends TryLike<any> {
         try {
             return f(this.error);
         } catch (ex) {
-            return failure(ex);
+            return failure(ex as Error);
         }
     }
 
@@ -254,7 +254,7 @@ export function Try<T>(block: () => T): TryLike<T> {
     try {
         return new Success(block());
     } catch (e) {
-        return new Failure(e);
+        return new Failure(e as Error);
     }
 }
 
@@ -265,7 +265,7 @@ export namespace Try {
                 .then(res => new Success(res))
                 .catch(e => new Failure(e));
         } catch (e) {
-            return Promise.resolve(new Failure(e));
+            return Promise.resolve(new Failure(e as Error));
         }
     }
 }