const e = either.left<string, string>('foo')
e
  .fold(
    left => either.left<string, string>(left),
    right => either.left<string, string>(mapFn(right))
  )

{
    const typecheck = <T>(t: T) => t;

    type OptionTuple2 = tuple.Tuple<option.Option<string>, option.Option<number>>;
    const optionTuple2 = typecheck<OptionTuple2>([
        option.some('foo'),
        option.some(1),
    ]);

    const sequenceOptionArray = traversable.sequence(option, array);
    sequenceOptionArray(optionTuple2); // errors
    sequenceOptionArray<[string, number]>(optionTuple2); // errors
    sequenceOptionArray<string | number>(optionTuple2); // works
}

const sequenced = sequenceOptionArray(optionTuple2);
sequenced.map(([ str, num ]) => str)

// Monoid module

export function getFunctionStaticMonoid<M>(monoid: StaticMonoid<M>): <A>() => StaticMonoid<(a: A) => M> {
  const empty = constant(constant(monoid.empty()))
  return <A>(): StaticMonoid<(a: A) => M> => ({
    empty,
    concat: (f, g) => a => monoid.concat(f(a), g(a))
  })
}

const getPredicateStaticMonoidAll = getFunctionStaticMonoid(monoidAll)
const getPredicateStaticMonoidAny = getFunctionStaticMonoid(monoidAny)

const isLessThan10 = (n: number) => n <= 10
const isEven = (n: number) => n % 2 === 0

const monoidPredicateAllNumber = getPredicateStaticMonoidAll<number>()
const isLessThan10AndEven = monoidPredicateAllNumber.concat(isLessThan10, isEven)

console.log(array.filter(isLessThan10AndEven, [1, 2, 3, 40])) // [ 2 ]

console.log(array.filter(getPredicateStaticMonoidAny<number>().concat(isLessThan10, isEven), [1, 2, 3, 40])) // [ 1, 2, 3, 40 ]

contramap<A>(fa: HKT<A>[F]): <B>(f: (b: B) => A) => HKT<B>[F]

type Predicate<A> = (a: A) => boolean

declare function contramap<A, B>(fa: Predicate<A>, f: (a: B) => A): Predicate<B>
declare function contramap2<A>(fa: Predicate<A>): <B>(f: (a: B) => A) => Predicate<B>

declare var o: Predicate<{ foo: string, bar: number }>

declare function f(): { foo: string }

contramap(o, f) // NO ERROR!
contramap2(o)(f) // ok, error: Property 'bar' is missing in type '{ foo: string; }'

declare global {
  interface Array<T> {
    __hkt: URI;
    __hkta: T;
  }
}

class Store<S, A> {
  constructor(
    public readonly get: (s: S) => A,
    public readonly s: S
  ) {}
}

import * as ixio from 'fp-ts/lib/IxIO'
import * as io from 'fp-ts/lib/IO'

//
// finite state machine
//

// By defining this state machine in a type, we can ensure that any sequence
// of operations which type checks is a valid sequence of operations on a door.
// The door can be open or closed
type DoorState =
  | 'Open'
  | 'Closed'

//
// operations
//

// A  represents the return type of the operation
// I represents the input state (the precondition)
// O represents output state (the postcondition)
class Operation<I extends DoorState, O extends DoorState, A> extends ixio.IxIO<I, O, A> {
  constructor(a: A, o: O) {
    super(i => new io.IO(() => {
      console.log(`The door was ${i} and now is ${o}`)
      return [a, o] as [A, O]
    }))
  }
}

class Open extends Operation<'Closed', 'Open', void> {
  constructor() {
    super(undefined, 'Open')
  }
}
class Close extends Operation<'Open', 'Closed', void> {
  constructor() {
    super(undefined, 'Closed')
  }
}
class RingBell extends Operation<'Closed', 'Closed', void> {
  constructor() {
    super(undefined, 'Closed')
  }
}

// error: Type '"Open"' is not assignable to type '"Closed"'
// if you open the door, you must close it
const x1: Operation<'Closed', 'Closed', void> = new Open()

// ok
const x2: Operation<'Closed', 'Closed', void> = new Open().ichain(() => new Close())

// error: Type '"Closed"' is not assignable to type '"Open"'
// you can't ring the bell when the door is open
const x3 = new Open().ichain(() => new RingBell())

// ok
const x4 = new Open().ichain(() => new Close()).ichain(() => new RingBell())

x4.run('Closed').run()
/*
The door was Closed and now is Open
The door was Open and now is Closed
The door was Closed and now is Closed
*/

import { fromNullable } from 'fp-ts/lib/Option'

const x = fromNullable(1)
const y = fromNullable(null)

console.log(JSON.stringify(x)) // => {"value":1}
console.log(JSON.stringify(y)) // => {}

declare function toNullable<A>(fa: HKTOption<A>): A | null

export class None<A> {
  ...
  toJSON(): null {
    return null
  }
}

export class Some<A> {
  ...
  toJSON(): A {
    return this.value
  }
}

export function fromNullable<A>(a: A | null | undefined): Option<A> {
  return a == null ? none : new Some(a)
}

export function toNullable<A>(fa: HKTOption<A>): A | null {
  return (fa as Option<A>).toJSON()
}

const x = fromNullable(1)
const y = fromNullable(null)

console.log(toNullable(x)) // => 1
console.log(toNullable(y)) // => null

console.log(JSON.stringify(x)) // => 1
console.log(JSON.stringify(y)) // => null

import { HKT, HKTS, HKT2, HKT2S } from 'fp-ts/lib/HKT'
import { StaticMonad } from 'fp-ts/lib/Monad'

export interface StaticTrans<T extends HKT2S> extends StaticMonad<T> {
  liftT<M extends HKTS>(monad: StaticMonad<M>): <A>(fa: HKT<A>[M]) => HKT2<M, A>[T]
}

type Tuple<A, B> = [A, B]

foldMap(array, monoidString, identity, ['a', 'b', 'c']) // => "cba"

Right(12).getOrElse(() => 17) // 12
Left(12).getOrElse(() => 17)  // 17

import * as option from 'fp-ts/lib/Option'
import * as array from 'fp-ts/lib/Array'
import { monoidSum } from 'fp-ts/lib/Monoid'
import { foldMap } from 'fp-ts/lib/Foldable'

const monoid = option.getStaticMonoid(monoidSum)
const as = [1]
// x1 :: Option<{}> // <= {} instead of number
const x1 = foldMap(array, monoid, a => option.some(a), as)

export function foldMap$<F extends HKTS, M>(foldable: StaticFoldable<F>, monoid: StaticMonoid<M>): <A>(f: (a: A) => M, fa: HKT<A>[F]) => M {
  return <A>(f: (a: A) => M, fa: HKT<A>[F]) => foldable.reduce((acc, x: A) => monoid.concat(f(x), acc), monoid.empty(), fa)
}

// x2 :: Option<number>
const x2 = foldMap$(array, monoid)(a => option.some(a), as)

function foldMap<F extends HKTS, M>(foldable: StaticFoldable<F>, monoid: StaticMonoid<M>): <A>(f: (a: A) => M, fa: HKT<A>[F]) => M

export type Dictionary<A> = { [key: string]: A }

    const timeout = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
    const task = new fp.task.Task(() => timeout(3000).then(() => 6));

    const taskValidation = task.map(validateAbove5);
    const mappedTaskValidation = taskValidation.map(validation => {
        return validation.map(x => x + 5);
    });

    mappedTaskValidation.run().then(console.log);

import {
    apply,
    either,
    eitherT,
    task,
} from 'fp-ts';

const eitherTInstance1 = new eitherT.EitherT(task, task.of(either.of<number, string>('foo')))
const eitherTInstance2 = new eitherT.EitherT(task, task.of(either.of<number, string>('foo')))
const eitherTInstance3 = apply.liftA2(eitherT, (a: string) => (b: string) => a)(
    eitherTInstance1,
    eitherTInstance2,
);
eitherTInstance3.value // <-- this returns any (!)

const allsuccess = [
    fp.either.right<string, number>(1),
    fp.either.right<string, number>(2),
    fp.either.right<string, number>(3),
]
    .map(fp.task.of)
    .map(task => new fp.eitherT.EitherT(fp.task, task));

sequence(fp.eitherT, array)(allsuccess).run();

import { StaticSemigroup } from "fp-ts/lib/Semigroup";

const eitherToValidation = <L, A>(
    either: either.Either<StaticSemigroup<L>, A>,
): validation.Validation<L, A> => {
    return either
        .fold(
            leftSemigroup => (
                validation.failure<L, A>([], leftSemigroup)
            ),
            right => validation.success<L, A>(right),
        );
};

export class Some<A> {
  _A: A // <= phantom type
  ...
}

declare function f<O extends Option<any>>(o: O): O['_A'];

// x :: number
const x = f(some(1))