diff --git a/async.ts b/async.ts
index b9528a5..bfa0aef 100644
--- a/async.ts
+++ b/async.ts
@@ -4,6 +4,8 @@ import type { Sync } from "./sync.ts";
 
 import { resolve, wait } from "./promise.ts";
 import { handleThrow } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 export type Async<A> = Sync<Promise<A>>;
 
@@ -78,3 +80,9 @@ export const MonadAsyncSequential: Monad<KindAsync> = {
   join,
   chain,
 };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadAsyncSequential);
+
+export const bindTo = bindTo_(MonadAsyncSequential);
diff --git a/async_either.ts b/async_either.ts
index dfdd559..6200287 100644
--- a/async_either.ts
+++ b/async_either.ts
@@ -20,7 +20,8 @@ import * as A from "./async.ts";
 import * as P from "./promise.ts";
 import { handleThrow, identity, pipe } from "./fn.ts";
 import { resolve } from "./promise.ts";
-
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 /**
  * The AsyncEither type can best be thought of as an asynchronous function that
  * returns an `Either`. ie. `async () => Promise<Either<B, A>>`. This
@@ -195,9 +196,11 @@ export function throwError<A = never, B = never>(b: B): AsyncEither<B, A> {
  * @example
  * ```ts
  * import * as AE from "./async_either.ts";
- * import {  } from "./fn.ts";
+ * import { flow } from "./fn.ts";
  *
- * const work = f
+ * const work = flow(AE.bimap((x: string) => x.length, (x: number) => x * 2));
+ * const left = await work(AE.left("Error"))(); // Left(5)
+ * const result = await work(AE.right(1))(); // Right(2)
  * ```
  *
  * @since 2.0.0
@@ -396,17 +399,17 @@ export function alt<I, J>(
  *
  * ```ts
  * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
- * import * as TE from "./async_either.ts";
- * import * as T from "./async.ts";
+ * import * as AE from "./async_either.ts";
+ * import * as A from "./async.ts";
  * import { flow, identity } from "./fn.ts";
  *
  * const hello = flow(
- *   TE.match(() => "World", identity),
+ *   AE.match(() => "World", identity),
  *   A.map((name) => `Hello ${name}!`),
  * );
  *
- * assertEquals(await hello(TE.right("Functional!"))(), "Hello Functional!!");
- * assertEquals(await hello(TE.left(Error))(), "Hello World!");
+ * assertEquals(await hello(AE.right("Functional!"))(), "Hello Functional!!");
+ * assertEquals(await hello(AE.left(Error))(), "Hello World!");
  * ```
  *
  * @since 2.0.0
@@ -445,3 +448,9 @@ export const MonadAsyncEitherSequential: Monad<KindAsyncEither> = {
   join,
   chain,
 };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadAsyncEitherSequential);
+
+export const bindTo = bindTo_(MonadAsyncEitherSequential);
diff --git a/chain.ts b/chain.ts
index e2c040e..de4b38c 100644
--- a/chain.ts
+++ b/chain.ts
@@ -12,3 +12,55 @@ export interface Chain<U extends Kind> extends TypeClass<U>, Apply<U> {
     ta: $<U, [A, B, C], [D], [E]>,
   ) => $<U, [I, B | J, C | K], [D], [E]>;
 }
+
+/**
+ * ChainRec
+ * https://github.com/fantasyland/static-land/blob/master/docs/spec.md#chain
+ */
+export interface ChainRec<U extends Kind> extends TypeClass<U>, Chain<U> {
+  readonly chainRec: <A, B, I, J = never, K = never, D = unknown, E = unknown>(
+    fati: (a: A) => $<U, [I, J, K], [D], [E]>,
+    a: A,
+  ) => $<U, [B, J, K], [D], [E]>;
+}
+
+// chainFirst
+export function chainFirst<U extends Kind>(
+  M: Chain<U>,
+): <A, I, J = never, K = never, D = unknown, E = unknown>(
+  f: (a: A) => $<U, [I, J, K], [D], [E]>,
+) => <B, C>(ma: $<U, [A, B, C], [D], [E]>) => $<U, [A, B, C], [D], [E]> {
+  // @ts-expect-error <type-errors> TODO: @baetheus
+  return (f) => (ma) => M.chain((a) => M.map(() => a)(f(a)))(ma);
+}
+
+// bind
+export function bind<U extends Kind>(
+  M: Chain<U>,
+): <
+  N extends string,
+  A,
+  B,
+  C,
+  I,
+  J = never,
+  K = never,
+  D = unknown,
+  E = unknown,
+>(
+  name: Exclude<N, keyof A>,
+  f: (a: A) => $<U, [I, J, K], [D], [E]>,
+) => <B, C>(
+  ma: $<U, [A, B, C], [D], [E]>,
+) => $<
+  U,
+  [{ readonly [K in keyof A | N]: K extends keyof A ? A[K] : I }],
+  [D],
+  [E]
+> {
+  return (name, f) =>
+    // @ts-expect-error <type-errors> TODO: @baetheus
+    M.chain((a) =>
+      M.map((b) => Object.assign({}, a, { [name]: b }) as any)(f(a))
+    );
+}
diff --git a/datum.ts b/datum.ts
index 2e67a92..9ed56c0 100644
--- a/datum.ts
+++ b/datum.ts
@@ -12,6 +12,8 @@ import type { Traversable } from "./traversable.ts";
 import { fromCompare } from "./ord.ts";
 import { isNotNil } from "./nilable.ts";
 import { flow, identity, pipe } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 /**
  * TODO: Lets get a monoid in here for tracking progress.
@@ -52,11 +54,11 @@ export const initial: Initial = { tag: "Initial" };
 export const pending: Pending = { tag: "Pending" };
 
 export function refresh<D>(value: D): Datum<D> {
-  return ({ tag: "Refresh", value });
+  return { tag: "Refresh", value };
 }
 
 export function replete<D>(value: D): Datum<D> {
-  return ({ tag: "Replete", value });
+  return { tag: "Replete", value };
 }
 
 export function constInitial<A = never>(): Datum<A> {
@@ -80,15 +82,7 @@ export function tryCatch<A>(fa: () => A): Datum<A> {
 }
 
 export function toLoading<A>(ta: Datum<A>): Datum<A> {
-  return pipe(
-    ta,
-    match(
-      constPending,
-      constPending,
-      refresh,
-      refresh,
-    ),
-  );
+  return pipe(ta, match(constPending, constPending, refresh, refresh));
 }
 
 export function isInitial<A>(ta: Datum<A>): ta is Initial {
@@ -160,12 +154,10 @@ export function map<A, I>(fai: (a: A) => I): (ta: Datum<A>) => Datum<I> {
   );
 }
 
-export function ap<A>(
-  ua: Datum<A>,
-): <I>(ufai: Datum<(a: A) => I>) => Datum<I> {
+export function ap<A>(ua: Datum<A>): <I>(ufai: Datum<(a: A) => I>) => Datum<I> {
   switch (ua.tag) {
     case "Initial":
-      return (ufai) => isLoading(ufai) ? pending : initial;
+      return (ufai) => (isLoading(ufai) ? pending : initial);
     case "Pending":
       return constPending;
     case "Replete":
@@ -178,19 +170,14 @@ export function ap<A>(
           ? pending
           : initial;
     case "Refresh":
-      return (ufai) => isSome(ufai) ? refresh(ufai.value(ua.value)) : pending;
+      return (ufai) => (isSome(ufai) ? refresh(ufai.value(ua.value)) : pending);
   }
 }
 
 export function chain<A, I>(
   fati: (a: A) => Datum<I>,
 ): (ta: Datum<A>) => Datum<I> {
-  return match(
-    constInitial,
-    constPending,
-    fati,
-    flow(fati, toLoading),
-  );
+  return match(constInitial, constPending, fati, flow(fati, toLoading));
 }
 
 export function join<A>(taa: Datum<Datum<A>>): Datum<A> {
@@ -198,14 +185,14 @@ export function join<A>(taa: Datum<Datum<A>>): Datum<A> {
 }
 
 export function alt<A>(tb: Datum<A>): (ta: Datum<A>) => Datum<A> {
-  return (ta) => isSome(ta) ? ta : tb;
+  return (ta) => (isSome(ta) ? ta : tb);
 }
 
 export function reduce<A, O>(
   foao: (o: O, a: A) => O,
   o: O,
 ): (ta: Datum<A>) => O {
-  return (ta) => isSome(ta) ? foao(o, ta.value) : o;
+  return (ta) => (isSome(ta) ? foao(o, ta.value) : o);
 }
 
 export function traverse<V extends Kind>(
@@ -217,58 +204,66 @@ export function traverse<V extends Kind>(
     match(
       () => A.of(constInitial()),
       () => A.of(constPending()),
-      (a) => pipe(favi(a), A.map((i) => replete(i))),
-      (a) => pipe(favi(a), A.map((i) => refresh(i))),
+      (a) =>
+        pipe(
+          favi(a),
+          A.map((i) => replete(i)),
+        ),
+      (a) =>
+        pipe(
+          favi(a),
+          A.map((i) => refresh(i)),
+        ),
     );
 }
 
 export function getShow<A>({ show }: Show<A>): Show<Datum<A>> {
-  return ({
+  return {
     show: match(
       () => `Initial`,
       () => `Pending`,
       (a) => `Replete(${show(a)})`,
       (a) => `Refresh(${show(a)})`,
     ),
-  });
+  };
 }
 
-export function getSemigroup<A>(
-  S: Semigroup<A>,
-): Semigroup<Datum<A>> {
-  return ({
+export function getSemigroup<A>(S: Semigroup<A>): Semigroup<Datum<A>> {
+  return {
     concat: (mx) =>
       match(
         () => mx,
         () => toLoading(mx),
         (v) =>
           isSome(mx)
-            ? (isRefresh(mx)
+            ? isRefresh(mx)
               ? refresh(S.concat(mx.value)(v))
-              : replete(S.concat(mx.value)(v)))
-            : (isPending(mx) ? refresh(v) : replete(v)),
-        (v) => isSome(mx) ? refresh(S.concat(mx.value)(v)) : refresh(v),
+              : replete(S.concat(mx.value)(v))
+            : isPending(mx)
+            ? refresh(v)
+            : replete(v),
+        (v) => (isSome(mx) ? refresh(S.concat(mx.value)(v)) : refresh(v)),
       ),
-  });
+  };
 }
 
 export function getMonoid<A>(S: Semigroup<A>): Monoid<Datum<A>> {
-  return ({
+  return {
     ...getSemigroup(S),
     empty: constInitial,
-  });
+  };
 }
 
 export function getEq<A>(S: Eq<A>): Eq<Datum<A>> {
-  return ({
+  return {
     equals: (b) =>
       match(
         () => isInitial(b),
         () => isPending(b),
-        (v) => isReplete(b) ? S.equals(b.value)(v) : false,
-        (v) => isRefresh(b) ? S.equals(b.value)(v) : false,
+        (v) => (isReplete(b) ? S.equals(b.value)(v) : false),
+        (v) => (isRefresh(b) ? S.equals(b.value)(v) : false),
       ),
-  });
+  };
 }
 
 export function getOrd<A>(O: Ord<A>): Ord<Datum<A>> {
@@ -276,11 +271,11 @@ export function getOrd<A>(O: Ord<A>): Ord<Datum<A>> {
     pipe(
       fst,
       match(
-        () => isInitial(snd) ? 0 : -1,
-        () => isInitial(snd) ? 1 : isPending(snd) ? 0 : -1,
+        () => (isInitial(snd) ? 0 : -1),
+        () => (isInitial(snd) ? 1 : isPending(snd) ? 0 : -1),
         (value) =>
           isNone(snd) ? 1 : isReplete(snd) ? O.compare(value, snd.value) : -1,
-        (value) => isRefresh(snd) ? O.compare(value, snd.value) : 1,
+        (value) => (isRefresh(snd) ? O.compare(value, snd.value) : 1),
       ),
     )
   );
@@ -295,3 +290,9 @@ export const TraversableDatum: Traversable<KindDatum> = {
   reduce,
   traverse,
 };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadDatum);
+
+export const bindTo = bindTo_(MonadDatum);
diff --git a/either.ts b/either.ts
index e360dbb..bb154f6 100644
--- a/either.ts
+++ b/either.ts
@@ -17,6 +17,8 @@ import * as O from "./option.ts";
 import { isNotNil } from "./nilable.ts";
 import { fromCompare } from "./ord.ts";
 import { flow, pipe } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 export type Left<L> = { tag: "Left"; left: L };
 
@@ -33,11 +35,11 @@ export interface KindRightEither<B> extends Kind {
 }
 
 export function left<E, A = never>(left: E): Either<E, A> {
-  return ({ tag: "Left", left });
+  return { tag: "Left", left };
 }
 
 export function right<A, E = never>(right: A): Either<E, A> {
-  return ({ tag: "Right", right });
+  return { tag: "Right", right };
 }
 
 export function of<A, B = never>(a: A): Either<B, A> {
@@ -49,9 +51,8 @@ export function throwError<A = never, B = never>(b: B): Either<B, A> {
 }
 
 export function fromNullable<E>(fe: () => E) {
-  return <A>(
-    a: A,
-  ): Either<E, NonNullable<A>> => (isNotNil(a) ? right(a) : left(fe()));
+  return <A>(a: A): Either<E, NonNullable<A>> =>
+    isNotNil(a) ? right(a) : left(fe());
 }
 
 export function tryCatch<E, A>(
@@ -86,18 +87,18 @@ export function fromPredicate<E, A>(
   predicate: Predicate<A>,
   onFalse: (a: A) => E,
 ): (a: A) => Either<E, A> {
-  return (a: A) => predicate(a) ? right(a) : left(onFalse(a));
+  return (a: A) => (predicate(a) ? right(a) : left(onFalse(a)));
 }
 
 export function match<L, R, B>(
   onLeft: (left: L) => B,
   onRight: (right: R) => B,
 ): (ta: Either<L, R>) => B {
-  return (ta) => isLeft(ta) ? onLeft(ta.left) : onRight(ta.right);
+  return (ta) => (isLeft(ta) ? onLeft(ta.left) : onRight(ta.right));
 }
 
 export function getOrElse<E, A>(onLeft: (e: E) => A) {
-  return (ma: Either<E, A>): A => isLeft(ma) ? onLeft(ma.left) : ma.right;
+  return (ma: Either<E, A>): A => (isLeft(ma) ? onLeft(ma.left) : ma.right);
 }
 
 export function getRight<E, A>(ma: Either<E, A>): O.Option<A> {
@@ -116,23 +117,17 @@ export function isRight<L, R>(m: Either<L, R>): m is Right<R> {
   return m.tag === "Right";
 }
 
-export function getShow<A, B>(
-  SB: Show<B>,
-  SA: Show<A>,
-): Show<Either<B, A>> {
-  return ({
+export function getShow<A, B>(SB: Show<B>, SA: Show<A>): Show<Either<B, A>> {
+  return {
     show: match(
       (left) => `Left(${SB.show(left)})`,
       (right) => `Right(${SA.show(right)})`,
     ),
-  });
+  };
 }
 
-export function getEq<A, B>(
-  SB: Eq<B>,
-  SA: Eq<A>,
-): Eq<Either<B, A>> {
-  return ({
+export function getEq<A, B>(SB: Eq<B>, SA: Eq<A>): Eq<Either<B, A>> {
+  return {
     equals: (b) => (a) => {
       if (isLeft(a)) {
         if (isLeft(b)) {
@@ -146,13 +141,10 @@ export function getEq<A, B>(
       }
       return SA.equals(b.right)(a.right);
     },
-  });
+  };
 }
 
-export function getOrd<A, B>(
-  OB: Ord<B>,
-  OA: Ord<A>,
-): Ord<Either<B, A>> {
+export function getOrd<A, B>(OB: Ord<B>, OA: Ord<A>): Ord<Either<B, A>> {
   return fromCompare((fst, snd) =>
     isLeft(fst)
       ? isLeft(snd) ? OB.compare(fst.left, snd.left) : -1
@@ -165,50 +157,52 @@ export function getOrd<A, B>(
 export function getLeftSemigroup<E = never, A = never>(
   SE: Semigroup<E>,
 ): Semigroup<Either<E, A>> {
-  return ({
+  return {
     concat: (x) => (y) =>
       isRight(x) ? x : isRight(y) ? y : left(SE.concat(x.left)(y.left)),
-  });
+  };
 }
 
 export function getRightSemigroup<E = never, A = never>(
   SA: Semigroup<A>,
 ): Semigroup<Either<E, A>> {
-  return ({
+  return {
     concat: (x) => (y) =>
       isLeft(x) ? x : isLeft(y) ? y : right(SA.concat(x.right)(y.right)),
-  });
+  };
 }
 
 export function getRightMonoid<E = never, A = never>(
   MA: Monoid<A>,
 ): Monoid<Either<E, A>> {
-  return ({
+  return {
     ...getRightSemigroup(MA),
     empty: () => right(MA.empty()),
-  });
+  };
 }
 
-export function getRightMonad<E>(
-  { concat }: Semigroup<E>,
-): Monad<KindRightEither<E>> {
-  return ({
+export function getRightMonad<E>({
+  concat,
+}: Semigroup<E>): Monad<KindRightEither<E>> {
+  return {
     of,
     ap: (ua) => (ufai) =>
       isLeft(ufai)
-        ? (isLeft(ua) ? left(concat(ua.left)(ufai.left)) : ufai)
-        : (isLeft(ua) ? ua : right(ufai.right(ua.right))),
+        ? isLeft(ua) ? left(concat(ua.left)(ufai.left)) : ufai
+        : isLeft(ua)
+        ? ua
+        : right(ufai.right(ua.right)),
     map,
     join,
     chain,
-  });
+  };
 }
 
 export function bimap<A, B, I, J>(
   fbj: (b: B) => J,
   fai: (a: A) => I,
 ): (ta: Either<B, A>) => Either<J, I> {
-  return (ta) => isLeft(ta) ? left(fbj(ta.left)) : right(fai(ta.right));
+  return (ta) => (isLeft(ta) ? left(fbj(ta.left)) : right(fai(ta.right)));
 }
 
 export function swap<E, A>(ma: Either<E, A>): Either<A, E> {
@@ -225,7 +219,7 @@ export function stringifyJSON<E>(
 export function map<A, I>(
   fai: (a: A) => I,
 ): <B>(ta: Either<B, A>) => Either<B, I> {
-  return (ta) => isLeft(ta) ? ta : right(fai(ta.right));
+  return (ta) => (isLeft(ta) ? ta : right(fai(ta.right)));
 }
 
 export function chainLeft<B, I, J>(
@@ -244,7 +238,7 @@ export function ap<A, B>(
 export function chain<A, I, J>(
   fati: (a: A) => Either<J, I>,
 ): <B>(ta: Either<B, A>) => Either<B | J, I> {
-  return (ta) => isLeft(ta) ? ta : fati(ta.right);
+  return (ta) => (isLeft(ta) ? ta : fati(ta.right));
 }
 
 export function join<A, B, J = never>(
@@ -256,13 +250,13 @@ export function join<A, B, J = never>(
 export function mapLeft<B, J>(
   fbj: (b: B) => J,
 ): <A>(ta: Either<B, A>) => Either<J, A> {
-  return (ta) => isLeft(ta) ? left(fbj(ta.left)) : ta;
+  return (ta) => (isLeft(ta) ? left(fbj(ta.left)) : ta);
 }
 
 export function alt<A, J>(
   tb: Either<J, A>,
 ): <B>(ta: Either<B, A>) => Either<B | J, A> {
-  return (ta) => isLeft(ta) ? tb : ta;
+  return (ta) => (isLeft(ta) ? tb : ta);
 }
 
 export function extend<A, I, B>(
@@ -275,7 +269,7 @@ export function reduce<A, O>(
   foao: (o: O, a: A) => O,
   o: O,
 ): <B>(ta: Either<B, A>) => O {
-  return (ta) => isLeft(ta) ? o : foao(o, ta.right);
+  return (ta) => (isLeft(ta) ? o : foao(o, ta.right));
 }
 
 export function traverse<V extends Kind>(
@@ -298,6 +292,12 @@ export const MonadEither: Monad<KindEither> = {
   chain,
 };
 
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadEither);
+
+export const bindTo = bindTo_(MonadEither);
+
 export const BifunctorEither: Bifunctor<KindEither> = { bimap, mapLeft };
 
 export const AltEither: Alt<KindEither> = { alt, map };
diff --git a/examples/category.ts b/examples/category.ts
index e22c9f4..018a11a 100644
--- a/examples/category.ts
+++ b/examples/category.ts
@@ -20,5 +20,3 @@ export const getCategoryMonoid = <A>(M: Monoid<A>): Category<Fix<A>> => ({
   id: M.empty,
   compose: M.concat,
 });
-
-
diff --git a/fn_either.ts b/fn_either.ts
index eaae2b2..d288a16 100644
--- a/fn_either.ts
+++ b/fn_either.ts
@@ -19,6 +19,8 @@ import type { Predicate } from "./predicate.ts";
 import type { Refinement } from "./refinement.ts";
 import type { Fn } from "./fn.ts";
 import type { Either } from "./either.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 import * as E from "./either.ts";
 import * as F from "./fn.ts";
@@ -698,3 +700,9 @@ export function getRightMonad<B>(
     chain,
   });
 }
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadFnEither);
+
+export const bindTo = bindTo_(MonadFnEither);
diff --git a/functor.ts b/functor.ts
index 472ab23..2514ebf 100644
--- a/functor.ts
+++ b/functor.ts
@@ -11,3 +11,13 @@ export interface Functor<U extends Kind> extends TypeClass<U> {
     ta: $<U, [A, B, C], [D], [E]>,
   ) => $<U, [I, B, C], [D], [E]>;
 }
+
+export function bindTo<U extends Kind>(
+  F: Functor<U>,
+): <N extends string>(
+  name: N,
+) => <A = never, B = never, C = never, D = unknown, E = unknown>(
+  fa: $<U, [A, B, C], [D], [E]>,
+) => $<U, [{ readonly [K in N]: A }, B, C], [D], [E]> {
+  return (name) => F.map((a) => ({ [name]: a } as any));
+}
diff --git a/identity.ts b/identity.ts
index 63770c1..2306468 100644
--- a/identity.ts
+++ b/identity.ts
@@ -1,6 +1,9 @@
 import type { Kind, Out } from "./kind.ts";
 import type { Monad } from "./monad.ts";
 
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
+
 export type Identity<A> = A;
 
 export interface KindIdentity extends Kind {
@@ -11,9 +14,7 @@ export function of<A>(a: A): Identity<A> {
   return a;
 }
 
-export function map<A, I>(
-  fai: (a: A) => I,
-): (ta: Identity<A>) => Identity<I> {
+export function map<A, I>(fai: (a: A) => I): (ta: Identity<A>) => Identity<I> {
   return fai;
 }
 
@@ -34,3 +35,9 @@ export function chain<A, I>(
 }
 
 export const MonadIdentity: Monad<KindIdentity> = { of, ap, map, join, chain };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadIdentity);
+
+export const bindTo = bindTo_(MonadIdentity);
diff --git a/nilable.ts b/nilable.ts
index 4786d01..60a6345 100644
--- a/nilable.ts
+++ b/nilable.ts
@@ -11,6 +11,8 @@ import type { Kind, Out } from "./kind.ts";
 import type { Monad } from "./monad.ts";
 import type { Predicate } from "./predicate.ts";
 import type { Show } from "./show.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 import { identity, pipe } from "./fn.ts";
 
@@ -107,6 +109,12 @@ export function alt<A>(tb: Nilable<A>): (ta: Nilable<A>) => Nilable<A> {
 
 export const MonadNilable: Monad<KindNilable> = { of, ap, map, join, chain };
 
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadNilable);
+
+export const bindTo = bindTo_(MonadNilable);
+
 export const AltNilable: Alt<KindNilable> = { alt, map };
 
 export function getShow<A>({ show }: Show<A>): Show<Nilable<A>> {
diff --git a/option.ts b/option.ts
index 6b5a3a5..d02b1cd 100644
--- a/option.ts
+++ b/option.ts
@@ -30,6 +30,8 @@ import type { Traversable } from "./traversable.ts";
 import { isNotNil } from "./nilable.ts";
 import { fromCompare } from "./ord.ts";
 import { flow, handleThrow, identity, pipe } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 /**
  * The None type represents the non-existence of a value.
@@ -103,7 +105,7 @@ export const none: Option<never> = { tag: "None" };
  * @since 2.0.0
  */
 export function some<A>(value: A): Option<A> {
-  return ({ tag: "Some", value });
+  return { tag: "Some", value };
 }
 
 /**
@@ -157,9 +159,7 @@ export function fromNullable<A>(a: A): Option<NonNullable<A>> {
 export function fromPredicate<A, B extends A>(
   refinement: Refinement<A, B>,
 ): (a: A) => Option<B>;
-export function fromPredicate<A>(
-  refinement: Predicate<A>,
-): (a: A) => Option<A>;
+export function fromPredicate<A>(refinement: Predicate<A>): (a: A) => Option<A>;
 export function fromPredicate<A>(predicate: Predicate<A>) {
   return (a: A): Option<A> => (predicate(a) ? some(a) : none);
 }
@@ -234,7 +234,7 @@ export function match<A, B>(onNone: () => B, onSome: (a: A) => B) {
  * @since 2.0.0
  */
 export function getOrElse<B>(onNone: () => B) {
-  return (ta: Option<B>): B => isNone(ta) ? onNone() : ta.value;
+  return (ta: Option<B>): B => (isNone(ta) ? onNone() : ta.value);
 }
 
 /**
@@ -358,7 +358,7 @@ export function of<A>(a: A): Option<A> {
  * @since 2.0.0
  */
 export function map<A, I>(fai: (a: A) => I): (ua: Option<A>) => Option<I> {
-  return (ua) => isNone(ua) ? none : some(fai(ua.value));
+  return (ua) => (isNone(ua) ? none : some(fai(ua.value)));
 }
 
 /**
@@ -443,7 +443,7 @@ export function ap<A>(
 export function chain<A, I>(
   fati: (a: A) => Option<I>,
 ): (ta: Option<A>) => Option<I> {
-  return (ua) => isNone(ua) ? ua : fati(ua.value);
+  return (ua) => (isNone(ua) ? ua : fati(ua.value));
 }
 
 /**
@@ -482,7 +482,7 @@ export function join<A>(taa: Option<Option<A>>): Option<A> {
  * @since 2.0.0
  */
 export function alt<A>(second: Option<A>): (first: Option<A>) => Option<A> {
-  return (first) => isNone(first) ? second : first;
+  return (first) => (isNone(first) ? second : first);
 }
 
 /**
@@ -559,7 +559,7 @@ export function filter<A>(
   predicate: Predicate<A>,
 ): (ta: Option<A>) => Option<A> {
   const _exists = exists(predicate);
-  return (ta) => _exists(ta) ? ta : none;
+  return (ta) => (_exists(ta) ? ta : none);
 }
 
 /**
@@ -677,7 +677,7 @@ export function reduce<A, O>(
   reducer: (accumulator: O, current: A) => O,
   initial: O,
 ): (ua: Option<A>) => O {
-  return (ua) => isSome(ua) ? reducer(initial, ua.value) : initial;
+  return (ua) => (isSome(ua) ? reducer(initial, ua.value) : initial);
 }
 
 /**
@@ -818,9 +818,9 @@ export const TraversableOption: Traversable<KindOption> = {
  * @since 2.0.0
  */
 export function getShow<A>({ show }: Show<A>): Show<Option<A>> {
-  return ({
+  return {
     show: (ma) => (isNone(ma) ? "None" : `${"Some"}(${show(ma.value)})`),
-  });
+  };
 }
 
 /**
@@ -842,13 +842,13 @@ export function getShow<A>({ show }: Show<A>): Show<Option<A>> {
  * @since 2.0.0
  */
 export function getEq<A>(S: Eq<A>): Eq<Option<A>> {
-  return ({
+  return {
     equals: (a) => (b) =>
       a === b ||
-      ((isSome(a) && isSome(b))
+      (isSome(a) && isSome(b)
         ? S.equals(a.value)(b.value)
-        : (isNone(a) && isNone(b))),
-  });
+        : isNone(a) && isNone(b)),
+  };
 }
 
 /**
@@ -897,13 +897,11 @@ export function getOrd<A>(O: Ord<A>): Ord<Option<A>> {
  *
  * @since 2.0.0
  */
-export function getSemigroup<A>(
-  S: Semigroup<A>,
-): Semigroup<Option<A>> {
-  return ({
+export function getSemigroup<A>(S: Semigroup<A>): Semigroup<Option<A>> {
+  return {
     concat: (x) => (y) =>
       isNone(x) ? y : isNone(y) ? x : of(S.concat(x.value)(y.value)),
-  });
+  };
 }
 
 /**
@@ -927,8 +925,14 @@ export function getSemigroup<A>(
  * @since 2.0.0
  */
 export function getMonoid<A>(M: Monoid<A>): Monoid<Option<A>> {
-  return ({
+  return {
     ...getSemigroup(M),
     empty: constNone,
-  });
+  };
 }
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadOption);
+
+export const bindTo = bindTo_(MonadOption);
diff --git a/record.ts b/record.ts
index 584f7d6..eade3cb 100644
--- a/record.ts
+++ b/record.ts
@@ -217,10 +217,7 @@ export function map<A, I>(
  *
  * @since 2.0.0
  */
-export function reduce<A, O>(
-  foao: (o: O, a: A, i: string) => O,
-  o: O,
-) {
+export function reduce<A, O>(foao: (o: O, a: A, i: string) => O, o: O) {
   return (rec: ReadonlyRecord<A>): O => {
     let result = o;
     for (const key in rec) {
@@ -281,13 +278,8 @@ export function collect<I>(
  *
  * @since 2.0.0
  */
-export function collapse<A>(
-  M: Monoid<A>,
-): (ua: ReadonlyRecord<A>) => A {
-  return reduce(
-    (first: A, second: A) => M.concat(second)(first),
-    M.empty(),
-  );
+export function collapse<A>(M: Monoid<A>): (ua: ReadonlyRecord<A>) => A {
+  return reduce((first: A, second: A) => M.concat(second)(first), M.empty());
 }
 
 /**
@@ -340,11 +332,7 @@ export function traverse<V extends Kind>(
       a: A,
       key: string,
     ): $<V, [Record<string, I>, J, K], [L], [M]> =>
-      pipe(
-        vis,
-        A.map(pusher(key)),
-        A.ap(favi(a, key)),
-      );
+      pipe(vis, A.map(pusher(key)), A.ap(favi(a, key)));
 
     return (ua) => pipe(ua, reduce(reducer, A.of({})));
   };
@@ -366,14 +354,53 @@ export function traverse<V extends Kind>(
  * Either<string | number, [number, string]>
  */
 // deno-fmt-ignore
-type Sequence<U extends Kind, R extends ReadonlyRecord<AnySub<U>>> = $<U, [
-    { [K in keyof R]: R[K] extends $<U, [infer A, infer _, infer _], any[], any[]> ? A : never; },
-    { [K in keyof R]: R[K] extends $<U, [infer _, infer B, infer _], any[], any[]> ? B : never; }[keyof R],
-    { [K in keyof R]: R[K] extends $<U, [infer _, infer _, infer C], any[], any[]> ? C : never; }[keyof R],
-  ], [
-    Intersect< { [K in keyof R]: R[K] extends $<U, any[], [infer D], any[]> ? D : never; }[keyof R] >,
-  ], [
-    Intersect< { [K in keyof R]: R[K] extends $<U, any[], any[], [infer E]> ? E : never; }[keyof R] >,
+type Sequence<U extends Kind, R extends ReadonlyRecord<AnySub<U>>> = $<
+  U,
+  [
+    {
+      [K in keyof R]: R[K] extends $<
+        U,
+        [infer A, infer _, infer _],
+        any[],
+        any[]
+      >
+        ? A
+        : never;
+    },
+    {
+      [K in keyof R]: R[K] extends $<
+        U,
+        [infer _, infer B, infer _],
+        any[],
+        any[]
+      >
+        ? B
+        : never;
+    }[keyof R],
+    {
+      [K in keyof R]: R[K] extends $<
+        U,
+        [infer _, infer _, infer C],
+        any[],
+        any[]
+      >
+        ? C
+        : never;
+    }[keyof R]
+  ],
+  [
+    Intersect<
+      {
+        [K in keyof R]: R[K] extends $<U, any[], [infer D], any[]> ? D : never;
+      }[keyof R]
+    >
+  ],
+  [
+    Intersect<
+      {
+        [K in keyof R]: R[K] extends $<U, any[], any[], [infer E]> ? E : never;
+      }[keyof R]
+    >
   ]
 >;
 
@@ -675,9 +702,7 @@ export function lookupWithKey(key: string) {
  * @since 2.0.0
  */
 export function deleteAt(key: string) {
-  return <A>(
-    rec: ReadonlyRecord<A>,
-  ): ReadonlyRecord<A> => {
+  return <A>(rec: ReadonlyRecord<A>): ReadonlyRecord<A> => {
     if (Object.hasOwn(rec, key)) {
       const out = { ...rec };
       delete out[key];
@@ -711,9 +736,7 @@ export function deleteAt(key: string) {
  * @since 2.0.0
  */
 export function deleteAtWithValue(key: string) {
-  return <A>(
-    rec: ReadonlyRecord<A>,
-  ): Pair<ReadonlyRecord<A>, Option<A>> => {
+  return <A>(rec: ReadonlyRecord<A>): Pair<ReadonlyRecord<A>, Option<A>> => {
     if (Object.hasOwn(rec, key)) {
       const out = { ...rec };
       const value = rec[key];
@@ -986,11 +1009,12 @@ export const TraversableRecord: Traversable<KindReadonlyRecord> = {
  * @since 2.0.0
  */
 export function getShow<A>(SA: Show<A>): Show<ReadonlyRecord<A>> {
-  return ({
+  return {
     show: (ua) =>
       `{${
-        Object.entries(ua).map(([key, value]) => `${key}: ${SA.show(value)}`)
+        Object.entries(ua)
+          .map(([key, value]) => `${key}: ${SA.show(value)}`)
           .join(", ")
       }}`,
-  });
+  };
 }
diff --git a/state.ts b/state.ts
index 028417a..06ef434 100644
--- a/state.ts
+++ b/state.ts
@@ -12,6 +12,8 @@ import type { InOut, Kind, Out } from "./kind.ts";
 import type { Monad } from "./monad.ts";
 
 import { flow, identity, pipe } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 /**
  * The State<E, A> type represents the core State structure. The input/output
@@ -315,3 +317,9 @@ export function execute<S>(s: S): <A>(ta: State<S, A>) => S {
  * @since 2.0.0
  */
 export const MonadState: Monad<KindState> = { of, ap, map, join, chain };
+
+export const Do = <A>() => of<A, A>(<A> {});
+
+export const bind = bind_(MonadState);
+
+export const bindTo = bindTo_(MonadState);
diff --git a/sync.ts b/sync.ts
index 7f17aa0..afb0dfa 100644
--- a/sync.ts
+++ b/sync.ts
@@ -5,6 +5,8 @@ import type { Monad } from "./monad.ts";
 import type { Traversable } from "./traversable.ts";
 
 import { constant, flow, pipe } from "./fn.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
 
 export type Sync<A> = () => A;
 
@@ -58,3 +60,9 @@ export const MonadSync: Monad<KindSync> = { of, ap, map, join, chain };
 export const ExtendsSync: Extend<KindSync> = { map, extend };
 
 export const TraversableSync: Traversable<KindSync> = { map, reduce, traverse };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadSync);
+
+export const bindTo = bindTo_(MonadSync);
diff --git a/sync_either.ts b/sync_either.ts
index d82f868..746012c 100644
--- a/sync_either.ts
+++ b/sync_either.ts
@@ -9,6 +9,9 @@ import type { Either } from "./either.ts";
 
 import * as E from "./either.ts";
 import * as I from "./sync.ts";
+import { bind as bind_ } from "./chain.ts";
+import { bindTo as bindTo_ } from "./functor.ts";
+
 import { constant, flow, identity, pipe } from "./fn.ts";
 
 export type SyncEither<L, R> = Sync<Either<L, R>>;
@@ -119,7 +122,14 @@ export function reduce<A, O>(
   foao: (o: O, a: A) => O,
   o: O,
 ): <B>(ta: SyncEither<B, A>) => O {
-  return (ta) => pipe(ta(), E.match(() => o, (a) => foao(o, a)));
+  return (ta) =>
+    pipe(
+      ta(),
+      E.match(
+        () => o,
+        (a) => foao(o, a),
+      ),
+    );
 }
 
 export const BifunctorSyncEither: Bifunctor<KindSyncEither> = {
@@ -140,3 +150,9 @@ export const AltSyncEither: Alt<KindSyncEither> = { alt, map };
 export const ExtendsSyncEither: Extend<KindSyncEither> = { map, extend };
 
 export const FoldableSyncEither: Foldable<KindSyncEither> = { reduce };
+
+export const Do = <A>() => of<A>(<A> {});
+
+export const bind = bind_(MonadSyncEither);
+
+export const bindTo = bindTo_(MonadSyncEither);
diff --git a/testing/async.test.ts b/testing/async.test.ts
index fd26974..b800ba7 100644
--- a/testing/async.test.ts
+++ b/testing/async.test.ts
@@ -19,6 +19,9 @@ function throwAsync(n: number): Promise<number> {
   return Promise.resolve(n);
 }
 
+const assertEqualsT = async <A>(actual: A.Async<A>, expected: A.Async<A>) =>
+  assertEquals(await actual(), await expected());
+
 Deno.test("Async of", async () => {
   assertEquals(await A.of(0)(), 0);
 });
@@ -44,7 +47,10 @@ Deno.test("Async of", async () => {
 
 Deno.test("Async apParallel", async () => {
   assertEquals(
-    await pipe(A.of((n: number) => n + 1), A.apParallel(A.of(1)))(),
+    await pipe(
+      A.of((n: number) => n + 1),
+      A.apParallel(A.of(1)),
+    )(),
     2,
   );
 });
@@ -58,31 +64,34 @@ Deno.test("Async join", async () => {
 });
 
 Deno.test("Async chain", async () => {
-  assertEquals(await pipe(A.of(1), A.chain((n) => A.of(n + 1)))(), 2);
+  assertEquals(
+    await pipe(
+      A.of(1),
+      A.chain((n) => A.of(n + 1)),
+    )(),
+    2,
+  );
 });
 
 Deno.test("Async apSeq", async () => {
   assertEquals(
-    await pipe(A.of((n: number) => n + 1), A.apSequential(A.of(1)))(),
+    await pipe(
+      A.of((n: number) => n + 1),
+      A.apSequential(A.of(1)),
+    )(),
     2,
   );
 });
 
-// Deno.test("Async Do, bind, bindTo", () => {
-//   assertEquals(
-//     pipe(
-//       A.Do<number, number, number>(),
-//       A.bind("one", () => A.of(1)),
-//       A.bind("two", ({ one }) => A.of(one + one)),
-//       A.map(({ one, two }) => one + two),
-//     ),
-//     A.of(3),
-//   );
-//   assertEquals(
-//     pipe(
-//       A.of(1),
-//       A.bindTo("one"),
-//     ),
-//     A.of({ one: 1 }),
-//   );
-// });
+Deno.test("Async Do, bind, bindTo", () => {
+  assertEqualsT(
+    pipe(
+      A.Do<number>(),
+      A.bind("one", () => A.of(1)),
+      A.bind("two", ({ one }) => A.of(one + one)),
+      A.map(({ one, two }) => one + two),
+    ),
+    A.of(3),
+  );
+  assertEqualsT(pipe(A.of(1), A.bindTo("one")), A.of({ one: 1 }));
+});
diff --git a/testing/async_either.test.ts b/testing/async_either.test.ts
index 93ee3ab..69c24a6 100644
--- a/testing/async_either.test.ts
+++ b/testing/async_either.test.ts
@@ -155,21 +155,21 @@ Deno.test("AsyncEither match", async () => {
   assertEquals(await fold(AE.left("asdf"))(), "asdf");
 });
 
-// Deno.test("AsyncEither Do, bind, bindTo", () => {
-//   assertEqualsT(
-//     pipe(
-//       AE.Do<number, number, number>(),
-//       AE.bind("one", () => AE.right(1)),
-//       AE.bind("two", ({ one }) => AE.right(one + one)),
-//       AE.map(({ one, two }) => one + two),
-//     ),
-//     AE.right(3),
-//   );
-//   assertEqualsT(
-//     pipe(
-//       AE.right(1),
-//       AE.bindTo("one"),
-//     ),
-//     AE.right({ one: 1 }),
-//   );
-// });
+Deno.test("AsyncEither Do, bind, bindTo", () => {
+  assertEqualsT(
+    pipe(
+      AE.Do<number>(),
+      AE.bind("one", () => AE.right(1)),
+      AE.bind("two", ({ one }) => AE.right(one + one)),
+      AE.map(({ one, two }) => one + two),
+    ),
+    AE.right(3),
+  );
+  assertEqualsT(
+    pipe(
+      AE.right(1),
+      AE.bindTo("one"),
+    ),
+    AE.right({ one: 1 }),
+  );
+});
diff --git a/testing/datum.test.ts b/testing/datum.test.ts
index 40dca62..6a174c8 100644
--- a/testing/datum.test.ts
+++ b/testing/datum.test.ts
@@ -308,21 +308,21 @@ Deno.test("Datum traverse", () => {
   assertEquals(add(D.refresh(1)), O.some(D.refresh(1)));
 });
 
-// Deno.test("Datum Do, bind, bindTo", () => {
-//   assertEquals(
-//     pipe(
-//       D.Do(),
-//       D.bind("one", () => D.replete(1)),
-//       D.bind("two", ({ one }) => D.refresh(one + one)),
-//       D.map(({ one, two }) => one + two),
-//     ),
-//     D.refresh(3),
-//   );
-//   assertEquals(
-//     pipe(
-//       D.replete(1),
-//       D.bindTo("one"),
-//     ),
-//     D.replete({ one: 1 }),
-//   );
-// });
+Deno.test("Datum Do, bind, bindTo", () => {
+  assertEquals(
+    pipe(
+      D.Do(),
+      D.bind("one", () => D.replete(1)),
+      D.bind("two", ({ one }) => D.refresh(one + one)),
+      D.map(({ one, two }) => one + two),
+    ),
+    D.refresh(3),
+  );
+  assertEquals(
+    pipe(
+      D.replete(1),
+      D.bindTo("one"),
+    ),
+    D.replete({ one: 1 }),
+  );
+});
diff --git a/testing/either.test.ts b/testing/either.test.ts
index 3fa2c1e..fe6da98 100644
--- a/testing/either.test.ts
+++ b/testing/either.test.ts
@@ -210,21 +210,21 @@ Deno.test("Either chainLeft", () => {
   assertEquals(chainLeft(E.left(1)), E.right(1));
 });
 
-// Deno.test("Datum Do, bind, bindTo", () => {
-//   assertEquals(
-//     pipe(
-//       E.Do(),
-//       E.bind("one", () => E.right(1)),
-//       E.bind("two", ({ one }) => E.right(one + one)),
-//       E.map(({ one, two }) => one + two),
-//     ),
-//     E.right(3),
-//   );
-//   assertEquals(
-//     pipe(
-//       E.right(1),
-//       E.bindTo("one"),
-//     ),
-//     E.right({ one: 1 }),
-//   );
-// });
+Deno.test("Datum Do, bind, bindTo", () => {
+  assertEquals(
+    pipe(
+      E.Do(),
+      E.bind("one", () => E.right(1)),
+      E.bind("two", ({ one }) => E.right(one + one)),
+      E.map(({ one, two }) => one + two),
+    ),
+    E.right(3),
+  );
+  assertEquals(
+    pipe(
+      E.right(1),
+      E.bindTo("one"),
+    ),
+    E.right({ one: 1 }),
+  );
+});
diff --git a/testing/nilable.test.ts b/testing/nilable.test.ts
index 0e018de..3ed825b 100644
--- a/testing/nilable.test.ts
+++ b/testing/nilable.test.ts
@@ -30,11 +30,17 @@ Deno.test("Nilable fromPredicate", () => {
 
 Deno.test("Nilable tryCatch", () => {
   assertEquals(N.tryCatch(todo), N.nil);
-  assertEquals(N.tryCatch(() => 1), 1);
+  assertEquals(
+    N.tryCatch(() => 1),
+    1,
+  );
 });
 
 Deno.test("Nilable match", () => {
-  const match = N.match(() => 0, (n: number) => n);
+  const match = N.match(
+    () => 0,
+    (n: number) => n,
+  );
   assertEquals(match(null), 0);
   assertEquals(match(undefined), 0);
   assertEquals(match(1), 1);
@@ -118,27 +124,21 @@ Deno.test("Nilable alt", () => {
 });
 
 Deno.test("Nilable chain", () => {
-  const chain = N.chain((n: number) => n === 0 ? N.nil : n);
+  const chain = N.chain((n: number) => (n === 0 ? N.nil : n));
   assertEquals(chain(undefined), N.nil);
   assertEquals(chain(null), N.nil);
   assertEquals(chain(1), 1);
 });
 
-// Deno.test("Nilable Do, bind, bindTo", () => {
-//   assertEquals(
-//     pipe(
-//       N.Do(),
-//       N.bind("one", () => N.make(1)),
-//       N.bind("two", ({ one }) => N.make(one + one)),
-//       N.map(({ one, two }) => one + two),
-//     ),
-//     N.make(3),
-//   );
-//   assertEquals(
-//     pipe(
-//       N.make(1),
-//       N.bindTo("one"),
-//     ),
-//     N.make({ one: 1 }),
-//   );
-// });
+Deno.test("Nilable Do, bind, bindTo", () => {
+  assertEquals(
+    pipe(
+      N.Do(),
+      N.bind("one", () => N.make(1)),
+      N.bind("two", ({ one }) => N.make(one + one)),
+      N.map(({ one, two }) => one + two),
+    ),
+    N.make(3),
+  );
+  assertEquals(pipe(N.make(1), N.bindTo("one")), N.make({ one: 1 }));
+});
diff --git a/testing/option.test.ts b/testing/option.test.ts
index 62cb65e..126d9ad 100644
--- a/testing/option.test.ts
+++ b/testing/option.test.ts
@@ -39,7 +39,10 @@ Deno.test("Option tryCatch", () => {
 });
 
 Deno.test("Option match", () => {
-  const match = O.match(() => 0, (n: number) => n);
+  const match = O.match(
+    () => 0,
+    (n: number) => n,
+  );
   assertEquals(match(O.none), 0);
   assertEquals(match(O.some(1)), 1);
 });
@@ -104,7 +107,7 @@ Deno.test("Option join", () => {
 });
 
 Deno.test("Option chain", () => {
-  const fati = (n: number) => n === 0 ? O.none : O.some(n);
+  const fati = (n: number) => (n === 0 ? O.none : O.some(n));
   assertEquals(pipe(O.some(0), O.chain(fati)), O.none);
   assertEquals(pipe(O.some(1), O.chain(fati)), O.some(1));
   assertEquals(pipe(O.none, O.chain(fati)), O.none);
@@ -118,7 +121,7 @@ Deno.test("Option reduce", () => {
 
 Deno.test("Option traverse", () => {
   const t1 = O.traverse(O.MonadOption);
-  const t2 = t1((n: number) => n === 0 ? O.none : O.some(1));
+  const t2 = t1((n: number) => (n === 0 ? O.none : O.some(1)));
   assertEquals(t2(O.none), O.some(O.none));
   assertEquals(t2(O.some(0)), O.none);
   assertEquals(t2(O.some(1)), O.some(O.some(1)));
@@ -168,7 +171,12 @@ Deno.test("Option partitionMap", () => {
 });
 
 Deno.test("Option extend", () => {
-  const extend = O.extend(O.match(() => -1, (n: number) => n + 1));
+  const extend = O.extend(
+    O.match(
+      () => -1,
+      (n: number) => n + 1,
+    ),
+  );
   assertEquals(extend(O.some(0)), O.some(1));
   assertEquals(extend(O.none), O.some(-1));
 });
@@ -223,21 +231,15 @@ Deno.test("Option getMonoid", () => {
   assertEquals(empty(), O.none);
 });
 
-// Deno.test("Option Do, bind, bindTo", () => {
-//   assertEquals(
-//     pipe(
-//       O.Do(),
-//       O.bind("one", () => O.some(1)),
-//       O.bind("two", ({ one }) => O.some(one + one)),
-//       O.map(({ one, two }) => one + two),
-//     ),
-//     O.some(3),
-//   );
-//   assertEquals(
-//     pipe(
-//       O.some(1),
-//       O.bindTo("one"),
-//     ),
-//     O.some({ one: 1 }),
-//   );
-// });
+Deno.test("Option Do, bind, bindTo", () => {
+  assertEquals(
+    pipe(
+      O.Do(),
+      O.bind("one", () => O.some(1)),
+      O.bind("two", ({ one }) => O.some(one + one)),
+      O.map(({ one, two }) => one + two),
+    ),
+    O.some(3),
+  );
+  assertEquals(pipe(O.some(1), O.bindTo("one")), O.some({ one: 1 }));
+});
diff --git a/testing/state.test.ts b/testing/state.test.ts
index 6951d3c..7437751 100644
--- a/testing/state.test.ts
+++ b/testing/state.test.ts
@@ -19,7 +19,10 @@ Deno.test("State put", () => {
 });
 
 Deno.test("State modify", () => {
-  assertEqualsS(S.modify((n: number) => n + 1), S.put(2));
+  assertEqualsS(
+    S.modify((n: number) => n + 1),
+    S.put(2),
+  );
 });
 
 Deno.test("State gets", () => {
@@ -34,8 +37,7 @@ Deno.test("State of", () => {
   assertEqualsS(S.of(1), S.id<number>());
 });
 
-Deno.test("State ap", () => {
-});
+Deno.test("State ap", () => {});
 
 Deno.test("State map", () => {
   assertEqualsS(pipe(S.id<number>(), S.map(add)), S.state(2, 1));
@@ -50,7 +52,10 @@ Deno.test("State join", () => {
 
 Deno.test("State chain", () => {
   assertEqualsS(
-    pipe(S.id<number>(), S.chain((n) => S.gets((m) => n + m))),
+    pipe(
+      S.id<number>(),
+      S.chain((n) => S.gets((m) => n + m)),
+    ),
     S.state(2, 1),
   );
 });
@@ -63,21 +68,15 @@ Deno.test("State execute", () => {
   assertEquals(pipe(S.id<number>(), S.execute(0)), 0);
 });
 
-// Deno.test("State Do, bind, bindTo", () => {
-//   assertEqualsS(
-//     pipe(
-//       S.Do<number, number, number>(),
-//       S.bind("one", () => S.make(1, 1)),
-//       S.bind("two", ({ one }) => S.make(one + one, 1)),
-//       S.map(({ one, two }) => one + two),
-//     ),
-//     S.make(3, 1),
-//   );
-//   assertEqualsS(
-//     pipe(
-//       S.make(1, 1),
-//       S.bindTo("one"),
-//     ),
-//     S.make({ one: 1 }, 1),
-//   );
-// });
+Deno.test("State Do, bind, bindTo", () => {
+  assertEqualsS(
+    pipe(
+      S.Do<number>(),
+      S.bind("one", () => S.state(1, 1)),
+      S.bind("two", ({ one }) => S.state(one + one, 1)),
+      S.map(({ one, two }) => one + two),
+    ),
+    S.state(3, 1),
+  );
+  assertEqualsS(pipe(S.state(1, 1), S.bindTo("one")), S.state({ one: 1 }, 1));
+});
diff --git a/testing/sync_either.test.ts b/testing/sync_either.test.ts
index d49f907..54a9322 100644
--- a/testing/sync_either.test.ts
+++ b/testing/sync_either.test.ts
@@ -125,21 +125,21 @@ Deno.test("SyncEither chainLeft", () => {
   assertEqualsIO(chainLeft(SE.left(1)), SE.right(2));
 });
 
-// Deno.test("Datum Do, bind, bindTo", () => {
-//   assertEqualsIO(
-//     pipe(
-//       SE.Do(),
-//       SE.bind("one", () => SE.right(1)),
-//       SE.bind("two", ({ one }) => SE.right(one + one)),
-//       SE.map(({ one, two }) => one + two),
-//     ),
-//     SE.right(3),
-//   );
-//   assertEqualsIO(
-//     pipe(
-//       SE.right(1),
-//       SE.bindTo("one"),
-//     ),
-//     SE.right({ one: 1 }),
-//   );
-// });
+Deno.test("Datum Do, bind, bindTo", () => {
+  assertEqualsIO(
+    pipe(
+      SE.Do(),
+      SE.bind("one", () => SE.right(1)),
+      SE.bind("two", ({ one }) => SE.right(one + one)),
+      SE.map(({ one, two }) => one + two),
+    ),
+    SE.right(3),
+  );
+  assertEqualsIO(
+    pipe(
+      SE.right(1),
+      SE.bindTo("one"),
+    ),
+    SE.right({ one: 1 }),
+  );
+});