dohrm/scalts

Identical blocks of code found in 2 locations. Consider refactoring.

Open

    apply4<B, C, D, E, F>( ob: Supplier< Optional<B> >, oc: Supplier< Optional<C> >, od: Supplier< Optional<D> >, oe: Supplier< Optional<E> >, f: ( a: A, b: B, c: C, d: D, e: E ) => F ): Optional<F> {
        return this.flatMap( a => ob().flatMap( b => oc().flatMap( c => od().flatMap( d => oe().map( e => f( a, b, c, d, e ) ) ) ) ) );
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    constructor(private oa: Future<A>, private ob: Supplier< Future<B> >, private oc: Supplier< Future<C> >, private od: Supplier< Future<D> >) {
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    constructor( private oa: Optional<A>,
                 private ob: Supplier< Optional<B> >,
                 private oc: Supplier< Optional<C> >,
                 private od: Supplier< Optional<D> > ) {
    }

• Read up
  Read up

FutureImpl has 23 functions (exceeds 20 allowed). Consider refactoring.

Open

class FutureImpl<A> implements Future<A> {
    private completeValue: Optional<Try<A>> = None;

    constructor(private _promise: Promise<A>, already?: Try<A>) {
        if (already) {

File Either.ts has 266 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/* tslint:disable:no-use-before-declare */

import {Optional, Some, None} from './Optional'

import { Supplier } from './types'

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    run<D>(f: (a: A, b: B, c: C) => D): Try<D> {
        return this.oa.apply2(this.ob, this.oc, f);
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    chain<E>(oe: Supplier< Future<E> >): FutureBuilder4<A, B, C, D, E> {
        return new FutureBuilder4(this.oa, this.ob, this.oc, this.od, oe);
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    chain<E>( oe: Supplier< Optional<E> > ): OptionalBuilder4<A, B, C, D, E> {
        return new OptionalBuilder4( this.oa, this.ob, this.oc, this.od, oe );
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    run<D>( f: ( a: A, b: B, c: C ) => D ): Optional<D> {
        return this.oa.apply2( this.ob, this.oc, f );
    }

• Read up
  Read up

TryImpl has 22 functions (exceeds 20 allowed). Consider refactoring.

Open

abstract class TryImpl<A> implements Try<A> {
    isSuccess: boolean;
    isFailure: boolean;

    toString(): string {

File Try.ts has 255 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/* tslint:disable:no-use-before-declare */

import {Optional, Some, None} from './Optional'
import {Either, Left, Right} from './Either'

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    chain<D>( od: Supplier< Optional<D> > ): OptionalBuilder3<A, B, C, D> {
        return new OptionalBuilder3( this.oa, this.ob, this.oc, od );
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    chain<D>(od: Supplier< Future<D> >): FutureBuilder3<A, B, C, D> {
        return new FutureBuilder3(this.oa, this.ob, this.oc, od);
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

    apply3<C, D, E, F>(ob: Supplier< Either<A, C> >, oc: Supplier< Either<A, D> >, od: Supplier< Either<A, E> >, f: (a: B, b: C, c: D, d: E)=>F): Either<A, F> {
        return this.flatMap(a => ob().flatMap(b => oc().flatMap(c => od().map(d => f(a, b, c, d)))));
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

    apply3<B, C, D, E>( ob: Supplier< Optional<B> >, oc: Supplier< Optional<C> >, od: Supplier< Optional<D> >, f: ( a: A, b: B, c: C, d: D ) => E ): Optional<E> {
        return this.flatMap( a => ob().flatMap( b => oc().flatMap( c => od().map( d => f( a, b, c, d ) ) ) ) );
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    run<C>(f: (a: A, b: B) => C): Try<C> {
        return this.oa.apply1(this.ob, f);
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    run<C>( f: ( a: A, b: B ) => C ): Optional<C> {
        return this.oa.apply1( this.ob, f );
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    getOrElse<X extends A>(x: () => X): A {
        return this.self.isLeft ? <A>this.self.value : x();
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    getOrElse<X extends B>(x: () => X): B {
        return this.self.isRight ? <B>this.self.value : x();
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

    chain<C>(oc: Supplier< Future<C> >): FutureBuilder2<A, B, C> {
        return new FutureBuilder2(this.oa, this.ob, oc);
    }

• Read up
  Read up