diff --git a/lib/agent.spec.ts b/lib/agent.spec.ts
index a841bc8..6cd5d74 100644
--- a/lib/agent.spec.ts
+++ b/lib/agent.spec.ts
@@ -76,12 +76,15 @@ describe('Agent', () => {
 								// side, to produce multiple values while the computation is performed
 								// The sync side just tells us that the effect of the computation is that
 								// the counter reaches the target
-								IO(async function* () {
-									while (s < target) {
-										yield ++s;
-										await setTimeout(10);
-									}
-								}, target),
+								IO(
+									async function* () {
+										while (s < target) {
+											yield ++s;
+											await setTimeout(10);
+										}
+									},
+									() => target,
+								),
 						),
 					),
 			});
diff --git a/lib/effects.spec.ts b/lib/effects.spec.ts
index a6f185c..e69de29 100644
--- a/lib/effects.spec.ts
+++ b/lib/effects.spec.ts
@@ -1,112 +0,0 @@
-import { expect } from '~/test-utils';
-import { Effect, doPipe, map, when, of, bindIO } from './effects';
-
-import { stub } from 'sinon';
-
-describe('Effects API', () => {
-	describe('Effect', () => {
-		it('allows chaining calculations', () => {
-			const effect = Effect.of(0).map((x) => x + 1);
-			expect(effect()).to.equal(1);
-		});
-
-		it('allows a sync and async executions', async () => {
-			const effect = Effect.of(0)
-				.map((x) => x + 1)
-				.flatMap((x) =>
-					Effect.from(
-						async () => x + 2,
-						() => x + 1,
-					),
-				)
-				.flatMap((x) =>
-					Effect.from(
-						async () => x + 1,
-						() => x + 1,
-					),
-				);
-			expect(effect()).to.equal(3);
-			expect(await effect).to.equal(4);
-		});
-
-		it('propagates errors in a promise', async () => {
-			const effect = Effect.of(0)
-				.map((x) => x + 1)
-				.flatMap((x) =>
-					Effect.from(
-						async () => {
-							if (x < 2) {
-								throw new Error('x is too small');
-							}
-							// This will never be reached
-							return x + 2;
-						},
-						() => x + 1,
-					),
-				)
-				.flatMap((x) =>
-					Effect.from(
-						async () => x + 1,
-						() => x + 1,
-					),
-				);
-			expect(effect()).to.equal(3);
-			await expect(effect).to.be.rejected;
-		});
-	});
-
-	describe('pipe', () => {
-		it('allows piping effects', async () => {
-			const effectFn = () =>
-				doPipe(
-					0,
-					map((x) => x + 1),
-					bindIO(
-						async (x) => x + 2,
-						(x) => x + 1,
-					),
-					map((x) => x + 1),
-					when((x) => x < 2, of),
-				);
-			expect(effectFn()()).to.equal(3);
-			expect(await effectFn()).to.equal(4);
-		});
-	});
-
-	describe('Observables', () => {
-		it('allows using an async generator as IO', async () => {
-			const effect = doPipe(
-				0,
-				map((x) => x + 1),
-				bindIO(
-					async function* (x) {
-						yield x + 1;
-						yield x + 2;
-					},
-					(x) => x + 1,
-				),
-				map((x) => x + 1),
-			);
-			const next = stub();
-
-			// Create a new promise to wait for the effect to
-			// finish
-			const promise = new Promise<void>((resolve, reject) => {
-				const subscriber = effect.subscribe({
-					next,
-					error: reject,
-					complete: () => {
-						resolve();
-						subscriber.unsubscribe();
-					},
-				});
-			});
-			await promise;
-			expect(effect()).to.equal(3);
-			expect(next).to.have.been.calledTwice;
-			expect(next).to.have.been.calledWith(3);
-			expect(next).to.have.been.calledWith(4);
-			expect(await effect).to.equal(4);
-		});
-	});
-});
diff --git a/lib/effects/do.ts b/lib/effects/do.ts
index fb0728b..cd2085f 100644
--- a/lib/effects/do.ts
+++ b/lib/effects/do.ts
@@ -1,7 +1,7 @@
 import { Effect } from './effect';
 import { pipe, Fn } from './pipe';
 
-type EfectFn<A, B> = Fn<Effect<A>, Effect<B>>;
+type EffectFn<A, B> = Fn<Effect<A>, Effect<B>>;
 
 /**
  * Chain functions from left to right, returning an Effect
@@ -9,232 +9,252 @@ type EfectFn<A, B> = Fn<Effect<A>, Effect<B>>;
  * Returns a new function that receives the same arguments as first
  * function and returns the result of the last function.
  */
-export function doPipe<A>(a: A): Effect<A>;
-export function doPipe<A, B>(a: A, fa: EfectFn<A, B>): Effect<B>;
+export function fromPipe<A>(a: A): Effect<A>;
+export function fromPipe<A, B>(a: A, fa: EffectFn<A, B>): Effect<B>;
 // This repetition is necessary unfortunately to ensure that typescript can
 // infer the correct types for the arguments
-export function doPipe<A, B, C>(
+export function fromPipe<A, B, C>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
 ): Effect<C>;
-export function doPipe<A, B, C, D>(
+export function fromPipe<A, B, C, D>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
 ): Effect<D>;
-export function doPipe<A, B, C, D, E>(
+export function fromPipe<A, B, C, D, E>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
 ): Effect<E>;
-export function doPipe<A, B, C, D, E, F>(
+export function fromPipe<A, B, C, D, E, F>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
 ): Effect<F>;
-export function doPipe<A, B, C, D, E, F, G>(
+export function fromPipe<A, B, C, D, E, F, G>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
 ): Effect<G>;
-export function doPipe<A, B, C, D, E, F, G, H>(
+export function fromPipe<A, B, C, D, E, F, G, H>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
 ): Effect<H>;
-export function doPipe<A, B, C, D, E, F, G, H, I>(
+export function fromPipe<A, B, C, D, E, F, G, H, I>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
 ): Effect<I>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
 ): Effect<J>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
 ): Effect<K>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
 ): Effect<L>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
 ): Effect<M>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
 ): Effect<N>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
 ): Effect<O>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
 ): Effect<P>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
 ): Effect<Q>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
+export function fromPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
 ): Effect<R>;
-export function doPipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
+export function fromPipe<
+	A,
+	B,
+	C,
+	D,
+	E,
+	F,
+	G,
+	H,
+	I,
+	J,
+	K,
+	L,
+	M,
+	N,
+	O,
+	P,
+	Q,
+	R,
+	S,
+>(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
 ): Effect<S>;
-export function doPipe<
+export function fromPipe<
 	A,
 	B,
 	C,
@@ -257,27 +277,27 @@ export function doPipe<
 	T,
 >(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
 ): Effect<T>;
-export function doPipe<
+export function fromPipe<
 	A,
 	B,
 	C,
@@ -301,28 +321,28 @@ export function doPipe<
 	U,
 >(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
-	fu: EfectFn<C, U>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
+	fu: EffectFn<T, U>,
 ): Effect<U>;
-export function doPipe<
+export function fromPipe<
 	A,
 	B,
 	C,
@@ -347,251 +367,266 @@ export function doPipe<
 	V,
 >(
 	a: A,
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
-	fu: EfectFn<C, U>,
-	fv: EfectFn<C, V>,
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
+	fu: EffectFn<T, U>,
+	fv: EffectFn<U, V>,
 ): Effect<V>;
-export function doPipe(a: any, ...fns: Array<EfectFn<any, any>>) {
+export function fromPipe(a: any, ...fns: Array<EffectFn<any, any>>) {
 	return (pipe as any)(a, Effect.of, ...fns);
 }
 
-/**
- * Alias of doPipe for more declarative definitions
- */
-export const fromPipe = doPipe;
-
 /**
  * Chain functions from left to right
  *
  * Returns a new function that receives the same arguments as first
  * function and returns the result of the last function.
  */
-export function doFlow<A, B>(fa: EfectFn<A, B>): Fn<A, Effect<B>>;
+export function fromFlow<A, B>(fa: EffectFn<A, B>): Effect<B>;
 // This repetition is necessary unfortunately to ensure that typescript can
 // infer the correct types for the arguments
-export function doFlow<A, B, C>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-): Fn<A, Effect<C>>;
-export function doFlow<A, B, C, D>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-): Fn<A, Effect<D>>;
-export function doFlow<A, B, C, D, E>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-): Fn<A, Effect<E>>;
-export function doFlow<A, B, C, D, E, F>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-): Fn<A, Effect<F>>;
-export function doFlow<A, B, C, D, E, F, G>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-): Fn<A, Effect<G>>;
-export function doFlow<A, B, C, D, E, F, G, H>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-): Fn<A, Effect<H>>;
-export function doFlow<A, B, C, D, E, F, G, H, I>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-): Fn<A, Effect<I>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-): Fn<A, Effect<J>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-): Fn<A, Effect<K>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-): Fn<A, Effect<L>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-): Fn<A, Effect<M>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-): Fn<A, Effect<N>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-): Fn<A, Effect<O>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-): Fn<A, Effect<P>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-): Fn<A, Effect<Q>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-): Fn<A, Effect<R>>;
-export function doFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-): Fn<A, Effect<S>>;
-export function doFlow<
+export function fromFlow<A, B, C>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+): Effect<C>;
+export function fromFlow<A, B, C, D>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+): Effect<D>;
+export function fromFlow<A, B, C, D, E>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+): Effect<E>;
+export function fromFlow<A, B, C, D, E, F>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+): Effect<F>;
+export function fromFlow<A, B, C, D, E, F, G>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+): Effect<G>;
+export function fromFlow<A, B, C, D, E, F, G, H>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+): Effect<H>;
+export function fromFlow<A, B, C, D, E, F, G, H, I>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+): Effect<I>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+): Effect<J>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+): Effect<K>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+): Effect<L>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+): Effect<M>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+): Effect<N>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+): Effect<O>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+): Effect<P>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+): Effect<Q>;
+export function fromFlow<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+): Effect<R>;
+export function fromFlow<
+	A,
+	B,
+	C,
+	D,
+	E,
+	F,
+	G,
+	H,
+	I,
+	J,
+	K,
+	L,
+	M,
+	N,
+	O,
+	P,
+	Q,
+	R,
+	S,
+>(
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+): Effect<S>;
+export function fromFlow<
 	A,
 	B,
 	C,
@@ -613,27 +648,27 @@ export function doFlow<
 	S,
 	T,
 >(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
-): Fn<A, Effect<T>>;
-export function doFlow<
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
+): Effect<T>;
+export function fromFlow<
 	A,
 	B,
 	C,
@@ -656,28 +691,28 @@ export function doFlow<
 	T,
 	U,
 >(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
-	fu: EfectFn<C, U>,
-): Fn<A, Effect<U>>;
-export function doFlow<
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
+	fu: EffectFn<T, U>,
+): Effect<U>;
+export function fromFlow<
 	A,
 	B,
 	C,
@@ -701,29 +736,29 @@ export function doFlow<
 	U,
 	V,
 >(
-	fa: EfectFn<A, B>,
-	fb: EfectFn<B, C>,
-	fc: EfectFn<C, D>,
-	fd: EfectFn<C, E>,
-	fe: EfectFn<C, F>,
-	fg: EfectFn<C, G>,
-	fh: EfectFn<C, H>,
-	fi: EfectFn<C, I>,
-	fj: EfectFn<C, J>,
-	fk: EfectFn<C, K>,
-	fl: EfectFn<C, L>,
-	fm: EfectFn<C, M>,
-	fn: EfectFn<C, N>,
-	fo: EfectFn<C, O>,
-	fp: EfectFn<C, P>,
-	fq: EfectFn<C, Q>,
-	fr: EfectFn<C, R>,
-	fs: EfectFn<C, S>,
-	ft: EfectFn<C, T>,
-	fu: EfectFn<C, U>,
-	fv: EfectFn<C, V>,
-): Fn<A, Effect<V>>;
-export function doFlow(...fns: Array<EfectFn<any, any>>) {
+	fa: EffectFn<A, B>,
+	fb: EffectFn<B, C>,
+	fc: EffectFn<C, D>,
+	fd: EffectFn<D, E>,
+	fe: EffectFn<E, F>,
+	fg: EffectFn<F, G>,
+	fh: EffectFn<G, H>,
+	fi: EffectFn<H, I>,
+	fj: EffectFn<I, J>,
+	fk: EffectFn<J, K>,
+	fl: EffectFn<K, L>,
+	fm: EffectFn<L, M>,
+	fn: EffectFn<M, N>,
+	fo: EffectFn<N, O>,
+	fp: EffectFn<O, P>,
+	fq: EffectFn<P, Q>,
+	fr: EffectFn<Q, R>,
+	fs: EffectFn<R, S>,
+	ft: EffectFn<S, T>,
+	fu: EffectFn<T, U>,
+	fv: EffectFn<U, V>,
+): Effect<V>;
+export function fromFlow(...fns: Array<EffectFn<any, any>>) {
 	return (a: any) => (pipe as any)(a, Effect.of, ...fns);
 }
 
@@ -731,4 +766,5 @@ export function doFlow(...fns: Array<EfectFn<any, any>>) {
  * Alias of doFlow for more declarative
  * definitions
  */
-export const then = doFlow;
+export const then = fromFlow;
+export const fromSequence = fromFlow;
diff --git a/lib/effects/effect.ts b/lib/effects/effect.ts
index 547870a..13789b4 100644
--- a/lib/effects/effect.ts
+++ b/lib/effects/effect.ts
@@ -151,17 +151,10 @@ function of<T>(t: T): Effect<T> {
 }
 
 /**
- * Create a side effect from an async function and a fallback
+ * Create a side effect from an async and sync sides
  * value.
- *
- * This is equivalent to calling `Effect.from(async, () => t)` but it provides
- * a shorter syntax.
  */
-export function IO(async: Async<void>): Effect<void>;
-export function IO<T>(async: Async<T>, t: T): Effect<T>;
-export function IO<T>(async: Async<T>, t?: T): Effect<T> {
-	return from(async, of(t!));
-}
+export const IO = from;
 
 /**
  * Type guard to check if a given value is an effect
diff --git a/lib/effects/helpers.ts b/lib/effects/helpers.ts
index 59a3194..00cf47f 100644
--- a/lib/effects/helpers.ts
+++ b/lib/effects/helpers.ts
@@ -23,16 +23,6 @@ export function flatMap<T, U>(
 	return (et: Effect<T>) => et.flatMap(ef);
 }
 
-/**
- * Chains two effects together.
- *
- * This returns a function on effects that can be used as
- * part of a pipe
- *
- * This is an alias of flatMap
- */
-export const bind = flatMap;
-
 /**
  * Creates a new IO effect from a async and sync
  * functions.
@@ -40,7 +30,7 @@ export const bind = flatMap;
  * If no sync function is used, then the identity function
  * will be used as the sync part.
  */
-export function bindIO<T, U extends T = T>(
+export function mapIO<T, U extends T = T>(
 	fa: (t: T) => AsyncReturn<U>,
 	// TODO: the `as U` cast is a potential source for bugs
 	// as the async side could return a value not in the sync side
@@ -48,7 +38,12 @@ export function bindIO<T, U extends T = T>(
 	// values match
 	fs: (t: T) => U = (t: T) => t as U,
 ): (et: Effect<T>) => Effect<U> {
-	return bind((t) => IO(() => fa(t), fs(t)));
+	return flatMap((t) =>
+		IO(
+			() => fa(t),
+			() => fs(t),
+		),
+	);
 }
 
 /**
@@ -62,7 +57,7 @@ export function when<T, U extends T = T>(
 	doIf: (t: T) => Effect<U>,
 	doElse: (t: T) => Effect<U> = (t) => Effect.of(t as U),
 ): (et: Effect<T>) => Effect<T> {
-	return bind((t) => (condition(t) ? doIf(t) : doElse(t)));
+	return flatMap((t) => (condition(t) ? doIf(t) : doElse(t)));
 }
 
 /**
@@ -114,19 +109,30 @@ export function tapIO<T, U = void>(
 ): (et: Effect<T>) => Effect<T> {
 	return (et: Effect<T>) =>
 		et.flatMap((t) =>
-			IO(async () => {
-				await f(t);
-				return t;
-			}, t),
+			IO(
+				async () => {
+					await f(t);
+					return t;
+				},
+				() => t,
+			),
 		);
 }
 
-/**
- * Set a property of an object in an effect.
- */
-export function set<T, K extends keyof T>(
-	key: K,
-	eu: Effect<T[K]>,
-): (et: Effect<T>) => Effect<T> {
-	return bind((t) => eu.map((u) => ({ ...t, [key]: u })));
+export function bind<N extends string | number | symbol, T, U>(
+	key: Exclude<N, keyof T>,
+	fn: (t: T) => Effect<U>,
+): (
+	et: Effect<T>,
+) => Effect<{ readonly [K in N | keyof T]: K extends keyof T ? T[K] : U }> {
+	return flatMap((t) => fn(t).map((u) => ({ ...t, [key]: u }) as any));
+}
+
+export function set<T, N extends string, U>(
+	key: Exclude<N, keyof T>,
+	fn: (t: T) => U,
+): (
+	et: Effect<T>,
+) => Effect<{ readonly [K in N | keyof T]: K extends keyof T ? T[K] : U }> {
+	return map((t) => ({ ...t, [key]: fn(t) }) as any);
 }
diff --git a/lib/effects/pipe.ts b/lib/effects/pipe.ts
index 78701a9..7efe937 100644
--- a/lib/effects/pipe.ts
+++ b/lib/effects/pipe.ts
@@ -24,122 +24,122 @@ export function flow<A extends any[], B, C, D, E>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
+	fd: Fn<D, E>,
 ): (...a: A) => E;
 export function flow<A extends any[], B, C, D, E, F>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
 ): (...a: A) => F;
 export function flow<A extends any[], B, C, D, E, F, G>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
 ): (...a: A) => G;
 export function flow<A extends any[], B, C, D, E, F, G, H>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
 ): (...a: A) => H;
 export function flow<A extends any[], B, C, D, E, F, G, H, I>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
 ): (...a: A) => I;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
 ): (...a: A) => J;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J, K>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
 ): (...a: A) => K;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J, K, L>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
 ): (...a: A) => L;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J, K, L, M>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
 ): (...a: A) => M;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J, K, L, M, N>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
 ): (...a: A) => N;
 export function flow<A extends any[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
 ): (...a: A) => O;
 export function flow<
 	A extends any[],
@@ -162,18 +162,18 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
 ): (...a: A) => P;
 export function flow<
 	A extends any[],
@@ -197,19 +197,19 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
 ): (...a: A) => Q;
 export function flow<
 	A extends any[],
@@ -234,20 +234,20 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
 ): (...a: A) => R;
 export function flow<
 	A extends any[],
@@ -273,21 +273,21 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
 ): (...a: A) => S;
 export function flow<
 	A extends any[],
@@ -314,22 +314,22 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
 ): (...a: A) => T;
 export function flow<
 	A extends any[],
@@ -357,23 +357,23 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
 ): (...a: A) => U;
 export function flow<
 	A extends any[],
@@ -402,24 +402,24 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
-	fv: Fn<C, V>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
+	fv: Fn<U, V>,
 ): (...a: A) => V;
 export function flow<
 	A extends any[],
@@ -449,25 +449,25 @@ export function flow<
 	fa: (...a: A) => B,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
-	fv: Fn<C, V>,
-	fw: Fn<C, W>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
+	fv: Fn<U, V>,
+	fw: Fn<V, W>,
 ): (...a: A) => W;
 export function flow(fa: (...a: any[]) => any, ...fns: Array<Fn<any, any>>) {
 	return fns.reduce(
@@ -498,210 +498,210 @@ export function pipe<A, B, C, D, E>(
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
+	fd: Fn<D, E>,
 ): E;
 export function pipe<A, B, C, D, E, F>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
 ): F;
 export function pipe<A, B, C, D, E, F, G>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
 ): G;
 export function pipe<A, B, C, D, E, F, G, H>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
 ): H;
 export function pipe<A, B, C, D, E, F, G, H, I>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
 ): I;
 export function pipe<A, B, C, D, E, F, G, H, I, J>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
 ): J;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
 ): K;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
 ): L;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
 ): M;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
 ): N;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
 ): O;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
 ): P;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
 ): Q;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
 ): R;
 export function pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
 	a: A,
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
 ): S;
 export function pipe<
 	A,
@@ -729,22 +729,22 @@ export function pipe<
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
 ): T;
 export function pipe<
 	A,
@@ -773,23 +773,23 @@ export function pipe<
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
 ): U;
 export function pipe<
 	A,
@@ -819,24 +819,24 @@ export function pipe<
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
-	fv: Fn<C, V>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
+	fv: Fn<U, V>,
 ): V;
 export function pipe<
 	A,
@@ -867,25 +867,25 @@ export function pipe<
 	fa: Fn<A, B>,
 	fb: Fn<B, C>,
 	fc: Fn<C, D>,
-	fd: Fn<C, E>,
-	fe: Fn<C, F>,
-	fg: Fn<C, G>,
-	fh: Fn<C, H>,
-	fi: Fn<C, I>,
-	fj: Fn<C, J>,
-	fk: Fn<C, K>,
-	fl: Fn<C, L>,
-	fm: Fn<C, M>,
-	fn: Fn<C, N>,
-	fo: Fn<C, O>,
-	fp: Fn<C, P>,
-	fq: Fn<C, Q>,
-	fr: Fn<C, R>,
-	fs: Fn<C, S>,
-	ft: Fn<C, T>,
-	fu: Fn<C, U>,
-	fv: Fn<C, V>,
-	fw: Fn<C, W>,
+	fd: Fn<D, E>,
+	fe: Fn<E, F>,
+	fg: Fn<F, G>,
+	fh: Fn<G, H>,
+	fi: Fn<H, I>,
+	fj: Fn<I, J>,
+	fk: Fn<J, K>,
+	fl: Fn<K, L>,
+	fm: Fn<L, M>,
+	fn: Fn<M, N>,
+	fo: Fn<N, O>,
+	fp: Fn<O, P>,
+	fq: Fn<P, Q>,
+	fr: Fn<Q, R>,
+	fs: Fn<R, S>,
+	ft: Fn<S, T>,
+	fu: Fn<T, U>,
+	fv: Fn<U, V>,
+	fw: Fn<V, W>,
 ): W;
 export function pipe(a: any, ...fns: Array<Fn<any, any>>) {
 	return fns.reduce((acc, f) => f(acc), a);
diff --git a/lib/task/tasks.ts b/lib/task/tasks.ts
index c83b314..a729fe6 100644
--- a/lib/task/tasks.ts
+++ b/lib/task/tasks.ts
@@ -2,7 +2,7 @@ import { createHash } from 'crypto';
 
 import assert from '../assert';
 import { Context, ContextAsArgs, TaskOp } from '../context';
-import { Effect, IO, when, pipe } from '../effects';
+import { Effect, IO, flatMap, pipe } from '../effects';
 import { Path } from '../path';
 
 import { Action, Instruction, Method } from './instructions';
@@ -58,7 +58,10 @@ export interface ActionTask<
 	 * the planner will wait for the observable to complete before continuing, but
 	 * use any state updates to communicate about state changes to its observers.
 	 */
-	action(s: TState, c: Context<TState, TPath, TOp>): Promise<TState>;
+	action(
+		s: TState,
+		c: Context<TState, TPath, TOp>,
+	): Promise<TState> | AsyncGenerator<TState, TState | void, void>;
 
 	/**
 	 * The task function grounds the task
@@ -146,17 +149,17 @@ function ground<
 			pipe(
 				state,
 				Effect.of,
-				when(
-					(s) => task.condition(s, context),
-					(s) => {
-						const e = task.effect(s, context);
-						if (Effect.is(e)) {
-							return e;
-						} else {
-							return IO(async () => task.action(s, context), e);
-						}
-					},
-				),
+				flatMap((s) => {
+					const e = task.effect(s, context);
+					if (Effect.is(e)) {
+						return e;
+					} else {
+						return IO(
+							() => task.action(s, context),
+							() => e,
+						);
+					}
+				}),
 			);
 		return Object.assign(fn, {
 			id,
@@ -252,7 +255,7 @@ export type ActionTaskWithEffectProps<
 	TPath extends Path = '/',
 	TOp extends TaskOp = 'update',
 > = Partial<
-	Omit<ActionTask<TState, TPath, TOp>, 'effect' | 'id' | 'action' | 'condition'>
+	Omit<ActionTask<TState, TPath, TOp>, 'effect' | 'id' | 'action'>
 > & {
 	effect(s: TState, c: Context<TState, TPath, TOp>): Effect<TState>;
 };