scats 1.0.28 → 1.0.33

package/README.md

@@ -67,41 +67,48 @@ Represents the result of error prone block.
 ```typescript
 import {Try} from 'scats';
 
-const a = Try(() => 1); // a = success(1);
-const b = Try(() => { throw new Error(2) }); // b = failure(new Error(2));
+const okResult = Try(() => 1); // a = success(1);
+const failedResult = Try(() => { throw new Error(2) }); // b = failure(new Error(2));
 
-a.toOption; // some(1)
-b.toOption; // none
+okResult.toOption; // some(1)
+failedResult.toOption; // none
 
-a.toEither; // right(1)
-b.toEither; // left(new Error(2))
+okResult.toEither; // right(1)
+failedResult.toEither; // left(new Error(2))
+okResult.toEitherMapLeft(error => 3); // right(1)
+failedResult.toEitherMapLeft(error => 3); // left(3)
 
-a.map(x => x + 1); // success(2);
-b.map(x => x + 1); // failure(new Error(2));
+okResult.map(value => value + 1); // success(2);
+failedResult.map(value => value + 1); // failure(new Error(2));
 
-a.isSuccess; // true
-a.isFailure; // false
+okResult.isSuccess; // true
+okResult.isFailure; // false
+failedResult.isSuccess; // false
+failedResult.isFailure; // true
 
-a.match({
-    success: () => 100,
-    failure: () => 200
+okResult.match({
+    success: value => 100,
+    failure: error => 200
 }); // 100
-b.match({
+failedResult.match({
     success: value => 100,
     failure: error => 200
 }); // 200
 
 
-a.foreach(x => console.log(x)); // prints 1
-b.foreach(x => console.log(x)); // prints nothing
+okResult.foreach(value => console.log(value)); // prints 1
+failedResult.foreach(value => console.log(value)); // prints nothing
+
+okResult.tapFailure(error => console.log(error.message)); // prints nothing
+failedResult.tapFailure(error => console.log(error.message)); // prints 2
 
-a.recover(e => 2); // success(1)
-b.recover(e => 2); // success(2)
-b.recover(e => { throw new Error('fallback'); }); // failure(new Error('fallback'));
+okResult.recover(error => 2); // success(1)
+failedResult.recover(error => 2); // success(2)
+failedResult.recover(error => { throw new Error('fallback'); }); // failure(new Error('fallback'));
 
-a.recoverWith(e => success(2)); // success(1)
-b.recoverWith(e => success(2)); // success(2)
-b.recoverWith(e => failure(new Error('fallback'))); // failure(new Error('fallback'));
+okResult.recoverWith(error => success(2)); // success(1)
+failedResult.recoverWith(error => success(2)); // success(2)
+failedResult.recoverWith(error => failure(new Error('fallback'))); // failure(new Error('fallback'));
 ```
 
 Also works with promises:

package/dist/hashmap.d.ts

@@ -2,11 +2,12 @@ import { Option } from './option';
 import { Collection } from './collection';
 import { HashSet } from './hashset';
 import { ArrayIterable } from './array-iterable';
-export declare class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>> {
+export declare type Tuple2<K, V> = [K, V];
+export declare class HashMap<K, V> extends ArrayIterable<Tuple2<K, V>, HashMap<K, V>> {
     private readonly map;
-    protected fromArray(array: [K, V][]): HashMap<K, V>;
+    protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V>;
     constructor(map: Map<K, V>);
-    static of<K, V>(...values: [k: K, v: V][]): HashMap<K, V>;
+    static of<K, V>(...values: Tuple2<K, V>[]): HashMap<K, V>;
     static empty: HashMap<any, any>;
     get size(): number;
     get isEmpty(): boolean;
@@ -18,15 +19,15 @@ export declare class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>>
     get keys(): Collection<K>;
     get values(): Collection<V>;
     get valueIterator(): IterableIterator<V>;
-    get entries(): Collection<[K, V]>;
-    get entriesIterator(): IterableIterator<[K, V]>;
+    get entries(): Collection<Tuple2<K, V>>;
+    get entriesIterator(): IterableIterator<Tuple2<K, V>>;
     appendedAll(map: HashMap<K, V>): HashMap<K, V>;
     concat(map: HashMap<K, V>): HashMap<K, V>;
     set(key: K, value: V): HashMap<K, V>;
     remove(key: K): HashMap<K, V>;
     containsKey(key: K): boolean;
     updated(key: K, value: V): HashMap<K, V>;
-    toCollection(): Collection<[K, V]>;
+    get toCollection(): Collection<Tuple2<K, V>>;
     get toMap(): Map<K, V>;
-    get toArray(): Array<[K, V]>;
+    get toArray(): Array<Tuple2<K, V>>;
 }

package/dist/hashmap.js

@@ -78,7 +78,7 @@ class HashMap extends array_iterable_1.ArrayIterable {
     updated(key, value) {
         return this.set(key, value);
     }
-    toCollection() {
+    get toCollection() {
         return new collection_1.Collection(Array.from(this.map.entries()));
     }
     get toMap() {

package/dist/hashset.d.ts

@@ -9,7 +9,7 @@ export declare class HashSet<T> extends ArrayIterable<T, HashSet<T>> {
     static of<T>(...items: T[]): HashSet<T>;
     get toCollection(): Collection<T>;
     get toSet(): Set<T>;
-    contains(item: T): any;
+    contains(item: T): boolean;
     map<B>(f: (item: T) => B): HashSet<B>;
     flatMap<B>(f: (item: T) => HashSet<B>): HashSet<B>;
     get toArray(): Array<T>;

package/dist/try.d.ts

@@ -26,6 +26,8 @@ export declare abstract class TryLike<T> implements Mappable<T> {
     mapPromise<B>(f: (v: T) => Promise<B>): Promise<TryLike<B>>;
     flatMapPromise<B>(f: (item: T) => Promise<TryLike<B>>): Promise<TryLike<B>>;
     foreach<U>(f: (value: T) => U): void;
+    tapFailure(f: (e: Error) => void): TryLike<T>;
+    toEitherWithLeft<L>(f: (e: Error) => L): Either<L, T>;
 }
 export declare class Success<T> extends TryLike<T> {
     private readonly result;

package/dist/try.js

@@ -25,6 +25,26 @@ class TryLike {
             f(this.get);
         }
     }
+    tapFailure(f) {
+        return this.match({
+            success: () => this,
+            failure: e => {
+                try {
+                    f(e);
+                    return this;
+                }
+                catch (ex) {
+                    return failure(ex);
+                }
+            }
+        });
+    }
+    toEitherWithLeft(f) {
+        return this.match({
+            success: r => either_1.right(r),
+            failure: e => either_1.left(f(e))
+        });
+    }
 }
 exports.TryLike = TryLike;
 class Success extends TryLike {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scats",
-  "version": "1.0.28",
+  "version": "1.0.33",
   "description": "Useful scala classes in typescript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/collection.ts

@@ -48,9 +48,9 @@ export class Collection<T> extends ArrayIterable<T, Collection<T>>
     }
 
     flatMap<B>(f: (item: T) => Collection<B>): Collection<B> {
-        let res: B[] = [];
+        const res: B[] = [];
         this.items.forEach(i => {
-            res = res.concat(f(i).items);
+            res.push(...f(i).items);
         });
         return new Collection<B>(res);
     }
@@ -106,10 +106,10 @@ export class Collection<T> extends ArrayIterable<T, Collection<T>>
      * @param f
      */
     async flatMapPromise<B>(f: (item: T) => Promise<Collection<B>>): Promise<Collection<B>> {
-        let res: B[] = [];
+        const res: B[] = [];
         for (let i = 0; i < this.items.length; i++) {
             const item = this.items[i];
-            res = res.concat((await f(item)).items);
+            res.push(...(await f(item)).items);
         }
         return new Collection<B>(res);
     }

package/src/hashmap.ts

@@ -3,9 +3,11 @@ import {Collection} from './collection';
 import {HashSet} from './hashset';
 import {ArrayIterable} from './array-iterable';
 
-export class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>> {
+export type Tuple2<K, V> = [K, V];
 
-    protected fromArray(array: [K, V][]): HashMap<K, V> {
+export class HashMap<K, V> extends ArrayIterable<Tuple2<K, V>, HashMap<K, V>> {
+
+    protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V> {
         return HashMap.of(...array);
     }
 
@@ -13,7 +15,7 @@ export class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>> {
         super();
     }
 
-    static of<K, V>(...values: [k: K, v: V][]): HashMap<K, V> {
+    static of<K, V>(...values: Tuple2<K, V>[]): HashMap<K, V> {
         return new HashMap<K, V>(new Map(values));
     }
 
@@ -59,11 +61,11 @@ export class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>> {
         return this.map.values();
     }
 
-    get entries(): Collection<[K, V]> {
+    get entries(): Collection<Tuple2<K, V>> {
         return new Collection(Array.from(this.map.entries()));
     }
 
-    get entriesIterator(): IterableIterator<[K, V]> {
+    get entriesIterator(): IterableIterator<Tuple2<K, V>> {
         return this.map.entries();
     }
 
@@ -99,15 +101,15 @@ export class HashMap<K, V> extends ArrayIterable<[K, V], HashMap<K, V>> {
         return this.set(key, value);
     }
 
-    toCollection(): Collection<[K, V]> {
-        return new Collection<[K, V]>(Array.from(this.map.entries()));
+    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<[K, V]> {
+    get toArray(): Array<Tuple2<K, V>> {
         return Array.from(this.map.entries());
     }
 }

package/src/hashset.ts

@@ -26,7 +26,7 @@ export class HashSet<T> extends ArrayIterable<T, HashSet<T>>{
         return this.items;
     }
 
-    contains(item: T): any {
+    contains(item: T): boolean {
         return this.items.has(item);
     }
 

package/src/try.ts

@@ -49,6 +49,28 @@ export abstract class TryLike<T> implements Mappable<T>{
         }
     }
 
+    tapFailure(f: (e: Error) => void): TryLike<T> {
+        return this.match<TryLike<T>>({
+            success: () => this,
+            failure: e => {
+                try {
+                    f(e);
+                    return this;
+                } catch (ex) {
+                    return failure(ex);
+                }
+            }
+        });
+    }
+
+    toEitherWithLeft<L>(f: (e: Error) => L): Either<L, T> {
+        return this.match<Either<L, T>>({
+            success: r => right(r),
+            failure: e => left(f(e))
+        });
+
+    }
+
 }