From 85281f6d29ad6cb39accc4206397728d82905455 Mon Sep 17 00:00:00 2001
From: Felipe Lalanne <1822826+pipex@users.noreply.github.com>
Date: Tue, 26 Sep 2023 10:24:00 -0300
Subject: [PATCH] Additional API improvements and fixes

Renames some effect helpers and makes condition usable with
tasks defined with an effect. This allows to have fewer levels of
callbacks when defining the effect for a task

Change-type: minor
---
 lib/agent.spec.ts      |   15 +-
 lib/effects.spec.ts    |  112 ----
 lib/effects/do.ts      | 1100 +++++++++++++++++++++-------------------
 lib/effects/effect.ts  |   11 +-
 lib/effects/helpers.ts |   56 +-
 lib/effects/pipe.ts    |  760 +++++++++++++--------------
 lib/task/tasks.ts      |   31 +-
 7 files changed, 1007 insertions(+), 1078 deletions(-)

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>;
 };