scats 1.4.0-dev → 1.4.1-dev

package/src/option.ts

@@ -1,226 +0,0 @@
-import {Collection} from './collection';
-import {Either, Left, left, Right, right} from './either';
-import {ArrayIterable} from './array-iterable';
-import {HashSet} from './hashset';
-import {HashMap} from './hashmap';
-import {Mappable} from './mappable';
-
-export interface OptionMatch<A, T> {
-    some: (value: A) => T;
-    none: () => T;
-}
-
-
-export abstract class Option<A> extends ArrayIterable<A, Option<A>> implements Mappable<A> {
-
-    abstract readonly get: A;
-
-    /** When a given condition is true, evaluates the `a` argument and returns
-     *  Some(a). When the condition is false, `a` is not evaluated and None is
-     *  returned.
-     */
-    static when<A>(cond: boolean): (a: () => A) => Option<A> {
-        return a => {
-            if (cond) {
-                return some(a());
-            } else {
-                return none;
-            }
-        };
-    }
-
-
-    static useless<A>(cond: boolean): (a: () => A) => Option<A> {
-        return Option.when(!cond);
-    }
-
-    protected fromArray(array: A[]): Option<A> {
-        if (array.length <= 0) {
-            return none;
-        } else {
-            return some(array[0]);
-        }
-    }
-
-    exists(p: (value: A) => boolean): boolean {
-        if (this.isEmpty) {
-            return false;
-        } else {
-            return p(this.get);
-        }
-    }
-
-    filter(p: (value: A) => boolean): Option<A> {
-        if (this.isEmpty) {
-            return none;
-        } else {
-            return p(this.get) ? this : none;
-        }
-    }
-
-    filterNot(p: (value: A) => boolean): Option<A> {
-        if (this.isEmpty) {
-            return none;
-        } else {
-            return p(this.get) ? none : this;
-        }
-    }
-
-    map<B>(f: (item: A) => B): Option<B> {
-        return this.isEmpty ? none : some(f(this.get));
-    }
-
-
-    flatMap<B>(p: (value: A) => Option<B>): Option<B> {
-        return this.isEmpty ? none : p(this.get);
-    }
-
-    async mapPromise<B>(f: (v: A) => Promise<B>): Promise<Option<B>> {
-        if (this.isEmpty) {
-            return Promise.resolve(none);
-        } else {
-            return option<B>(await f(this.get));
-        }
-    }
-
-
-    flatMapPromise<B>(f: (item: A) => Promise<Mappable<B>>): Promise<Mappable<B>> {
-        if (this.isEmpty) {
-            return Promise.resolve(none);
-        } else {
-            return f(this.get);
-        }
-    }
-
-
-    foldValue<B>(ifEmpty: () => B): (f: (_: A) => B) => B {
-        if (this.isEmpty) {
-            return function() { return ifEmpty(); };
-        } else {
-            return (f: (_: A) => B) => { return f(this.get); };
-        }
-    }
-
-    forall(p: (_: A) => boolean): boolean {
-        return this.isEmpty ? true : p(this.get);
-    }
-
-
-    foreach(f: (_: A) => void): void {
-        if (this.nonEmpty) {
-            f(this.get);
-        }
-    }
-
-    getOrElse(f: () => A): A {
-        return this.isEmpty ? f() : this.get;
-    }
-
-    getOrElseValue(other: A): A {
-        return this.isEmpty ? other : this.get;
-    }
-
-    getOrElseThrow(error: () => Error): A {
-        if (this.isEmpty) {
-            throw error();
-        } else {
-            return this.get;
-        }
-    }
-
-
-    contains<A1 extends A>(x: A1): boolean {
-        return this.isEmpty ? false : x === this.get;
-    }
-
-    get isDefined(): boolean {
-        return !this.isEmpty;
-    }
-
-    orElse(alternative: () => Option<A>): Option<A> {
-        return this.isEmpty ? alternative() : this;
-    }
-
-
-    orElseValue(alternative: Option<A>): Option<A> {
-        return this.isEmpty ? alternative : this;
-    }
-
-    get orNull(): A | null {
-        return this.isEmpty ? null : this.get;
-    }
-
-    get orUndefined(): A | undefined {
-        return this.isEmpty ? undefined : this.get;
-    }
-
-    get toCollection(): Collection<A> {
-        return this.isEmpty ? Collection.empty : Collection.of(this.get);
-    }
-
-    toRight<X>(left: () => X): Either<X, A> {
-        return this.isEmpty ? new Left(left()) : right(this.get);
-    }
-
-    toLeft<X>(right: () => X): Either<A, X> {
-        return this.isEmpty ? new Right(right()) : left(this.get);
-    }
-
-    get toArray(): A[] {
-        return this.isEmpty ? [] : [this.get];
-    }
-
-    get toSet(): HashSet<A> {
-        return this.isEmpty ? HashSet.empty : HashSet.of(this.get);
-    }
-
-    match<T>(matcher: OptionMatch<A, T>): T {
-        return this.isEmpty ? matcher.none() : matcher.some(this.get);
-    }
-
-    toMap<K, V>(mapper: (item: A) => [K, V]): HashMap<K, V> {
-        return this.isEmpty ? HashMap.empty : HashMap.of(...this.map(mapper).toArray);
-    }
-
-}
-
-
-export class Some<A> extends Option<A> {
-
-    constructor(private readonly value: A) {
-        super();
-    }
-
-    get get(): A {
-        return this.value;
-    }
-
-    get isEmpty(): boolean {
-        return false;
-    }
-
-}
-
-
-export class None<A> extends Option<A> {
-
-    get get(): A {
-        throw new Error('No such element.');
-    }
-
-    get isEmpty(): boolean {
-        return true;
-    }
-
-}
-
-export function option<A>(value: A | null | undefined): Option<A> {
-    return value === null || typeof value === 'undefined' ? none : some(value);
-}
-
-
-export function some<A>(value: A): Some<A> {
-    return new Some<A>(value);
-}
-
-export const none: Option<any> = new None<any>();

package/src/try.ts

@@ -1,281 +0,0 @@
-import {none, Option, some} from './option';
-import {Either, left, right} from './either';
-import {identity} from './util';
-import {Mappable} from './mappable';
-
-export interface TryMatch<T, R> {
-    success: (result: T) => R;
-    failure: (error: Error) => R;
-}
-
-
-export abstract class TryLike<T> implements Mappable<T>{
-    abstract readonly toOption: Option<T>;
-    abstract readonly toEither: Either<Error, T>;
-    abstract map<B>(f: (x: T) => B): TryLike<B>;
-    abstract readonly isFailure: boolean;
-    abstract readonly isSuccess: boolean;
-    abstract getOrElse(value: () => T): T;
-    abstract getOrElseValue(value: T): T;
-    abstract orElse(value: () => TryLike<T>): TryLike<T>;
-    abstract readonly get: T;
-    abstract match<R>(matcher: TryMatch<T, R>): R;
-    abstract flatMap<U>(f: (value: T) => TryLike<U>): TryLike<U>;
-    abstract filter(p: (value: T) => boolean): TryLike<T>;
-    abstract readonly failed: TryLike<Error>;
-    abstract fold<U>(fa: (e: Error) => U, fb: (result: T) => U): U;
-    // no lower bound generic in typescript: https://github.com/Microsoft/TypeScript/issues/14520
-    abstract recover(f: (e: Error) => any): TryLike<any>;
-    abstract recoverWith(f: (e: Error) => TryLike<any>): TryLike<any>;
-    abstract transform<U>(s: (value: T) => TryLike<U>, f: (e: Error) => TryLike<U>): TryLike<U>;
-
-    async mapPromise<B>(f: (v: T) => Promise<B>): Promise<TryLike<B>> {
-        return this.match({
-            success: r => Try.promise(() => f(r)),
-            failure: () => Promise.resolve(this as unknown as TryLike<B>)
-        });
-    }
-
-    flatMapPromise<B>(f: (item: T) => Promise<TryLike<B>>): Promise<TryLike<B>> {
-        return this.match({
-            success: r => f(r),
-            failure: () => Promise.resolve(this as unknown as TryLike<B>)
-        });
-    }
-
-    foreach<U>(f: (value: T) => U): void {
-        if (this.isSuccess) {
-            f(this.get);
-        }
-    }
-
-    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 as Error);
-                }
-            }
-        });
-    }
-
-    toEitherWithLeft<L>(f: (e: Error) => L): Either<L, T> {
-        return this.match<Either<L, T>>({
-            success: r => right(r),
-            failure: e => left(f(e))
-        });
-
-    }
-
-}
-
-
-
-export class Success<T> extends TryLike<T> {
-
-    readonly isSuccess = true;
-    readonly isFailure = false;
-
-    constructor(private readonly result: T) {
-        super();
-    }
-
-    get toOption(): Option<T> {
-        return some(this.result);
-    }
-
-    get toEither(): Either<Error, T> {
-        return right(this.result);
-    }
-
-    map<B>(f: (x: T) => B): TryLike<B> {
-        return success(f(this.result));
-    }
-
-    get get(): T {
-        return this.result;
-    }
-
-    getOrElse(_: () => T): T {
-        return this.result;
-    }
-
-    getOrElseValue(_: T): T {
-        return this.result;
-    }
-
-    orElse(_: () => TryLike<T>): TryLike<T> {
-        return this;
-    }
-
-    match<R>(matcher: TryMatch<T, R>): R {
-        return matcher.success(this.result);
-    }
-
-    flatMap<U>(f: (value: T) => TryLike<U>): TryLike<U> {
-        try {
-            return f(this.result);
-        } catch (e) {
-            return failure(e as Error);
-        }
-    }
-
-    filter(p: (value: T) => boolean): TryLike<T> {
-        try {
-            if (p(this.result)) {
-                return this;
-            } else {
-                return failure(new Error('Predicate does not hold for ' + this.result));
-            }
-        } catch (e) {
-            return failure(e as Error);
-        }
-    }
-
-    get failed(): TryLike<Error> {
-        return failure(new Error('Success.failed'));
-    }
-
-    fold<U>(fa: (e: Error) => U, fb: (result: T) => U): U {
-        try {
-            return fb(this.result);
-        } catch (e) {
-            return fa(e as Error);
-        }
-    }
-
-    recover(_: (e: Error) => any): TryLike<any> {
-        return this;
-    }
-
-    recoverWith(_: (e: Error) => TryLike<any>): TryLike<any> {
-        return this;
-    }
-
-    transform<U>(s: (value: T) => TryLike<U>, _: (e: Error) => TryLike<U>): TryLike<U> {
-        return this.flatMap(s);
-    }
-
-
-
-
-}
-
-export class Failure extends TryLike<any> {
-
-    readonly isSuccess = false;
-    readonly isFailure = true;
-
-    constructor(private readonly error: Error) {
-        super();
-    }
-
-    get toOption(): Option<any> {
-        return none;
-    }
-
-    get toEither(): Either<Error, any> {
-        return left(this.error);
-    }
-
-    map<B>(_: (x: any) => B): TryLike<any> {
-        return this;
-    }
-
-    get get(): any {
-        throw this.error;
-    }
-
-    getOrElse<T>(value: () => T): T {
-        return value();
-    }
-
-    getOrElseValue<T>(value: T): T {
-        return value;
-    }
-
-    orElse<T>(value: () => TryLike<T>): TryLike<T> {
-        try {
-            return value();
-        } catch (e) {
-            return failure(e as Error);
-        }
-    }
-
-    match<R>(matcher: TryMatch<any, R>): R {
-        return matcher.failure(this.error);
-    }
-
-    flatMap<U>(_: (value: any) => TryLike<U>): TryLike<U> {
-        return this;
-    }
-
-    filter(_: (value: any) => boolean): TryLike<any> {
-        return this;
-    }
-
-    get failed(): TryLike<Error> {
-        return success(this.error);
-    }
-
-    fold<U>(fa: (e: Error) => U, _: (result: any) => U): U {
-        return fa(this.error);
-    }
-
-    recover(f: (e: Error) => any): TryLike<any> {
-        try {
-            return success(f(this.error));
-        } catch (ex) {
-            return failure(ex as Error);
-        }
-    }
-
-    recoverWith(f: (e: Error) => TryLike<any>): TryLike<any> {
-        return this.transform(identity, f);
-    }
-
-    transform<U>(s: (value: any) => TryLike<U>, f: (e: Error) => TryLike<U>): TryLike<U> {
-        try {
-            return f(this.error);
-        } catch (ex) {
-            return failure(ex as Error);
-        }
-    }
-
-
-}
-
-
-export function Try<T>(block: () => T): TryLike<T> {
-    try {
-        return new Success(block());
-    } catch (e) {
-        return new Failure(e as Error);
-    }
-}
-
-export namespace Try {
-    export function promise<T>(block: () => Promise<T>): Promise<TryLike<T>> {
-        try {
-            return block()
-                .then(res => new Success(res))
-                .catch(e => new Failure(e));
-        } catch (e) {
-            return Promise.resolve(new Failure(e as Error));
-        }
-    }
-}
-
-
-
-export function success<T>(x: T): Success<T> {
-    return new Success<T>(x);
-}
-
-export function failure(x: Error): Failure {
-    return new Failure(x);
-}

package/src/util.ts

@@ -1,146 +0,0 @@
-import {none, Option, some} from './option';
-import {Mappable} from './mappable';
-
-export function identity<T>(x: T): T {
-    return x;
-}
-
-
-export function toErrorConversion(x: unknown): Error {
-    if (x instanceof Error) {
-        return x as Error;
-    } else {
-        return new Error(`${x}`);
-    }
-}
-
-export type StepFunction<R> = (state: any) => R;
-export type StepCondition = (state: any) => boolean;
-export interface Filterable<T, R extends Mappable<T>> {
-    filter(p: (x: T ) => boolean): R;
-}
-export type MaybeWithFilter<C extends Mappable<any>, R> = C extends Filterable<any, Mappable<any>> ? StepWithFilter<R> : Step<R>;
-export type TaskMaybeWithFilter<C extends Mappable<any>> = C extends Filterable<any, Mappable<any>> ? TaskWithFilter<C> : Task<C>;
-
-export interface Step<R> {
-
-    readonly name: Option<string>;
-    invokeStep(state: any): R;
-
-}
-
-export type Task<C extends Mappable<any>> = Step<Promise<C>>;
-
-export class StepWithFilter<R> implements Step<R>{
-
-    constructor(readonly name: Option<string>,
-                readonly f: StepFunction<R>,
-                readonly filter: Option<StepCondition>) {
-    }
-
-    if(condition: (state: any) => boolean): Step<R> {
-        return new StepWithFilter(this.name, this.f, some(condition));
-    }
-
-    invokeStep(state: Record<string, unknown>): R {
-        const result = this.f(state);
-        return this.filter.filter(() => 'filter' in result).map(filter => {
-            return (result as unknown as Filterable<any, any>).filter(x => {
-                this.name.foreach(name => state[name] = x);
-                return filter(state);
-            }) as unknown as R;
-        }).getOrElseValue(result as unknown as R);
-    }
-
-}
-
-export class TaskWithFilter<C extends Mappable<any>> implements Task<C> {
-
-    constructor(readonly name: Option<string>,
-                readonly f: StepFunction<Promise<C>>,
-                readonly filter: Option<StepCondition>) {
-    }
-
-    if(condition: (state: any) => boolean): Step<Promise<C>> {
-        return new TaskWithFilter(this.name, this.f, some(condition));
-    }
-
-    async invokeStep(state: Record<string, unknown>): Promise<C> {
-        const result = await this.f(state);
-        return this.filter.filter(() => 'filter' in result).map(filter => {
-            return (result as unknown as Filterable<any, any>).filter(x => {
-                this.name.foreach(name => state[name] = x);
-                return filter(state);
-            }) as C;
-        }).getOrElseValue(result as unknown as C);
-    }
-
-}
-
-export function step<C extends Mappable<any>>(name: string, f: StepFunction<C>): MaybeWithFilter<C, C> {
-    return new StepWithFilter<C>(some(name), f, none) as MaybeWithFilter<C, C>;
-}
-
-export function task<C extends Mappable<any>>(name: string, f: StepFunction<Promise<C>>): TaskMaybeWithFilter<C> {
-    return new TaskWithFilter<C>(some(name), f, none) as MaybeWithFilter<C, Promise<C>>;
-}
-
-export function forComprehension<C extends Mappable<any>>(...steps: Step<C>[]): { yield: (final: (state: any) => any) => C } {
-
-    return {
-        yield: function(final: (state: any) => any): C {
-
-            function processStep(stepIdx: number, acc: any): C {
-                const result = steps[stepIdx].invokeStep(acc);
-
-                if (stepIdx < steps.length - 1) {
-                    return result.flatMap(x => {
-                        steps[stepIdx].name.foreach(name => acc[name] = x);
-                        return processStep(stepIdx + 1, acc);
-                    }) as C;
-                } else {
-                    return result.map(x => {
-                        steps[stepIdx].name.foreach(name => acc[name] = x);
-                        return final(acc);
-                    }) as C;
-                }
-
-            }
-
-            return processStep(0, {});
-        }
-    };
-
-
-}
-
-export namespace forComprehension {
-
-    export function promise<C extends Mappable<any>>(...steps: Task<C>[]): { yield: (final: (state: any) => any) => Promise<C> } {
-
-        return {
-            yield: function (final: (state: any) => any): Promise<C> {
-
-                async function processStep(stepIdx: number, acc: any): Promise<C> {
-                    const result = await steps[stepIdx].invokeStep(acc);
-
-                    if (stepIdx < steps.length - 1) {
-                        return await result.flatMapPromise(x => {
-                            steps[stepIdx].name.foreach(name => acc[name] = x);
-                            return processStep(stepIdx + 1, acc);
-                        }) as C;
-                    } else {
-                        return result.map(x => {
-                            steps[stepIdx].name.foreach(name => acc[name] = x);
-                            return final(acc);
-                        }) as C;
-                    }
-
-                }
-
-                return processStep(0, {});
-            }
-        };
-
-    }
-}