kind-adt 0.2.0 → 0.2.1

package/README.md

@@ -597,12 +597,101 @@ import { show } from "showify";
 export function println(...args: unknown[]) {
   console.log(
     ...args.map((arg) =>
-      typeof arg === "string" ? arg : show(arg, { colors: true, trailingComma: "true", indent: 2 }),
+      typeof arg === "string" ? arg : show(arg, { colors: true, trailingComma: "auto", indent: 2 }),
     ),
   );
 }
 ```
 
+### Add your own methods to ADTs
+
+> [!WARNING]
+>
+> This feature is not recommended for most users, as it may lead to unexpected behavior while module resolution. Use it at your own risk.
+
+ADTs and ADT constructors in kind-adt use a prototype chain to provide “methods” like `.pipe()`. Due to the nature of how prototypes work in JavaScript, you can add your own methods (or “[monkey patch](https://en.wikipedia.org/wiki/Monkey_patch)”) to ADTs or ADT constructors by modifying the prototype of the ADT or ADT constructor.
+
+kind-adt exports four prototypes for you to use, including the `PipeableProto` mentioned in the [Functional pipelines with `.pipe()`](#functional-pipelines-with-pipe) section:
+
+```typescript
+import {
+  type Pipeable,
+  PipeableProto,
+  type PipeableFunction,
+  PipeableFunctionProto,
+  type ADT,
+  ADTProto,
+  type ADTConstructor,
+  ADTConstructorProto,
+} from "kind-adt";
+```
+
+Each `XxxProto` has a related `Xxx` type, which is the type of the object that can be created from the prototype. ADTs and ADT constructors in kind-adt follow the following prototype chain:
+
+```typescript
+╔══════════════════════════════════╗   ╔════════════╗   ╔═════════════════╗
+║ Concrete ADT (e.g., `Some(...)`) ║ ← ║ `ADTProto` ║ ← ║ `PipeableProto` ║
+╚══════════════════════════════════╝   ╚════════════╝   ╚═════════════════╝
+
+╔═════════════════════════════════════════╗   ╔═══════════════════════╗   ╔═════════════════════════╗
+║ Concrete ADT constructor (e.g., `None`) ║ ← ║ `ADTConstructorProto` ║ ← ║ `PipeableFunctionProto` ║
+╚═════════════════════════════════════════╝   ╚═══════════════════════╝   ╚═════════════════════════╝
+```
+
+Note that though ADTs and ADT constructors share the same `.pipe()` method, they actually have independent prototype chains. This means that you have to patch both prototypes if you want to add your own methods to both ADTs and ADT constructors.
+
+The following example shows how to add a `.println()` method to add ADTs and ADT constructors with type safety. We’ll create a `patches.ts` file to add the method to the prototypes of ADTs and ADT constructors.
+
+```typescript
+// patches.ts
+import { type ADT, ADTProto, type ADTConstructor, ADTConstructorProto } from "kind-adt";
+import { show } from "showify";
+
+/* Make TypeScript aware of the new method with a module augmentation
+   https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation */
+declare module "kind-adt" {
+  interface ADT {
+    println(): void;
+  }
+
+  interface ADTConstructor {
+    println(): void;
+  }
+}
+
+/* Add the method to the ADT prototype */
+ADTProto.println = function println(this: ADT) {
+  console.log(show(this, { colors: true, trailingComma: "auto", indent: 2 }));
+};
+ADTConstructorProto.println = function println(this: ADTConstructor) {
+  console.log(show(this, { colors: true, trailingComma: "auto", indent: 2 }));
+};
+
+/* Ensure TypeScript treats this file as a module */
+export {};
+```
+
+Then you can import the `patches.ts` file in your main file to apply the patches:
+
+```typescript
+import "./patches"; // Import the patches file
+
+import { type Data, make } from "kind-adt";
+
+type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
+
+const { Some, None } = make<OptionHKT>();
+interface OptionHKT extends HKT {
+  return: Option<Arg0<this>>;
+}
+
+Some(42).println(); // Prints: Some(42)
+None.println(); // Prints: None
+```
+
 ## FAQ
 
 ### I don’t want to install another package for HKT. Can I implement my own?

package/index.d.ts

@@ -126,12 +126,89 @@ export interface Pipeable {
   // 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.
- */
+/** The prototype to build a {@linkcode Pipeable} object. */
 export const PipeableProto: Pipeable;
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export interface PipeableFunction extends Function {
+  /**
+   * 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 PipeableFunction}. */
+export const PipeableFunctionProto: PipeableFunction;
+
+export interface ADT extends Pipeable {}
+/** The prototype of ADTs. */
+export const ADTProto: ADT;
+
+export interface ADTConstructor extends PipeableFunction {}
+/** The prototype of ADT constructors. */
+export const ADTConstructorProto: ADTConstructor;
+
 /**************
  * Main types *
  **************/
@@ -172,7 +249,7 @@ export type Tagged<
     { readonly [I in IndexOf<Fields> as `_${I}`]: Fields[I] }
   : never
 > &
-  Pipeable;
+  ADT;
 
 /**
  * Create an ADT with tagged types.
@@ -382,16 +459,16 @@ export type Constructor<
   [Type] extends (
     [Tagged] // Non-generic ADT
   ) ?
-    { readonly _tag: Tag } & Pipeable &
+    { readonly _tag: Tag } & ADT &
       ((...args: ExtractFields<Extract<Type, Tagged<Tag>>>) => Type)
   : // Generic ADT
   Type extends TypeLambda<[never], unknown> ?
     unknown extends _UpperBound<HKTParams<Type>[0]> ?
-      { readonly _tag: Tag } & Pipeable &
+      { readonly _tag: Tag } & ADT &
         (<T = never>(
           ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
         ) => ApplyHKT<Type, [T]>)
-    : { readonly _tag: Tag } & Pipeable &
+    : { readonly _tag: Tag } & ADT &
         (<T extends _UpperBound<HKTParams<Type>[0]> = never>(
           ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T]>, Tag>>
         ) => ApplyHKT<Type, [T]>)
@@ -399,21 +476,21 @@ export type Constructor<
     [unknown, unknown] extends (
       [_UpperBound<HKTParams<Type>[0]>, _UpperBound<HKTParams<Type>[1]>]
     ) ?
-      { readonly _tag: Tag } & Pipeable &
+      { readonly _tag: Tag } & ADT &
         (<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 } & Pipeable &
+      { readonly _tag: Tag } & ADT &
         (<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 } & Pipeable &
+      { readonly _tag: Tag } & ADT &
         (<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 &
+    : { readonly _tag: Tag } & ADT &
         (<
           T extends _UpperBound<HKTParams<Type>[0]> = never,
           U extends _UpperBound<HKTParams<Type>[1]> = never,
@@ -421,7 +498,7 @@ export type Constructor<
           ...args: ExtractFields<FilterTagged<ApplyHKT<Type, [T, U]>, Tag>>
         ) => ApplyHKT<Type, [T, U]>)
   : Type extends TypeLambda<[never, never, never], unknown> ?
-    { readonly _tag: Tag } & Pipeable &
+    { readonly _tag: Tag } & ADT &
       (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
         U extends _UpperBound<HKTParams<Type>[1]> = never,
@@ -430,7 +507,7 @@ export type Constructor<
         ...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 &
+    { readonly _tag: Tag } & ADT &
       (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
         U extends _UpperBound<HKTParams<Type>[1]> = never,
@@ -440,7 +517,7 @@ export type Constructor<
         ...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 } & Pipeable &
+    { readonly _tag: Tag } & ADT &
       (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
         U extends _UpperBound<HKTParams<Type>[1]> = never,
@@ -455,7 +532,7 @@ export type Constructor<
   : Type extends (
     TypeLambda<[never, never, never, never, never, never], unknown>
   ) ?
-    { readonly _tag: Tag } & Pipeable &
+    { readonly _tag: Tag } & ADT &
       (<
         T extends _UpperBound<HKTParams<Type>[0]> = never,
         U extends _UpperBound<HKTParams<Type>[1]> = never,

package/index.js

@@ -36,11 +36,7 @@ export function make(variants) {
           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 }),
-        }
+        { _tag: tag }
       ),
       ADTConstructorProto
     );
@@ -394,6 +390,29 @@ function inspect({ ancestors, c, level }, expand) {
     body = body.values[2];
   }
 
+  let shouldCollapse = false;
+  let firstFieldNode;
+  if (fields.length === 1) {
+    firstFieldNode = expand(fields[0]);
+    shouldCollapse =
+      firstFieldNode.type === "between" ||
+      (firstFieldNode.type === "variant" &&
+        firstFieldNode.inline.type === "between" &&
+        firstFieldNode.wrap.type === "between") ||
+      (firstFieldNode.type === "sequence" &&
+        firstFieldNode.values.slice(0, -1).every((v) => v.type === "text") &&
+        firstFieldNode.values[firstFieldNode.values.length - 1].type ===
+          "between") ||
+      (firstFieldNode.type === "sequence" &&
+        firstFieldNode.values.slice(0, -1).every((v) => v.type === "text") &&
+        firstFieldNode.values[firstFieldNode.values.length - 1].type ===
+          "variant" &&
+        firstFieldNode.values[firstFieldNode.values.length - 1].inline.type ===
+          "between" &&
+        firstFieldNode.values[firstFieldNode.values.length - 1].wrap.type ===
+          "between");
+  }
+
   return (
     fields.length ?
       variant(
@@ -405,17 +424,25 @@ function inspect({ ancestors, c, level }, expand) {
           ...(body.type === "text" ? [text(")")] : [text(") "), body]),
         ]),
         body.type === "text" ?
-          between(
-            fields.map((field) => pair(expand(field), text(","))),
-            text(c.cyan(this._tag) + "("),
-            text(")")
-          )
-        : pair(
-            between(
+          shouldCollapse ?
+            sequence([text(c.cyan(this._tag) + "("), firstFieldNode, text(")")])
+          : between(
               fields.map((field) => pair(expand(field), text(","))),
               text(c.cyan(this._tag) + "("),
-              text(") ")
-            ),
+              text(")")
+            )
+        : pair(
+            shouldCollapse ?
+              sequence([
+                text(c.cyan(this._tag) + "("),
+                firstFieldNode,
+                text(") "),
+              ])
+            : between(
+                fields.map((field) => pair(expand(field), text(","))),
+                text(c.cyan(this._tag) + "("),
+                text(") ")
+              ),
             body
           )
       )
@@ -470,10 +497,18 @@ export const PipeableProto = {
   },
 };
 
-const ADTProto = {
-  ...PipeableProto,
-  [Symbol.for("showify.inspect.custom")]: inspect,
-};
+export const PipeableFunctionProto = { ...PipeableProto };
+Object.setPrototypeOf(PipeableFunctionProto, Function.prototype);
+
+export const ADTProto = Object.create(PipeableProto);
+ADTProto[Symbol.for("showify.inspect.custom")] = inspect;
 
-const ADTConstructorProto = { ...ADTProto };
-Object.setPrototypeOf(ADTConstructorProto, Function.prototype);
+export const ADTConstructorProto = Object.create(PipeableFunctionProto);
+ADTConstructorProto.toJSON = function toJSON() {
+  return { _tag: this.tag };
+};
+ADTConstructorProto[Symbol.for("nodejs.util.inspect.custom")] =
+  function inspect() {
+    return { _tag: this.tag };
+  };
+ADTConstructorProto[Symbol.for("showify.inspect.custom")] = inspect;

package/package.json

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