kind-adt 0.1.0 → 0.1.1

package/README.md

@@ -27,10 +27,10 @@ import { type Data, make } from "kind-adt";
 import type { Arg0, HKT } from "hkt-core";
 
 // Define an ADT
-export type Option<T> = Data<
-  Some: [value: T],
-  None: [],
->;
+export type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
 
 // Generate constructors and match functions for the ADT
 export const { Some, None, match } = make<OptionHKT>();
@@ -75,10 +75,10 @@ npm install kind-adt
 ```typescript
 import type { Data } from "kind-adt";
 
-export type Option<T> = Data<
-  Some: [T],
-  None: [],
->;
+export type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
 // Expands to:
 // export type Option<T> =
 //   | { readonly _tag: "Some"; readonly _0: T }
@@ -232,10 +232,10 @@ You can extract the type of each variant of an ADT using the `Tagged` utility ty
 ```typescript
 import type { Data, Tagged } from "kind-adt";
 
-type Option<T> = Data<
-  Some: [T],
-  None: [],
->;
+type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
 
 type Some<T> = Extract<Option<T>, Tagged<"Some">>;
 // Expands to:
@@ -255,10 +255,10 @@ type None = Extract<Option<unknown>, Tagged<"None">>;
 Let’s revisit the `Option<T>` example in the quickstart section.
 
 ```typescript
-type Option<T> = Data<
-  Some: [T],
-  None: [],
->;
+type Option<T> = Data<{
+  Some: [value: T];
+  None: [];
+}>;
 
 const Option = make<OptionHKT>();
 interface OptionHKT extends HKT {
@@ -294,15 +294,15 @@ function Option.match<T, R>(adt: Option<T>, cases: {
 This also applies to other ADTs, such as `Result`, `Either`, etc.
 
 ```typescript
-type Result<T, E> = Data<
-  Ok: [value: T],
-  Err: [error: E],
->;
+type Result<T, E> = Data<{
+  Ok: [value: T];
+  Err: [error: E];
+}>;
 
-type Either<A, B> = Data<
-  Left: [value: A],
-  Right: [value: B],
->;
+type Either<A, B> = Data<{
+  Left: [value: A];
+  Right: [value: B];
+}>;
 ```
 
 ### Syntax sugar for ADTs with only one object field

package/package.json

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

package/utils.d.ts

@@ -1,4 +1,5 @@
 import type { ShowOptions } from "showify";
+
 /**
  * Print arguments including (possibly) ADTs to `stdout` with newline.
  * @param args The arguments to print.
@@ -24,6 +25,7 @@ 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

@@ -1,6 +1,6 @@
 import { Node as SerializerNode, serializer, show as stringify } from "showify";
 
-import { unwrap } from ".";
+import { unwrap } from "./index.js";
 
 const { between, pair, sequence, text, variant } = SerializerNode;
 
@@ -30,9 +30,7 @@ const { between, pair, sequence, text, variant } = SerializerNode;
  */
 export function println(...args) {
   getConsole().log(
-    ...args.map((arg) =>
-      typeof arg === "string" ? arg : show(arg, { colors: true, indent: 2 }),
-    ),
+    ...args.map((arg) => (typeof arg === "string" ? arg : show(arg, { colors: true, indent: 2 }))),
   );
 }
 
@@ -103,31 +101,29 @@ export function show(value, options = {}) {
             fields.length ?
               variant(
                 sequence([
-                  text(c.blue(val._tag) + "("),
+                  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]),
                 ]),
                 body.type === "text" ?
                   between(
                     fields.map((field) => pair(expand(field), text(","))),
-                    text(c.blue(val._tag) + "("),
+                    text(c.cyan(val._tag) + "("),
                     text(")"),
                   )
                 : pair(
                     between(
                       fields.map((field) => pair(expand(field), text(","))),
-                      text(c.blue(val._tag) + "("),
+                      text(c.cyan(val._tag) + "("),
                       text(") "),
                     ),
                     body,
                   ),
               )
-            : body.type === "text" ? text(c.blue(val._tag))
-            : pair(text(c.blue(val._tag) + " "), body)
+            : body.type === "text" ? text(c.cyan(val._tag))
+            : pair(text(c.cyan(val._tag) + " "), body)
           );
         },
       }),