@fncts/schema 0.0.11 → 0.0.13

package/_src/Schema/derivations.ts

@@ -66,11 +66,13 @@ export function deriveStruct<A extends Record<string, any>>(
 ): Schema<A> {
   const maybeFieldsKeys: Vector<PropertyKey> = ownKeys(maybeFields);
   let propertySignatures                     = ownKeys(requiredFields).map((key) =>
+    // @ts-expect-error
     AST.createPropertySignature(key, requiredFields[key]!.ast, false, true),
   );
 
   if (optionalFields) {
     propertySignatures = propertySignatures.concat(
+      // @ts-expect-error
       ownKeys(optionalFields).map((key) => AST.createPropertySignature(key, optionalFields[key]!.ast, true, true)),
     );
   }
@@ -89,6 +91,7 @@ export function deriveStruct<A extends Record<string, any>>(
         maybeFieldsKeys.map((key) =>
           AST.createPropertySignature(
             key,
+            // @ts-expect-error
             AST.createUnion(Vector(AST.undefinedKeyword, AST.createLiteral(null), maybeFields![key]!.ast)),
             true,
             true,
@@ -103,7 +106,8 @@ export function deriveStruct<A extends Record<string, any>>(
     AST.createTypeLiteral(
       propertySignatures.concat(
         maybeFieldsKeys.map((key) =>
-          AST.createPropertySignature(key, Schema.maybe(maybeFields![key]!).ast, true, true),
+          // @ts-expect-error
+          AST.createPropertySignature(key, Schema.maybe(maybeFields![key]!).ast, false, true),
         ),
       ),
       Vector.empty(),
@@ -158,10 +162,9 @@ export function deriveLazy<A>(f: (_: Schema<A>) => Schema<A>): Schema<A> {
 }
 
 /**
- * @tsplus derive fncts.schema.Schema[fncts.Array]<_> 10
  * @tsplus derive fncts.schema.Schema[fncts.ReadonlyArray]<_> 10
  */
-export function deriveArray<A extends ReadonlyArray<any>>(
+export function deriveReadonlyArray<A extends ReadonlyArray<any>>(
   ...[element]: [A] extends [ReadonlyArray<infer _A>]
     ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
       ? [element: Schema<_A>]
@@ -171,6 +174,19 @@ export function deriveArray<A extends ReadonlyArray<any>>(
   return Schema.array(element) as unknown as Schema<A>;
 }
 
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Array]<_> 10
+ */
+export function deriveArray<A extends Array<any>>(
+  ...[element]: [A] extends [Array<infer _A>]
+    ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True
+      ? [element: Schema<_A>]
+      : never
+    : never
+): Schema<A> {
+  return Schema.mutableArray(element) as unknown as Schema<A>;
+}
+
 /**
  * @tsplus derive fncts.schema.Schema<_> 15
  */

package/_src/Schema.ts

@@ -1,17 +1,19 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Schema/*.ts }
-export * from "./Schema/api.js";
-export * from "./Schema/definition.js";
 export * from "./Schema/derivations.js";
+export * from "./Schema/definition.js";
+export * from "./Schema/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Schema/api/*.ts }
-export * from "./Schema/api/conc.js";
-export * from "./Schema/api/either.js";
-export * from "./Schema/api/hashMap.js";
-export * from "./Schema/api/hashSet.js";
-export * from "./Schema/api/immutableArray.js";
-export * from "./Schema/api/list.js";
 export * from "./Schema/api/maybe.js";
+export * from "./Schema/api/list.js";
+export * from "./Schema/api/immutableArray.js";
+export * from "./Schema/api/hashSet.js";
+export * from "./Schema/api/hashMap.js";
+export * from "./Schema/api/either.js";
+export * from "./Schema/api/conc.js";
 // codegen:end
 
 export type {} from "./Parser.js";

package/_src/Show.ts

@@ -0,0 +1,169 @@
+import type { TemplateLiteral, TemplateLiteralSpan } from "@fncts/schema/AST";
+
+import { ASTTag } from "@fncts/schema/AST";
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+import { memoize } from "@fncts/schema/utils";
+
+/**
+ * @tsplus getter fncts.schema.Schema show
+ */
+export function show<A>(self: Schema<A>): string {
+  const ev = go(self.ast);
+  return ev.run;
+}
+
+const go = memoize(function go(ast: AST): Eval<string> {
+  AST.concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration: {
+      return ast.annotations.get(ASTAnnotation.Identifier).match(
+        () => Eval.now("Unknown Type"),
+        (id) => {
+          return ast.typeParameters
+            .traverse(Eval.Applicative)(go)
+            .map((ts) => {
+              if (ts.length <= 0) {
+                return id;
+              } else {
+                return `${id}<${ts.join(", ")}>`;
+              }
+            });
+        },
+      );
+    }
+    case ASTTag.Literal: {
+      if (ast.literal === null) {
+        return Eval.now("null");
+      } else {
+        return Eval.now(ast.literal.toString());
+      }
+    }
+    case ASTTag.UniqueSymbol:
+      return Eval.now(ast.symbol.toString());
+    case ASTTag.UndefinedKeyword:
+      return Eval.now("undefined");
+    case ASTTag.VoidKeyword:
+      return Eval.now("void");
+    case ASTTag.NeverKeyword:
+      return Eval.now("never");
+    case ASTTag.UnknownKeyword:
+      return Eval.now("unknown");
+    case ASTTag.AnyKeyword:
+      return Eval.now("any");
+    case ASTTag.StringKeyword:
+      return Eval.now("string");
+    case ASTTag.NumberKeyword:
+      return Eval.now("number");
+    case ASTTag.BooleanKeyword:
+      return Eval.now("boolean");
+    case ASTTag.BigIntKeyword:
+      return Eval.now("bigint");
+    case ASTTag.SymbolKeyword:
+      return Eval.now("symbol");
+    case ASTTag.ObjectKeyword:
+      return Eval.now("object");
+    case ASTTag.TemplateLiteral:
+      return Eval.now("`" + formatTemplateLiteral(ast) + "`");
+    case ASTTag.Tuple:
+      return Do((Δ) => {
+        const elements     = Δ(ast.elements.map((element) => element.type).traverse(Eval.Applicative)(go));
+        const restElements = Δ(
+          ast.rest.match(
+            () => Eval.now(Vector.empty<string>()),
+            (rest) => rest.traverse(Eval.Applicative)(go),
+          ),
+        );
+
+        return Δ(
+          Eval(() => {
+            if (elements.length === 0 && restElements.length === 1) {
+              if (ast.isReadonly) {
+                return `ReadonlyArray<${restElements[0]}>`;
+              } else {
+                return `Array<${restElements[0]}>`;
+              }
+            }
+
+            const prefix = (ast.isReadonly ? "readonly " : "") + "[" + elements.join(", ");
+            const middle = restElements.length > 0 ? ", " : "";
+            const suffix = restElements.map((s) => `...${s}`).join(", ") + "]";
+            return prefix + middle + suffix;
+          }),
+        );
+      });
+    case ASTTag.TypeLiteral:
+      return Do((Δ) => {
+        const propertySignatures = Δ(ast.propertySignatures.traverse(Eval.Applicative)((ps) => go(ps.type)));
+        const indexSignatures    = Δ(
+          ast.indexSignatures.traverse(Eval.Applicative)((is) => go(is.parameter).zip(go(is.type))),
+        );
+
+        const required: Array<[PropertyKey, string]> = [];
+        const optional: Array<[PropertyKey, string]> = [];
+
+        ast.propertySignatures.forEachWithIndex((i, ps) => {
+          const name = ps.name;
+          if (!ps.isOptional) {
+            required.push([name, propertySignatures[i]!]);
+          } else {
+            optional.push([name, propertySignatures[i]!]);
+          }
+        });
+
+        const prefix     = "{";
+        const properties = required
+          .concat(optional)
+          .sort(([k1], [k2]) => k1.toLocaleString().localeCompare(k2.toLocaleString()))
+          .map(([propertyKey, type]) => `${String(propertyKey)}: ${type}`)
+          .join(", ");
+        const index  = indexSignatures.map(([param, type]) => `[x: ${param}]: ${type}`).join(", ");
+        const suffix = "}";
+
+        return prefix + " " + properties + (index.length === 0 ? "" : ", ") + index + " " + suffix;
+      });
+    case ASTTag.Union:
+      return ast.types
+        .traverse(Eval.Applicative)(go)
+        .map((ts) => ts.join(" | "));
+    case ASTTag.Lazy: {
+      const f   = () => go(ast.getAST());
+      const get = memoize<typeof f, Eval<string>>(f);
+      return Eval.defer(() => get(f));
+    }
+    case ASTTag.Enum: {
+      return Eval.now(ast.enums.map(([name]) => name).join(" | "));
+    }
+    case ASTTag.Refinement: {
+      return ast.annotations.get(ASTAnnotation.Identifier).match(
+        () => go(ast.from).map((from) => `Refined<${from}>`),
+        (id) => Eval.now(id),
+      );
+    }
+    case ASTTag.Transform:
+      return go(ast.to);
+    case ASTTag.Validation: {
+      return go(ast.from).map((from) => {
+        const validationNames = ast.validation.map((v) => v.name).join(" & ");
+
+        if (validationNames.length <= 0) {
+          return from;
+        }
+
+        return `${from} & ${validationNames}`;
+      });
+    }
+  }
+});
+
+function formatTemplateLiteralSpan(span: TemplateLiteralSpan): string {
+  switch (span.type._tag) {
+    case ASTTag.StringKeyword:
+      return "${string}";
+    case ASTTag.NumberKeyword:
+      return "${number}";
+  }
+}
+
+function formatTemplateLiteral(ast: TemplateLiteral): string {
+  return ast.head + ast.spans.map((span) => formatTemplateLiteralSpan(span) + span.literal).join("");
+}

package/_src/global.ts

@@ -47,6 +47,10 @@ import { Parser } from "@fncts/schema/Parser/definition";
  * @tsplus global
  */
 import { ParseResult } from "@fncts/schema/ParseResult";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/schema/Schema";
 /**
  * @tsplus global
  */
@@ -54,7 +58,7 @@ import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
 /**
  * @tsplus global
  */
-import {} from "@fncts/schema/Schema"
+import {} from "@fncts/schema/Show";
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -46,6 +46,10 @@ import { Parser } from "@fncts/schema/Parser/definition";
  * @tsplus global
  */
 import { ParseResult } from "@fncts/schema/ParseResult";
+/**
+ * @tsplus global
+ */
+import {} from "@fncts/schema/Schema";
 /**
  * @tsplus global
  */
@@ -53,7 +57,7 @@ import { OptionalSchema, Schema } from "@fncts/schema/Schema/definition";
 /**
  * @tsplus global
  */
-import {} from "@fncts/schema/Schema";
+import {} from "@fncts/schema/Show";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/schema",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "dependencies": {
-    "@fncts/base": "0.0.32",
-    "@fncts/typelevel": "0.0.15"
+    "@fncts/base": "0.0.33",
+    "@fncts/typelevel": "0.0.16"
   },
   "exports": {
     "./*": {