diff --git a/docs/fantas-eel-and-specification/10.ts b/docs/fantas-eel-and-specification/10.ts
index b1ebe807e..18805ff69 100644
--- a/docs/fantas-eel-and-specification/10.ts
+++ b/docs/fantas-eel-and-specification/10.ts
@@ -11,6 +11,6 @@ import { Plus } from '../../src/Plus'
 import { Monoid } from '../../src/Monoid'
 
 export const getMonoid = <F>(plus: Plus<F>) => <A>(): Monoid<HKT<F, A>> => ({
-  concat: plus.alt,
+  concat: x => y => plus.alt(x, y),
   empty: plus.zero
 })
diff --git a/docs/fantas-eel-and-specification/13.ts b/docs/fantas-eel-and-specification/13.ts
index 2e368859b..2ce353665 100644
--- a/docs/fantas-eel-and-specification/13.ts
+++ b/docs/fantas-eel-and-specification/13.ts
@@ -57,7 +57,7 @@ export const sqrt = (x: number): either.Either<string, number> =>
 
 console.log(
   either
-    .right(16)
+    .right<string, number>(16)
     .chain(sqrt)
     .chain(sqrt)
 )
@@ -65,7 +65,7 @@ console.log(
 
 console.log(
   either
-    .right(81)
+    .right<string, number>(81)
     .chain(sqrt)
     .map(x => -x)
     .chain(sqrt)
@@ -73,7 +73,7 @@ console.log(
 )
 // => left("Hey, no!")
 
-console.log(either.left('eep').chain(sqrt))
+console.log(either.left<string, number>('eep').chain(sqrt))
 // => left("eep")
 
 //
@@ -90,7 +90,9 @@ const flights = {
   JFK: ['LAX', 'DEN']
 }
 
-const whereNext = (x: keyof typeof flights): Array<string> => flights[x] || []
+type FLIGHT = keyof typeof flights
+
+const whereNext = (x: FLIGHT): Array<FLIGHT> => (flights[x] || []) as Array<FLIGHT>
 
 console.log(array.chain(whereNext, array.chain(whereNext, whereNext('LAX'))))
 // => [ 'JFK', 'ATL', 'ATL', 'ORD', 'DFW', 'JFK', 'ATL' ]
diff --git a/docs/fantas-eel-and-specification/17.ts b/docs/fantas-eel-and-specification/17.ts
index 33941012b..60f68ba8f 100644
--- a/docs/fantas-eel-and-specification/17.ts
+++ b/docs/fantas-eel-and-specification/17.ts
@@ -50,7 +50,7 @@ export const isSurvivor = (game: Game): boolean => {
 export const fromBoard = (board: Board): Game => {
   return new Store(pointer => {
     const [x, y] = pointer.value
-    return getBoardValue(board, x, y).getOrElse(() => false)
+    return getBoardValue(board, x, y).getOrElseValue(false)
   }, new Tuple([0, 0]))
 }
 
diff --git a/docs/fantas-eel-and-specification/18.ts b/docs/fantas-eel-and-specification/18.ts
index ab17bde52..78b4e4591 100644
--- a/docs/fantas-eel-and-specification/18.ts
+++ b/docs/fantas-eel-and-specification/18.ts
@@ -35,7 +35,9 @@ export class Costar<F, B, C> {
 import * as array from '../../src/Array'
 
 // Takes a list of ints to the sum
-export const sum = new Costar<'Array', number, number>(array, (xs: Array<number>) => xs.reduce((acc, x) => acc + x, 0))
+export const sum = new Costar<'Array', number, number>(array, (xs: HKT<'Array', number>) =>
+  (xs as Array<number>).reduce((acc, x) => acc + x, 0)
+)
 
 // Make every element 1, then sum them!
 export const length = sum.promap<any, number>(() => 1, x => x)
diff --git a/docs/fantas-eel-and-specification/8.ts b/docs/fantas-eel-and-specification/8.ts
index d876ce4d5..4c4a548bc 100644
--- a/docs/fantas-eel-and-specification/8.ts
+++ b/docs/fantas-eel-and-specification/8.ts
@@ -47,9 +47,9 @@ console.log(option.none.ap(option.none)) // => none
 import * as either from '../../src/Either'
 
 console.log(either.right(2).ap(either.right((x: number) => -x))) // => right(-2)
-console.log(either.left('halp').ap(either.right((x: number) => -x))) // => left("halp")
-console.log(either.right(2).ap(either.left('eek'))) // => left("eek")
-console.log(either.left('halp').ap(either.left('eek'))) // => left("eek")
+console.log(either.left<string, number>('halp').ap(either.right((x: number) => -x))) // => left("halp")
+console.log(either.right<string, number>(2).ap(either.left<string, (x: number) => number>('eek'))) // => left("eek")
+console.log(either.left<string, number>('halp').ap(either.left<string, (x: number) => number>('eek'))) // => left("eek")
 
 //
 // Task
diff --git a/docs/fantas-eel-and-specification/9.ts b/docs/fantas-eel-and-specification/9.ts
index d6d95206c..6652cdfd8 100644
--- a/docs/fantas-eel-and-specification/9.ts
+++ b/docs/fantas-eel-and-specification/9.ts
@@ -12,7 +12,8 @@ export const append = <A>(y: A) => (xs: Array<A>) => xs.concat([y])
 export function insideOut<F extends HKTS>(F: Applicative<F>): <A>(xs: Array<HKTAs<F, A>>) => HKTAs<F, Array<A>>
 export function insideOut<F>(F: Applicative<F>): <A>(xs: Array<HKT<F, A>>) => HKT<F, Array<A>>
 export function insideOut<F>(F: Applicative<F>): <A>(xs: Array<HKT<F, A>>) => HKT<F, Array<A>> {
-  return <A>(xs: Array<HKT<F, A>>) => xs.reduce((acc, x) => liftA2(F)<A, Array<A>, Array<A>>(append)(x)(acc), F.of([]))
+  return <A>(xs: Array<HKT<F, A>>) =>
+    xs.reduce((acc, x) => liftA2(F)<A, Array<A>, Array<A>>(append)(x)(acc), F.of<A[]>([]))
 }
 
 import * as option from '../../src/Option'
@@ -37,10 +38,13 @@ import { getArrayMonoid } from '../../src/Monoid'
 const monoidArrayNumber = getArrayMonoid<number>()
 
 // Usual implementation:
-console.log(option.concat(monoidArrayNumber)(option.some([2]))(option.some([3]))) // => some([2, 3])
-console.log(option.concat(monoidArrayNumber)(option.some([2]))(option.none)) // => some([2])
-console.log(option.concat(monoidArrayNumber)(option.none)(option.some([3]))) // => some([3])
-console.log(option.concat(monoidArrayNumber)(option.none)(option.none)) // => none
+
+const { concat } = option.getSemigroup(monoidArrayNumber)
+
+console.log(concat(option.some([2]))(option.some([3]))) // => some([2, 3])
+console.log(concat(option.some([2]))(option.none)) // => some([2])
+console.log(concat(option.none)(option.some([3]))) // => some([3])
+console.log(concat(option.none)(option.none)) // => none
 
 // With the above implementation
 
diff --git a/examples/ArrayOption.ts b/examples/ArrayOption.ts
index d93b22a0c..fe611d0b0 100644
--- a/examples/ArrayOption.ts
+++ b/examples/ArrayOption.ts
@@ -32,8 +32,8 @@ export class ArrayOption<A> implements FantasyMonad<URI, A> {
   chain<B>(f: (a: A) => ArrayOption<B>): ArrayOption<B> {
     return new ArrayOption(optionTArray.chain(a => f(a).value, this.value))
   }
-  getOrElse(f: Lazy<A>): Array<A> {
-    return optionT.getOrElse(array)(f)(this.value)
+  getOrElseValue(a: A): Array<A> {
+    return optionT.getOrElseValue(array)(a)(this.value)
   }
   fold<R>(none: Lazy<R>, some: (a: A) => R): Array<R> {
     return optionT.fold(array)(none, some, this.value)
diff --git a/examples/EitherOption.ts b/examples/EitherOption.ts
index 7420cd11a..ab3cb75ce 100644
--- a/examples/EitherOption.ts
+++ b/examples/EitherOption.ts
@@ -33,8 +33,8 @@ export class EitherOption<L, A> implements FantasyMonad<URI, A> {
   chain<B>(f: (a: A) => EitherOption<L, B>): EitherOption<L, B> {
     return new EitherOption(optionTEither.chain(a => f(a).value, this.value))
   }
-  getOrElse(f: Lazy<A>): either.Either<L, A> {
-    return optionT.getOrElse(either)(f)(this.value)
+  getOrElseValue(a: A): either.Either<L, A> {
+    return optionT.getOrElseValue(either)(a)(this.value)
   }
   fold<R>(none: Lazy<R>, some: (a: A) => R): either.Either<L, R> {
     return optionT.fold(either)(none, some, this.value)
diff --git a/examples/Moore.ts b/examples/Moore.ts
index 298e44f13..30ed6839b 100644
--- a/examples/Moore.ts
+++ b/examples/Moore.ts
@@ -67,8 +67,7 @@ export const extract = <L, A>(fa: Moore<L, A>): A => fa.extract()
 
 export const extend = <L, A, B>(f: (fa: Moore<L, A>) => B, fa: Moore<L, A>): Moore<L, B> => fa.extend(f)
 
-export const promap = <A, B, C, D>(f: (a: A) => B, g: (c: C) => D) => (fla: Moore<B, C>): Moore<A, D> =>
-  fla.promap(f, g)
+export const promap = <A, B, C, D>(f: (a: A) => B, g: (c: C) => D, fla: Moore<B, C>): Moore<A, D> => fla.promap(f, g)
 
 /** Construct a Moore machine from a state valuation and transition function */
 export const unfoldMoore = <S, L, A>(f: (s: S) => [A, (l: L) => S]) => (s: S): Moore<L, A> => {
diff --git a/examples/ReaderIO.ts b/examples/ReaderIO.ts
index 987529099..8ab24304c 100644
--- a/examples/ReaderIO.ts
+++ b/examples/ReaderIO.ts
@@ -18,21 +18,21 @@ export class ReaderIO<E, A> implements FantasyMonad<URI, A> {
   readonly _A: A
   readonly _L: E
   readonly _URI: URI
-  constructor(readonly value: (e: E) => io.IO<A>) {}
+  constructor(readonly run: (e: E) => io.IO<A>) {}
   map<B>(f: (a: A) => B): ReaderIO<E, B> {
-    return new ReaderIO(readerTIO.map(f, this.value))
+    return new ReaderIO(readerTIO.map(f, this.run))
   }
   of<E, B>(b: B): ReaderIO<E, B> {
     return of(b)
   }
   ap<B>(fab: ReaderIO<E, (a: A) => B>): ReaderIO<E, B> {
-    return new ReaderIO(readerTIO.ap(fab.value, this.value))
+    return new ReaderIO(readerTIO.ap(fab.run, this.run))
   }
   ap_<B, C>(this: ReaderIO<E, (a: B) => C>, fb: ReaderIO<E, B>): ReaderIO<E, C> {
     return fb.ap(this)
   }
   chain<B>(f: (a: A) => ReaderIO<E, B>): ReaderIO<E, B> {
-    return new ReaderIO(readerTIO.chain(a => f(a).value, this.value))
+    return new ReaderIO(readerTIO.chain(a => f(a).run, this.run))
   }
 }
 
@@ -48,6 +48,8 @@ export const ask = <E>(e: E): ReaderIO<E, E> => new ReaderIO(readerT.ask(io)())
 
 export const asks = <E, A>(f: (e: E) => A): ReaderIO<E, A> => new ReaderIO(readerT.asks(io)(f))
 
+export const local = <E>(f: (e: E) => E) => <A>(fa: ReaderIO<E, A>): ReaderIO<E, A> => new ReaderIO(e => fa.run(f(e)))
+
 export const readerIO: Monad<URI> = {
   URI,
   map,
diff --git a/examples/ReaderTaskEither.ts b/examples/ReaderTaskEither.ts
new file mode 100644
index 000000000..c64b2eafb
--- /dev/null
+++ b/examples/ReaderTaskEither.ts
@@ -0,0 +1,82 @@
+import * as readerT from 'fp-ts/lib/ReaderT'
+import * as taskEither from 'fp-ts/lib/TaskEither'
+import { TaskEither } from 'fp-ts/lib/TaskEither'
+import { Monad, FantasyMonad } from 'fp-ts/lib/Monad'
+import { Task } from 'fp-ts/lib/Task'
+import { Either } from 'fp-ts/lib/Either'
+
+const readerTTaskEither = readerT.getReaderT(taskEither)
+
+declare module 'fp-ts/lib/HKT' {
+  interface URI2HKT3<U, L, A> {
+    ReaderTaskEither: ReaderTaskEither<U, L, A>
+  }
+}
+
+export const URI = 'ReaderTaskEither'
+
+export type URI = typeof URI
+
+export class ReaderTaskEither<E, L, A> implements FantasyMonad<URI, A> {
+  readonly _A: A
+  readonly _L: L
+  readonly _U: E
+  readonly _URI: URI
+  constructor(readonly run: (e: E) => TaskEither<L, A>) {}
+  map<B>(f: (a: A) => B): ReaderTaskEither<E, L, B> {
+    return new ReaderTaskEither(readerTTaskEither.map(f, this.run))
+  }
+  of<E, B>(b: B): ReaderTaskEither<E, L, B> {
+    return of(b)
+  }
+  ap<B>(fab: ReaderTaskEither<E, L, (a: A) => B>): ReaderTaskEither<E, L, B> {
+    return new ReaderTaskEither(readerTTaskEither.ap(fab.run, this.run))
+  }
+  ap_<B, C>(this: ReaderTaskEither<E, L, (a: B) => C>, fb: ReaderTaskEither<E, L, B>): ReaderTaskEither<E, L, C> {
+    return fb.ap(this)
+  }
+  chain<B>(f: (a: A) => ReaderTaskEither<E, L, B>): ReaderTaskEither<E, L, B> {
+    return new ReaderTaskEither(readerTTaskEither.chain(a => f(a).run, this.run))
+  }
+}
+
+export const map = <E, L, A, B>(f: (a: A) => B, fa: ReaderTaskEither<E, L, A>): ReaderTaskEither<E, L, B> => fa.map(f)
+
+export const of = <E, L, A>(a: A): ReaderTaskEither<E, L, A> => new ReaderTaskEither(readerTTaskEither.of(a))
+
+export const ap = <E, L, A, B>(
+  fab: ReaderTaskEither<E, L, (a: A) => B>,
+  fa: ReaderTaskEither<E, L, A>
+): ReaderTaskEither<E, L, B> => fa.ap(fab)
+
+export const chain = <E, L, A, B>(
+  f: (a: A) => ReaderTaskEither<E, L, B>,
+  fa: ReaderTaskEither<E, L, A>
+): ReaderTaskEither<E, L, B> => fa.chain(f)
+
+export const ask = <E, L>(e: E): ReaderTaskEither<E, L, E> => new ReaderTaskEither(readerT.ask(taskEither)())
+
+export const asks = <E, L, A>(f: (e: E) => A): ReaderTaskEither<E, L, A> =>
+  new ReaderTaskEither(readerT.asks(taskEither)(f))
+
+export const local = <E>(f: (e: E) => E) => <L, A>(fa: ReaderTaskEither<E, L, A>): ReaderTaskEither<E, L, A> =>
+  new ReaderTaskEither(e => fa.run(f(e)))
+
+export const right = <E, L, A>(fa: Task<A>): ReaderTaskEither<E, L, A> =>
+  new ReaderTaskEither(() => taskEither.right(fa))
+
+export const left = <E, L, A>(fa: Task<L>): ReaderTaskEither<E, L, A> => new ReaderTaskEither(() => taskEither.left(fa))
+
+export const fromEither = <E, L, A>(fa: Either<L, A>): ReaderTaskEither<E, L, A> =>
+  new ReaderTaskEither(() => taskEither.fromEither(fa))
+
+export const tryCatch = <E, L, A>(f: (e: E) => Promise<A>, onrejected: (reason: {}) => L): ReaderTaskEither<E, L, A> =>
+  new ReaderTaskEither(e => taskEither.tryCatch(() => f(e), onrejected))
+
+export const readerTaskEither: Monad<URI> = {
+  URI,
+  map,
+  of,
+  ap,
+  chain
+}
diff --git a/package-lock.json b/package-lock.json
index eb25fc469..18f75a6a8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts",
-  "version": "0.5.3",
+  "version": "0.6.0-dev.20171016",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -1029,9 +1029,9 @@
       }
     },
     "typescript": {
-      "version": "2.5.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.5.3.tgz",
-      "integrity": "sha512-ptLSQs2S4QuS6/OD1eAKG+S5G8QQtrU5RT32JULdZQtM1L3WTi34Wsu48Yndzi8xsObRAB9RPt/KhA9wlpEF6w==",
+      "version": "2.6.0-rc",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.6.0-rc.tgz",
+      "integrity": "sha512-5dDv8NNGYmipBdXnt9mqWqIbzQ/mY5XWjrLeNEROmkHGJ6TnacHUihXi2SvKMHQsCafbJZqaSO+agMRl8F36GA==",
       "dev": true
     },
     "unzip-response": {
diff --git a/package.json b/package.json
index d10250cd3..db5ecc89d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts",
-  "version": "0.5.4",
+  "version": "0.6.0-dev.20171016",
   "description": "Functional programming in TypeScript",
   "files": ["lib"],
   "main": "lib/index.js",
@@ -36,7 +36,7 @@
     "ts-node": "3.1.0",
     "tslint": "4.4.2",
     "tslint-config-standard": "4.0.0",
-    "typescript": "^2.5.2"
+    "typescript": "2.6.0-rc"
   },
   "tags": ["typescript", "static-land", "fantasy-land", "algebraic-data-types", "functional-programming"],
   "keywords": ["typescript", "static-land", "fantasy-land", "algebraic-data-types", "functional-programming"]
diff --git a/src/Alt.ts b/src/Alt.ts
index 6a73a8af7..be631e925 100644
--- a/src/Alt.ts
+++ b/src/Alt.ts
@@ -2,9 +2,9 @@ import { HKT } from './HKT'
 import { Functor, FantasyFunctor } from './Functor'
 
 export interface Alt<F> extends Functor<F> {
-  alt: <A>(fx: HKT<F, A>) => (fy: HKT<F, A>) => HKT<F, A>
+  alt<A>(fx: HKT<F, A>, fy: HKT<F, A>): HKT<F, A>
 }
 
 export interface FantasyAlt<F, A> extends FantasyFunctor<F, A> {
-  alt: (fy: HKT<F, A>) => HKT<F, A>
+  alt(fy: HKT<F, A>): HKT<F, A>
 }
diff --git a/src/Applicative.ts b/src/Applicative.ts
index 89b4378b5..27ec934fe 100644
--- a/src/Applicative.ts
+++ b/src/Applicative.ts
@@ -1,4 +1,4 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Apply, FantasyApply } from './Apply'
 import {
   getFunctorComposition,
@@ -17,39 +17,42 @@ export interface FantasyApplicative<F, A> extends FantasyApply<F, A> {}
 
 export interface ApplicativeComposition<F, G> extends FunctorComposition<F, G> {
   of: <A>(a: A) => HKT<F, HKT<G, A>>
-  ap: <A, B>(fgab: HKT<F, HKT<G, (a: A) => B>>, fga: HKT<F, HKT<G, A>>) => HKT<F, HKT<G, B>>
+  ap<A, B>(fgab: HKT<F, HKT<G, (a: A) => B>>, fga: HKT<F, HKT<G, A>>): HKT<F, HKT<G, B>>
 }
 
 export interface ApplicativeComposition11<F extends HKTS, G extends HKTS> extends FunctorComposition11<F, G> {
   of: <A>(a: A) => HKTAs<F, HKTAs<G, A>>
-  ap: <A, B>(fgab: HKTAs<F, HKTAs<G, (a: A) => B>>, fga: HKTAs<F, HKTAs<G, A>>) => HKTAs<F, HKTAs<G, B>>
+  ap<A, B>(fgab: HKTAs<F, HKTAs<G, (a: A) => B>>, fga: HKTAs<F, HKTAs<G, A>>): HKTAs<F, HKTAs<G, B>>
 }
 
 export interface ApplicativeComposition12<F extends HKTS, G extends HKT2S> extends FunctorComposition12<F, G> {
   of: <L, A>(a: A) => HKTAs<F, HKT2As<G, L, A>>
-  ap: <L, A, B>(fgab: HKTAs<F, HKT2As<G, L, (a: A) => B>>, fga: HKTAs<F, HKT2As<G, L, A>>) => HKTAs<F, HKT2As<G, L, B>>
+  ap<L, A, B>(fgab: HKTAs<F, HKT2As<G, L, (a: A) => B>>, fga: HKTAs<F, HKT2As<G, L, A>>): HKTAs<F, HKT2As<G, L, B>>
 }
 
 export interface ApplicativeComposition21<F extends HKT2S, G extends HKTS> extends FunctorComposition21<F, G> {
   of: <L, A>(a: A) => HKT2As<F, L, HKTAs<G, A>>
-  ap: <L, A, B>(fgab: HKT2As<F, L, HKTAs<G, (a: A) => B>>, fga: HKT2As<F, L, HKTAs<G, A>>) => HKT2As<F, L, HKTAs<G, B>>
+  ap<L, A, B>(fgab: HKT2As<F, L, HKTAs<G, (a: A) => B>>, fga: HKT2As<F, L, HKTAs<G, A>>): HKT2As<F, L, HKTAs<G, B>>
 }
 
 export interface ApplicativeComposition22<F extends HKT2S, G extends HKT2S> extends FunctorComposition22<F, G> {
   of: <L, M, A>(a: A) => HKT2As<F, L, HKT2As<G, M, A>>
-  ap: <L, M, A, B>(
+  ap<L, M, A, B>(
     fgab: HKT2As<F, L, HKT2As<G, M, (a: A) => B>>,
     fga: HKT2As<F, L, HKT2As<G, M, A>>
-  ) => HKT2As<F, L, HKT2As<G, M, B>>
+  ): HKT2As<F, L, HKT2As<G, M, B>>
 }
 
 export class Ops {
   /** Perform a applicative action when a condition is true */
-  when<F extends HKT2S>(F: Applicative<F>): (condition: boolean) => <L>(fu: HKT2As<F, L, void>) => HKT2As<F, L, void>
-  when<F extends HKTS>(F: Applicative<F>): (condition: boolean) => (fu: HKTAs<F, void>) => HKTAs<F, void>
-  when<F>(F: Applicative<F>): (condition: boolean) => (fu: HKT<F, void>) => HKT<F, void>
-  when<F>(F: Applicative<F>): (condition: boolean) => (fu: HKT<F, void>) => HKT<F, void> {
-    return condition => fu => (condition ? fu : F.of(undefined))
+  when<F extends HKT3S>(
+    F: Applicative<F>
+  ): <U, L>(condition: boolean, fu: HKT3As<F, U, L, void>) => HKT3As<F, U, L, void>
+  when<F extends HKT2S>(F: Applicative<F>): <L>(condition: boolean, fu: HKT2As<F, L, void>) => HKT2As<F, L, void>
+  when<F extends HKTS>(F: Applicative<F>): (condition: boolean, fu: HKTAs<F, void>) => HKTAs<F, void>
+  when<F>(F: Applicative<F>): (condition: boolean, fu: HKT<F, void>) => HKT<F, void>
+  when<F>(F: Applicative<F>): (condition: boolean, fu: HKT<F, void>) => HKT<F, void> {
+    return (condition, fu) => (condition ? fu : F.of(undefined))
   }
 
   getApplicativeComposition<F extends HKT2S, G extends HKT2S>(
diff --git a/src/Apply.ts b/src/Apply.ts
index e57269a6f..08cfc6696 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -1,9 +1,9 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Functor, FantasyFunctor } from './Functor'
 import { Curried2, Curried3, Curried4, identity, constant } from './function'
 
 export interface Apply<F> extends Functor<F> {
-  ap: <A, B>(fab: HKT<F, (a: A) => B>, fa: HKT<F, A>) => HKT<F, B>
+  ap<A, B>(fab: HKT<F, (a: A) => B>, fa: HKT<F, A>): HKT<F, B>
 }
 
 /*
@@ -14,11 +14,14 @@ export interface Apply<F> extends Functor<F> {
 
 */
 export interface FantasyApply<F, A> extends FantasyFunctor<F, A> {
-  ap: <B>(fab: HKT<F, (a: A) => B>) => HKT<F, B>
+  ap<B>(fab: HKT<F, (a: A) => B>): HKT<F, B>
 }
 
 export class Ops {
   /** Combine two effectful actions, keeping only the result of the first */
+  applyFirst<F extends HKT3S>(
+    apply: Apply<F>
+  ): <U, L, A>(fa: HKT3As<F, U, L, A>) => <B>(fb: HKT3As<F, U, L, B>) => HKT3As<F, U, L, A>
   applyFirst<F extends HKT2S>(
     apply: Apply<F>
   ): <L, A>(fa: HKT2As<F, L, A>) => <B>(fb: HKT2As<F, L, B>) => HKT2As<F, L, A>
@@ -29,6 +32,9 @@ export class Ops {
   }
 
   /** Combine two effectful actions, keeping only the result of the second */
+  applySecond<F extends HKT3S>(
+    apply: Apply<F>
+  ): <U, L, A>(fa: HKT3As<F, U, L, A>) => <B>(fb: HKT3As<F, U, L, B>) => HKT3As<F, U, L, B>
   applySecond<F extends HKT2S>(
     apply: Apply<F>
   ): <L, A>(fa: HKT2As<F, L, A>) => <B>(fb: HKT2As<F, L, B>) => HKT2As<F, L, B>
@@ -42,6 +48,9 @@ export class Ops {
    * Lift a function of two arguments to a function which accepts and returns
    * values wrapped with the type constructor `F`
    */
+  liftA2<F extends HKT3S>(
+    apply: Apply<F>
+  ): <A, B, C>(f: Curried2<A, B, C>) => <U, L>(fa: HKT3As<F, U, L, A>) => (fb: HKT3As<F, U, L, B>) => HKT3As<F, U, L, C>
   liftA2<F extends HKT2S>(
     apply: Apply<F>
   ): <A, B, C>(f: Curried2<A, B, C>) => <L>(fa: HKT2As<F, L, A>) => (fb: HKT2As<F, L, B>) => HKT2As<F, L, C>
@@ -57,6 +66,11 @@ export class Ops {
    * Lift a function of three arguments to a function which accepts and returns
    * values wrapped with the type constructor `F`
    */
+  liftA3<F extends HKT3S>(
+    apply: Apply<F>
+  ): <A, B, C, D>(
+    f: Curried3<A, B, C, D>
+  ) => <U, L>(fa: HKT3As<F, U, L, A>) => (fb: HKT3As<F, U, L, B>) => (fc: HKT3As<F, U, L, C>) => HKT3As<F, U, L, D>
   liftA3<F extends HKT2S>(
     apply: Apply<F>
   ): <A, B, C, D>(
@@ -78,6 +92,13 @@ export class Ops {
    * Lift a function of four arguments to a function which accepts and returns
    * values wrapped with the type constructor `F`
    */
+  liftA4<F extends HKT3S>(
+    apply: Apply<F>
+  ): <A, B, C, D, E>(
+    f: Curried4<A, B, C, D, E>
+  ) => <U, L>(
+    fa: HKT3As<F, U, L, A>
+  ) => (fb: HKT3As<F, U, L, B>) => (fc: HKT3As<F, U, L, C>) => (fd: HKT3As<F, U, L, D>) => HKT3As<F, U, L, E>
   liftA4<F extends HKT2S>(
     apply: Apply<F>
   ): <A, B, C, D, E>(
diff --git a/src/Array.ts b/src/Array.ts
index 28b004003..c810db049 100644
--- a/src/Array.ts
+++ b/src/Array.ts
@@ -12,9 +12,6 @@ import { Option, fromNullable } from './Option'
 import * as option from './Option'
 import { Ord, toNativeComparator } from './Ord'
 import { Extend } from './Extend'
-import { Filterable } from './Filterable'
-import { Either } from './Either'
-import { Witherable } from './Witherable'
 import { Predicate, identity, constant, Lazy, Endomorphism, Refinement, tuple } from './function'
 
 // Adapted from https://github.com/purescript/purescript-arrays
@@ -57,7 +54,7 @@ export class Ops {
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKT2As<F, L, B>, ta: Array<A>) => HKT2As<F, L, Array<B>>
   traverse<F extends HKTS>(F: Applicative<F>): <A, B>(f: (a: A) => HKTAs<F, B>, ta: Array<A>) => HKTAs<F, Array<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Array<A>) => HKT<F, Array<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Array<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Array<A>) => HKT<F, Array<B>> {
     const liftedSnoc: <A>(fa: HKT<F, Array<A>>) => (fb: HKT<F, A>) => HKT<F, Array<A>> = liftA2(F)(snoc)
     return (f, ta) => reduce((fab, a) => liftedSnoc(fab)(f(a)), F.of(empty()), ta)
@@ -69,7 +66,7 @@ export const traverse: Ops['traverse'] = ops.traverse
 
 export const zero = empty
 
-export const alt = <A>(x: Array<A>) => (y: Array<A>): Array<A> => x.concat(y)
+export const alt = <A>(x: Array<A>, y: Array<A>): Array<A> => x.concat(y)
 
 export const unfoldr = <A, B>(f: (b: B) => Option<[A, B]>, b: B): Array<A> => {
   const ret: Array<A> = []
@@ -89,20 +86,6 @@ export const unfoldr = <A, B>(f: (b: B) => Option<[A, B]>, b: B): Array<A> => {
 
 export const extend = <A, B>(f: (fa: Array<A>) => B, fa: Array<A>): Array<B> => fa.map((_, i, as) => f(as.slice(i)))
 
-export const partitionMap = <A, L, R>(f: (a: A) => Either<L, R>, fa: Array<A>): { left: Array<L>; right: Array<R> } => {
-  const left: Array<L> = []
-  const right: Array<R> = []
-  for (let i = 0; i < fa.length; i++) {
-    f(fa[i]).fold(l => left.push(l), r => right.push(r))
-  }
-  return { left, right }
-}
-
-export const wilt = <M>(M: Applicative<M>) => <A, L, R>(
-  f: (a: A) => HKT<M, Either<L, R>>,
-  ta: Array<A>
-): HKT<M, { left: Array<L>; right: Array<R> }> => M.map(es => partitionMap(e => e, es), traverse(M)(f, ta))
-
 /** Break an array into its first element and remaining elements */
 export const fold = <A, B>(nil: Lazy<B>, cons: (head: A, tail: Array<A>) => B, as: Array<A>): B =>
   as.length === 0 ? nil() : cons(as[0], as.slice(1))
@@ -278,7 +261,7 @@ export const reverse = <A>(as: Array<A>): Array<A> => copy(as).reverse()
  * which contain a value, creating a new array
  */
 export const mapOption = <A, B>(f: (a: A) => Option<B>) => (as: Array<A>): Array<B> =>
-  chain(a => option.fold(empty, of, f(a)), as)
+  chain(a => f(a).fold(empty, of), as)
 
 /**
  * Filter an array of optional values, keeping only the elements which contain
@@ -316,9 +299,7 @@ export const array: Monoid<Array<any>> &
   Traversable<URI> &
   Alternative<URI> &
   Plus<URI> &
-  Extend<URI> &
-  Filterable<URI> &
-  Witherable<URI> = {
+  Extend<URI> = {
   URI,
   empty,
   concat,
@@ -331,7 +312,5 @@ export const array: Monoid<Array<any>> &
   traverse,
   zero,
   alt,
-  extend,
-  partitionMap,
-  wilt
+  extend
 }
diff --git a/src/Bifunctor.ts b/src/Bifunctor.ts
index 235ada681..ae970a0aa 100644
--- a/src/Bifunctor.ts
+++ b/src/Bifunctor.ts
@@ -2,9 +2,9 @@ import { HKT2 } from './HKT'
 
 export interface Bifunctor<F> {
   readonly URI: F
-  bimap: <L, A, M, B>(f: (u: L) => M, g: (a: A) => B) => (fla: HKT2<F, L, A>) => HKT2<F, M, B>
+  bimap<L, A, M, B>(f: (u: L) => M, g: (a: A) => B, fla: HKT2<F, L, A>): HKT2<F, M, B>
 }
 
 export interface FantasyBifunctor<F, L, A> {
-  bimap: <M, B>(f: (l: L) => M, g: (a: A) => B) => HKT2<F, M, B>
+  bimap<M, B>(f: (l: L) => M, g: (a: A) => B): HKT2<F, M, B>
 }
diff --git a/src/Chain.ts b/src/Chain.ts
index 0a1ff79e9..650c1f451 100644
--- a/src/Chain.ts
+++ b/src/Chain.ts
@@ -1,16 +1,16 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Apply, FantasyApply } from './Apply'
-import { Kleisli } from './function'
 
 export interface Chain<F> extends Apply<F> {
-  chain: <A, B>(f: Kleisli<F, A, B>, fa: HKT<F, A>) => HKT<F, B>
+  chain<A, B>(f: (a: A) => HKT<F, B>, fa: HKT<F, A>): HKT<F, B>
 }
 
 export interface FantasyChain<F, A> extends FantasyApply<F, A> {
-  chain: <B>(f: Kleisli<F, A, B>) => HKT<F, B>
+  chain<B>(f: (a: A) => HKT<F, B>): HKT<F, B>
 }
 
 export class Ops {
+  flatten<F extends HKT3S>(chain: Chain<F>): <U, L, A>(mma: HKT3As<F, U, L, HKT3As<F, U, L, A>>) => HKT3As<F, U, L, A>
   flatten<F extends HKT2S>(chain: Chain<F>): <L, A>(mma: HKT2As<F, L, HKT2As<F, L, A>>) => HKT2As<F, L, A>
   flatten<F extends HKTS>(chain: Chain<F>): <A>(mma: HKTAs<F, HKTAs<F, A>>) => HKTAs<F, A>
   flatten<F>(chain: Chain<F>): <A>(mma: HKT<F, HKT<F, A>>) => HKT<F, A>
diff --git a/src/ChainRec.ts b/src/ChainRec.ts
index 68d07ebe0..49b866f15 100644
--- a/src/ChainRec.ts
+++ b/src/ChainRec.ts
@@ -4,11 +4,11 @@ import { Either } from './Either'
 import { isLeft } from './Either'
 
 export interface ChainRec<F> extends Chain<F> {
-  chainRec: <A, B>(f: (a: A) => HKT<F, Either<A, B>>, a: A) => HKT<F, B>
+  chainRec<A, B>(f: (a: A) => HKT<F, Either<A, B>>, a: A): HKT<F, B>
 }
 
 export interface FantasyChainRec<F, A> extends FantasyChain<F, A> {
-  chainRec: <A, B>(f: (a: A) => HKT<F, Either<A, B>>) => HKT<F, B>
+  chainRec<A, B>(f: (a: A) => HKT<F, Either<A, B>>): HKT<F, B>
 }
 
 export const tailRec = <A, B>(f: (a: A) => Either<A, B>, a: A): B => {
diff --git a/src/Comonad.ts b/src/Comonad.ts
index b64daea07..7b6d720b0 100644
--- a/src/Comonad.ts
+++ b/src/Comonad.ts
@@ -2,7 +2,7 @@ import { HKT } from './HKT'
 import { Extend, FantasyExtend } from './Extend'
 
 export interface Comonad<F> extends Extend<F> {
-  extract: <A>(ca: HKT<F, A>) => A
+  extract<A>(ca: HKT<F, A>): A
 }
 
 export interface FantasyComonad<F, A> extends FantasyExtend<F, A> {
diff --git a/src/Const.ts b/src/Const.ts
index 281c359ae..cf4cdc507 100644
--- a/src/Const.ts
+++ b/src/Const.ts
@@ -31,9 +31,6 @@ export class Const<L, A> implements FantasyFunctor<URI, A>, FantasyContravariant
   fold<B>(f: (l: L) => B): B {
     return f(this.value)
   }
-  equals(S: Setoid<L>, fy: Const<L, A>): boolean {
-    return this.fold(x => fy.fold(y => S.equals(x)(y)))
-  }
   inspect() {
     return this.toString()
   }
@@ -42,36 +39,29 @@ export class Const<L, A> implements FantasyFunctor<URI, A>, FantasyContravariant
   }
 }
 
-export const equals = <L>(S: Setoid<L>) => <A>(fx: Const<L, A>) => (fy: Const<L, A>): boolean => {
-  return fx.equals(S, fy)
-}
-
 export const getSetoid = <L, A>(S: Setoid<L>): Setoid<Const<L, A>> => ({
-  equals: x => y => equals(S)(x)(y)
+  equals: x => y => x.fold(ax => y.fold(ay => S.equals(ax)(ay)))
 })
 
 export const map = <L, A, B>(f: (a: A) => B, fa: Const<L, A>): Const<L, B> => fa.map(f)
 
-export const contramap = <L, A>(fa: Const<L, A>): (<B>(f: (b: B) => A) => Const<L, B>) => <B>(f: (b: B) => A) =>
-  fa.contramap(f)
+export const contramap = <L, A, B>(f: (b: B) => A, fa: Const<L, A>): Const<L, B> => fa.contramap(f)
+
+export const ap = <L>(S: Semigroup<L>) => <A, B>(fab: Const<L, (a: A) => B>, fa: Const<L, A>): Const<L, B> =>
+  new Const(S.concat(fab.fold(identity))(fa.fold(identity)))
 
 export const getApply = <L>(S: Semigroup<L>): Apply<URI> => ({
   URI,
   map,
-  ap<A, B>(fab: Const<L, (a: A) => B>, fa: Const<L, A>): Const<L, B> {
-    return new Const(S.concat(fab.fold(identity))(fa.fold(identity)))
-  }
+  ap: ap(S)
 })
 
-export const getApplicative = <L>(M: Monoid<L>): Applicative<URI> => {
-  const empty = new Const<L, any>(M.empty())
-  return {
-    ...getApply(M),
-    of<A>(b: A): Const<L, A> {
-      return empty
-    }
-  }
-}
+export const of = <L>(M: Monoid<L>) => <A>(b: A): Const<L, A> => new Const<L, any>(M.empty())
+
+export const getApplicative = <L>(M: Monoid<L>): Applicative<URI> => ({
+  ...getApply(M),
+  of: of(M)
+})
 
 export const const_: Functor<URI> & Contravariant<URI> = {
   URI,
diff --git a/src/Contravariant.ts b/src/Contravariant.ts
index 4cb944f9c..eba5a0559 100644
--- a/src/Contravariant.ts
+++ b/src/Contravariant.ts
@@ -1,22 +1,25 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 
 export interface Contravariant<F> {
   readonly URI: F
-  contramap: <A>(fa: HKT<F, A>) => <B>(f: (b: B) => A) => HKT<F, B>
+  contramap<A, B>(f: (b: B) => A, fa: HKT<F, A>): HKT<F, B>
 }
 
 export interface FantasyContravariant<F, A> {
-  contramap: <B>(f: (b: B) => A) => HKT<F, B>
+  contramap<B>(f: (b: B) => A): HKT<F, B>
 }
 
 export class Ops {
+  lift<F extends HKT3S>(
+    contravariant: Contravariant<F>
+  ): <A, B>(f: (b: B) => A) => <U, L>(fa: HKT3As<F, U, L, A>) => HKT3As<F, U, L, B>
   lift<F extends HKT2S>(
     contravariant: Contravariant<F>
   ): <A, B>(f: (b: B) => A) => <L>(fa: HKT2As<F, L, A>) => HKT2As<F, L, B>
   lift<F extends HKTS>(contravariant: Contravariant<F>): <A, B>(f: (b: B) => A) => (fa: HKTAs<F, A>) => HKTAs<F, B>
   lift<F>(contravariant: Contravariant<F>): <A, B>(f: (b: B) => A) => (fa: HKT<F, A>) => HKT<F, B>
   lift<F>(contravariant: Contravariant<F>): <A, B>(f: (b: B) => A) => (fa: HKT<F, A>) => HKT<F, B> {
-    return f => fa => contravariant.contramap(fa)(f)
+    return f => fa => contravariant.contramap(f, fa)
   }
 }
 
diff --git a/src/Either.ts b/src/Either.ts
index 7db9b42f8..6e2a7b6b1 100644
--- a/src/Either.ts
+++ b/src/Either.ts
@@ -9,9 +9,6 @@ import { Bifunctor, FantasyBifunctor } from './Bifunctor'
 import { Alt, FantasyAlt } from './Alt'
 import { ChainRec, tailRec } from './ChainRec'
 import { Option, none, some } from './Option'
-import { Monoid } from './Monoid'
-import { Filterable } from './Filterable'
-import { Witherable } from './Witherable'
 import { constFalse, Predicate, Lazy, toString } from './function'
 
 declare module './HKT' {
@@ -71,16 +68,13 @@ export class Left<L, A>
   fold<B>(left: (l: L) => B, right: (a: A) => B): B {
     return left(this.value)
   }
+  getOrElseValue(a: A): A {
+    return a
+  }
   /** Returns the value from this `Right` or the given argument if this is a `Left` */
   getOrElse(f: (l: L) => A): A {
     return f(this.value)
   }
-  getOrElseValue(value: A): A {
-    return value
-  }
-  equals(SL: Setoid<L>, SA: Setoid<A>): (fy: Either<L, A>) => boolean {
-    return fy => fy.fold(SL.equals(this.value), constFalse)
-  }
   mapLeft<M>(f: (l: L) => M): Either<M, A> {
     return left(f(this.value))
   }
@@ -142,16 +136,13 @@ export class Right<L, A>
   fold<B>(left: (l: L) => B, right: (a: A) => B): B {
     return right(this.value)
   }
-  /** Returns the value from this `Right` or the given argument if this is a `Left` */
-  getOrElse(f: (l: L) => A): A {
+  getOrElseValue(a: A): A {
     return this.value
   }
-  getOrElseValue(value: A): A {
+  /** Returns the value from this `Right` or the given argument if this is a `Left` */
+  getOrElse(f: (l: L) => A): A {
     return this.value
   }
-  equals(SL: Setoid<L>, SA: Setoid<A>): (fy: Either<L, A>) => boolean {
-    return fy => fy.fold(constFalse, y => SA.equals(this.value)(y))
-  }
   mapLeft<M>(f: (l: L) => M): Either<M, A> {
     return this as any
   }
@@ -166,20 +157,19 @@ export class Right<L, A>
   }
 }
 
-export const equals = <L, A>(SL: Setoid<L>, SA: Setoid<A>) => (fx: Either<L, A>) => (fy: Either<L, A>): boolean =>
-  fx.equals(SL, SA)(fy)
+export const fold = <L, A, B>(left: (l: L) => B, right: (a: A) => B) => (fa: Either<L, A>): B => fa.fold(left, right)
 
 export const getSetoid = <L, A>(SL: Setoid<L>, SA: Setoid<A>): Setoid<Either<L, A>> => ({
-  equals: equals(SL, SA)
+  equals: x => y =>
+    x.fold(lx => y.fold(ly => SL.equals(lx)(ly), constFalse), ax => y.fold(constFalse, ay => SA.equals(ax)(ay)))
 })
 
-export const fold = <L, A, B>(left: (l: L) => B, right: (a: A) => B, fa: Either<L, A>): B => fa.fold(left, right)
+/** Returns the value from this `Right` or the given argument if this is a `Left` */
+export const getOrElseValue = <L, A>(a: A) => (fa: Either<L, A>): A => fa.getOrElseValue(a)
 
 /** Returns the value from this `Right` or the given argument if this is a `Left` */
 export const getOrElse = <L, A>(f: (l: L) => A) => (fa: Either<L, A>): A => fa.getOrElse(f)
 
-export const getOrElseValue = <A>(value: A) => <L>(fa: Either<L, A>): A => fa.getOrElseValue(value)
-
 export const map = <L, A, B>(f: (a: A) => B, fa: Either<L, A>): Either<L, B> => fa.map(f)
 
 export const of = <L, A>(a: A): Either<L, A> => new Right(a)
@@ -188,10 +178,9 @@ export const ap = <L, A, B>(fab: Either<L, (a: A) => B>, fa: Either<L, A>): Eith
 
 export const chain = <L, A, B>(f: (a: A) => Either<L, B>, fa: Either<L, A>): Either<L, B> => fa.chain(f)
 
-export const bimap = <L, V, A, B>(f: (u: L) => V, g: (a: A) => B) => (fau: Either<L, A>): Either<V, B> =>
-  fau.bimap(f, g)
+export const bimap = <L, V, A, B>(f: (u: L) => V, g: (a: A) => B, fla: Either<L, A>): Either<V, B> => fla.bimap(f, g)
 
-export const alt = <L, A>(fx: Either<L, A>) => (fy: Either<L, A>): Either<L, A> => fx.alt(fy)
+export const alt = <L, A>(fx: Either<L, A>, fy: Either<L, A>): Either<L, A> => fx.alt(fy)
 
 export const extend = <L, A, B>(f: (ea: Either<L, A>) => B, ea: Either<L, A>): Either<L, B> => ea.extend(f)
 
@@ -204,7 +193,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Either<L, A>) => HKTAs<F, Either<L, B>>
-  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Either<L, A>) => HKT<F, Either<L, B>>
+  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Either<L, B>>
   traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Either<L, A>) => HKT<F, Either<L, B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
@@ -253,39 +242,6 @@ export const tryCatch = <A>(f: Lazy<A>): Either<Error, A> => {
   }
 }
 
-export const getFilterable = <M>(M: Monoid<M>): Filterable<URI> => {
-  const empty = left<M, any>(M.empty())
-  function partitionMap<A, L, R>(f: (a: A) => Either<L, R>, fa: Either<M, A>) {
-    return fa.fold(
-      l => ({ left: fa as any, right: fa as any }),
-      a => f(a).fold(l => ({ left: right(l), right: empty }), a => ({ left: empty, right: right<M, R>(a) }))
-    )
-  }
-  return { URI, map, partitionMap }
-}
-
-export const getWitherable = <M>(monoid: Monoid<M>): Witherable<URI> => {
-  const empty = left<any, any>(monoid.empty())
-  function wilt<M>(
-    applicative: Applicative<M>
-  ): <A, L, R>(
-    f: (a: A) => HKT<M, Either<L, R>>,
-    ta: Either<M, A>
-  ) => HKT<M, { left: Either<M, L>; right: Either<M, R> }> {
-    return (f, ta) =>
-      ta.fold(
-        () => applicative.of({ left: ta as any, right: ta as any }),
-        a =>
-          applicative.map(
-            e => e.fold(l => ({ left: right(l), right: empty }), r => ({ left: empty, right: right(r) })),
-            f(a)
-          )
-      )
-  }
-  const filterable = getFilterable(monoid)
-  return { ...filterable, wilt, traverse, reduce }
-}
-
 export const either: Monad<URI> &
   Foldable<URI> &
   Traversable<URI> &
diff --git a/src/Exception.ts b/src/Exception.ts
index 2419cb9f9..8df052c66 100644
--- a/src/Exception.ts
+++ b/src/Exception.ts
@@ -33,7 +33,8 @@ export const catchException = <A>(handler: (e: Error) => IO<A>) => (action: IO<A
     }
   })
 
-/** Runs an IO and returns eventual Exceptions as a `Left` value. If the
+/**
+ * Runs an IO and returns eventual Exceptions as a `Left` value. If the
  * computation succeeds the result gets wrapped in a `Right`.
  */
 export const tryCatch = <A>(action: IO<A>): IO<Either<Error, A>> =>
diff --git a/src/Extend.ts b/src/Extend.ts
index 4c48f5048..9d166fc76 100644
--- a/src/Extend.ts
+++ b/src/Extend.ts
@@ -1,16 +1,18 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
-import { Cokleisli } from './function'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Functor, FantasyFunctor } from './Functor'
 
 export interface Extend<F> extends Functor<F> {
-  extend: <A, B>(f: Cokleisli<F, A, B>, ea: HKT<F, A>) => HKT<F, B>
+  extend<A, B>(f: (fa: HKT<F, A>) => B, ea: HKT<F, A>): HKT<F, B>
 }
 
 export interface FantasyExtend<F, A> extends FantasyFunctor<F, A> {
-  extend: <B>(f: Cokleisli<F, A, B>) => HKT<F, B>
+  extend<B>(f: (fa: HKT<F, A>) => B): HKT<F, B>
 }
 
 export class Ops {
+  duplicate<F extends HKT3S>(
+    extend: Extend<F>
+  ): <U, L, A>(ma: HKT3As<F, U, L, A>) => HKT3As<F, U, L, HKT3As<F, U, L, A>>
   duplicate<F extends HKT2S>(extend: Extend<F>): <L, A>(ma: HKT2As<F, L, A>) => HKT2As<F, L, HKT2As<F, L, A>>
   duplicate<F extends HKTS>(extend: Extend<F>): <A>(ma: HKTAs<F, A>) => HKTAs<F, HKTAs<F, A>>
   duplicate<F>(extend: Extend<F>): <A>(ma: HKT<F, A>) => HKT<F, HKT<F, A>>
diff --git a/src/Filterable.ts b/src/Filterable.ts
deleted file mode 100644
index edf23053f..000000000
--- a/src/Filterable.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
-import { Functor, FantasyFunctor } from './Functor'
-import { Either, fromPredicate, left, right } from './Either'
-import { Option, fromPredicate as optionFromPredicate } from './Option'
-import { Predicate, identity } from './function'
-
-export interface Filterable<F> extends Functor<F> {
-  /** partition a data structure based on an either predicate */
-  partitionMap: <A, L, R>(f: (a: A) => Either<L, R>, fa: HKT<F, A>) => { left: HKT<F, L>; right: HKT<F, R> }
-}
-
-export interface FantasyFilterable<F, A> extends FantasyFunctor<F, A> {
-  /** partition a data structure based on an either predicate */
-  partitionMap: <L, R>(f: (a: A) => Either<L, R>) => { left: HKT<F, L>; right: HKT<F, R> }
-}
-
-export class Ops {
-  /** partition a data structure based on boolean predicate */
-  partition<F extends HKT2S>(
-    F: Filterable<F>
-  ): <A>(predicate: Predicate<A>) => <L>(fa: HKT2As<F, L, A>) => { no: HKT2As<F, L, A>; yes: HKT2As<F, L, A> }
-  partition<F extends HKTS>(
-    F: Filterable<F>
-  ): <A>(predicate: Predicate<A>) => (fa: HKTAs<F, A>) => { no: HKTAs<F, A>; yes: HKTAs<F, A> }
-  partition<F>(F: Filterable<F>): <A>(predicate: Predicate<A>) => (fa: HKT<F, A>) => { no: HKT<F, A>; yes: HKT<F, A> }
-  partition<F>(F: Filterable<F>): <A>(predicate: Predicate<A>) => (fa: HKT<F, A>) => { no: HKT<F, A>; yes: HKT<F, A> } {
-    return predicate => fa => {
-      const { left, right } = F.partitionMap(fromPredicate(predicate, identity), fa)
-      return { no: left, yes: right }
-    }
-  }
-
-  /** map over a data structure and filter based on a maybe */
-  filterMap<F extends HKT2S>(
-    F: Filterable<F>
-  ): <A, B>(f: (a: A) => Option<B>) => <L>(fa: HKT2As<F, L, A>) => HKT2As<F, L, B>
-  filterMap<F extends HKTS>(F: Filterable<F>): <A, B>(f: (a: A) => Option<B>) => (fa: HKTAs<F, A>) => HKTAs<F, B>
-  filterMap<F>(F: Filterable<F>): <A, B>(f: (a: A) => Option<B>) => (fa: HKT<F, A>) => HKT<F, B>
-  filterMap<F>(F: Filterable<F>): <A, B>(f: (a: A) => Option<B>) => (fa: HKT<F, A>) => HKT<F, B> {
-    return <A, B>(f: (a: A) => Option<B>) => (fa: HKT<F, A>) =>
-      F.partitionMap((a: A) => f(a).fold(() => left<null, B>(null), b => right<null, B>(b)), fa).right
-  }
-
-  /** filter a data structure based on a boolean */
-  filter<F extends HKT2S>(F: Filterable<F>): <A>(predicate: Predicate<A>) => <L>(fa: HKT2As<F, L, A>) => HKT2As<F, L, A>
-  filter<F extends HKTS>(F: Filterable<F>): <A>(predicate: Predicate<A>) => (fa: HKTAs<F, A>) => HKTAs<F, A>
-  filter<F>(F: Filterable<F>): <A>(predicate: Predicate<A>) => (fa: HKT<F, A>) => HKT<F, A>
-  filter<F>(F: Filterable<F>): <A>(predicate: Predicate<A>) => (fa: HKT<F, A>) => HKT<F, A> {
-    return <A>(predicate: Predicate<A>) => (fa: HKT<F, A>) => this.filterMap(F)(optionFromPredicate(predicate))(fa)
-  }
-
-  partitioned<F extends HKT2S>(
-    F: Filterable<F>
-  ): <L, M, R>(fa: HKT2As<F, M, Either<L, R>>) => { left: HKT2As<F, M, L>; right: HKT2As<F, M, R> }
-  partitioned<F extends HKTS>(
-    F: Filterable<F>
-  ): <L, R>(fa: HKTAs<F, Either<L, R>>) => { left: HKTAs<F, L>; right: HKTAs<F, R> }
-  partitioned<F>(F: Filterable<F>): <L, R>(fa: HKT<F, Either<L, R>>) => { left: HKT<F, L>; right: HKT<F, R> }
-  partitioned<F>(F: Filterable<F>): <L, R>(fa: HKT<F, Either<L, R>>) => { left: HKT<F, L>; right: HKT<F, R> } {
-    return <L, A>(fa: HKT<F, Either<L, A>>) => F.partitionMap(a => a, fa)
-  }
-
-  /** Filter out all the `None` values */
-  filtered<F extends HKT2S>(F: Filterable<F>): <L, A>(fa: HKT2As<F, L, Option<A>>) => HKT2As<F, L, A>
-  filtered<F extends HKTS>(F: Filterable<F>): <A>(fa: HKTAs<F, Option<A>>) => HKTAs<F, A>
-  filtered<F>(F: Filterable<F>): <A>(fa: HKT<F, Option<A>>) => HKT<F, A>
-  filtered<F>(F: Filterable<F>): <A>(fa: HKT<F, Option<A>>) => HKT<F, A> {
-    return <A>(fa: HKT<F, Option<A>>) => this.filterMap(F)((oa: Option<A>) => oa)(fa)
-  }
-}
-
-const ops = new Ops()
-export const partition: Ops['partition'] = ops.partition
-export const filterMap: Ops['filterMap'] = ops.filterMap
-export const filter: Ops['filter'] = ops.filter
-export const partitioned: Ops['partitioned'] = ops.partitioned
-export const filtered: Ops['filtered'] = ops.filtered
diff --git a/src/Foldable.ts b/src/Foldable.ts
index c49ca3bb6..8a3383510 100644
--- a/src/Foldable.ts
+++ b/src/Foldable.ts
@@ -1,4 +1,4 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Monoid, getEndomorphismMonoid, monoidArray } from './Monoid'
 import { Applicative } from './Applicative'
 import { applyFirst } from './Apply'
@@ -6,15 +6,15 @@ import { identity } from './function'
 
 export interface Foldable<F> {
   readonly URI: F
-  reduce: <A, B>(f: (b: B, a: A) => B, b: B, fa: HKT<F, A>) => B
+  reduce<A, B>(f: (b: B, a: A) => B, b: B, fa: HKT<F, A>): B
 }
 
 export interface FantasyFoldable<A> {
-  reduce: <B>(f: (b: B, a: A) => B, b: B) => B
+  reduce<B>(f: (b: B, a: A) => B, b: B): B
 }
 
 export interface FoldableComposition<F, G> {
-  reduce: <A, B>(f: (b: B, a: A) => B, b: B, fga: HKT<F, HKT<G, A>>) => B
+  reduce<A, B>(f: (b: B, a: A) => B, b: B, fga: HKT<F, HKT<G, A>>): B
 }
 
 export const getFoldableComposition = <F, G>(F: Foldable<F>, G: Foldable<G>): FoldableComposition<F, G> => {
@@ -53,6 +53,10 @@ export class Ops {
    * Traverse a data structure, performing some effects encoded by an
    * `Applicative` functor at each value, ignoring the final result.
    */
+  traverse_<M extends HKT3S, F>(
+    M: Applicative<M>,
+    F: Foldable<F>
+  ): <U, L, A, B>(f: (a: A) => HKT3As<M, U, L, B>, fa: HKT<F, A>) => HKT3As<M, U, L, void>
   traverse_<M extends HKT2S, F>(
     M: Applicative<M>,
     F: Foldable<F>
@@ -70,6 +74,10 @@ export class Ops {
    * Perform all of the effects in some data structure in the order
    * given by the `Foldable` instance, ignoring the final result.
    */
+  sequence_<M extends HKT3S, F>(
+    M: Applicative<M>,
+    F: Foldable<F>
+  ): <U, L, A>(fa: HKT<F, HKT3As<M, U, L, A>>) => HKT3As<M, U, L, void>
   sequence_<M extends HKT2S, F>(
     M: Applicative<M>,
     F: Foldable<F>
diff --git a/src/Free.ts b/src/Free.ts
index 0889ed878..e7ee71b1a 100644
--- a/src/Free.ts
+++ b/src/Free.ts
@@ -1,7 +1,7 @@
 // adapted from http://okmij.org/ftp/Computation/free-monad.html
 // and https://github.com/purescript/purescript-free
 
-import { HKT, HKTS, HKTAs, HKT2S, HKT2As } from './HKT'
+import { HKT, HKTS, HKTAs, HKT2S, HKT2As, HKT3S, HKT3As } from './HKT'
 import { FantasyMonad, Monad } from './Monad'
 import { NaturalTransformation } from './NaturalTransformation'
 import { toString } from './function'
@@ -94,6 +94,9 @@ export const hoistFree = <F, G>(f: NaturalTransformation<F, G>): (<A>(fa: Free<F
   substFree(fa => liftF(f(fa)))
 
 export class Ops {
+  foldFree<M extends HKT3S>(
+    M: Monad<M>
+  ): <F>(f: NaturalTransformation<F, M>) => <U, L, A>(fa: Free<F, A>) => HKT3As<M, U, L, A>
   foldFree<M extends HKT2S>(
     M: Monad<M>
   ): <F>(f: NaturalTransformation<F, M>) => <L, A>(fa: Free<F, A>) => HKT2As<M, L, A>
diff --git a/src/Functor.ts b/src/Functor.ts
index b483425fb..a5a583397 100644
--- a/src/Functor.ts
+++ b/src/Functor.ts
@@ -1,33 +1,33 @@
-import { HKT, HKT2, HKTAs, HKTS, HKT2As, HKT2S } from './HKT'
+import { HKT, HKT2, HKTAs, HKTS, HKT2As, HKT2S, HKT3S, HKT3As, HKT3 } from './HKT'
 import { constant } from './function'
 
 export interface Functor<F> {
   readonly URI: F
-  map: <A, B>(f: (a: A) => B, fa: HKT<F, A>) => HKT<F, B>
+  map<A, B>(f: (a: A) => B, fa: HKT<F, A>): HKT<F, B>
 }
 
 export interface FantasyFunctor<F, A> {
-  map: <B>(f: (a: A) => B) => HKT<F, B>
+  map<B>(f: (a: A) => B): HKT<F, B>
 }
 
 export interface FunctorComposition<F, G> {
-  map: <A, B>(f: (a: A) => B, fa: HKT<F, HKT<G, A>>) => HKT<F, HKT<G, B>>
+  map<A, B>(f: (a: A) => B, fa: HKT<F, HKT<G, A>>): HKT<F, HKT<G, B>>
 }
 
 export interface FunctorComposition11<F extends HKTS, G extends HKTS> {
-  map: <A, B>(f: (a: A) => B, fa: HKTAs<F, HKTAs<G, A>>) => HKTAs<F, HKTAs<G, B>>
+  map<A, B>(f: (a: A) => B, fa: HKTAs<F, HKTAs<G, A>>): HKTAs<F, HKTAs<G, B>>
 }
 
 export interface FunctorComposition12<F extends HKTS, G extends HKT2S> {
-  map: <L, A, B>(f: (a: A) => B, fa: HKTAs<F, HKT2As<G, L, A>>) => HKTAs<F, HKT2As<G, L, B>>
+  map<L, A, B>(f: (a: A) => B, fa: HKTAs<F, HKT2As<G, L, A>>): HKTAs<F, HKT2As<G, L, B>>
 }
 
 export interface FunctorComposition21<F extends HKT2S, G extends HKTS> {
-  map: <L, A, B>(f: (a: A) => B, fa: HKT2As<F, L, HKTAs<G, A>>) => HKT2As<F, L, HKTAs<G, B>>
+  map<L, A, B>(f: (a: A) => B, fa: HKT2As<F, L, HKTAs<G, A>>): HKT2As<F, L, HKTAs<G, B>>
 }
 
 export interface FunctorComposition22<F extends HKT2S, G extends HKT2S> {
-  map: <L, M, A, B>(f: (a: A) => B, fa: HKT2As<F, L, HKT2As<G, M, A>>) => HKT2As<F, L, HKT2As<G, M, B>>
+  map<L, M, A, B>(f: (a: A) => B, fa: HKT2As<F, L, HKT2As<G, M, A>>): HKT2As<F, L, HKT2As<G, M, B>>
 }
 
 export class Ops {
@@ -35,6 +35,7 @@ export class Ops {
    * Lift a function of one argument to a function which accepts and returns
    * values wrapped with the type constructor `F`
    */
+  lift<F extends HKT3S>(F: Functor<F>): <A, B>(f: (a: A) => B) => <U, L>(fa: HKT3As<F, U, L, A>) => HKT3As<F, U, L, B>
   lift<F extends HKT2S>(F: Functor<F>): <A, B>(f: (a: A) => B) => <L>(fa: HKT2As<F, L, A>) => HKT2As<F, L, B>
   lift<F extends HKTS>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKTAs<F, A>) => HKTAs<F, B>
   lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
@@ -43,6 +44,7 @@ export class Ops {
   }
 
   /** Ignore the return value of a computation, using the specified return value instead (`<$`) */
+  voidRight<F extends HKT3S>(F: Functor<F>): <A>(a: A) => <U, L, B>(fb: HKT3<F, U, L, B>) => HKT3As<F, U, L, A>
   voidRight<F extends HKT2S>(F: Functor<F>): <A>(a: A) => <L, B>(fb: HKT2<F, L, B>) => HKT2As<F, L, A>
   voidRight<F extends HKTS>(F: Functor<F>): <A>(a: A) => <B>(fb: HKT<F, B>) => HKTAs<F, A>
   voidRight<F>(F: Functor<F>): <A>(a: A) => <B>(fb: HKT<F, B>) => HKT<F, A>
@@ -51,6 +53,7 @@ export class Ops {
   }
 
   /** A version of `voidRight` with its arguments flipped (`$>`) */
+  voidLeft<F extends HKT3S>(F: Functor<F>): <U, L, A>(fa: HKT3<F, U, L, A>) => <B>(b: B) => HKT3As<F, U, L, B>
   voidLeft<F extends HKT2S>(F: Functor<F>): <L, A>(fa: HKT2<F, L, A>) => <B>(b: B) => HKT2As<F, L, B>
   voidLeft<F extends HKTS>(F: Functor<F>): <A>(fa: HKT<F, A>) => <B>(b: B) => HKTAs<F, B>
   voidLeft<F>(F: Functor<F>): <A>(fa: HKT<F, A>) => <B>(b: B) => HKT<F, B>
@@ -62,6 +65,9 @@ export class Ops {
    * Apply a value in a computational context to a value in no context.
    * Generalizes `flip`
    */
+  flap<F extends HKT3S>(
+    functor: Functor<F>
+  ): <U, L, A, B>(ff: HKT3As<F, U, L, (a: A) => B>) => (a: A) => HKT3As<F, U, L, B>
   flap<F extends HKT2S>(functor: Functor<F>): <L, A, B>(ff: HKT2As<F, L, (a: A) => B>) => (a: A) => HKT2As<F, L, B>
   flap<F extends HKTS>(functor: Functor<F>): <A, B>(ff: HKTAs<F, (a: A) => B>) => (a: A) => HKTAs<F, B>
   flap<F>(functor: Functor<F>): <A, B>(ff: HKT<F, (a: A) => B>) => (a: A) => HKT<F, B>
diff --git a/src/IO.ts b/src/IO.ts
index 84605ab16..e45271df8 100644
--- a/src/IO.ts
+++ b/src/IO.ts
@@ -45,11 +45,8 @@ export const ap = <A, B>(fab: IO<(a: A) => B>, fa: IO<A>): IO<B> => fa.ap(fab)
 
 export const chain = <A, B>(f: (a: A) => IO<B>, fa: IO<A>): IO<B> => fa.chain(f)
 
-export const concat = <A>(S: Semigroup<A>) => (fx: IO<A>) => (fy: IO<A>): IO<A> =>
-  new IO(() => S.concat(fx.run())(fy.run()))
-
 export const getSemigroup = <A>(S: Semigroup<A>): Semigroup<IO<A>> => ({
-  concat: concat(S)
+  concat: x => y => new IO(() => S.concat(x.run())(y.run()))
 })
 
 export const getMonoid = <A>(M: Monoid<A>): Monoid<IO<A>> => {
diff --git a/src/Identity.ts b/src/Identity.ts
index 6e4b1c0c9..9077df2bf 100644
--- a/src/Identity.ts
+++ b/src/Identity.ts
@@ -74,11 +74,8 @@ export class Identity<A>
   }
 }
 
-export const equals = <A>(setoid: Setoid<A>) => (fx: Identity<A>) => (fy: Identity<A>): boolean =>
-  setoid.equals(fx.value)(fy.value)
-
 export const getSetoid = <A>(setoid: Setoid<A>): Setoid<Identity<A>> => ({
-  equals: equals(setoid)
+  equals: x => y => setoid.equals(x.value)(y.value)
 })
 
 export const map = <A, B>(f: (a: A) => B, fa: Identity<A>): Identity<B> => fa.map(f)
@@ -91,7 +88,7 @@ export const chain = <A, B>(f: (a: A) => Identity<B>, fa: Identity<A>): Identity
 
 export const reduce = <A, B>(f: (b: B, a: A) => B, b: B, fa: Identity<A>): B => fa.reduce(f, b)
 
-export const alt = <A>(fx: Identity<A>) => (fy: Identity<A>): Identity<A> => {
+export const alt = <A>(fx: Identity<A>, fy: Identity<A>): Identity<A> => {
   return fx.alt(fy)
 }
 
@@ -107,7 +104,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <A, B>(f: (a: A) => HKTAs<F, B>, ta: Identity<A>) => HKTAs<F, Identity<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Identity<A>) => HKT<F, Identity<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Identity<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Identity<A>) => HKT<F, Identity<B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/Invariant.ts b/src/Invariant.ts
index 6d3bd6008..2d68e8ba3 100644
--- a/src/Invariant.ts
+++ b/src/Invariant.ts
@@ -2,5 +2,5 @@ import { HKT } from './HKT'
 
 export interface Invariant<F> {
   readonly URI: F
-  imap: <A, B>(f: (a: A) => B, g: (b: B) => A, fa: HKT<F, A>) => HKT<F, B>
+  imap<A, B>(f: (a: A) => B, g: (b: B) => A, fa: HKT<F, A>): HKT<F, B>
 }
diff --git a/src/IxMonad.ts b/src/IxMonad.ts
index 9b41b9c26..067063607 100644
--- a/src/IxMonad.ts
+++ b/src/IxMonad.ts
@@ -5,12 +5,12 @@ import { constant } from './function'
 
 export interface IxMonad<F> {
   readonly URI: F
-  iof: <I, A>(a: A) => HKT3<F, I, I, A>
-  ichain: <I, O, Z, A, B>(f: (a: A) => HKT3<F, O, Z, B>, fa: HKT3<F, I, O, A>) => HKT3<F, I, Z, B>
+  iof<I, A>(a: A): HKT3<F, I, I, A>
+  ichain<I, O, Z, A, B>(f: (a: A) => HKT3<F, O, Z, B>, fa: HKT3<F, I, O, A>): HKT3<F, I, Z, B>
 }
 
 export interface FantasyIxMonad<F, A, O, I> {
-  ichain: <Z, B>(f: (a: A) => HKT3<F, O, Z, B>) => HKT3<F, I, Z, B>
+  ichain<Z, B>(f: (a: A) => HKT3<F, O, Z, B>): HKT3<F, I, Z, B>
 }
 
 export class Ops {
diff --git a/src/Monoidal.ts b/src/Monoidal.ts
index ebe006c3b..f481f0566 100644
--- a/src/Monoidal.ts
+++ b/src/Monoidal.ts
@@ -10,21 +10,20 @@ import { liftA2 } from './Apply'
  * - https://bartoszmilewski.com/2017/02/06/applicative-functors/
  */
 export interface Monoidal<F> extends Functor<F> {
-  readonly URI: F
-  unit: () => HKT<F, void>
-  mult: <A>(fa: HKT<F, A>) => <B>(fb: HKT<F, B>) => HKT<F, [A, B]>
+  unit(): HKT<F, void>
+  mult<A, B>(fa: HKT<F, A>, fb: HKT<F, B>): HKT<F, [A, B]>
 }
 
 export const fromApplicative = <F>(applicative: Applicative<F>): Monoidal<F> => ({
   URI: applicative.URI,
   map: applicative.map,
   unit: () => applicative.of(undefined),
-  mult: liftA2(applicative)(tupleCurried)
+  mult: <A, B>(fa: HKT<F, A>, fb: HKT<F, B>) => liftA2(applicative)<A, B, [A, B]>(tupleCurried)(fa)(fb)
 })
 
 export const toApplicative = <F>(monoidal: Monoidal<F>): Applicative<F> => ({
   URI: monoidal.URI,
   map: monoidal.map,
   of: a => monoidal.map(constant(a), monoidal.unit()),
-  ap: (fab, fa) => monoidal.map(([f, a]) => f(a), monoidal.mult(fab)(fa))
+  ap: (fab, fa) => monoidal.map(([f, a]) => f(a), monoidal.mult(fab, fa))
 })
diff --git a/src/NonEmptyArray.ts b/src/NonEmptyArray.ts
index aaa608cf6..6eb7f5b06 100644
--- a/src/NonEmptyArray.ts
+++ b/src/NonEmptyArray.ts
@@ -97,7 +97,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <A, B>(f: (a: A) => HKTAs<F, B>, ta: NonEmptyArray<A>) => HKTAs<F, NonEmptyArray<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: NonEmptyArray<A>) => HKT<F, NonEmptyArray<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, NonEmptyArray<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: NonEmptyArray<A>) => HKT<F, NonEmptyArray<B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/Option.ts b/src/Option.ts
index 9af35fbc8..1de166100 100644
--- a/src/Option.ts
+++ b/src/Option.ts
@@ -9,10 +9,7 @@ import { Extend, FantasyExtend } from './Extend'
 import { Setoid } from './Setoid'
 import { Traversable, FantasyTraversable } from './Traversable'
 import { Alternative, FantasyAlternative } from './Alternative'
-import { Filterable, FantasyFilterable } from './Filterable'
-import { Either } from './Either'
-import { Witherable, FantasyWitherable } from './Witherable'
-import { constant, constFalse, constTrue, Lazy, Predicate, toString } from './function'
+import { constant, Lazy, Predicate, toString } from './function'
 
 declare module './HKT' {
   interface URI2HKT<A> {
@@ -30,8 +27,6 @@ export class None<A>
   implements FantasyMonad<URI, A>,
     FantasyFoldable<A>,
     FantasyTraversable<URI, A>,
-    FantasyFilterable<URI, A>,
-    FantasyWitherable<URI, A>,
     FantasyAlternative<URI, A>,
     FantasyExtend<URI, A> {
   static value: Option<never> = new None()
@@ -64,14 +59,6 @@ export class None<A>
   traverse<F>(F: Applicative<F>): <B>(f: (a: A) => HKT<F, B>) => HKT<F, Option<B>> {
     return f => F.of(none)
   }
-  partitionMap<L, R>(f: (a: A) => Either<L, R>): { left: Option<L>; right: Option<R> } {
-    return { left: none, right: none }
-  }
-  wilt<M>(
-    M: Applicative<M>
-  ): <L, R>(f: (a: A) => HKT<M, Either<L, R>>) => HKT<M, { left: Option<L>; right: Option<R> }> {
-    return <L, R>(f: (a: A) => HKT<M, Either<L, R>>) => M.of({ left: none, right: none })
-  }
   alt(fa: Option<A>): Option<A> {
     return fa
   }
@@ -81,18 +68,12 @@ export class None<A>
   fold<B>(n: Lazy<B>, s: (a: A) => B): B {
     return n()
   }
+  getOrElseValue(a: A): A {
+    return a
+  }
   getOrElse(f: Lazy<A>): A {
     return f()
   }
-  getOrElseValue(value: A): A {
-    return value
-  }
-  concat(S: Semigroup<A>): (fy: Option<A>) => Option<A> {
-    return fy => fy
-  }
-  equals(S: Setoid<A>): (fy: Option<A>) => boolean {
-    return fy => fy.fold(constTrue, constFalse)
-  }
   toNullable(): A | null {
     return null
   }
@@ -133,8 +114,6 @@ export class Some<A>
   implements FantasyMonad<URI, A>,
     FantasyFoldable<A>,
     FantasyTraversable<URI, A>,
-    FantasyFilterable<URI, A>,
-    FantasyWitherable<URI, A>,
     FantasyAlternative<URI, A>,
     FantasyExtend<URI, A> {
   readonly _tag: 'Some' = 'Some'
@@ -166,25 +145,6 @@ export class Some<A>
   traverse<F>(F: Applicative<F>): <B>(f: (a: A) => HKT<F, B>) => HKT<F, Option<B>> {
     return f => F.map(b => some(b), f(this.value))
   }
-  partitionMap<L, R>(f: (a: A) => Either<L, R>): { left: Option<L>; right: Option<R> } {
-    return f(this.value).fold<{ left: Option<L>; right: Option<R> }>(
-      l => ({ left: some(l), right: none }),
-      a => ({ left: none, right: some(a) })
-    )
-  }
-  wilt<M>(
-    M: Applicative<M>
-  ): <L, R>(f: (a: A) => HKT<M, Either<L, R>>) => HKT<M, { left: Option<L>; right: Option<R> }> {
-    return <L, R>(f: (a: A) => HKT<M, Either<L, R>>) =>
-      M.map(
-        e =>
-          e.fold<{ left: Option<L>; right: Option<R> }>(
-            l => ({ left: some(l), right: none }),
-            r => ({ left: none, right: some(r) })
-          ),
-        f(this.value)
-      )
-  }
   alt(fa: Option<A>): Option<A> {
     return this
   }
@@ -194,18 +154,12 @@ export class Some<A>
   fold<B>(n: Lazy<B>, s: (a: A) => B): B {
     return s(this.value)
   }
-  getOrElse(f: Lazy<A>): A {
+  getOrElseValue(a: A): A {
     return this.value
   }
-  getOrElseValue(value: A): A {
+  getOrElse(f: Lazy<A>): A {
     return this.value
   }
-  concat(S: Semigroup<A>): (fy: Option<A>) => Option<A> {
-    return fy => fy.fold(() => this, y => new Some(S.concat(this.value)(y)))
-  }
-  equals(S: Setoid<A>): (fy: Option<A>) => boolean {
-    return fy => fy.fold(constFalse, y => S.equals(this.value)(y))
-  }
   toNullable(): A | null {
     return this.value
   }
@@ -240,10 +194,10 @@ export class Some<A>
   }
 }
 
-export const equals = <A>(S: Setoid<A>) => (fx: Option<A>) => (fy: Option<A>): boolean => fx.equals(S)(fy)
+export const fold = <A, B>(n: Lazy<B>, s: (a: A) => B) => (fa: Option<A>): B => fa.fold(n, s)
 
 export const getSetoid = <A>(S: Setoid<A>): Setoid<Option<A>> => ({
-  equals: equals(S)
+  equals: x => y => x.fold(() => y.isNone(), ax => y.fold(() => false, ay => S.equals(ax)(ay)))
 })
 
 export const map = <A, B>(f: (a: A) => B, fa: Option<A>): Option<B> => fa.map(f)
@@ -262,12 +216,7 @@ export const reduce = <A, B>(f: (b: B, a: A) => B, b: B, fa: Option<A>): B => fa
 /** Returns this option if it is non empty and the predicate `p` return `true` when applied to this Option's value. Otherwise returns none */
 export const filter = <A>(p: Predicate<A>) => (fa: Option<A>): Option<A> => fa.filter(p)
 
-// overload here to support 'None' as first argument
-export function alt(fx: Option<never>): <A>(fy: Option<A>) => Option<A>
-export function alt<A>(fx: Option<A>): (fy: Option<A>) => Option<A>
-export function alt<A>(fx: Option<A>): (fy: Option<A>) => Option<A> {
-  return fy => fx.alt(fy)
-}
+export const alt = <A>(fx: Option<A>, fy: Option<A>): Option<A> => fx.alt(fy)
 
 export const extend = <A, B>(f: (ea: Option<A>) => B, ea: Option<A>): Option<B> => ea.extend(f)
 
@@ -275,45 +224,33 @@ export const zero = <A>(): Option<A> => none
 
 export const empty = zero
 
-const first = { empty, concat: alt }
-const last = getDualMonoid(first)
-
-/** Option monoid returning the left-most non-`None` value */
-export const getFirstMonoid = <A>(): Monoid<Option<A>> => first
-
-/** Option monoid returning the right-most non-`None` value */
-export const getLastMonoid = <A>(): Monoid<Option<A>> => last
+/** Option monoid returning the left-most non-None value */
+export const getFirstMonoid = <A>(): Monoid<Option<A>> => ({
+  concat: x => y => alt(x, y),
+  empty
+})
 
-export const concat = <A>(S: Semigroup<A>) => (fx: Option<A>) => (fy: Option<A>): Option<A> => fx.concat(S)(fy)
+/** Option monoid returning the right-most non-None value */
+export const getLastMonoid = <A>(): Monoid<Option<A>> => getDualMonoid(getFirstMonoid())
 
 export const getSemigroup = <A>(S: Semigroup<A>): Semigroup<Option<A>> => ({
-  concat: concat(S)
+  concat: x => y => x.fold(() => y, ax => y.fold(() => x, ay => some(S.concat(ax)(ay))))
 })
 
 export const getMonoid = <A>(S: Semigroup<A>): Monoid<Option<A>> => ({ ...getSemigroup(S), empty })
 
-export const partitionMap = <A, L, R>(
-  f: (a: A) => Either<L, R>,
-  fa: Option<A>
-): { left: Option<L>; right: Option<R> } => fa.partitionMap(f)
-
-export const wilt = <M>(M: Applicative<M>) => <A, L, R>(
-  f: (a: A) => HKT<M, Either<L, R>>,
-  ta: Option<A>
-): HKT<M, { left: Option<L>; right: Option<R> }> => ta.wilt(M)(f)
-
 export const isSome = <A>(fa: Option<A>): fa is Some<A> => fa._tag === 'Some'
 
 export const isNone = <A>(fa: Option<A>): fa is None<A> => fa === none
 
-export const fold = <A, B>(n: Lazy<B>, s: (a: A) => B, fa: Option<A>): B => fa.fold(n, s)
-
 /**
  * Takes a default value, and a `Option` value. If the `Option` value is
  * `None` the default value is returned, otherwise the value inside the
  * `Some` is returned
  */
-export const fromOption = <A>(a: A) => (fa: Option<A>): A => fa.getOrElseValue(a)
+export const getOrElseValue = <A>(a: A) => (fa: Option<A>): A => fa.getOrElseValue(a)
+
+export const getOrElse = <A>(f: Lazy<A>) => (fa: Option<A>): A => fa.getOrElse(f)
 
 export const fromNullable = <A>(a: A | null | undefined): Option<A> => (a == null ? none : new Some(a))
 
@@ -330,7 +267,7 @@ export class Ops {
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKT2As<F, L, B>, ta: Option<A>) => HKT2As<F, L, Option<B>>
   traverse<F extends HKTS>(F: Applicative<F>): <A, B>(f: (a: A) => HKTAs<F, B>, ta: Option<A>) => HKTAs<F, Option<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Option<A>) => HKT<F, Option<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Option<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Option<A>) => HKT<F, Option<B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
@@ -339,14 +276,7 @@ export class Ops {
 const ops = new Ops()
 export const traverse: Ops['traverse'] = ops.traverse
 
-export const option: Monad<URI> &
-  Foldable<URI> &
-  Plus<URI> &
-  Traversable<URI> &
-  Alternative<URI> &
-  Extend<URI> &
-  Filterable<URI> &
-  Witherable<URI> = {
+export const option: Monad<URI> & Foldable<URI> & Plus<URI> & Traversable<URI> & Alternative<URI> & Extend<URI> = {
   URI,
   map,
   of,
@@ -356,7 +286,5 @@ export const option: Monad<URI> &
   traverse,
   zero,
   alt,
-  extend,
-  partitionMap,
-  wilt
+  extend
 }
diff --git a/src/Pair.ts b/src/Pair.ts
index 402f002c1..2ca24ba23 100644
--- a/src/Pair.ts
+++ b/src/Pair.ts
@@ -88,23 +88,19 @@ export const getSetoid = <A>(S: Setoid<A>): Setoid<Pair<A>> => ({
   equals: x => y => S.equals(x.fst())(y.fst()) && S.equals(x.snd())(y.snd())
 })
 
-export const getOrd = <A>(O: Ord<A>): Ord<Pair<A>> => {
-  const S = getSetoid(O)
-  return {
-    ...S,
-    compare: x => y => orderingSemigroup.concat(O.compare(x.fst())(y.fst()))(O.compare(x.snd())(y.snd()))
-  }
-}
+export const getOrd = <A>(O: Ord<A>): Ord<Pair<A>> => ({
+  ...getSetoid(O),
+  compare: x => y => orderingSemigroup.concat(O.compare(x.fst())(y.fst()))(O.compare(x.snd())(y.snd()))
+})
 
 export const getSemigroup = <A>(S: Semigroup<A>): Semigroup<Pair<A>> => ({
   concat: x => y => new Pair([S.concat(x.fst())(y.fst()), S.concat(x.snd())(y.snd())])
 })
 
 export const getMonoid = <A>(M: Monoid<A>): Monoid<Pair<A>> => {
-  const S = getSemigroup(M)
   const empty = new Pair([M.empty(), M.empty()])
   return {
-    ...S,
+    ...getSemigroup(M),
     empty: () => empty
   }
 }
@@ -123,7 +119,7 @@ export class Ops {
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKT2As<F, L, B>, ta: Pair<A>) => HKT2As<F, L, Pair<B>>
   traverse<F extends HKTS>(F: Applicative<F>): <A, B>(f: (a: A) => HKTAs<F, B>, ta: Pair<A>) => HKTAs<F, Pair<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Pair<A>) => HKT<F, Pair<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Pair<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: Pair<A>) => HKT<F, Pair<B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/Profunctor.ts b/src/Profunctor.ts
index ae44dcaf6..e0962d6ec 100644
--- a/src/Profunctor.ts
+++ b/src/Profunctor.ts
@@ -1,18 +1,38 @@
-import { HKT2 } from './HKT'
+import { HKT2, HKT2S, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Functor, FantasyFunctor } from './Functor'
 
 export interface Profunctor<F> extends Functor<F> {
-  promap: <A, B, C, D>(f: (a: A) => B, g: (c: C) => D) => (fbc: HKT2<F, B, C>) => HKT2<F, A, D>
+  promap<A, B, C, D>(f: (a: A) => B, g: (c: C) => D, fbc: HKT2<F, B, C>): HKT2<F, A, D>
 }
 
 export interface FantasyProfunctor<F, B, C> extends FantasyFunctor<F, C> {
   promap: <A, D>(f: (a: A) => B, g: (c: C) => D) => HKT2<F, A, D>
 }
 
-export const lmap = <F>(profunctor: Profunctor<F>) => <A, B>(f: (a: A) => B) => <C>(
-  fbc: HKT2<F, B, C>
-): HKT2<F, A, C> => profunctor.promap(f, (c: C) => c)(fbc)
+export class Ops {
+  lmap<F extends HKT3S>(
+    profunctor: Profunctor<F>
+  ): <A, B>(f: (a: A) => B) => <U, C>(fbc: HKT3As<F, U, B, C>) => HKT3As<F, U, A, C>
+  lmap<F extends HKT2S>(
+    profunctor: Profunctor<F>
+  ): <A, B>(f: (a: A) => B) => <C>(fbc: HKT2As<F, B, C>) => HKT2As<F, A, C>
+  lmap<F>(profunctor: Profunctor<F>): <A, B>(f: (a: A) => B) => <C>(fbc: HKT2<F, B, C>) => HKT2<F, A, C>
+  lmap<F>(profunctor: Profunctor<F>): <A, B>(f: (a: A) => B) => <C>(fbc: HKT2<F, B, C>) => HKT2<F, A, C> {
+    return f => fbc => profunctor.promap(f, c => c, fbc)
+  }
 
-export const rmap = <F>(profunctor: Profunctor<F>) => <C, D>(g: (c: C) => D) => <B>(
-  fbc: HKT2<F, B, C>
-): HKT2<F, B, D> => profunctor.promap((b: B) => b, g)(fbc)
+  rmap<F extends HKT3S>(
+    profunctor: Profunctor<F>
+  ): <C, D>(g: (c: C) => D) => <U, B>(fbc: HKT3As<F, U, B, C>) => HKT3As<F, U, B, D>
+  rmap<F extends HKT2S>(
+    profunctor: Profunctor<F>
+  ): <C, D>(g: (c: C) => D) => <B>(fbc: HKT2As<F, B, C>) => HKT2As<F, B, D>
+  rmap<F>(profunctor: Profunctor<F>): <C, D>(g: (c: C) => D) => <B>(fbc: HKT2<F, B, C>) => HKT2<F, B, D>
+  rmap<F>(profunctor: Profunctor<F>): <C, D>(g: (c: C) => D) => <B>(fbc: HKT2<F, B, C>) => HKT2<F, B, D> {
+    return g => fbc => profunctor.promap(b => b, g, fbc)
+  }
+}
+
+const ops = new Ops()
+export const lmap: Ops['lmap'] = ops.lmap
+export const rmap: Ops['rmap'] = ops.rmap
diff --git a/src/Random.ts b/src/Random.ts
index 586c7c69e..0a5d93053 100644
--- a/src/Random.ts
+++ b/src/Random.ts
@@ -2,23 +2,26 @@ import { IO } from './IO'
 
 // Adapted from https://github.com/purescript/purescript-random
 
-/** Returns a random number between 0 (inclusive) and 1 (exclusive). This is
+/**
+ * Returns a random number between 0 (inclusive) and 1 (exclusive). This is
  * a direct wrapper around JavaScript's `Math.random()`.
  */
-export const random = (): IO<number> => new IO(() => Math.random())
+export const random: IO<number> = new IO(() => Math.random())
 
-/** Takes a range specified by `low` (the first argument) and `high` (the
+/**
+ * Takes a range specified by `low` (the first argument) and `high` (the
  * second), and returns a random integer uniformly distributed in the closed
  * interval `[low, high]`. It is unspecified what happens if `low > high`,
  * or if either of `low` or `high` is not an integer.
  */
 export const randomInt = (low: number, high: number): IO<number> =>
-  random().map(n => Math.floor((high - low + 1) * n + low))
+  random.map(n => Math.floor((high - low + 1) * n + low))
 
-/** Returns a random number between a minimum value (inclusive) and a maximum
+/**
+ * Returns a random number between a minimum value (inclusive) and a maximum
  * value (exclusive). It is unspecified what happens if `maximum < minimum`.
  */
-export const randomRange = (min: number, max: number): IO<number> => random().map(n => (max - min + 1) * n + min)
+export const randomRange = (min: number, max: number): IO<number> => random.map(n => (max - min + 1) * n + min)
 
 /** Returns a random boolean value with an equal chance of being `true` or `false` */
-export const randomBool = (): IO<boolean> => random().map(n => n < 0.5)
+export const randomBool: IO<boolean> = random.map(n => n < 0.5)
diff --git a/src/Reader.ts b/src/Reader.ts
index 4af32c128..17ce6a784 100644
--- a/src/Reader.ts
+++ b/src/Reader.ts
@@ -1,5 +1,5 @@
 import { Monad, FantasyMonad } from './Monad'
-import { identity, Endomorphism } from './function'
+import { identity } from './function'
 
 export const URI = 'Reader'
 
@@ -36,8 +36,7 @@ export const ask = <E>(): Reader<E, E> => new Reader(identity)
 export const asks = <E, A>(f: (e: E) => A): Reader<E, A> => new Reader(f)
 
 /** changes the value of the local context during the execution of the action `fa` */
-export const local = <E>(f: Endomorphism<E>) => <A>(fa: Reader<E, A>): Reader<E, A> =>
-  new Reader((e: E) => fa.run(f(e)))
+export const local = <E>(f: (e: E) => E) => <A>(fa: Reader<E, A>): Reader<E, A> => new Reader((e: E) => fa.run(f(e)))
 
 export const reader: Monad<URI> = {
   URI,
diff --git a/src/Semigroupoid.ts b/src/Semigroupoid.ts
index d3f9b5ca9..06e117921 100644
--- a/src/Semigroupoid.ts
+++ b/src/Semigroupoid.ts
@@ -2,9 +2,9 @@ import { HKT2 } from './HKT'
 
 export interface Semigroupoid<F> {
   readonly URI: F
-  compose: <A, B>(bc: HKT2<F, A, B>) => <L>(ab: HKT2<F, L, A>) => HKT2<F, L, B>
+  compose<L, A, B>(bc: HKT2<F, A, B>, ab: HKT2<F, L, A>): HKT2<F, L, B>
 }
 
 export interface FantasySemigroupoid<F, L, A> {
-  compose: <B>(bc: HKT2<F, A, B>) => HKT2<F, L, B>
+  compose<B>(bc: HKT2<F, A, B>): HKT2<F, L, B>
 }
diff --git a/src/StrMap.ts b/src/StrMap.ts
index d554c9b97..330d76a0c 100644
--- a/src/StrMap.ts
+++ b/src/StrMap.ts
@@ -93,7 +93,7 @@ export class Ops {
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKT2As<F, L, B>, ta: StrMap<A>) => HKT2As<F, L, StrMap<B>>
   traverse<F extends HKTS>(F: Applicative<F>): <A, B>(f: (a: A) => HKTAs<F, B>, ta: StrMap<A>) => HKTAs<F, StrMap<B>>
-  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: StrMap<A>) => HKT<F, StrMap<B>>
+  traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, StrMap<B>>
   traverse<F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, B>, ta: StrMap<A>) => HKT<F, StrMap<B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/TaskEither.ts b/src/TaskEither.ts
index 712fe11b7..99cca443a 100644
--- a/src/TaskEither.ts
+++ b/src/TaskEither.ts
@@ -17,6 +17,10 @@ export const URI = 'TaskEither'
 
 export type URI = typeof URI
 
+const eitherTfold = eitherT.fold(task)
+const eitherTmapLeft = eitherT.mapLeft(task)
+const eitherTtoOption = eitherT.toOption(task)
+
 export class TaskEither<L, A> implements FantasyMonad<URI, A> {
   readonly _A: A
   readonly _L: L
@@ -35,13 +39,13 @@ export class TaskEither<L, A> implements FantasyMonad<URI, A> {
     return new TaskEither(eitherTTask.chain(a => f(a).value, this.value))
   }
   fold<R>(left: (l: L) => R, right: (a: A) => R): task.Task<R> {
-    return eitherT.fold(task)(left, right, this.value)
+    return eitherTfold(left, right, this.value)
   }
   mapLeft<M>(f: (l: L) => M): TaskEither<M, A> {
-    return new TaskEither(eitherT.mapLeft(task)(f)(this.value))
+    return new TaskEither(eitherTmapLeft(f)(this.value))
   }
   toOption(): task.Task<Option<A>> {
-    return eitherT.toOption(task)(this.value)
+    return eitherTtoOption(this.value)
   }
 }
 
@@ -53,12 +57,14 @@ export const ap = <L, A, B>(fab: TaskEither<L, (a: A) => B>, fa: TaskEither<L, A
 
 export const chain = <L, A, B>(f: (a: A) => TaskEither<L, B>, fa: TaskEither<L, A>): TaskEither<L, B> => fa.chain(f)
 
-export const right = <L, A>(fa: task.Task<A>): TaskEither<L, A> => new TaskEither(eitherT.right(task)(fa))
+const eitherTright = eitherT.right(task)
+export const right = <L, A>(fa: task.Task<A>): TaskEither<L, A> => new TaskEither(eitherTright(fa))
 
-export const left = <L, A>(fa: task.Task<L>): TaskEither<L, A> => new TaskEither(eitherT.left(task)(fa))
+const eitherTleft = eitherT.left(task)
+export const left = <L, A>(fa: task.Task<L>): TaskEither<L, A> => new TaskEither(eitherTleft(fa))
 
-export const fromEither = <L, A>(fa: either.Either<L, A>): TaskEither<L, A> =>
-  new TaskEither(eitherT.fromEither(task)(fa))
+const eitherTfromEither = eitherT.fromEither(task)
+export const fromEither = <L, A>(fa: either.Either<L, A>): TaskEither<L, A> => new TaskEither(eitherTfromEither(fa))
 
 export const tryCatch = <L, A>(f: Lazy<Promise<A>>, onrejected: (reason: {}) => L): TaskEither<L, A> =>
   new TaskEither(task.tryCatch(f)(onrejected))
diff --git a/src/These.ts b/src/These.ts
index 9afc2e571..91ffb18da 100644
--- a/src/These.ts
+++ b/src/These.ts
@@ -7,7 +7,7 @@ import { Traversable, FantasyTraversable } from './Traversable'
 import { Option, none, some } from './Option'
 import { Setoid } from './Setoid'
 import { Semigroup } from './Semigroup'
-import { constFalse, toString } from './function'
+import { toString, constFalse } from './function'
 import { Monad } from './Monad'
 
 // Data type isomorphic to `α ∨ β ∨ (α ∧ β)`
@@ -35,12 +35,6 @@ export class This<L, A>
   map<B>(f: (a: A) => B): These<L, B> {
     return this as any
   }
-  ap<B>(SL: Semigroup<L>, fab: These<L, (a: A) => B>): These<L, B> {
-    return fab.fold(() => fab as any, () => this as any, (l, _) => this_(SL.concat(l)(this.value)))
-  }
-  chain<B>(SL: Semigroup<L>, f: (a: A) => These<L, B>): These<L, B> {
-    return this as any
-  }
   bimap<M, B>(f: (l: L) => M, g: (a: A) => B): These<M, B> {
     return this_(f(this.value))
   }
@@ -56,17 +50,6 @@ export class This<L, A>
   fold<B>(this_: (l: L) => B, that: (a: A) => B, both: (l: L, a: A) => B): B {
     return this_(this.value)
   }
-  equals(setoidL: Setoid<L>, setoidA: Setoid<A>): (fy: These<L, A>) => boolean {
-    return fy => fy.fold(l => setoidL.equals(l)(this.value), constFalse, constFalse)
-  }
-  concat(SL: Semigroup<L>, SA: Semigroup<A>): (fy: These<L, A>) => These<L, A> {
-    return fy =>
-      fy.fold(
-        l => this_(SL.concat(this.value)(l)),
-        a => both(this.value, a),
-        (l, a) => both(SL.concat(this.value)(l), a)
-      )
-  }
   inspect() {
     return this.toString()
   }
@@ -85,12 +68,6 @@ export class That<L, A>
   map<B>(f: (a: A) => B): These<L, B> {
     return new That(f(this.value))
   }
-  ap<B>(SL: Semigroup<L>, fab: These<L, (a: A) => B>): These<L, B> {
-    return fab.fold(() => fab as any, f => that(f(this.value)), (l, f) => both(l, f(this.value)))
-  }
-  chain<B>(SL: Semigroup<L>, f: (a: A) => These<L, B>): These<L, B> {
-    return f(this.value)
-  }
   bimap<M, B>(f: (l: L) => M, g: (a: A) => B): These<M, B> {
     return that(g(this.value))
   }
@@ -106,17 +83,6 @@ export class That<L, A>
   fold<B>(this_: (l: L) => B, that: (a: A) => B, both: (l: L, a: A) => B): B {
     return that(this.value)
   }
-  equals(setoidL: Setoid<L>, setoidA: Setoid<A>): (fy: These<L, A>) => boolean {
-    return fy => fy.fold(constFalse, a => setoidA.equals(a)(this.value), constFalse)
-  }
-  concat(SL: Semigroup<L>, SA: Semigroup<A>): (fy: These<L, A>) => These<L, A> {
-    return fy =>
-      fy.fold(
-        l => both(l, this.value),
-        a => that(SA.concat(this.value)(a)),
-        (l, a) => both(l, SA.concat(this.value)(a))
-      )
-  }
   inspect() {
     return this.toString()
   }
@@ -135,16 +101,6 @@ export class Both<L, A>
   map<B>(f: (a: A) => B): These<L, B> {
     return new Both(this.l, f(this.a))
   }
-  ap<B>(SL: Semigroup<L>, fab: These<L, (a: A) => B>): These<L, B> {
-    return fab.fold(() => fab as any, f => both(this.l, f(this.a)), (l, f) => both(SL.concat(l)(this.l), f(this.a)))
-  }
-  chain<B>(SL: Semigroup<L>, f: (a: A) => These<L, B>): These<L, B> {
-    return f(this.a).fold(
-      l => this_(SL.concat(this.l)(l)),
-      a => both(this.l, a),
-      (l, a) => both(SL.concat(this.l)(l), a)
-    )
-  }
   bimap<M, B>(f: (l: L) => M, g: (a: A) => B): These<M, B> {
     return both(f(this.l), g(this.a))
   }
@@ -160,17 +116,6 @@ export class Both<L, A>
   fold<B>(this_: (l: L) => B, that: (a: A) => B, both: (l: L, a: A) => B): B {
     return both(this.l, this.a)
   }
-  equals(setoidL: Setoid<L>, setoidA: Setoid<A>): (fy: These<L, A>) => boolean {
-    return fy => fy.fold(constFalse, constFalse, (l, a) => setoidL.equals(l)(this.l) && setoidA.equals(a)(this.a))
-  }
-  concat(SL: Semigroup<L>, SA: Semigroup<A>): (fy: These<L, A>) => These<L, A> {
-    return fy =>
-      fy.fold(
-        l => both(SL.concat(this.l)(l), this.a),
-        a => both(this.l, SA.concat(this.a)(a)),
-        (l, a) => both(SL.concat(this.l)(l), SA.concat(this.a)(a))
-      )
-  }
   inspect() {
     return this.toString()
   }
@@ -179,45 +124,55 @@ export class Both<L, A>
   }
 }
 
-export const equals = <L, A>(SL: Setoid<L>, SA: Setoid<A>) => (fx: These<L, A>) => (fy: These<L, A>): boolean =>
-  fx.equals(SL, SA)(fy)
+export const fold = <L, A, B>(this_: (l: L) => B, that: (a: A) => B, both: (l: L, a: A) => B) => (fa: These<L, A>): B =>
+  fa.fold(this_, that, both)
 
 export const getSetoid = <L, A>(SL: Setoid<L>, SA: Setoid<A>): Setoid<These<L, A>> => ({
-  equals: equals(SL, SA)
+  equals: x => y =>
+    x.fold(
+      lx => y.fold(ly => SL.equals(lx)(ly), constFalse, constFalse),
+      ax => y.fold(constFalse, ay => SA.equals(ax)(ay), constFalse),
+      (lx, ax) => y.fold(constFalse, constFalse, (ly, ay) => SL.equals(lx)(ly) && SA.equals(ax)(ay))
+    )
 })
 
-export const concat = <L, A>(SL: Semigroup<L>, SA: Semigroup<A>) => (fx: These<L, A>) => (
-  fy: These<L, A>
-): These<L, A> => fx.concat(SL, SA)(fy)
-
 export const getSemigroup = <L, A>(SL: Semigroup<L>, SA: Semigroup<A>): Semigroup<These<L, A>> => ({
-  concat: concat(SL, SA)
+  concat: x => y =>
+    x.fold(
+      lx => y.fold(ly => this_(SL.concat(lx)(ly)), ay => both(lx, ay), (ly, ay) => both(SL.concat(lx)(ly), ay)),
+      ax => y.fold(lx => both(lx, ax), ay => that(SA.concat(ax)(ay)), (ly, ay) => both(ly, SA.concat(ax)(ay))),
+      (lx, ax) =>
+        y.fold(
+          ly => both(SL.concat(lx)(ly), ax),
+          ay => both(lx, SA.concat(ax)(ay)),
+          (ly, ay) => both(SL.concat(lx)(ly), SA.concat(ax)(ay))
+        )
+    )
 })
 
-export const fold = <L, A, B>(this_: (l: L) => B, that: (a: A) => B, both: (l: L, a: A) => B, fa: These<L, A>): B =>
-  fa.fold(this_, that, both)
-
 export const map = <L, A, B>(f: (a: A) => B, fa: These<L, A>): These<L, B> => fa.map(f)
 
 export const of = <L, A>(a: A): These<L, A> => new That(a)
 
-/** deprecated */
-export const ap = <L, A, B>(SL: Semigroup<L>, fab: These<L, (a: A) => B>, fa: These<L, A>): These<L, B> =>
-  fa.ap(SL, fab)
+export const ap = <L>(S: Semigroup<L>) => <A, B>(fab: These<L, (a: A) => B>, fa: These<L, A>) =>
+  chain(S)(f => map(f, fa), fab)
 
-/** deprecated */
-export const chain = <L, A, B>(SL: Semigroup<L>, f: (a: A) => These<L, B>, fa: These<L, A>): These<L, B> =>
-  fa.chain(SL, f)
+export const chain = <L>(S: Semigroup<L>) => <A, B>(f: (a: A) => These<L, B>, fa: These<L, A>): These<L, B> =>
+  fa.fold(
+    () => fa as any,
+    a => f(a),
+    (l1, a) => f(a).fold(l2 => this_(S.concat(l1)(l2)), b => both(l1, b), (l2, b) => both(S.concat(l1)(l2), b))
+  )
 
-export const getMonad = <L>(SL: Semigroup<L>): Monad<URI> => ({
+export const getMonad = <L>(S: Semigroup<L>): Monad<URI> => ({
   URI,
   map,
   of,
-  ap: <A, B>(fab: These<L, (a: A) => B>, fa: These<L, A>) => fa.ap(SL, fab),
-  chain: <A, B>(f: (a: A) => These<L, B>, fa: These<L, A>) => fa.chain(SL, f)
+  ap: ap(S),
+  chain: chain(S)
 })
 
-export const bimap = <L, M, A, B>(f: (l: L) => M, g: (a: A) => B) => (fla: These<L, A>): These<M, B> => fla.bimap(f, g)
+export const bimap = <L, M, A, B>(f: (l: L) => M, g: (a: A) => B, fla: These<L, A>): These<M, B> => fla.bimap(f, g)
 
 export const reduce = <L, A, B>(f: (b: B, a: A) => B, b: B, fa: These<L, A>): B => fa.reduce(f, b)
 
@@ -228,7 +183,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKTAs<F, B>, ta: These<L, A>) => HKTAs<F, These<L, B>>
-  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: These<L, A>) => HKT<F, These<L, B>>
+  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, These<L, B>>
   traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: These<L, A>) => HKT<F, These<L, B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/Trace.ts b/src/Trace.ts
index c6a84b492..bd5561258 100644
--- a/src/Trace.ts
+++ b/src/Trace.ts
@@ -5,7 +5,8 @@ import { Monad } from './Monad'
 
 // Adapted from https://github.com/garyb/purescript-debug
 
-/** Log any value to the console for debugging purposes and then
+/**
+ * Log any value to the console for debugging purposes and then
  * return a value. This will log the value's underlying representation for
  * low-level debugging
  */
@@ -18,7 +19,8 @@ export const trace = <A>(message: any, out: Lazy<A>): A => {
 export const spy = <A>(a: A): A => trace(a, () => a)
 
 export class Ops {
-  /** Log a message to the console for debugging purposes and then return the
+  /**
+   * Log a message to the console for debugging purposes and then return the
    * unit value of the Applicative `F`
    */
   traceA<F extends HKT2S>(F: Applicative<F>): <L>(message: any) => HKT2As<F, L, void>
@@ -28,7 +30,8 @@ export class Ops {
     return x => trace(x, () => F.of(undefined))
   }
 
-  /** Log any value to the console and return it in `Monad`
+  /**
+   * Log any value to the console and return it in `Monad`
    * useful when one has monadic chains
    */
   traceM<F extends HKT2S>(F: Monad<F>): <L, A>(a: A) => HKT2As<F, L, A>
diff --git a/src/Traversable.ts b/src/Traversable.ts
index 05e9b8933..85a8d54cd 100644
--- a/src/Traversable.ts
+++ b/src/Traversable.ts
@@ -1,4 +1,4 @@
-import { HKT, HKTS, HKT2S, HKTAs, HKT2As } from './HKT'
+import { HKT, HKTS, HKT2S, HKTAs, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Functor, FantasyFunctor, FunctorComposition, getFunctorComposition } from './Functor'
 import { Foldable, FantasyFoldable, FoldableComposition, getFoldableComposition } from './Foldable'
 import { Applicative } from './Applicative'
@@ -29,6 +29,10 @@ export interface TraversableComposition11<F extends HKTS, G extends HKTS>
 }
 
 export class Ops {
+  sequence<F extends HKT3S, T extends HKTS>(
+    F: Applicative<F>,
+    T: Traversable<T>
+  ): <U, L, A>(tfa: HKTAs<T, HKT3As<F, U, L, A>>) => HKT3As<F, U, L, HKTAs<T, A>>
   sequence<F extends HKT2S, T extends HKTS>(
     F: Applicative<F>,
     T: Traversable<T>
diff --git a/src/Tuple.ts b/src/Tuple.ts
index 56aa56184..d66a6424f 100644
--- a/src/Tuple.ts
+++ b/src/Tuple.ts
@@ -11,12 +11,12 @@ import { Foldable, FantasyFoldable } from './Foldable'
 import { Applicative } from './Applicative'
 import { Traversable, FantasyTraversable } from './Traversable'
 import { Semigroupoid, FantasySemigroupoid } from './Semigroupoid'
-import { Cokleisli, toString } from './function'
+import { toString } from './function'
 import { ChainRec } from './ChainRec'
 import { Chain } from './Chain'
 import { Either, isLeft, Right, Left } from './Either'
 
-// https://github.com/purescript/purescript-tuples
+// Adapted from https://github.com/purescript/purescript-tuples
 
 declare module './HKT' {
   interface URI2HKT2<L, A> {
@@ -56,7 +56,7 @@ export class Tuple<L, A>
   extract(): A {
     return this.snd()
   }
-  extend<B>(f: Cokleisli<URI, A, B>): Tuple<L, B> {
+  extend<B>(f: (fa: Tuple<L, A>) => B): Tuple<L, B> {
     return new Tuple([this.fst(), f(this)])
   }
   reduce<B>(f: (c: B, b: A) => B, c: B): B {
@@ -79,18 +79,17 @@ export const fst = <L, A>(fa: Tuple<L, A>): L => fa.fst()
 /** Returns the second component of a tuple. */
 export const snd = <L, A>(fa: Tuple<L, A>): A => fa.snd()
 
-export const compose = <A, B>(bc: Tuple<A, B>) => <L>(fa: Tuple<L, A>): Tuple<L, B> => {
+export const compose = <L, A, B>(bc: Tuple<A, B>, fa: Tuple<L, A>): Tuple<L, B> => {
   return fa.compose(bc)
 }
 
 export const map = <L, A, B>(f: (b: A) => B, fa: Tuple<L, A>): Tuple<L, B> => fa.map(f)
 
-export const bimap = <L, A, M, B>(f: (l: L) => M, g: (a: A) => B): ((fla: Tuple<L, A>) => Tuple<M, B>) => fla =>
-  fla.bimap(f, g)
+export const bimap = <L, A, M, B>(f: (l: L) => M, g: (a: A) => B, fla: Tuple<L, A>): Tuple<M, B> => fla.bimap(f, g)
 
 export const extract = snd
 
-export const extend = <L, A, B>(f: Cokleisli<URI, A, B>, fa: Tuple<L, A>): Tuple<L, B> => fa.extend(f)
+export const extend = <L, A, B>(f: (fa: Tuple<L, A>) => B, fa: Tuple<L, A>): Tuple<L, B> => fa.extend(f)
 
 export const reduce = <L, A, B>(f: (c: B, b: A) => B, c: B, fa: Tuple<L, A>): B => fa.reduce(f, c)
 
@@ -106,60 +105,55 @@ export const getSetoid = <L, A>(SA: Setoid<L>, SB: Setoid<A>): Setoid<Tuple<L, A
  * To obtain the result, the `fst`s are `compare`d, and if they are `EQ`ual, the
  * `snd`s are `compare`d.
  */
-export const getOrd = <L, A>(OA: Ord<L>, OB: Ord<A>): Ord<Tuple<L, A>> =>
-  getOrdSemigroup<Tuple<L, A>>().concat(contramapOrd(fst, OA))(contramapOrd(snd, OB))
+export const getOrd = <L, A>(OL: Ord<L>, OA: Ord<A>): Ord<Tuple<L, A>> =>
+  getOrdSemigroup<Tuple<L, A>>().concat(contramapOrd(fst, OL))(contramapOrd(snd, OA))
 
-export const getSemigroup = <L, A>(SA: Semigroup<L>, SB: Semigroup<A>): Semigroup<Tuple<L, A>> => ({
+export const getSemigroup = <L, A>(SL: Semigroup<L>, SA: Semigroup<A>): Semigroup<Tuple<L, A>> => ({
   concat: x => y => {
     const [xa, xb] = x.value
     const [ya, yb] = y.value
-    return new Tuple([SA.concat(xa)(ya), SB.concat(xb)(yb)])
+    return new Tuple([SL.concat(xa)(ya), SA.concat(xb)(yb)])
   }
 })
 
-export const getMonoid = <L, A>(MA: Monoid<L>, MB: Monoid<A>): Monoid<Tuple<L, A>> => {
-  const empty = new Tuple([MA.empty(), MB.empty()])
+export const getMonoid = <L, A>(ML: Monoid<L>, MA: Monoid<A>): Monoid<Tuple<L, A>> => {
+  const empty = new Tuple([ML.empty(), MA.empty()])
   return {
-    ...getSemigroup(MA, MB),
+    ...getSemigroup(ML, MA),
     empty: () => empty
   }
 }
 
+export const ap = <L>(S: Semigroup<L>) => <A, B>(fab: Tuple<L, (b: A) => B>, fa: Tuple<L, A>): Tuple<L, B> =>
+  new Tuple([S.concat(fa.fst())(fab.fst()), fab.snd()(fa.snd())])
+
 export const getApply = <L>(S: Semigroup<L>): Apply<URI> => ({
   URI,
   map,
-  ap<A, B>(fab: Tuple<L, (b: A) => B>, fa: Tuple<L, A>): Tuple<L, B> {
-    return new Tuple([S.concat(fa.fst())(fab.fst()), fab.snd()(fa.snd())])
-  }
+  ap: ap(S)
 })
 
-export const getApplicative = <L>(monoidA: Monoid<L>): Applicative<URI> => {
-  const empty = monoidA.empty()
-  return {
-    ...getApply(monoidA),
-    of<A>(a: A): Tuple<L, A> {
-      return new Tuple([empty, a])
-    }
-  }
+export const of = <L>(M: Monoid<L>) => <A>(a: A): Tuple<L, A> => new Tuple([M.empty(), a])
+
+export const getApplicative = <L>(M: Monoid<L>): Applicative<URI> => ({
+  ...getApply(M),
+  of: of(M)
+})
+
+export const chain = <L>(M: Monoid<L>) => <A, B>(f: (b: A) => Tuple<L, B>, fa: Tuple<L, A>): Tuple<L, B> => {
+  const lb = f(fa.snd())
+  return new Tuple([M.concat(fa.fst())(lb.fst()), lb.snd()])
 }
 
 export const getChain = <L>(M: Monoid<L>): Chain<URI> => ({
   ...getApply(M),
-  chain<A, B>(f: (b: A) => Tuple<L, B>, fa: Tuple<L, A>): Tuple<L, B> {
-    const lb = f(fa.snd())
-    return new Tuple([M.concat(fa.fst())(lb.fst()), lb.snd()])
-  }
+  chain: chain(M)
 })
 
-export const getMonad = <L>(M: Monoid<L>): Monad<URI> => {
-  const empty = M.empty()
-  return {
-    ...getChain(M),
-    of<B>(b: B): Tuple<L, B> {
-      return new Tuple([empty, b])
-    }
-  }
-}
+export const getMonad = <L>(M: Monoid<L>): Monad<URI> => ({
+  ...getChain(M),
+  of: of(M)
+})
 
 export const chainRec = <L>(M: Monoid<L>) => <A, B>(f: (a: A) => Tuple<L, Either<A, B>>, a: A): Tuple<L, B> => {
   let result = f(a)
@@ -183,7 +177,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKTAs<F, B>, ta: Tuple<L, A>) => HKTAs<F, Tuple<L, B>>
-  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Tuple<L, A>) => HKT<F, Tuple<L, B>>
+  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Tuple<L, B>>
   traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Tuple<L, A>) => HKT<F, Tuple<L, B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
diff --git a/src/Unfoldable.ts b/src/Unfoldable.ts
index 6846a9a24..5a2e70964 100644
--- a/src/Unfoldable.ts
+++ b/src/Unfoldable.ts
@@ -1,4 +1,4 @@
-import { HKT } from './HKT'
+import { HKT, HKTS, HKTAs, HKT2S, HKT2As, HKT3S, HKT3As } from './HKT'
 import { Applicative } from './Applicative'
 import { Traversable } from './Traversable'
 import * as option from './Option'
@@ -21,14 +21,32 @@ export const replicate = <F>(unfoldable: Unfoldable<F>) => (n: number) => <A>(a:
   return unfoldable.unfoldr(step, n)
 }
 
-/** Perform an Applicative action `n` times, and accumulate all the results. */
-export const replicateA = <F, T>(
-  applicative: Applicative<F>,
-  unfoldableTraversable: Unfoldable<T> & Traversable<T>
-) => (n: number) => <A>(ma: HKT<F, A>): HKT<F, HKT<T, A>> =>
-  sequence(applicative, unfoldableTraversable)(replicate(unfoldableTraversable)(n)(ma))
-
 /** The container with no elements - unfolded with zero iterations. */
 export const none = <F, A>(unfoldable: Unfoldable<F>): HKT<F, A> => unfoldable.unfoldr(constant(option.none), undefined)
 
 export const singleton = <F>(unfoldable: Unfoldable<F>) => <A>(a: A): HKT<F, A> => replicate(unfoldable)(1)(a)
+
+export class Ops {
+  /** Perform an Applicative action `n` times, and accumulate all the results. */
+  replicateA<F extends HKT3S, T>(
+    applicative: Applicative<F>,
+    unfoldableTraversable: Unfoldable<T> & Traversable<T>
+  ): (n: number) => <U, L, A>(ma: HKT3As<F, U, L, A>) => HKT3As<F, U, L, HKT<T, A>>
+  replicateA<F extends HKT2S, T>(
+    applicative: Applicative<F>,
+    unfoldableTraversable: Unfoldable<T> & Traversable<T>
+  ): (n: number) => <L, A>(ma: HKT2As<F, L, A>) => HKT2As<F, L, HKT<T, A>>
+  replicateA<F extends HKTS, T>(
+    applicative: Applicative<F>,
+    unfoldableTraversable: Unfoldable<T> & Traversable<T>
+  ): (n: number) => <A>(ma: HKTAs<F, A>) => HKTAs<F, HKT<T, A>>
+  replicateA<F, T>(
+    applicative: Applicative<F>,
+    unfoldableTraversable: Unfoldable<T> & Traversable<T>
+  ): (n: number) => <A>(ma: HKT<F, A>) => HKT<F, HKT<T, A>> {
+    return n => ma => sequence(applicative, unfoldableTraversable)(replicate(unfoldableTraversable)(n)(ma))
+  }
+}
+
+const ops = new Ops()
+export const replicateA: Ops['replicateA'] = ops.replicateA
diff --git a/src/Validation.ts b/src/Validation.ts
index 2722124f7..d2aa05c09 100644
--- a/src/Validation.ts
+++ b/src/Validation.ts
@@ -10,7 +10,6 @@ import { Alt, FantasyAlt } from './Alt'
 import { constFalse, Predicate, toString } from './function'
 import { Option, some, none } from './Option'
 import { Either, left, right } from './Either'
-import * as nonEmptyArray from './NonEmptyArray'
 
 declare module './HKT' {
   interface URI2HKT2<L, A> {
@@ -80,10 +79,6 @@ export class Failure<L, A>
   toEither(): Either<L, A> {
     return left(this.value)
   }
-  /** Lift the Invalid value into a NonEmptyArray */
-  toValidationNea(): Option<Validation<nonEmptyArray.NonEmptyArray<L>, A>> {
-    return some(failure(nonEmptyArray)(nonEmptyArray.of(this.value)))
-  }
   inspect() {
     return this.toString()
   }
@@ -147,10 +142,6 @@ export class Success<L, A>
   toEither(): Either<L, A> {
     return right(this.value)
   }
-  /** Lift the Invalid value into a NonEmptyArray */
-  toValidationNea(): Option<Validation<nonEmptyArray.NonEmptyArray<L>, A>> {
-    return none
-  }
   inspect() {
     return this.toString()
   }
@@ -159,17 +150,14 @@ export class Success<L, A>
   }
 }
 
-export const equals = <L, A>(SL: Setoid<L>, SA: Setoid<A>) => (fx: Validation<L, A>) => (
-  fy: Validation<L, A>
-): boolean => fx.equals(SL, SA)(fy)
+export const fold = <L, A, B>(failure: (l: L) => B, success: (a: A) => B) => (fa: Validation<L, A>): B =>
+  fa.fold(failure, success)
 
 export const getSetoid = <L, A>(SL: Setoid<L>, SA: Setoid<A>): Setoid<Validation<L, A>> => ({
-  equals: equals(SL, SA)
+  equals: x => y =>
+    x.fold(lx => y.fold(ly => SL.equals(lx)(ly), constFalse), ax => y.fold(constFalse, ay => SA.equals(ax)(ay)))
 })
 
-export const fold = <L, A, B>(failure: (l: L) => B, success: (a: A) => B, fa: Validation<L, A>): B =>
-  fa.fold(failure, success)
-
 export const map = <L, A, B>(f: (a: A) => B, fa: Validation<L, A>): Validation<L, B> => fa.map(f)
 
 export const of = <L, A>(a: A): Validation<L, A> => new Success(a)
@@ -180,7 +168,7 @@ export const bimap = <M>(S: Semigroup<M>) => <L, A, B>(f: (l: L) => M, g: (a: A)
   fa: Validation<L, A>
 ): Validation<M, B> => fa.bimap(S)(f, g)
 
-export const alt = <L, A>(fx: Validation<L, A>) => (fy: Validation<L, A>): Validation<L, A> => fx.alt(fy)
+export const alt = <L, A>(fx: Validation<L, A>, fy: Validation<L, A>): Validation<L, A> => fx.alt(fy)
 
 export const reduce = <L, A, B>(f: (b: B, a: A) => B, b: B, fa: Validation<L, A>): B => fa.reduce(f, b)
 
@@ -191,7 +179,7 @@ export class Ops {
   traverse<F extends HKTS>(
     F: Applicative<F>
   ): <L, A, B>(f: (a: A) => HKTAs<F, B>, ta: Validation<L, A>) => HKTAs<F, Validation<L, B>>
-  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Validation<L, A>) => HKT<F, Validation<L, B>>
+  traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: HKT<URI, A>) => HKT<F, Validation<L, B>>
   traverse<F>(F: Applicative<F>): <L, A, B>(f: (a: A) => HKT<F, B>, ta: Validation<L, A>) => HKT<F, Validation<L, B>> {
     return (f, ta) => ta.traverse(F)(f)
   }
@@ -228,9 +216,6 @@ export const toOption = <L, A>(fa: Validation<L, A>): Option<A> => fa.toOption()
 
 export const toEither = <L, A>(fa: Validation<L, A>): Either<L, A> => fa.toEither()
 
-export const toValidationNea = <L, A>(fa: Validation<L, A>): Option<Validation<nonEmptyArray.NonEmptyArray<L>, A>> =>
-  fa.toValidationNea()
-
 export const validation: Semigroup<Validation<any, any>> &
   Functor<URI> &
   Applicative<URI> &
diff --git a/src/Witherable.ts b/src/Witherable.ts
deleted file mode 100644
index 7f5bdf967..000000000
--- a/src/Witherable.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { HKT, HKTS, HKTAs } from './HKT'
-import { Traversable, FantasyTraversable } from './Traversable'
-import { Filterable, FantasyFilterable } from './Filterable'
-import { Applicative } from './Applicative'
-import { Either, left, right } from './Either'
-import { Option } from './Option'
-
-export type Wilt<T, L, R> = {
-  left: HKT<T, L>
-  right: HKT<T, R>
-}
-
-export type Wilt1<T extends HKTS, L, R> = {
-  left: HKTAs<T, L>
-  right: HKTAs<T, R>
-}
-
-export interface Witherable<T> extends Traversable<T>, Filterable<T> {
-  wilt: <F>(F: Applicative<F>) => <A, L, R>(f: (a: A) => HKT<F, Either<L, R>>, ta: HKT<T, A>) => HKT<F, Wilt<T, L, R>>
-}
-
-export interface FantasyWitherable<T, A> extends FantasyTraversable<T, A>, FantasyFilterable<T, A> {
-  wilt: <F>(F: Applicative<F>) => <L, R>(f: (a: A) => HKT<F, Either<L, R>>) => HKT<F, Wilt<T, L, R>>
-}
-
-export class Ops {
-  /**  A default implementation of `wither` using `wilt` */
-  wither<F extends HKTS, T extends HKTS>(
-    F: Applicative<F>,
-    T: Witherable<T>
-  ): <A, B>(f: (a: A) => HKT<F, Option<B>>, ta: HKT<T, A>) => HKTAs<F, HKTAs<T, B>>
-  wither<F, T>(
-    F: Applicative<F>,
-    T: Witherable<T>
-  ): <A, B>(f: (a: A) => HKT<F, Option<B>>, ta: HKT<T, A>) => HKT<F, HKT<T, B>>
-  wither<F, T>(
-    F: Applicative<F>,
-    T: Witherable<T>
-  ): <A, B>(f: (a: A) => HKT<F, Option<B>>, ta: HKT<T, A>) => HKT<F, HKT<T, B>> {
-    return <A, B>(f: (a: A) => HKT<F, Option<B>>, ta: HKT<T, A>): HKT<F, HKT<T, B>> => {
-      const mb: HKT<F, Wilt<T, null, B>> = T.wilt(F)(
-        a => F.map(ob => ob.fold(() => left(null), b => right(b)), f(a)),
-        ta
-      )
-      return F.map(w => w.right, mb)
-    }
-  }
-
-  /** Partition between `Left` and `Right` values - with effects in `m` */
-  wilted<F extends HKTS, T extends HKTS>(
-    F: Applicative<F>,
-    T: Witherable<T>
-  ): <L, R>(tm: HKT<T, HKT<F, Either<L, R>>>) => HKTAs<F, Wilt1<T, L, R>>
-  wilted<F, T>(F: Applicative<F>, T: Witherable<T>): <L, R>(tm: HKT<T, HKT<F, Either<L, R>>>) => HKT<F, Wilt<T, L, R>>
-  wilted<F, T>(F: Applicative<F>, T: Witherable<T>): <L, R>(tm: HKT<T, HKT<F, Either<L, R>>>) => HKT<F, Wilt<T, L, R>> {
-    return tm => T.wilt(F)(me => me, tm)
-  }
-
-  /** Filter out all the `Nothing` values - with effects in `m` */
-  withered<F extends HKTS, T extends HKTS>(
-    F: Applicative<F>,
-    T: Witherable<T>
-  ): <A>(tm: HKT<T, HKT<F, Option<A>>>) => HKTAs<F, HKTAs<T, A>>
-  withered<F, T>(F: Applicative<F>, T: Witherable<T>): <A>(tm: HKT<T, HKT<F, Option<A>>>) => HKT<F, HKT<T, A>>
-  withered<F, T>(F: Applicative<F>, T: Witherable<T>): <A>(tm: HKT<T, HKT<F, Option<A>>>) => HKT<F, HKT<T, A>> {
-    return tm => this.wither(F, T)(moa => moa, tm)
-  }
-}
-
-const ops = new Ops()
-export const wither: Ops['wither'] = ops.wither
-export const wilted: Ops['wilted'] = ops.wilted
-export const withered: Ops['withered'] = ops.withered
diff --git a/src/function.ts b/src/function.ts
index 76b3a643b..3f315d2b6 100644
--- a/src/function.ts
+++ b/src/function.ts
@@ -31,12 +31,10 @@ export type Refinement<A, B extends A> = (a: A) => a is B
 
 export const not = <A>(predicate: Predicate<A>): Predicate<A> => a => !predicate(a)
 
-export function or<A, B1 extends A>(
-  p1: Refinement<A, B1>
-): <B2 extends A>(p2: Refinement<A, B2>) => Refinement<A, B1 | B2>
-export function or<A>(p1: Predicate<A>): (p2: Predicate<A>) => Predicate<A>
-export function or<A>(p1: Predicate<A>): (p2: Predicate<A>) => Predicate<A> {
-  return p2 => a => p1(a) || p2(a)
+export function or<A, B1 extends A, B2 extends A>(p1: Refinement<A, B1>, p2: Refinement<A, B2>): Refinement<A, B1 | B2>
+export function or<A>(p1: Predicate<A>, p2: Predicate<A>): Predicate<A>
+export function or<A>(p1: Predicate<A>, p2: Predicate<A>): Predicate<A> {
+  return a => p1(a) || p2(a)
 }
 
 export const and = <A>(p1: Predicate<A>, p2: Predicate<A>): Predicate<A> => a => p1(a) && p2(a)
diff --git a/src/index.ts b/src/index.ts
index 57049e7f7..6e22bb7dd 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -34,8 +34,6 @@ import * as extend from './Extend'
 export { extend }
 import * as field from './Field'
 export { field }
-import * as filterable from './Filterable'
-export { filterable }
 import * as foldable from './Foldable'
 export { foldable }
 import * as free from './Free'
@@ -118,7 +116,5 @@ import * as unfoldable from './Unfoldable'
 export { unfoldable }
 import * as validation from './Validation'
 export { validation }
-import * as witherable from './Witherable'
-export { witherable }
 import * as writer from './Writer'
 export { writer }
diff --git a/test/Applicative.ts b/test/Applicative.ts
index db0ebd969..cdea156d1 100644
--- a/test/Applicative.ts
+++ b/test/Applicative.ts
@@ -18,8 +18,8 @@ describe('Applicative', () => {
 
     const somefailure = [
       validation.success<string, number>(1),
-      validation.failure(monoidString)('[fail 1]'),
-      validation.failure(monoidString)('[fail 2]')
+      validation.failure(monoidString)<number>('[fail 1]'),
+      validation.failure(monoidString)<number>('[fail 2]')
     ].map(a => new taskValidation.TaskValidation(task.of(a)))
 
     const p1 = sequence(taskValidation, array)(allsuccess).value.run()
@@ -44,9 +44,9 @@ describe('Applicative', () => {
     const action = new io.IO(() => {
       log.push('action called')
     })
-    when(io)(false)(action).run()
+    when(io)(false, action).run()
     assert.deepEqual(log, [])
-    when(io)(true)(action).run()
+    when(io)(true, action).run()
     assert.deepEqual(log, ['action called'])
   })
 })
diff --git a/test/Apply.ts b/test/Apply.ts
index e9853d878..7156d751c 100644
--- a/test/Apply.ts
+++ b/test/Apply.ts
@@ -4,15 +4,20 @@ import * as either from '../src/Either'
 import { eqOptions, eqEithers } from './helpers'
 
 describe('Apply', () => {
+  const r1 = either.right<string, number>(1)
+  const r2 = either.right<string, number>(2)
+  const foo = either.left<string, number>('foo')
+  const bar = either.left<string, number>('bar')
+
   it('applyFirst', () => {
     eqOptions(applyFirst(option)(option.some(5))(option.some(6)), option.some(5))
     eqOptions(applyFirst(option)(option.some(5))(option.empty()), option.empty())
     eqOptions(applyFirst(option)(option.empty())(option.some(6)), option.empty())
 
-    eqEithers(applyFirst(either)(either.right(1))(either.right(2)), either.right(1))
-    eqEithers(applyFirst(either)(either.left(3))(either.right(4)), either.left(3))
-    eqEithers(applyFirst(either)(either.right(5))(either.left(6)), either.left(6))
-    eqEithers(applyFirst(either)(either.left(7))(either.left(8)), either.left(7))
+    eqEithers(applyFirst(either)(r1)(r2), r1)
+    eqEithers(applyFirst(either)(foo)(r1), foo)
+    eqEithers(applyFirst(either)(r1)(foo), foo)
+    eqEithers(applyFirst(either)(foo)(bar), foo)
   })
 
   it('applySecond', () => {
@@ -20,22 +25,22 @@ describe('Apply', () => {
     eqOptions(applySecond(option)(option.some(5))(option.empty()), option.empty())
     eqOptions(applySecond(option)(option.empty())(option.some(6)), option.empty())
 
-    eqEithers(applySecond(either)(either.right(1))(either.right(2)), either.right(2))
-    eqEithers(applySecond(either)(either.left(3))(either.right(4)), either.left(3))
-    eqEithers(applySecond(either)(either.right(5))(either.left(6)), either.left(6))
-    eqEithers(applySecond(either)(either.left(7))(either.left(8)), either.left(7))
+    eqEithers(applySecond(either)(r1)(r2), r2)
+    eqEithers(applySecond(either)(foo)(r1), foo)
+    eqEithers(applySecond(either)(r1)(foo), foo)
+    eqEithers(applySecond(either)(foo)(bar), foo)
   })
 
   it('liftA2', () => {
     const f = (a: number) => (b: number) => a + b
     eqOptions(liftA2(option)(f)(option.some(2))(option.some(3)), option.some(5))
-    eqEithers(liftA2(either)(f)(either.right(2))(either.right(3)), either.right(5))
+    eqEithers(liftA2(either)(f)(r2)(either.right(3)), either.right(5))
   })
 
   it('liftA3', () => {
     const f = (a: number) => (b: number) => (c: number) => a + b + c
     eqOptions(liftA3(option)(f)(option.some(2))(option.some(3))(option.some(4)), option.some(9))
-    eqEithers(liftA3(either)(f)(either.right(2))(either.right(3))(either.right(4)), either.right(9))
+    eqEithers(liftA3(either)(f)(r2)(either.right(3))(either.right(4)), either.right(9))
   })
 
   it('liftA4', () => {
@@ -43,7 +48,7 @@ describe('Apply', () => {
     const optionf = liftA4(option)(f)
     eqOptions(optionf(option.some(2))(option.some(3))(option.some(4))(option.some(5)), option.some(14))
     const eitherf = liftA4(either)(f)
-    eqEithers(eitherf(either.right(2))(either.right(3))(either.right(4))(either.right(5)), either.right(14))
+    eqEithers(eitherf(r2)(either.right(3))(either.right(4))(either.right(5)), either.right(14))
   })
 
   it('ap_', () => {
diff --git a/test/Contravariant.ts b/test/Contravariant.ts
index 3c97e9c7f..65080a222 100644
--- a/test/Contravariant.ts
+++ b/test/Contravariant.ts
@@ -17,7 +17,7 @@ class Predicate<A> {
   constructor(public readonly run: (a: A) => boolean) {}
 }
 
-const contramap = <A>(fa: Predicate<A>) => <B>(f: (b: B) => A): Predicate<B> => new Predicate(b => fa.run(f(b)))
+const contramap = <A, B>(f: (b: B) => A, fa: Predicate<A>): Predicate<B> => new Predicate(b => fa.run(f(b)))
 
 const predicate: Contravariant<URI> = {
   URI,
diff --git a/test/Either.ts b/test/Either.ts
index 32775dac9..8c8da9a11 100644
--- a/test/Either.ts
+++ b/test/Either.ts
@@ -11,9 +11,9 @@ import {
   fromPredicate,
   tryCatch,
   fromOption,
-  bimap,
   fromNullable,
-  equals
+  bimap,
+  getSetoid
 } from '../src/Either'
 import { eqEithers as eq } from './helpers'
 import { none, some } from '../src/Option'
@@ -23,8 +23,8 @@ describe('Either', () => {
   it('fold', () => {
     const f = (s: string) => `left${s.length}`
     const g = (s: string) => `right${s.length}`
-    assert.strictEqual(fold(f, g, left('abc')), 'left3')
-    assert.strictEqual(fold(f, g, right('abc')), 'right3')
+    assert.strictEqual(fold(f, g)(left('abc')), 'left3')
+    assert.strictEqual(fold(f, g)(right('abc')), 'right3')
   })
 
   it('map', () => {
@@ -36,21 +36,21 @@ describe('Either', () => {
   it('bimap', () => {
     const f = (s: string): number => s.length
     const g = (n: number): boolean => n > 2
-    eq(bimap(f, g)(right(1)), right(false))
+    eq(bimap(f, g, right(1)), right(false))
   })
 
   it('ap', () => {
     const f = (s: string): number => s.length
-    eq(ap(right(f), right('abc')), right(3))
-    eq(ap(right(f), left('s')), left('s'))
-    eq(ap(left<any, any>(f), right('abc')), left(f))
-    eq(ap(left<any, any>(f), left('abc')), left(f))
+    eq(ap(right<string, (s: string) => number>(f), right<string, string>('abc')), right(3))
+    eq(ap(right<string, (s: string) => number>(f), left<string, string>('a')), left<string, number>('a'))
+    eq(ap(left<string, (s: string) => number>('a'), right<string, string>('abc')), left<string, number>('a'))
+    eq(ap(left<string, (s: string) => number>('a'), left<string, string>('b')), left<string, number>('a'))
   })
 
   it('chain', () => {
-    const f = (s: string) => right(s.length)
-    eq(chain(f, right('abc')), right(3))
-    eq(chain(f, left('s')), left('s'))
+    const f = (s: string) => right<string, number>(s.length)
+    eq(chain(f, right<string, string>('abc')), right(3))
+    eq(chain(f, left<string, string>('a')), left('a'))
   })
 
   it('fromPredicate', () => {
@@ -69,12 +69,12 @@ describe('Either', () => {
     const e2 = tryCatch(() => {
       return JSON.parse(``)
     })
-    eq(e2, left({}))
+    eq(e2, left<Error, any>(new Error()))
   })
 
   it('getOrElse', () => {
-    assert.equal(getOrElse(() => 17)(right(12)), 12)
-    assert.equal(getOrElse(() => 17)(left(12)), 17)
+    assert.equal(getOrElse((l: number) => 17)(right(12)), 12)
+    assert.equal(getOrElse((l: number) => 17)(left(12)), 17)
     assert.equal(getOrElse((l: number) => l + 1)(left(12)), 13)
   })
 
@@ -95,7 +95,7 @@ describe('Either', () => {
   })
 
   it('equals', () => {
-    const eq = equals(setoidString, setoidNumber)
+    const eq = getSetoid(setoidString, setoidNumber).equals
     assert.strictEqual(eq(right(1))(right(1)), true)
     assert.strictEqual(eq(right(1))(right(2)), false)
     assert.strictEqual(eq(left('foo'))(left('foo')), true)
diff --git a/test/Filterable.ts b/test/Filterable.ts
deleted file mode 100644
index edbbde6fe..000000000
--- a/test/Filterable.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import * as assert from 'assert'
-import * as filterable from '../src/Filterable'
-import * as array from '../src/Array'
-import * as either from '../src/Either'
-import * as option from '../src/Option'
-
-describe('Filterable', () => {
-  it('partitionMap', () => {
-    const isEven = (n: number) => n % 2 === 0
-    const { left, right } = array.partitionMap(
-      (a: string): either.Either<number, string> => (isEven(a.length) ? either.right(a) : either.left(a.length)),
-      ['a', 'bb', 'ccc']
-    )
-    assert.deepEqual(left, [1, 3])
-    assert.deepEqual(right, ['bb'])
-  })
-
-  it('partition', () => {
-    const isEven = (n: number) => n % 2 === 0
-    const { no, yes } = filterable.partition(array)(isEven)([1, 2, 3])
-    assert.deepEqual(no, [1, 3])
-    assert.deepEqual(yes, [2])
-  })
-
-  it('filterMap', () => {
-    const xs = filterable.filterMap(array)((s: string) => (s.length >= 2 ? option.some(s.length) : option.none))([
-      'a',
-      'bb',
-      'ccc'
-    ])
-    assert.deepEqual(xs, [2, 3])
-  })
-
-  it('filter', () => {
-    const isEven = (n: number) => n % 2 === 0
-    const xs = filterable.filter(array)(isEven)([1, 2, 3])
-    assert.deepEqual(xs, [2])
-  })
-
-  it('partitioned', () => {
-    const { left, right } = filterable.partitioned(array)([
-      either.left<string, number>('a'),
-      either.right<string, number>(1)
-    ])
-    assert.deepEqual(left, ['a'])
-    assert.deepEqual(right, [1])
-  })
-
-  it('filtered', () => {
-    const xs = filterable.filtered(array)([option.some(1), option.none] as Array<option.Option<number>>)
-    assert.deepEqual(xs, [1])
-  })
-})
diff --git a/test/Monoidal.ts b/test/Monoidal.ts
index 15f4c6fa1..c31c9ab32 100644
--- a/test/Monoidal.ts
+++ b/test/Monoidal.ts
@@ -6,11 +6,11 @@ import * as either from '../src/Either'
 describe('Monoidal', () => {
   it('fromApplicative', () => {
     const monoidalOption = fromApplicative(option)
-    assert.deepEqual(monoidalOption.mult(option.some(1))(option.some('a')), option.some([1, 'a']))
-    assert.deepEqual(monoidalOption.mult(option.some(1))(option.none), option.none)
+    assert.deepEqual(monoidalOption.mult(option.some(1), option.some('a')), option.some([1, 'a']))
+    assert.deepEqual(monoidalOption.mult(option.some(1), option.none), option.none)
     const monoidalEither = fromApplicative(either)
-    assert.deepEqual(monoidalEither.mult(either.right(1))(either.right('a')), either.right([1, 'a']))
-    assert.deepEqual(monoidalEither.mult(either.right(1))(either.left('error')), either.left('error'))
+    assert.deepEqual(monoidalEither.mult(either.right(1), either.right('a')), either.right([1, 'a']))
+    assert.deepEqual(monoidalEither.mult(either.right(1), either.left('error')), either.left('error'))
   })
 
   it('toApplicative', () => {
diff --git a/test/Option.ts b/test/Option.ts
index 2ac5ace76..586076c32 100644
--- a/test/Option.ts
+++ b/test/Option.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert'
 import {
-  equals,
+  getSetoid,
   fold,
   none,
   map,
@@ -23,8 +23,8 @@ describe('Option', () => {
   it('fold', () => {
     const f = () => 'none'
     const g = (s: string) => `some${s.length}`
-    assert.strictEqual(fold(f, g, none), 'none')
-    assert.strictEqual(fold(f, g, some('abc')), 'some3')
+    assert.strictEqual(fold(f, g)(none), 'none')
+    assert.strictEqual(fold(f, g)(some('abc')), 'some3')
   })
 
   it('getOrElse', () => {
@@ -42,11 +42,11 @@ describe('Option', () => {
   })
 
   it('equals', () => {
-    const eq = equals(setoidNumber)
-    assert.strictEqual(eq(none)(none), true)
-    assert.strictEqual(eq(none)(some(1)), false)
-    assert.strictEqual(eq(some(2))(some(1)), false)
-    assert.strictEqual(eq(some(2))(some(2)), true)
+    const { equals } = getSetoid(setoidNumber)
+    assert.strictEqual(equals(none)(none), true)
+    assert.strictEqual(equals(none)(some(1)), false)
+    assert.strictEqual(equals(some(2))(some(1)), false)
+    assert.strictEqual(equals(some(2))(some(2)), true)
   })
 
   it('map', () => {
@@ -98,10 +98,10 @@ describe('Option', () => {
   })
 
   it('alt', () => {
-    eq(alt(some(1))(some(2)), some(1))
-    eq(alt(none)(some(2)), some(2))
-    eq(alt(some(1))(none), some(1))
-    eq(alt(none)(none), none)
+    eq(alt(some(1), some(2)), some(1))
+    eq(alt(none, some(2)), some(2))
+    eq(alt(some(1), none), some(1))
+    eq(alt(none, none), none)
   })
 
   it('fromNullable', () => {
diff --git a/test/These.ts b/test/These.ts
index 5b83d3b6f..42af068d7 100644
--- a/test/These.ts
+++ b/test/These.ts
@@ -1,55 +1,34 @@
 import * as assert from 'assert'
-import { this_, that, both, fromThese, bimap } from '../src/These'
+import { this_, that, both, fromThese, bimap, getSetoid, getSemigroup } from '../src/These'
 import { setoidNumber, setoidString } from '../src/Setoid'
 import { monoidSum, monoidString } from '../src/Monoid'
 
 describe('These', () => {
   it('equals', () => {
-    assert.strictEqual(this_(2).equals(setoidNumber, setoidNumber)(this_(2)), true)
-    assert.strictEqual(this_(2).equals(setoidNumber, setoidNumber)(this_(3)), false)
+    const { equals } = getSetoid(setoidNumber, setoidNumber)
+    assert.strictEqual(equals(this_(2))(this_(2)), true)
+    assert.strictEqual(equals(this_(2))(this_(3)), false)
   })
 
   it('concat', () => {
-    assert.strictEqual(
-      this_('a').concat(monoidString, monoidSum)(this_('b')).equals(setoidString, setoidNumber)(
-        this_<string, number>('ab')
-      ),
-      true
-    )
-    assert.strictEqual(
-      this_('a').concat(monoidString, monoidSum)(that<string, number>(2)).equals(setoidString, setoidNumber)(
-        both<string, number>('a', 2)
-      ),
-      true
-    )
+    const { equals } = getSetoid(setoidString, setoidNumber)
+    const { concat } = getSemigroup(monoidString, monoidSum)
+    assert.strictEqual(equals(concat(this_('a'))(this_('b')))(this_('ab')), true)
+    assert.strictEqual(equals(concat(this_('a'))(that(2)))(both('a', 2)), true)
   })
 
   it('map', () => {
+    const { equals } = getSetoid(setoidNumber, setoidNumber)
     const double = (n: number) => n * 2
-    assert.strictEqual(
-      this_(2)
-        .map(double)
-        .equals(setoidNumber, setoidNumber)(this_<number, number>(2)),
-      true
-    )
-    assert.strictEqual(
-      that(2)
-        .map(double)
-        .equals(setoidNumber, setoidNumber)(that<number, number>(4)),
-      true
-    )
-    assert.strictEqual(
-      both(1, 2)
-        .map(double)
-        .equals(setoidNumber, setoidNumber)(both<number, number>(1, 4)),
-      true
-    )
+    assert.strictEqual(equals(this_<number, number>(2).map(double))(this_(2)), true)
+    assert.strictEqual(equals(that<number, number>(2).map(double))(that(4)), true)
+    assert.strictEqual(equals(both(1, 2).map(double))(both(1, 4)), true)
   })
 
   it('bimap', () => {
     const len = (s: string): number => s.length
     const double = (n: number): number => n * 2
-    assert.deepEqual(bimap(len, double)(both('foo', 1)), both(3, 2))
+    assert.deepEqual(bimap(len, double, both('foo', 1)), both(3, 2))
   })
 
   it('fromThese', () => {
@@ -60,19 +39,10 @@ describe('These', () => {
   })
 
   it('bimap', () => {
+    const { equals } = getSetoid(setoidNumber, setoidNumber)
     const double = (n: number) => n * 2
     const len = (s: string) => s.length
-    assert.strictEqual(
-      this_('a')
-        .bimap(len, double)
-        .equals(setoidNumber, setoidNumber)(this_<number, number>(1)),
-      true
-    )
-    assert.strictEqual(
-      that(2)
-        .bimap(len, double)
-        .equals(setoidNumber, setoidNumber)(that<number, number>(4)),
-      true
-    )
+    assert.strictEqual(equals(this_<string, number>('a').bimap(len, double))(this_(1)), true)
+    assert.strictEqual(equals(that<string, number>(2).bimap(len, double))(that(4)), true)
   })
 })
diff --git a/test/Tuple.ts b/test/Tuple.ts
index c74162c0d..228ca7552 100644
--- a/test/Tuple.ts
+++ b/test/Tuple.ts
@@ -7,7 +7,7 @@ import { sort } from '../src/Array'
 
 describe('Tuple', () => {
   it('compose', () => {
-    assert.deepEqual(compose(new Tuple([1, 's']))(new Tuple([true, 2])), new Tuple([true, 's']))
+    assert.deepEqual(compose(new Tuple([1, 's']), new Tuple([true, 2])), new Tuple([true, 's']))
   })
 
   it('map', () => {
@@ -18,7 +18,7 @@ describe('Tuple', () => {
   it('bimap', () => {
     const double = (n: number): number => n * 2
     const len = (s: string): number => s.length
-    assert.deepEqual(bimap(len, double)(new Tuple(['s', 1])), new Tuple([1, 2]))
+    assert.deepEqual(bimap(len, double, new Tuple(['s', 1])), new Tuple([1, 2]))
   })
 
   it('getSemigroup', () => {
diff --git a/test/Unfoldable.ts b/test/Unfoldable.ts
index 9a2a80d1a..22b0c4a74 100644
--- a/test/Unfoldable.ts
+++ b/test/Unfoldable.ts
@@ -1,16 +1,16 @@
-// import * as assert from 'assert'
+import * as assert from 'assert'
 
-// import { replicate, replicateA } from '../src/Unfoldable'
-// import * as array from '../src/Array'
-// import * as option from '../src/Option'
-// import { eqOptions as eq } from './helpers'
+import { replicate, replicateA } from '../src/Unfoldable'
+import * as array from '../src/Array'
+import * as option from '../src/Option'
+import { eqOptions as eq } from './helpers'
 
-// describe('Unfoldable', () => {
-//   it('replicate', () => {
-//     assert.deepEqual(replicate(array)(2, 's'), ['s', 's'])
-//   })
+describe('Unfoldable', () => {
+  it('replicate', () => {
+    assert.deepEqual(replicate(array)(2)('s'), ['s', 's'])
+  })
 
-//   it('replicateA', () => {
-//     eq(replicateA(option, array)(2, option.some(1)), option.some([1, 1]))
-//   })
-// })
+  it('replicateA', () => {
+    eq(replicateA(option, array)(2)(option.some(1)), option.some([1, 1]))
+  })
+})
diff --git a/test/Validation.ts b/test/Validation.ts
index a12b460a7..aa3a43751 100644
--- a/test/Validation.ts
+++ b/test/Validation.ts
@@ -45,7 +45,7 @@ describe('Validation', () => {
 
   it('equals', () => {
     const failure = validation.failure(monoidString)
-    const eq = validation.equals(setoidString, setoidNumber)
+    const eq = validation.getSetoid(setoidString, setoidNumber).equals
     assert.strictEqual(eq(validation.success(1))(validation.success(1)), true)
     assert.strictEqual(eq(validation.success(1))(validation.success(2)), false)
     assert.strictEqual(eq(failure('foo'))(failure('foo')), true)
diff --git a/test/Witherable.ts b/test/Witherable.ts
deleted file mode 100644
index 6d071321d..000000000
--- a/test/Witherable.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import * as assert from 'assert'
-import * as witherable from '../src/Witherable'
-import * as array from '../src/Array'
-import * as option from '../src/Option'
-import * as identity from '../src/Identity'
-
-describe('Witherable', () => {
-  it('Array/wither', () => {
-    const f = (n: number): identity.Identity<option.Option<number>> =>
-      n > 5 ? identity.of(option.some(n * 10)) : identity.of(option.none)
-    assert.deepEqual(witherable.wither(identity, array)(f, [1, 2, 3]).value, [])
-    assert.deepEqual(witherable.wither(identity, array)(f, [1, 2, 6]).value, [60])
-  })
-
-  it('Option/wither', () => {
-    const f = (n: number): identity.Identity<option.Option<number>> =>
-      n > 5 ? identity.of(option.some(n * 10)) : identity.of(option.none)
-    assert.deepEqual(witherable.wither(identity, option)(f, option.some(6)).value, option.some(60))
-    assert.deepEqual(witherable.wither(identity, option)(f, option.some(5)).value, option.none)
-    assert.deepEqual(witherable.wither(identity, option)(f, option.none).value, option.none)
-  })
-
-  it('withered', () => {
-    assert.deepEqual(
-      witherable.withered(identity, array)<number>([identity.of(option.none), identity.of(option.some(1))]).value,
-      [1]
-    )
-  })
-})
diff --git a/test/function.ts b/test/function.ts
index cc2d15892..28e86c0eb 100644
--- a/test/function.ts
+++ b/test/function.ts
@@ -53,7 +53,7 @@ describe('function', () => {
     // as predicate
     const gt3 = (n: number) => n > 3
     const lt2 = (n: number) => n < 2
-    const outside2and3 = or(lt2)(gt3)
+    const outside2and3 = or(lt2, gt3)
     assert.strictEqual(outside2and3(1), true)
     assert.strictEqual(outside2and3(4), true)
     assert.strictEqual(outside2and3(2.5), false)
@@ -68,7 +68,7 @@ describe('function', () => {
     }
     const isB = (a: A): a is B => a instanceof B
     const isC = (a: A): a is C => a instanceof C
-    const isBOrC = or(isB)(isC)
+    const isBOrC = or(isB, isC)
     function f(a: any): 'B' | 'C' | 'else' {
       if (isBOrC(a)) {
         return a._tag