kind-adt 0.1.2 → 0.2.0

package/README.md

@@ -58,8 +58,8 @@ match(safeDivide(42, 2), {
 - 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).
-- Debug your ADTs with [optional utilities](#optional-utilities) ([`println`](#println) and [`show`](#show)) from `kind-adt/utils`.
+- Tiny footprint (~2kB minzipped).
+- Convert your ADTs to human-readable strings with [showify](https://github.com/Snowflyt/showify) integration.
 
 ## Installation
 
@@ -95,7 +95,7 @@ You can create **constructors**, **deconstructors** and **type guards** using th
 
 ```typescript
 import { make } from "kind-adt";
-import { println } from "kind-adt/utils";
+import { show } from "showify"; // Optional dependency
 import type { Arg0, HKT } from "hkt-core";
 
 export const { Some, None, match: matchOption, isSome, ifSome /* ... */ } = make<OptionHKT>();
@@ -106,8 +106,9 @@ interface OptionHKT extends HKT {
 Some(42); // => { _tag: "Some", _0: 42 }
 // ^?: <number>(args_0: number) => Option<number>
 
-// Use `println` to print the ADT in a readable format
-println(Some(42)); // Some(42)
+// Use `show` from showify to print the ADT in a readable format
+console.log(show(Some(42), { indent: 2, trailingComma: "auto", colors: true }));
+// Some(42)
 ```
 
 <details>
@@ -123,9 +124,6 @@ export const IpAddr = make<IpAddr>();
 
 IpAddr.V4(127, 0, 0, 1); // => { _tag: "V4", _0: 127, _1: 0, _2: 0, _3: 1 }
 IpAddr.V6("::1"); // => { _tag: "V6", _0: "::1" }
-
-println(IpAddr.V4(127, 0, 0, 1)); // V4(127, 0, 0, 1)
-println(IpAddr.V6("::1")); // V6("::1")
 ```
 
 </details>
@@ -224,7 +222,7 @@ matchOption(Some(42), {
 - Check out the [syntax sugar for ADTs with only one object field](#syntax-sugar-for-adts-with-only-one-object-field) and [recursive ADTs](#recursive-adts).
 - See how to [check the type of an ADT with **type guards** and extract the fields with **`unwrap`**](#type-guards-and-unwrap).
 - Check out the [conditional deconstructors](#conditional-deconstructors-if) if you are tired with using `match` on a single variant with a verbose catch-all case.
-- See how to use [optional utilities](#optional-utilities) like `println` and `show` to debug your ADTs with ease.
+- See how to use [showify](#convert-adts-to-human-readable-strings) to convert your ADTs to human-readable strings.
 
 ## Recipes
 
@@ -560,18 +558,20 @@ const result = Option.ifSome(
 );
 ```
 
-## Optional Utilities
+### Convert ADTs to human-readable strings
 
-> [!NOTE]
->
-> To use the `println` and `show` utilities, the [showify](https://github.com/Snowflyt/showify) package is required to be installed.
+kind-adt provides integration with the [showify](https://github.com/Snowflyt/showify) package, which allows you to convert objects to human-readable strings. This is especially useful for debugging and logging purposes.
 
-### `println`
+To use this feature, you need to install the [showify](https://github.com/Snowflyt/showify) package:
 
-You can use the `println` function to print an ADT in a readable format, which is especially useful for debugging.
+```shell
+npm install showify
+```
 
-```typescript
-import { println } from "kind-adt/utils";
+Then you can use the `show` function to convert an ADT to a human-readable string.
+
+```javascript
+import { show } from "showify";
 
 // Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
 const tree = Tree.Node(
@@ -580,8 +580,8 @@ const tree = Tree.Node(
   Tree.Node(4, Tree.Empty, Tree.Node(3, Tree.Empty, Tree.Empty)),
 );
 
-// ANSI colors are supported
-println(tree);
+// Print the ADT with ANSI colors and indented format
+console.log(show(tree, { indent: 2, trailingComma: "auto", colors: true }));
 // Node(
 //   1,
 //   Node(2, Node(3, Empty, Empty), Empty),
@@ -589,31 +589,18 @@ println(tree);
 // )
 ```
 
-Check out [`show`](#show) if you want more control over the output.
-
-### `show`
-
-The `println` utility uses the [showify](https://github.com/Snowflyt/showify) package to convert an ADT into a string. Since `println` accepts variadic arguments, it does not support passing options to control the output. If you want more control over the output, you can use the `show` function to convert an ADT into a string, which accepts an optional `ShowOptions` object from the showify package to control the output.
+If you find it tedious to write `console.log(show(...))` every time, you can create a utility function to print the ADT directly:
 
-```typescript
-import { show } from "kind-adt/utils";
-
-// Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
-const tree = Tree.Node(1, Tree.Node(2, Tree.Empty, Tree.Empty), Tree.Empty);
-
-console.log(show(tree));
-// Node(1, Node(2, Empty, Empty), Empty)
+```javascript
+import { show } from "showify";
 
-console.log(show(tree, { indent: 4, breakLength: 0, trailingComma: "auto" }));
-// Node(
-//     1,
-//     Node(
-//         2,
-//         Empty,
-//         Empty,
-//     ),
-//     Empty,
-// )
+export function println(...args: unknown[]) {
+  console.log(
+    ...args.map((arg) =>
+      typeof arg === "string" ? arg : show(arg, { colors: true, trailingComma: "true", indent: 2 }),
+    ),
+  );
+}
 ```
 
 ## FAQ

package/index.d.ts

@@ -19,13 +19,13 @@
  * @see {@linkcode Data} for details on how to create an ADT.
  */
 export function make<F extends Tagged | TypeLambda<never, Tagged>>(
-  variants?: readonly Instantiate<F>["_tag"][],
+  variants?: readonly Instantiate<F>["_tag"][]
 ): Instantiate<F> extends infer Type extends Tagged ?
   Spread<
     { readonly [Tag in Type["_tag"] as Tag]: Constructor<F, Tag> },
     {
       readonly [Tag in Type["_tag"] as `is${Tag}`]: (
-        adt: Type,
+        adt: Type
       ) => adt is FilterTagged<Type, Tag>;
     },
     { readonly unwrap: Deconstructor<Type> },
@@ -474,14 +474,14 @@ export type Constructor<
  * A type guard function for an ADT.
  */
 export type Guard<T extends Tagged, Tag extends string> = (
-  adt: T,
+  adt: T
 ) => adt is FilterTagged<T, Tag>;
 
 /**
  * A deconstructor for an ADT.
  */
 export type Deconstructor<Type extends Tagged> = <T extends Type>(
-  adt: T,
+  adt: T
 ) => ExtractFields<T>;
 
 type ConditionalDeconstructorOf<
@@ -492,7 +492,7 @@ type ConditionalDeconstructorOf<
     <R1, R2 = void>(
       adt: F,
       onMatch: (...args: ExtractFields<FilterTagged<F, Tag>>) => R1,
-      otherwise?: (adt: Exclude<F, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<F, Tagged<Tag>>) => R2
     ) => R1 | R2
   : [F] extends [TypeLambda<[never], Tagged>] ?
     ConditionalDeconstructor1<F, Tag>
@@ -510,14 +510,14 @@ type ConditionalDeconstructor1<
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T]>, Tagged<Tag>>) => R2
     ) => R1 | R2
   : <T extends HKTParams<F>[0], R1, R2 = void>(
       adt: ApplyHKT<F, [T]>,
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T]>, Tagged<Tag>>) => R2
     ) => R1 | R2;
 
 type ConditionalDeconstructor2<
@@ -530,7 +530,7 @@ type ConditionalDeconstructor2<
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2
     ) => R1 | R2
   : unknown extends HKTParams<F>[0] ?
     <T, U extends HKTParams<F>[1], R1, R2 = void>(
@@ -538,7 +538,7 @@ type ConditionalDeconstructor2<
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2
     ) => R1 | R2
   : unknown extends HKTParams<F>[1] ?
     <T extends HKTParams<F>[0], U, R1, R2 = void>(
@@ -546,14 +546,14 @@ type ConditionalDeconstructor2<
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2
     ) => R1 | R2
   : <T extends HKTParams<F>[0], U extends HKTParams<F>[1], R1, R2 = void>(
       adt: ApplyHKT<F, [T, U]>,
       onMatch: (
         ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
       ) => R1,
-      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2,
+      otherwise?: (adt: Exclude<ApplyHKT<F, [T, U]>, Tagged<Tag>>) => R2
     ) => R1 | R2;
 
 // Fallback conditional deconstructor type
@@ -566,7 +566,7 @@ export type ConditionalDeconstructor<
 > = <T extends Type, R1, R2 = void>(
   adt: T,
   onMatch: (...args: ExtractFields<FilterTagged<T, Tag>>) => R1,
-  otherwise?: (adt: Exclude<T, Tagged<Tag>>) => R2,
+  otherwise?: (adt: Exclude<T, Tagged<Tag>>) => R2
 ) => R1 | R2;
 
 type MatcherOf<F extends Tagged | TypeLambda<never, Tagged>> =
@@ -578,7 +578,7 @@ type MatcherOf<F extends Tagged | TypeLambda<never, Tagged>> =
           readonly [Tag in F["_tag"]]: (
             ...args: ExtractFields<FilterTagged<F, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <R>(
         adt: F,
@@ -586,7 +586,7 @@ type MatcherOf<F extends Tagged | TypeLambda<never, Tagged>> =
           readonly [Tag in F["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<F, Tag>>
           ) => R;
-        } & { _: (adt: F) => R },
+        } & { _: (adt: F) => R }
       ): R;
       <R>(cases: {
         readonly [Tag in F["_tag"]]: (
@@ -598,7 +598,7 @@ type MatcherOf<F extends Tagged | TypeLambda<never, Tagged>> =
           readonly [Tag in F["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<F, Tag>>
           ) => R;
-        } & { _: (adt: F) => R },
+        } & { _: (adt: F) => R }
       ): (adt: F) => R;
     }
   : [F] extends [TypeLambda<[never], Tagged>] ? Matcher1<F>
@@ -614,7 +614,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T, R>(
         adt: ApplyHKT<F, [T]>,
@@ -622,7 +622,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T]>) => R }
       ): R;
       <T, R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -634,7 +634,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T]>) => R }
       ): (adt: ApplyHKT<F, [T]>) => R;
     }
   : {
@@ -644,7 +644,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T extends HKTParams<F>[0], R>(
         adt: ApplyHKT<F, [T]>,
@@ -652,7 +652,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T]>) => R }
       ): R;
       <T extends HKTParams<F>[0], R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -664,7 +664,7 @@ type Matcher1<F extends TypeLambda<[never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T]>) => R }
       ): (adt: ApplyHKT<F, [T]>) => R;
     };
 
@@ -677,7 +677,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T, U, R>(
         adt: ApplyHKT<F, [T, U]>,
@@ -685,7 +685,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): R;
       <T, U, R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -697,7 +697,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): (adt: ApplyHKT<F, [T, U]>) => R;
     }
   : unknown extends HKTParams<F>[0] ?
@@ -708,7 +708,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T, U extends HKTParams<F>[1], R>(
         adt: ApplyHKT<F, [T, U]>,
@@ -716,7 +716,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): R;
       <T, U extends HKTParams<F>[1], R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -728,7 +728,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): (adt: ApplyHKT<F, [T, U]>) => R;
     }
   : unknown extends HKTParams<F>[1] ?
@@ -739,7 +739,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T extends HKTParams<F>[0], U, R>(
         adt: ApplyHKT<F, [T, U]>,
@@ -747,7 +747,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): R;
       <T extends HKTParams<F>[0], U, R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -759,7 +759,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): (adt: ApplyHKT<F, [T, U]>) => R;
     }
   : {
@@ -769,7 +769,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        },
+        }
       ): R;
       <T extends HKTParams<F>[0], U extends HKTParams<F>[1], R>(
         adt: ApplyHKT<F, [T, U]>,
@@ -777,7 +777,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): R;
       <T extends HKTParams<F>[0], U extends HKTParams<F>[1], R>(cases: {
         readonly [Tag in Instantiate<F>["_tag"]]: (
@@ -789,7 +789,7 @@ type Matcher2<F extends TypeLambda<[never, never], Tagged>> =
           readonly [Tag in Instantiate<F>["_tag"]]?: (
             ...args: ExtractFields<FilterTagged<ApplyHKT<F, [T, U]>, Tag>>
           ) => R;
-        } & { _: (adt: ApplyHKT<F, [T, U]>) => R },
+        } & { _: (adt: ApplyHKT<F, [T, U]>) => R }
       ): (adt: ApplyHKT<F, [T, U]>) => R;
     };
 
@@ -804,7 +804,7 @@ export interface Matcher<Type extends Tagged> {
       readonly [Tag in Type["_tag"]]: (
         ...args: ExtractFields<FilterTagged<T, Tag>>
       ) => R;
-    },
+    }
   ): R;
   <T extends Type, R>(
     adt: T,
@@ -812,7 +812,7 @@ export interface Matcher<Type extends Tagged> {
       readonly [Tag in Type["_tag"]]?: (
         ...args: ExtractFields<FilterTagged<T, Tag>>
       ) => R;
-    } & { _: (adt: T) => R },
+    } & { _: (adt: T) => R }
   ): R;
   <T extends Type, R>(cases: {
     readonly [Tag in Type["_tag"]]: (
@@ -824,7 +824,7 @@ export interface Matcher<Type extends Tagged> {
       readonly [Tag in Type["_tag"]]?: (
         ...args: ExtractFields<FilterTagged<T, Tag>>
       ) => R;
-    } & { _: (adt: T) => R },
+    } & { _: (adt: T) => R }
   ): (adt: T) => R;
 }
 
@@ -839,7 +839,7 @@ type MatcherOfW<F extends Tagged | TypeLambda<never, Tagged>> =
         },
       >(
         adt: F,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<ValueOf<Cases>>;
       <
         Cases extends {
@@ -849,7 +849,7 @@ type MatcherOfW<F extends Tagged | TypeLambda<never, Tagged>> =
         } & { _: (adt: F) => unknown },
       >(
         adt: F,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         Cases extends {
@@ -858,7 +858,7 @@ type MatcherOfW<F extends Tagged | TypeLambda<never, Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (adt: F) => ReturnType<ValueOf<Cases>>;
       <
         Cases extends {
@@ -867,9 +867,9 @@ type MatcherOfW<F extends Tagged | TypeLambda<never, Tagged>> =
           ) => unknown;
         } & { _: (adt: F) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: F,
+        adt: F
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     }
   : [F] extends [TypeLambda<[never], Tagged>] ? Matcher1W<F>
@@ -889,7 +889,7 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
         },
       >(
         adt: ApplyHKT<F, [T]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -901,7 +901,7 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T]>) => R },
       >(
         adt: ApplyHKT<F, [T]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -912,9 +912,9 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T]>,
+        adt: ApplyHKT<F, [T]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -925,9 +925,9 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
           ) => R;
         } & { _: (adt: ApplyHKT<F, [T]>) => R },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T]>,
+        adt: ApplyHKT<F, [T]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     }
   : {
@@ -940,7 +940,7 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
         },
       >(
         adt: T,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -951,7 +951,7 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T]>) => unknown },
       >(
         adt: ApplyHKT<F, [T]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -961,9 +961,9 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T]>,
+        adt: ApplyHKT<F, [T]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -973,9 +973,9 @@ type Matcher1W<F extends TypeLambda<[never], Tagged>> =
           ) => unknown;
         } & { _: (adt: ApplyHKT<F, [T]>) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T]>,
+        adt: ApplyHKT<F, [T]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     };
 
@@ -992,7 +992,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1004,7 +1004,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1015,9 +1015,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1028,9 +1028,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     }
   : unknown extends HKTParams<F>[0] ?
@@ -1045,7 +1045,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1057,7 +1057,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1068,9 +1068,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T,
@@ -1081,9 +1081,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     }
   : unknown extends HKTParams<F>[1] ?
@@ -1098,7 +1098,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1110,7 +1110,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1121,9 +1121,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1134,9 +1134,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     }
   : {
@@ -1150,7 +1150,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1162,7 +1162,7 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
         adt: ApplyHKT<F, [T, U]>,
-        cases: Cases,
+        cases: Cases
       ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1173,9 +1173,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
       <
         T extends HKTParams<F>[0],
@@ -1186,9 +1186,9 @@ type Matcher2W<F extends TypeLambda<[never, never], Tagged>> =
           ) => unknown;
         } & { _: (adt: ApplyHKT<F, [T, U]>) => unknown },
       >(
-        cases: Cases,
+        cases: Cases
       ): (
-        adt: ApplyHKT<F, [T, U]>,
+        adt: ApplyHKT<F, [T, U]>
       ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
     };
 
@@ -1206,7 +1206,7 @@ export interface MatcherW<Type extends Tagged> {
     },
   >(
     adt: T,
-    cases: Cases,
+    cases: Cases
   ): ReturnType<ValueOf<Cases>>;
   <
     T extends Type,
@@ -1217,7 +1217,7 @@ export interface MatcherW<Type extends Tagged> {
     } & { _: (adt: T) => unknown },
   >(
     adt: T,
-    cases: Cases,
+    cases: Cases
   ): ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
   <
     T extends Type,
@@ -1227,7 +1227,7 @@ export interface MatcherW<Type extends Tagged> {
       ) => unknown;
     },
   >(
-    cases: Cases,
+    cases: Cases
   ): (adt: T) => ReturnType<ValueOf<Cases>>;
   <
     T extends Type,
@@ -1237,9 +1237,9 @@ export interface MatcherW<Type extends Tagged> {
       ) => unknown;
     } & { _: (adt: T) => unknown },
   >(
-    cases: Cases,
+    cases: Cases
   ): (
-    adt: T,
+    adt: T
   ) => ReturnType<Extract<ValueOf<Cases>, (...args: never) => unknown>>;
 }
 

package/index.js

@@ -21,28 +21,29 @@ export function make(variants) {
     renameFunction((adt) => {
       if (adt == null || adt._tag !== tag)
         throw new TypeError(
-          `Expected \`${tag}(...)\`, but got \`${stringify(adt)}\``,
+          `Expected \`${tag}(...)\`, but got \`${stringify(adt)}\``
         );
       return unwrap(adt);
     }, `unwrap${tag}`);
 
   /* Constructor */
-  const createConstructor = (tag) => {
-    const result = Object.create(PipeableProto);
-    result._tag = tag;
-    result.toJSON = () => ({ _tag: tag });
-    result[Symbol.for("nodejs.util.inspect.custom")] = () => ({ _tag: tag });
-
-    return 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),
-      result,
+  const createConstructor = (tag) =>
+    Object.setPrototypeOf(
+      Object.assign(
+        renameFunction((...args) => {
+          const result = Object.create(ADTProto);
+          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 }),
+        }
+      ),
+      ADTConstructorProto
     );
-  };
 
   const result = {
     unwrap:
@@ -50,12 +51,12 @@ export function make(variants) {
         function unwrap(adt) {
           if (adt == null || variants.indexOf(adt._tag) === -1)
             throw new TypeError(
-              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``,
+              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``
             );
           return entriesOf(adt)
             .filter(
               ([key]) =>
-                key.startsWith("_") && !Object.is(Number(key.slice(1)), NaN),
+                key.startsWith("_") && !Object.is(Number(key.slice(1)), NaN)
             )
             .sort(([a], [b]) => Number(a.slice(1)) - Number(b.slice(1)))
             .map(([, value]) => value);
@@ -70,14 +71,14 @@ export function make(variants) {
             return function match(adt) {
               if (adt == null || variants.indexOf(adt._tag) === -1)
                 throw new TypeError(
-                  `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``,
+                  `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``
                 );
               return _match(adt, cases);
             };
           }
           if (adt == null || variants.indexOf(adt._tag) === -1)
             throw new TypeError(
-              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``,
+              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``
             );
           return _match(adt, cases);
         }
@@ -98,14 +99,14 @@ export function make(variants) {
             return function matchW(adt) {
               if (adt == null || variants.indexOf(adt._tag) === -1)
                 throw new TypeError(
-                  `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``,
+                  `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``
                 );
               return _match(adt, cases);
             };
           }
           if (adt == null || variants.indexOf(adt._tag) === -1)
             throw new TypeError(
-              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``,
+              `Expected ${variants.map((tag) => "`" + tag + "(...)`").join("/")}, but got \`${stringify(adt)}\``
             );
           return _match(adt, cases);
         }
@@ -174,7 +175,7 @@ export function make(variants) {
 export function unwrap(adt) {
   return entriesOf(adt)
     .filter(
-      ([key]) => key.startsWith("_") && !Object.is(Number(key.slice(1)), NaN),
+      ([key]) => key.startsWith("_") && !Object.is(Number(key.slice(1)), NaN)
     )
     .sort(([a], [b]) => Number(a.slice(1)) - Number(b.slice(1)))
     .map(([, value]) => value);
@@ -192,7 +193,7 @@ function _match(adt, cases) {
   if (adt != null && cases[adt._tag]) return cases[adt._tag](...unwrap(adt));
   if (cases._) return cases._(adt);
   throw new Error(
-    `No case found for \`${stringify(adt)}\`. Consider adding a catch-all case (\`_\`) if needed`,
+    `No case found for \`${stringify(adt)}\`. Consider adding a catch-all case (\`_\`) if needed`
   );
 }
 
@@ -228,6 +229,22 @@ function matchesPrefix(str, prefix) {
 /****************************
  * Common utility functions *
  ****************************/
+/**
+ * A polyfill for `Array#flatMap` to support pre ES2019 environments.
+ * @param arr The array to flatten.
+ * @param fn The function to call on each element of the array.
+ * @returns
+ */
+function flatMap(arr, fn) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const value = fn(arr[i], i, arr);
+    if (Array.isArray(value)) Array.prototype.push.apply(result, value);
+    else result.push(value);
+  }
+  return result;
+}
+
 /**
  * Get the entries of an object.
  * @private
@@ -295,7 +312,7 @@ const stringify = (value) => {
         const entries = Array.from(value.entries())
           .map(
             ([k, v]) =>
-              `${serialize(k, nextAncestors)} => ${serialize(v, nextAncestors)}`,
+              `${serialize(k, nextAncestors)} => ${serialize(v, nextAncestors)}`
           )
           .join(", ");
         return `Map(${value.size}) ` + (entries ? `{ ${entries} }` : "{}");
@@ -328,7 +345,7 @@ const stringify = (value) => {
       const objectEntries = Reflect.ownKeys(value)
         .map((key) => {
           const keyDisplay =
-            typeof key === "symbol" ? `[${key.toString()}]`
+            typeof key === "symbol" ? key.toString()
             : identifierRegex.test(key) ? key
             : JSON.stringify(key);
           const val = value[key];
@@ -348,6 +365,75 @@ const stringify = (value) => {
   return serialize(value, []);
 };
 
+/**
+ * Custom inspect function for ADT to interact with the
+ * [showify](https://github.com/Snowflyt/showify) package.
+ * @returns
+ */
+function inspect({ ancestors, c, level }, expand) {
+  const fields = unwrap(this);
+  const fieldKeys = fields.map((_, i) => `_${i}`);
+
+  let body = expand(this, {
+    level,
+    omittedKeys: new Set([
+      "_tag",
+      ...fieldKeys,
+      "toJSON",
+      Symbol.for("nodejs.util.inspect.custom"),
+      Symbol.for("showify.inspect.custom"),
+    ]),
+    ancestors,
+  });
+  if (
+    body.type === "sequence" &&
+    body.values[0].type === "text" &&
+    body.values[0].value.startsWith("[Function")
+  ) {
+    body.values[2].ref = body.ref;
+    body = body.values[2];
+  }
+
+  return (
+    fields.length ?
+      variant(
+        sequence([
+          text(c.cyan(this._tag) + "("),
+          ...flatMap(fields, (field, i, arr) =>
+            i === arr.length - 1 ? expand(field) : [expand(field), text(", ")]
+          ),
+          ...(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(
+              fields.map((field) => pair(expand(field), text(","))),
+              text(c.cyan(this._tag) + "("),
+              text(") ")
+            ),
+            body
+          )
+      )
+    : body.type === "text" ? text(c.cyan(this._tag))
+    : pair(text(c.cyan(this._tag) + " "), body)
+  );
+}
+const text = (value) => ({ type: "text", value });
+const variant = (inline, wrap) => ({ type: "variant", inline, wrap });
+const sequence = (values) => ({ type: "sequence", values });
+const pair = (left, right) => sequence([left, right]);
+const between = (values, open, close) => ({
+  type: "between",
+  values,
+  open,
+  close,
+});
+
 export const PipeableProto = {
   pipe(...fs) {
     // Optimization inspired by Effect
@@ -373,7 +459,7 @@ export const PipeableProto = {
         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)))))))),
+          fs[7](fs[6](fs[5](fs[4](fs[3](fs[2](fs[1](fs[0](this))))))))
         );
       default: {
         let result = this;
@@ -383,3 +469,11 @@ export const PipeableProto = {
     }
   },
 };
+
+const ADTProto = {
+  ...PipeableProto,
+  [Symbol.for("showify.inspect.custom")]: inspect,
+};
+
+const ADTConstructorProto = { ...ADTProto };
+Object.setPrototypeOf(ADTConstructorProto, Function.prototype);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kind-adt",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "🪴 The kind of ADTs you can count on in TypeScript",
   "keywords": [
     "typescript",
@@ -24,13 +24,5 @@
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
-  "types": "./index.d.ts",
-  "peerDependencies": {
-    "showify": ">=0.1"
-  },
-  "peerDependenciesMeta": {
-    "showify": {
-      "optional": true
-    }
-  }
+  "types": "./index.d.ts"
 }

package/utils.d.ts

@@ -1,59 +0,0 @@
-import type { ShowOptions } from "showify";
-
-/**
- * Print arguments including (possibly) ADTs to `stdout` with newline.
- * @param args The arguments to print.
- *
- * @example
- * ```typescript
- * // Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
- * const tree = Tree.Node(
- *   1,
- *   Tree.Node(2, Tree.Node(3, Tree.Empty, Tree.Empty), Tree.Empty),
- *   Tree.Node(4, Tree.Empty, Tree.Node(3, Tree.Empty, Tree.Empty)),
- * );
- *
- * // ANSI colors are supported
- * println(tree);
- * // Node(
- * //   1,
- * //   Node(2, Node(3, Empty, Empty), Empty),
- * //   Node(4, Empty, Node(3, Empty, Empty))
- * // )
- * ```
- *
- * @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.
- * @param options The options for stringification.
- * @returns
- *
- * @example
- * ```typescript
- * // Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
- * const tree = Tree.Node(
- *   1,
- *   Tree.Node(2, Tree.Empty, Tree.Empty),
- *   Tree.Empty,
- * );
- *
- * console.log(show(tree));
- * // Node(1, Node(2, Empty, Empty), Empty)
- *
- * console.log(show(tree, { indent: 4, breakLength: 0, trailingComma: "auto" }));
- * // Node(
- * //     1,
- * //     Node(
- * //         2,
- * //         Empty,
- * //         Empty,
- * //     ),
- * //     Empty,
- * // )
- * ```
- */
-export declare function show(value: unknown, options?: ShowOptions): string;

package/utils.js

@@ -1,168 +0,0 @@
-import { Node as SerializerNode, serializer, show as stringify } from "showify";
-
-import { unwrap } from "./index.js";
-
-const { between, pair, sequence, text, variant } = SerializerNode;
-
-/**
- * Print arguments including (possibly) ADTs to `stdout` with newline.
- * @param args The arguments to print.
- *
- * @example
- * ```typescript
- * // Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
- * const tree = Tree.Node(
- *   1,
- *   Tree.Node(2, Tree.Node(3, Tree.Empty, Tree.Empty), Tree.Empty),
- *   Tree.Node(4, Tree.Empty, Tree.Node(3, Tree.Empty, Tree.Empty)),
- * );
- *
- * // ANSI colors are supported
- * println(tree);
- * // Node(
- * //   1,
- * //   Node(2, Node(3, Empty, Empty), Empty),
- * //   Node(4, Empty, Node(3, Empty, Empty))
- * // )
- * ```
- *
- * @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 }))),
-  );
-}
-
-/**
- * Stringify a (possibly) ADT to human-readable format.
- * @param value The value to stringify.
- * @param options The options for stringification.
- * @returns
- *
- * @example
- * ```typescript
- * // Suppose we have an ADT `data Tree<T> = Empty | Node(T, Tree<T>, Tree<T>)`
- * const tree = Tree.Node(
- *   1,
- *   Tree.Node(2, Tree.Empty, Tree.Empty),
- *   Tree.Empty,
- * );
- *
- * console.log(show(tree));
- * // Node(1, Node(2, Empty, Empty), Empty)
- *
- * console.log(show(tree, { indent: 4, breakLength: 0, trailingComma: "auto" }));
- * // Node(
- * //     1,
- * //     Node(
- * //         2,
- * //         Empty,
- * //         Empty,
- * //     ),
- * //     Empty,
- * // )
- * ```
- */
-export function show(value, options = {}) {
-  return stringify(value, {
-    ...options,
-    serializers: [
-      serializer({
-        if: (value, { omittedKeys }) =>
-          "_tag" in value &&
-          typeof value._tag === "string" &&
-          // Detect if `_tag` is already omitted to avoid infinite recursion
-          !omittedKeys.has("_tag"),
-        then: (val, { ancestors, c, level }, expand) => {
-          const fields = unwrap(val);
-          const fieldKeys = fields.map((_, i) => `_${i}`);
-
-          let body = expand(val, {
-            level,
-            omittedKeys: new Set([
-              "_tag",
-              ...fieldKeys,
-              "toJSON",
-              Symbol.for("nodejs.util.inspect.custom"),
-            ]),
-            ancestors,
-          });
-          if (
-            body.type === "sequence" &&
-            body.values[0].type === "text" &&
-            body.values[0].value.startsWith("[Function")
-          ) {
-            body.values[2].ref = body.ref;
-            body = body.values[2];
-          }
-
-          return (
-            fields.length ?
-              variant(
-                sequence([
-                  text(c.cyan(val._tag) + "("),
-                  ...flatMap(fields, (field, i, arr) =>
-                    i === arr.length - 1 ? expand(field) : [expand(field), text(", ")],
-                  ),
-                  ...(body.type === "text" ? [text(")")] : [text(") "), body]),
-                ]),
-                body.type === "text" ?
-                  between(
-                    fields.map((field) => pair(expand(field), text(","))),
-                    text(c.cyan(val._tag) + "("),
-                    text(")"),
-                  )
-                : pair(
-                    between(
-                      fields.map((field) => pair(expand(field), text(","))),
-                      text(c.cyan(val._tag) + "("),
-                      text(") "),
-                    ),
-                    body,
-                  ),
-              )
-            : body.type === "text" ? text(c.cyan(val._tag))
-            : pair(text(c.cyan(val._tag) + " "), body)
-          );
-        },
-      }),
-      ...(options.serializers || []),
-    ],
-  });
-}
-
-/****************************
- * Common utility functions *
- ****************************/
-/**
- * A polyfill for `Array#flatMap` to support pre ES2019 environments.
- * @param arr The array to flatten.
- * @param fn The function to call on each element of the array.
- * @returns
- */
-const flatMap = (arr, fn) => {
-  const result = [];
-  for (let i = 0; i < arr.length; i++) {
-    const value = fn(arr[i], i, arr);
-    if (Array.isArray(value)) Array.prototype.push.apply(result, value);
-    else result.push(value);
-  }
-  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;
-  };
-})();