@fncts/schema 0.0.14 → 0.0.15

package/_src/Parser/interpreter.ts

@@ -1,8 +1,7 @@
-import type { Literal } from "../AST.js";
-import type { Hook } from "../ASTAnnotation.js";
 import type { MutableVector } from "@fncts/base/collection/immutable/Vector";
 import type { Validation } from "@fncts/base/data/Branded";
 
+import { globalValue } from "@fncts/base/data/Global";
 import {
   isBigInt,
   isBoolean,
@@ -14,10 +13,32 @@ import {
   isUndefined,
 } from "@fncts/base/util/predicates";
 
-import { ASTTag, concrete } from "../AST.js";
+import { ASTTag, concrete, getSearchTree } from "../AST.js";
+import { RefinementError, TransformationError } from "../ParseError.js";
 import { getKeysForIndexSignature, getTemplateLiteralRegex, memoize, ownKeys } from "../utils.js";
 
-const go = memoize(function go(ast: AST): Parser<any> {
+const decodeMemoMap = globalValue(
+  Symbol.for("fncts.schema.Parser.decodeMemoMap"),
+  () => new WeakMap<AST, Parser<any>>(),
+);
+
+const encodeMemoMap = globalValue(
+  Symbol.for("fncts.schema.Parser.encodeMemoMap"),
+  () => new WeakMap<AST, Parser<any>>(),
+);
+
+function goMemo(ast: AST, isDecoding: boolean): Parser<any> {
+  const memoMap = isDecoding ? decodeMemoMap : encodeMemoMap;
+  const memo    = memoMap.get(ast);
+  if (memo) {
+    return memo;
+  }
+  const parser = go(ast, isDecoding);
+  memoMap.set(ast, parser);
+  return parser;
+}
+
+function go(ast: AST, isDecoding: boolean): Parser<any> {
   concrete(ast);
   switch (ast._tag) {
     case ASTTag.Declaration:
@@ -53,18 +74,18 @@ const go = memoize(function go(ast: AST): Parser<any> {
       return Parser.fromRefinement(ast, (u): u is any => isString(u) && regex.test(u));
     }
     case ASTTag.Tuple: {
-      const elements = ast.elements.map((e) => go(e.type));
-      const rest     = ast.rest.map((rest) => rest.map(go));
+      const elements = ast.elements.map((e) => goMemo(e.type, isDecoding));
+      const rest     = ast.rest.map((rest) => rest.map((ast) => goMemo(ast, isDecoding)));
       return Parser.make((input, options) => {
         if (!Array.isArray(input)) {
-          return ParseResult.fail(ParseError.TypeError(unknownArray, input));
+          return ParseResult.fail(ParseError.TypeError(AST.unknownArray, input));
         }
         const output: Array<any>                = [];
         const errors: MutableVector<ParseError> = Vector.emptyPushable();
         const allErrors = options?.allErrors;
         let i           = 0;
         for (; i < elements.length; i++) {
-          if (input.length < i + i) {
+          if (input.length < i + 1) {
             if (!ast.elements[i]!.isOptional) {
               const e = ParseError.IndexError(i, Vector(ParseError.MissingError));
               errors.push(e);
@@ -73,23 +94,24 @@ const go = memoize(function go(ast: AST): Parser<any> {
               } else {
                 return ParseResult.failures(errors);
               }
-            } else {
-              const parser = elements[i]!;
-              const t      = parser(input[i], options);
-              Either.concrete(t);
-              if (t.isLeft()) {
-                const e = ParseError.IndexError(i, t.left.errors);
-                errors.push(e);
-                if (allErrors) {
-                  continue;
-                } else {
-                  return ParseResult.failures(errors);
-                }
+            }
+          } else {
+            const parser = elements[i]!;
+            const t      = parser(input[i], options);
+            Either.concrete(t);
+            if (t.isLeft()) {
+              const e = ParseError.IndexError(i, t.left.errors);
+              errors.push(e);
+              if (allErrors) {
+                continue;
+              } else {
+                return ParseResult.failures(errors);
               }
-              output.push(t.right);
             }
+            output.push(t.right);
           }
         }
+
         if (rest.isJust()) {
           const head = rest.value.unsafeHead!;
           const tail = rest.value.tail;
@@ -148,11 +170,13 @@ const go = memoize(function go(ast: AST): Parser<any> {
       if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
         return Parser.fromRefinement(ast, (u): u is Exclude<typeof u, null> => u !== null);
       }
-      const propertySignatureTypes = ast.propertySignatures.map((f) => go(f.type));
-      const indexSignatures        = ast.indexSignatures.map((is) => [go(is.parameter), go(is.type)] as const);
+      const propertySignatureTypes = ast.propertySignatures.map((f) => goMemo(f.type, isDecoding));
+      const indexSignatures        = ast.indexSignatures.map(
+        (is) => [goMemo(is.parameter, isDecoding), goMemo(is.type, isDecoding)] as const,
+      );
       return Parser.make((input, options) => {
         if (!isRecord(input)) {
-          return ParseResult.fail(ParseError.TypeError(unknownRecord, input));
+          return ParseResult.fail(ParseError.TypeError(AST.unknownRecord, input));
         }
         const output: any                       = {};
         const expectedKeys: any                 = {};
@@ -247,13 +271,13 @@ const go = memoize(function go(ast: AST): Parser<any> {
       });
     }
     case ASTTag.Union: {
-      const searchTree = getSearchTree(ast.types);
+      const searchTree = getSearchTree(ast.types, isDecoding);
       const ownKeys    = Reflect.ownKeys(searchTree.keys);
       const len        = ownKeys.length;
       const otherwise  = searchTree.otherwise;
       const map        = new Map<any, Parser<any>>();
       ast.types.forEach((ast) => {
-        map.set(ast, go(ast));
+        map.set(ast, goMemo(ast, isDecoding));
       });
       return Parser.make((input, options) => {
         const errors = Vector.emptyPushable<ParseError>();
@@ -289,7 +313,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
               }
             }
           } else {
-            errors.push(ParseError.TypeError(unknownRecord, input));
+            errors.push(ParseError.TypeError(AST.unknownRecord, input));
           }
         }
         for (let i = 0; i < otherwise.length; i++) {
@@ -308,33 +332,52 @@ const go = memoize(function go(ast: AST): Parser<any> {
       });
     }
     case ASTTag.Lazy: {
-      const f   = () => go(ast.getAST());
+      const f   = () => goMemo(ast.getAST(), isDecoding);
       const get = memoize<void, Parser<any>>(f);
       return Parser.make((a, options) => get()(a, options));
     }
     case ASTTag.Refinement: {
-      const from = go(ast.from);
-      if (ast.isReversed) {
-        const to = go(ast.from.getTo);
+      if (isDecoding) {
+        const from = goMemo(ast.from, isDecoding);
+        return Parser.make((input, options) =>
+          from(input, options)
+            .mapLeft((failure) => ParseFailure(Vector(RefinementError(ast, input, "From", failure.errors))))
+            .flatMap((a) =>
+              ast
+                .decode(a, options)
+                .mapLeft((failure) => ParseFailure(Vector(RefinementError(ast, input, "Predicate", failure.errors)))),
+            ),
+        );
+      } else {
+        const from = goMemo(ast.from, true);
+        const to   = goMemo(ast.from.getTo, false);
         return Parser.make((input, options) =>
           to(input, options)
             .flatMap((a) => ast.decode(a, options))
             .flatMap((a) => from(a, options)),
         );
       }
-      return Parser.make((input, options) => from(input, options).flatMap((a) => ast.decode(a, options)));
     }
     case ASTTag.Transform: {
-      const from = go(ast.from);
-      if (ast.isReversed) {
-        const to = go(ast.to);
-        return Parser.make((input, options) =>
-          to(input, options)
-            .flatMap((a) => ast.encode(a, options))
-            .flatMap((a) => from(a, options)),
-        );
-      }
-      return Parser.make((input, options) => from(input, options).flatMap((a) => ast.decode(a, options)));
+      const transformation = isDecoding ? ast.decode : ast.encode;
+      const from           = isDecoding ? goMemo(ast.from, true) : goMemo(ast.to, false);
+      const to             = isDecoding ? goMemo(ast.to, true) : goMemo(ast.from, false);
+      return Parser.make((input, options) =>
+        from(input, options)
+          .mapLeft((failure) =>
+            ParseFailure(Vector(TransformationError(ast, input, isDecoding ? "Encoded" : "Type", failure.errors))),
+          )
+          .flatMap((a) =>
+            transformation(a, options).mapLeft((failure) =>
+              ParseFailure(Vector(TransformationError(ast, input, "Transformation", failure.errors))),
+            ),
+          )
+          .flatMap((a) =>
+            to(a, options).mapLeft((failure) =>
+              ParseFailure(Vector(TransformationError(ast, input, isDecoding ? "Type" : "Encoded", failure.errors))),
+            ),
+          ),
+      );
     }
     case ASTTag.Validation: {
       return Parser.make((u, options) => {
@@ -358,85 +401,8 @@ const go = memoize(function go(ast: AST): Parser<any> {
       });
     }
   }
-});
-
-export function parserFor(ast: AST): Parser<any> {
-  return go(ast);
-}
-
-const unknownArray = AST.createTuple(Vector.empty(), Just(Vector(AST.unknownKeyword)), true);
-
-const unknownRecord = AST.createTypeLiteral(
-  Vector.empty(),
-  Vector(
-    AST.createIndexSignature(AST.stringKeyword, AST.unknownKeyword, true),
-    AST.createIndexSignature(AST.symbolKeyword, AST.unknownKeyword, true),
-  ),
-);
-
-function getLiterals(ast: AST): ReadonlyArray<[PropertyKey, Literal]> {
-  AST.concrete(ast);
-  switch (ast._tag) {
-    case ASTTag.Declaration:
-      return getLiterals(ast.type);
-    case ASTTag.TypeLiteral: {
-      const out: Array<[PropertyKey, Literal]> = [];
-      for (let i = 0; i < ast.propertySignatures.length; i++) {
-        const propertySignature = ast.propertySignatures[i]!;
-        if (propertySignature.type.isLiteral() && !propertySignature.isOptional) {
-          out.push([propertySignature.name, propertySignature.type]);
-        }
-      }
-      return out;
-    }
-    case ASTTag.Refinement:
-      return getLiterals(ast.from);
-    case ASTTag.Transform:
-      return ast.isReversed ? getLiterals(ast.to) : getLiterals(ast.from.getFrom);
-  }
-  return [];
 }
 
-function getSearchTree(members: Vector<AST>): {
-  keys: {
-    readonly [key: PropertyKey]: {
-      buckets: { [literal: string]: ReadonlyArray<AST> };
-      ast: AST;
-    };
-  };
-  otherwise: ReadonlyArray<AST>;
-} {
-  const keys: {
-    [key: PropertyKey]: {
-      buckets: { [literal: string]: Array<AST> };
-      ast: AST;
-    };
-  } = {};
-  const otherwise: Array<AST> = [];
-  for (let i = 0; i < members.length; i++) {
-    const member = members[i]!;
-    const tags   = getLiterals(member);
-    if (tags.length > 0) {
-      for (let j = 0; j < tags.length; j++) {
-        const [key, literal] = tags[j]!;
-        const hash           = String(literal.literal);
-        keys[key]!         ||= { buckets: {}, ast: AST.neverKeyword };
-        const buckets        = keys[key]!.buckets;
-        if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
-          if (j < tags.length - 1) {
-            continue;
-          }
-          buckets[hash]!.push(member);
-          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
-        } else {
-          buckets[hash]! = [member];
-          keys[key]!.ast = AST.createUnion(Vector(keys[key]!.ast, literal));
-          break;
-        }
-      }
-    } else {
-      otherwise.push(member);
-    }
-  }
-  return { keys, otherwise };
+export function parserFor(ast: AST, isDecoding: boolean): Parser<any> {
+  return goMemo(ast, isDecoding);
 }

package/_src/Schema/api.ts

@@ -1,7 +1,5 @@
 import type { Literal, ParseOptions, TemplateLiteral, TypeLiteral } from "../AST.js";
 import type { Brand, Validation } from "@fncts/base/data/Branded";
-import type { Check } from "@fncts/typelevel";
-import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { show } from "@fncts/base/data/Showable";
 
@@ -51,11 +49,7 @@ export function filter<A, B extends A>(refinement: Refinement<A, B>): (self: Sch
 export function filter<A>(predicate: Predicate<A>): (self: Schema<A>) => Schema<A>;
 export function filter<A>(predicate: Predicate<A>) {
   return (self: Schema<A>): Schema<A> => {
-    const ast: AST = AST.createRefinement(
-      self.ast,
-      (a: A) => (predicate(a) ? ParseResult.succeed(a) : ParseResult.fail(ParseError.TypeError(ast, a))),
-      false,
-    );
+    const ast: AST = AST.createRefinement(self.ast, predicate);
     return Schema.fromAST(ast);
   };
 }
@@ -67,8 +61,7 @@ export function brand<A, K extends string>(validation: Validation<A, K>) {
   return (self: Schema<A>): Schema<A & Brand.Valid<A, K>> => {
     const ast = AST.createRefinement(
       self.ast,
-      (a: A) => (validation.validate(a) ? ParseResult.succeed(a) : ParseResult.fail(ParseError.TypeError(ast, a))),
-      false,
+      validation.validate,
       self.ast.annotations.annotate(ASTAnnotation.Brand, Vector(validation)),
     );
     return Schema.fromAST(ast);
@@ -528,7 +521,7 @@ export function transformOrFail<A, B>(
   encode: (input: B, options?: ParseOptions) => ParseResult<A>,
 ) {
   return (from: Schema<A>): Schema<B> => {
-    return Schema.fromAST(AST.createTransform(from.ast, to.ast, decode, encode, false));
+    return Schema.fromAST(AST.createTransform(from.ast, to.ast, decode, encode));
   };
 }
 

package/_src/Show.ts

@@ -1,18 +1,31 @@
 import type { TemplateLiteral, TemplateLiteralSpan } from "@fncts/schema/AST";
 
+import { globalValue } from "@fncts/base/data/Global";
 import { ASTTag } from "@fncts/schema/AST";
 import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
 import { memoize } from "@fncts/schema/utils";
 
+const showMemoMap = globalValue(Symbol.for("fncts.schema.Guard.showMemoMap"), () => new WeakMap<AST, Eval<string>>());
+
+function goMemo(ast: AST): Eval<string> {
+  const memo = showMemoMap.get(ast);
+  if (memo) {
+    return memo;
+  }
+  const s = go(ast);
+  showMemoMap.set(ast, s);
+  return s;
+}
+
 /**
  * @tsplus getter fncts.schema.Schema show
  */
 export function show<A>(self: Schema<A>): string {
-  const ev = go(self.ast);
+  const ev = goMemo(self.ast);
   return ev.run;
 }
 
-const go = memoize(function go(ast: AST): Eval<string> {
+function go(ast: AST): Eval<string> {
   AST.concrete(ast);
   switch (ast._tag) {
     case ASTTag.Declaration: {
@@ -20,7 +33,7 @@ const go = memoize(function go(ast: AST): Eval<string> {
         () => Eval.now("Unknown Type"),
         (id) => {
           return ast.typeParameters
-            .traverse(Eval.Applicative)(go)
+            .traverse(Eval.Applicative)(goMemo)
             .map((ts) => {
               if (ts.length <= 0) {
                 return id;
@@ -66,11 +79,11 @@ const go = memoize(function go(ast: AST): Eval<string> {
       return Eval.now("`" + formatTemplateLiteral(ast) + "`");
     case ASTTag.Tuple:
       return Do((Δ) => {
-        const elements     = Δ(ast.elements.map((element) => element.type).traverse(Eval.Applicative)(go));
+        const elements     = Δ(ast.elements.traverse(Eval.Applicative)((element) => goMemo(element.type)));
         const restElements = Δ(
           ast.rest.match(
             () => Eval.now(Vector.empty<string>()),
-            (rest) => rest.traverse(Eval.Applicative)(go),
+            (rest) => rest.traverse(Eval.Applicative)(goMemo),
           ),
         );
 
@@ -93,9 +106,9 @@ const go = memoize(function go(ast: AST): Eval<string> {
       });
     case ASTTag.TypeLiteral:
       return Do((Δ) => {
-        const propertySignatures = Δ(ast.propertySignatures.traverse(Eval.Applicative)((ps) => go(ps.type)));
+        const propertySignatures = Δ(ast.propertySignatures.traverse(Eval.Applicative)((ps) => goMemo(ps.type)));
         const indexSignatures    = Δ(
-          ast.indexSignatures.traverse(Eval.Applicative)((is) => go(is.parameter).zip(go(is.type))),
+          ast.indexSignatures.traverse(Eval.Applicative)((is) => goMemo(is.parameter).zip(goMemo(is.type))),
         );
 
         const required: Array<[PropertyKey, string]> = [];
@@ -123,26 +136,26 @@ const go = memoize(function go(ast: AST): Eval<string> {
       });
     case ASTTag.Union:
       return ast.types
-        .traverse(Eval.Applicative)(go)
+        .traverse(Eval.Applicative)(goMemo)
         .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));
+      const f   = () => goMemo(ast.getAST());
+      const get = memoize<void, Eval<string>>(f);
+      return Eval.defer(() => get());
     }
     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}>`),
+        () => goMemo(ast.from).map((from) => `Refined<${from}>`),
         (id) => Eval.now(id),
       );
     }
     case ASTTag.Transform:
-      return go(ast.to);
+      return goMemo(ast.to);
     case ASTTag.Validation: {
-      return go(ast.from).map((from) => {
+      return goMemo(ast.from).map((from) => {
         const validationNames = ast.validation.map((v) => v.name).join(" & ");
 
         if (validationNames.length <= 0) {
@@ -153,7 +166,7 @@ const go = memoize(function go(ast: AST): Eval<string> {
       });
     }
   }
-});
+}
 
 function formatTemplateLiteralSpan(span: TemplateLiteralSpan): string {
   switch (span.type._tag) {

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/schema",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "dependencies": {
-    "@fncts/base": "0.0.34",
-    "@fncts/typelevel": "0.0.17"
+    "@fncts/base": "0.0.35",
+    "@fncts/typelevel": "0.0.18"
   },
   "exports": {
     "./*": {