kind-adt 0.1.1 → 0.1.3

package/README.md

@@ -48,13 +48,14 @@ function safeDivide(n: number, d: number) {
 match(safeDivide(42, 2), {
   Some: (n) => console.log("Result:", n),
   None: () => console.log("Division by zero!"),
-});
+});
 ```
 
 ## Features
 
 - _One_ type to define your **A**lgebraic **D**ata **T**ype (`Data`).
 - _One_ function to create **constructors**, **deconstructors**, **type guards** and **pattern matching function** for your ADT with **type safety** (`make`).
+- Support for **functional pipelines** with a [`.pipe()` method](#functional-pipelines-with-pipe) on all ADTs.
 - [**Readable type signatures**](#provide-more-readable-type-signatures) for your ADT with _labeled tuples_.
 - [**Recursive ADTs**](#recursive-adts) with ease.
 - Tiny footprint (~1kB minzipped).
@@ -197,6 +198,8 @@ pipe(
 ); // => 84
 ```
 
+See also the [functional pipelines with `.pipe()`](#functional-pipelines-with-pipe) section for details on kind-adt’s built-in alternative to external pipe utilities.
+
 Note that `ADT.match` requires the return type of each case to be the same. To allow different return types, you can use the `ADT.matchW` function, where the `W` suffix stands for _wider_. `ADT.matchW` can be used the same way as `ADT.match`, supporting both curried and non-curried overloads.
 
 <div align="right">
@@ -250,6 +253,60 @@ type None = Extract<Option<unknown>, Tagged<"None">>;
 // }
 ```
 
+### Functional pipelines with `.pipe()`
+
+Every ADT in kind-adt supports a `.pipe()` method, allowing for a more functional and fluent style of programming similar to libraries like [Effect](https://github.com/Effect-TS/effect) or [RxJS](https://rxjs.dev/api/index/function/pipe).
+
+```typescript
+import { type Data, make } from "kind-adt";
+import type { Arg0, HKT } from "hkt-core";
+
+type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
+
+const { Some, None, match } = make<OptionHKT>();
+interface OptionHKT extends HKT {
+  return: Option<Arg0<this>>;
+}
+
+const map: <T, R>(fn: (value: T) => R) => (opt: Option<T>) => Option<R> = (fn) =>
+  match({
+    Some: (value) => Some(fn(value)),
+    None: () => None,
+  });
+
+// Using pipe with an ADT
+Some(42).pipe(
+  map((n) => n + 1),
+  map((n) => n * 2),
+  match({
+    Some: (n) => console.log("Result:", n),
+    None: () => console.log("No value"),
+  }),
+);
+//> Result: 86
+```
+
+Under the hood, any value returned by a constructor already has a `.pipe()` method, which takes a sequence of functions and applies them one after another, with each function receiving the result of the previous function.
+
+You can also create your own objects with the same `.pipe()` functionality using the exported `Pipeable` interface and `PipeableProto`:
+
+```typescript
+import { type Pipeable, PipeableProto } from "kind-adt";
+
+// Create a pipeable object
+const myData = Object.create(PipeableProto);
+myData.value = 42;
+
+// Use the pipe method
+const result = myData.pipe(
+  (obj) => obj.value * 2,
+  (n) => n.toString(),
+); // => "84"
+```
+
 ### Provide more readable type signatures
 
 Let’s revisit the `Option<T>` example in the quickstart section.

package/index.d.ts

@@ -54,6 +54,84 @@ export function make<F extends Tagged | TypeLambda<never, Tagged>>(
  */
 export function unwrap<T extends Tagged>(adt: T): ExtractFields<T>;
 
+/**
+ * A type that supports an [RxJS](https://rxjs.dev/api/index/function/pipe)-like
+ * (or [Effect](https://github.com/Effect-TS/effect)-like) `.pipe()` method.
+ */
+export interface Pipeable {
+  /**
+   * Pipe the value through a series of functions.
+   *
+   * **Example**
+   *
+   * ```typescript
+   * import { type Data, make } from "kind-adt";
+   *
+   * type BoxNumber = Data<{
+   *   Box: [number];
+   * }>;
+   * const { Box } = make<BoxNumber>();
+   *
+   * Box(42).pipe((box) => box._0 + 1, (n) => n * 2, (n) => n.toString()); // => "86"
+   * ```
+   */
+  pipe<A>(this: A): A;
+  pipe<A, B = never>(this: A, ab: (a: A) => B): B;
+  // prettier-ignore
+  pipe<A, B = never, C = never>(this: A, ab: (a: A) => B, bc: (b: B) => C): C;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E): E;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F): F;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G): G;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H): H;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I): I;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J): J;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K): K;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L): L;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M): M;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N): N;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O): O;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P): P;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q): Q;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R): R;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S): S;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T): T;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U): U;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V): V;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W): W;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X): X;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never, Y = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y): Y;
+  // prettier-ignore
+  pipe<A, B = never, C = never, D = never, E = never, F = never, G = never, H = never, I = never, J = never, K = never, L = never, M = never, N = never, O = never, P = never, Q = never, R = never, S = never, T = never, U = never, V = never, W = never, X = never, Y = never, Z = never>(this: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (t: T) => U, uv: (u: U) => V, vw: (v: V) => W, wx: (w: W) => X, xy: (x: X) => Y, yz: (y: Y) => Z): Z;
+}
+
+/**
+ * The prototype to build a {@linkcode Pipeable} object.
+ */
+export const PipeableProto: Pipeable;
+
 /**************
  * Main types *
  **************/
@@ -93,7 +171,8 @@ export type Tagged<
   ) extends infer Fields ?
     { readonly [I in IndexOf<Fields> as `_${I}`]: Fields[I] }
   : never
->;
+> &
+  Pipeable;
 
 /**
  * Create an ADT with tagged types.
@@ -303,89 +382,92 @@ export type Constructor<
   [Type] extends (
     [Tagged] // Non-generic ADT
   ) ?
-    { readonly _tag: Tag } & ((
-      ...args: ExtractFields<Extract<Type, Tagged<Tag>>>
-    ) => Type)
+    { readonly _tag: Tag } & Pipeable &
+      ((...args: ExtractFields<Extract<Type, Tagged<Tag>>>) => Type)
   : // Generic ADT
   Type extends TypeLambda<[never], unknown> ?
     unknown extends _UpperBound<HKTParams<Type>[0]> ?
-      { readonly _tag: Tag } & (<T = never>(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
-      ) => ApplyHKT<Type, [T]>)
-    : { readonly _tag: Tag } & (<
-        T extends _UpperBound<HKTParams<Type>[0]> = never,
-      >(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
-      ) => ApplyHKT<Type, [T]>)
+      { readonly _tag: Tag } & Pipeable &
+        (<T = never>(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
+        ) => ApplyHKT<Type, [T]>)
+    : { readonly _tag: Tag } & Pipeable &
+        (<T extends _UpperBound<HKTParams<Type>[0]> = never>(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
+        ) => ApplyHKT<Type, [T]>)
   : Type extends TypeLambda<[never, never], unknown> ?
     [unknown, unknown] extends (
       [_UpperBound<HKTParams<Type>[0]>, _UpperBound<HKTParams<Type>[1]>]
     ) ?
-      { readonly _tag: Tag } & (<T = never, U = never>(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
-      ) => ApplyHKT<Type, [T, U]>)
+      { readonly _tag: Tag } & Pipeable &
+        (<T = never, U = never>(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
+        ) => ApplyHKT<Type, [T, U]>)
     : unknown extends _UpperBound<HKTParams<Type>[0]> ?
-      { readonly _tag: Tag } & (<
-        T = never,
-        U extends _UpperBound<HKTParams<Type>[1]> = never,
-      >(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
-      ) => ApplyHKT<Type, [T, U]>)
+      { readonly _tag: Tag } & Pipeable &
+        (<T = never, U extends _UpperBound<HKTParams<Type>[1]> = never>(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
+        ) => ApplyHKT<Type, [T, U]>)
     : unknown extends _UpperBound<HKTParams<Type>[1]> ?
-      { readonly _tag: Tag } & (<
+      { readonly _tag: Tag } & Pipeable &
+        (<T extends _UpperBound<HKTParams<Type>[0]> = never, U = never>(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
+        ) => ApplyHKT<Type, [T, U]>)
+    : { readonly _tag: Tag } & Pipeable &
+        (<
+          T extends _UpperBound<HKTParams<Type>[0]> = never,
+          U extends _UpperBound<HKTParams<Type>[1]> = never,
+        >(
+          ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
+        ) => ApplyHKT<Type, [T, U]>)
+  : Type extends TypeLambda<[never, never, never], unknown> ?
+    { readonly _tag: Tag } & Pipeable &
+      (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
-        U = never,
+        U extends _UpperBound<HKTParams<Type>[1]> = never,
+        V extends _UpperBound<HKTParams<Type>[2]> = never,
       >(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
-      ) => ApplyHKT<Type, [T, U]>)
-    : { readonly _tag: Tag } & (<
+        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U, V]>, Tag>>
+      ) => ApplyHKT<Type, [T, U, V]>)
+  : Type extends TypeLambda<[never, never, never, never], unknown> ?
+    { readonly _tag: Tag } & Pipeable &
+      (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
         U extends _UpperBound<HKTParams<Type>[1]> = never,
+        V extends _UpperBound<HKTParams<Type>[2]> = never,
+        W extends _UpperBound<HKTParams<Type>[3]> = never,
       >(
-        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
-      ) => ApplyHKT<Type, [T, U]>)
-  : Type extends TypeLambda<[never, never, never], unknown> ?
-    { readonly _tag: Tag } & (<
-      T extends _UpperBound<HKTParams<Type>[0]> = never,
-      U extends _UpperBound<HKTParams<Type>[1]> = never,
-      V extends _UpperBound<HKTParams<Type>[2]> = never,
-    >(
-      ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U, V]>, Tag>>
-    ) => ApplyHKT<Type, [T, U, V]>)
-  : Type extends TypeLambda<[never, never, never, never], unknown> ?
-    { readonly _tag: Tag } & (<
-      T extends _UpperBound<HKTParams<Type>[0]> = never,
-      U extends _UpperBound<HKTParams<Type>[1]> = never,
-      V extends _UpperBound<HKTParams<Type>[2]> = never,
-      W extends _UpperBound<HKTParams<Type>[3]> = never,
-    >(
-      ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U, V, W]>, Tag>>
-    ) => ApplyHKT<Type, [T, U, V, W]>)
+        ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U, V, W]>, Tag>>
+      ) => ApplyHKT<Type, [T, U, V, W]>)
   : Type extends TypeLambda<[never, never, never, never, never], unknown> ?
-    { readonly _tag: Tag } & (<
-      T extends _UpperBound<HKTParams<Type>[0]> = never,
-      U extends _UpperBound<HKTParams<Type>[1]> = never,
-      V extends _UpperBound<HKTParams<Type>[2]> = never,
-      W extends _UpperBound<HKTParams<Type>[3]> = never,
-      X extends _UpperBound<HKTParams<Type>[4]> = never,
-    >(
-      ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U, V, W, X]>, Tag>>
-    ) => ApplyHKT<Type, [T, U, V, W, X]>)
+    { readonly _tag: Tag } & Pipeable &
+      (<
+        T extends _UpperBound<HKTParams<Type>[0]> = never,
+        U extends _UpperBound<HKTParams<Type>[1]> = never,
+        V extends _UpperBound<HKTParams<Type>[2]> = never,
+        W extends _UpperBound<HKTParams<Type>[3]> = never,
+        X extends _UpperBound<HKTParams<Type>[4]> = never,
+      >(
+        ...args: ExtractFields<
+          FilterTagged<ApplyHKT<Type, [T, U, V, W, X]>, Tag>
+        >
+      ) => ApplyHKT<Type, [T, U, V, W, X]>)
   : Type extends (
     TypeLambda<[never, never, never, never, never, never], unknown>
   ) ?
-    { readonly _tag: Tag } & (<
-      T extends _UpperBound<HKTParams<Type>[0]> = never,
-      U extends _UpperBound<HKTParams<Type>[1]> = never,
-      V extends _UpperBound<HKTParams<Type>[2]> = never,
-      W extends _UpperBound<HKTParams<Type>[3]> = never,
-      X extends _UpperBound<HKTParams<Type>[4]> = never,
-      Y extends _UpperBound<HKTParams<Type>[5]> = never,
-    >(
-      ...args: ExtractFields<
-        FilterTagged<ApplyHKT<Type, [T, U, V, W, X, Y]>, Tag>
-      >
-    ) => ApplyHKT<Type, [T, U, V, W, X, Y]>)
+    { readonly _tag: Tag } & Pipeable &
+      (<
+        T extends _UpperBound<HKTParams<Type>[0]> = never,
+        U extends _UpperBound<HKTParams<Type>[1]> = never,
+        V extends _UpperBound<HKTParams<Type>[2]> = never,
+        W extends _UpperBound<HKTParams<Type>[3]> = never,
+        X extends _UpperBound<HKTParams<Type>[4]> = never,
+        Y extends _UpperBound<HKTParams<Type>[5]> = never,
+      >(
+        ...args: ExtractFields<
+          FilterTagged<ApplyHKT<Type, [T, U, V, W, X, Y]>, Tag>
+        >
+      ) => ApplyHKT<Type, [T, U, V, W, X, Y]>)
   : /* support up to 6 type parameters */ never;
 
 /**
@@ -1412,7 +1494,7 @@ type HKTParams<F> =
  * type _1 = TolerantResult<OptionHKT>; // => Option<unknown>
  * ```
  */
-export type TolerantResult<F extends TypeLambda> =
+type TolerantResult<F extends TypeLambda> =
   HKTParams<F> extends infer Params extends unknown[] ?
     ApplyHKT<
       F,
@@ -1453,3 +1535,6 @@ type _CheckVariance<Lower, Upper> =
     : "covariant"
   : [Upper] extends [Lower] ? "contravariant"
   : "invariant";
+
+/* Ensure TypeScript treats this file as a module to prevent internal from exportation */
+export {};

package/index.js

@@ -28,17 +28,21 @@ export function make(variants) {
 
   /* Constructor */
   const createConstructor = (tag) =>
-    Object.assign(
-      renameFunction((...args) => {
-        const result = { _tag: tag };
-        for (let i = 0; i < args.length; i++) result["_" + i] = args[i];
-        return result;
-      }, tag),
-      {
-        _tag: tag,
-        toJSON: () => ({ _tag: tag }),
-        [Symbol.for("nodejs.util.inspect.custom")]: () => ({ _tag: tag }),
-      },
+    Object.setPrototypeOf(
+      Object.assign(
+        renameFunction((...args) => {
+          const result = Object.create(PipeableProto);
+          result._tag = tag;
+          for (let i = 0; i < args.length; i++) result["_" + i] = args[i];
+          return result;
+        }, tag),
+        {
+          _tag: tag,
+          toJSON: () => ({ _tag: tag }),
+          [Symbol.for("nodejs.util.inspect.custom")]: () => ({ _tag: tag }),
+        },
+      ),
+      PipeableFunctionProto,
     );
 
   const result = {
@@ -344,3 +348,42 @@ const stringify = (value) => {
 
   return serialize(value, []);
 };
+
+export const PipeableProto = {
+  pipe(...fs) {
+    // Optimization inspired by Effect
+    // https://github.com/Effect-TS/effect/blob/f293e97ab2a26f45586de106b85119c5d98ab4c7/packages/effect/src/Pipeable.ts#L491-L524
+    switch (fs.length) {
+      case 0:
+        return this;
+      case 1:
+        return fs[0](this);
+      case 2:
+        return fs[1](fs[0](this));
+      case 3:
+        return fs[2](fs[1](fs[0](this)));
+      case 4:
+        return fs[3](fs[2](fs[1](fs[0](this))));
+      case 5:
+        return fs[4](fs[3](fs[2](fs[1](fs[0](this)))));
+      case 6:
+        return fs[5](fs[4](fs[3](fs[2](fs[1](fs[0](this))))));
+      case 7:
+        return fs[6](fs[5](fs[4](fs[3](fs[2](fs[1](fs[0](this)))))));
+      case 8:
+        return fs[7](fs[6](fs[5](fs[4](fs[3](fs[2](fs[1](fs[0](this))))))));
+      case 9:
+        return fs[8](
+          fs[7](fs[6](fs[5](fs[4](fs[3](fs[2](fs[1](fs[0](this)))))))),
+        );
+      default: {
+        let result = this;
+        for (const f of fs) result = f(result);
+        return result;
+      }
+    }
+  },
+};
+
+const PipeableFunctionProto = { pipe: PipeableProto.pipe };
+Object.setPrototypeOf(PipeableFunctionProto, Function.prototype);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kind-adt",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "🪴 The kind of ADTs you can count on in TypeScript",
   "keywords": [
     "typescript",

package/utils.d.ts

@@ -1,5 +1,4 @@
 import type { ShowOptions } from "showify";
-
 /**
  * Print arguments including (possibly) ADTs to `stdout` with newline.
  * @param args The arguments to print.
@@ -25,7 +24,6 @@ import type { ShowOptions } from "showify";
  * @see {@linkcode show} if you want more control over the output.
  */
 export declare function println(...args: unknown[]): void;
-
 /**
  * Stringify a (possibly) ADT to human-readable format.
  * @param value The value to stringify.

package/utils.js

@@ -29,8 +29,10 @@ const { between, pair, sequence, text, variant } = SerializerNode;
  * @see {@linkcode show} if you want more control over the output.
  */
 export function println(...args) {
-  getConsole().log(
-    ...args.map((arg) => (typeof arg === "string" ? arg : show(arg, { colors: true, indent: 2 }))),
+  console.log(
+    ...args.map((arg) =>
+      typeof arg === "string" ? arg : show(arg, { colors: true, indent: 2 }),
+    ),
   );
 }
 
@@ -103,7 +105,9 @@ export function show(value, options = {}) {
                 sequence([
                   text(c.cyan(val._tag) + "("),
                   ...flatMap(fields, (field, i, arr) =>
-                    i === arr.length - 1 ? expand(field) : [expand(field), text(", ")],
+                    i === arr.length - 1 ?
+                      expand(field)
+                    : [expand(field), text(", ")],
                   ),
                   ...(body.type === "text" ? [text(")")] : [text(") "), body]),
                 ]),
@@ -150,19 +154,3 @@ const flatMap = (arr, fn) => {
   }
   return result;
 };
-
-// `console` is not standard in JavaScript. Though rare, it is possible that `console` is not
-// available in some environments. We use a proxy to handle this case and ignore errors if `console`
-// is not available.
-const getConsole = (() => {
-  let cachedConsole = undefined;
-  return () => {
-    if (cachedConsole !== undefined) return cachedConsole;
-    try {
-      cachedConsole = new Function("return console")();
-    } catch {
-      cachedConsole = null;
-    }
-    return cachedConsole;
-  };
-})();