@fncts/schema 0.0.13 → 0.0.15

package/_src/Parser/api.ts

@@ -7,7 +7,7 @@ import { parserFor } from "./interpreter.js";
  * @tsplus getter fncts.schema.Parser decode
  */
 export function decode<A>(schema: Schema<A>): Parser<A> {
-  return parserFor(schema.ast);
+  return parserFor(schema.ast, true);
 }
 
 /**
@@ -23,7 +23,7 @@ export function decodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: Parse
  * @tsplus getter fncts.schema.Parser encode
  */
 export function encode<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => ParseResult<unknown> {
-  return parserFor(schema.ast.reverse);
+  return parserFor(schema.ast, false);
 }
 
 /**
@@ -31,35 +31,22 @@ export function encode<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptio
  * @tsplus getter fncts.schema.Parser encodeMaybe
  */
 export function encodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => Maybe<unknown> {
-  return parseMaybe(schema.ast.reverse);
-}
-
-/**
- * @tsplus getter fncts.schema.Schema is
- * @tsplus getter fncts.schema.Parser is
- */
-export function is<A>(schema: Schema<A>) {
-  return (input: unknown, options?: ParseOptions): input is A => {
-    return parserFor(schema.ast)(input, options).isRight();
-  };
+  return (input, options) => encode(schema)(input, options).toMaybe;
 }
 
 function parseMaybe(ast: AST) {
-  const parse = parserFor(ast);
+  const parse = parserFor(ast, true);
   return (input: unknown, options?: ParseOptions): Maybe<any> => {
     return parse(input, options).toMaybe;
   };
 }
 
 function parseOrThrow(ast: AST) {
-  const parser = parserFor(ast);
+  const parser = parserFor(ast, true);
   return (input: unknown, options?: ParseOptions) => {
-    return parser(input, options).match({
-      Left: (errors) => {
-        throw new Error(ParseError.format(errors));
-      },
-      Right: Function.identity,
-    });
+    return parser(input, options).match((failure) => {
+      throw new Error(ParseError.format(failure.errors));
+    }, Function.identity);
   };
 }
 

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.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;
@@ -97,7 +119,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
             const t = head(input[i], options);
             Either.concrete(t);
             if (t.isLeft()) {
-              const e = ParseError.IndexError(i, t.left);
+              const e = ParseError.IndexError(i, t.left.errors);
               errors.push(e);
               if (allErrors) {
                 continue;
@@ -116,7 +138,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
               const t = tail[j]!(input[i], options);
               Either.concrete(t);
               if (t.isLeft()) {
-                const e = ParseError.IndexError(i, t.left);
+                const e = ParseError.IndexError(i, t.left.errors);
                 errors.push(e);
                 if (allErrors) {
                   continue;
@@ -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                 = {};
@@ -178,7 +202,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
             const t: ParseResult<unknown> = parser(input[name], options);
             Either.concrete(t);
             if (t.isLeft()) {
-              const e = ParseError.KeyError(AST.createKey(name), name, t.left);
+              const e = ParseError.KeyError(AST.createKey(name), name, t.left.errors);
               errors.push(e);
               if (allErrors) {
                 continue;
@@ -202,7 +226,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
               let t = parameter(key, options);
               Either.concrete(t);
               if (t.isLeft()) {
-                const e = ParseError.KeyError(AST.createKey(key), key, t.left);
+                const e = ParseError.KeyError(AST.createKey(key), key, t.left.errors);
                 errors.push(e);
                 if (allErrors) {
                   continue;
@@ -214,7 +238,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
               t = type(input[key], options);
               Either.concrete(t);
               if (t.isLeft()) {
-                const e = ParseError.KeyError(AST.createKey(key), key, t.left);
+                const e = ParseError.KeyError(AST.createKey(key), key, t.left.errors);
                 errors.push(e);
                 if (allErrors) {
                   continue;
@@ -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>();
@@ -272,7 +296,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
                     if (t.isRight()) {
                       return t;
                     } else {
-                      errors.push(ParseError.UnionMemberError(t.left));
+                      errors.push(ParseError.UnionMemberError(t.left.errors));
                     }
                   }
                 } else {
@@ -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++) {
@@ -298,7 +322,7 @@ const go = memoize(function go(ast: AST): Parser<any> {
           if (t.isRight()) {
             return t;
           } else {
-            errors.push(ParseError.UnionMemberError(t.left));
+            errors.push(ParseError.UnionMemberError(t.left.errors));
           }
         }
 
@@ -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/conc.ts

@@ -49,7 +49,7 @@ export function concParser<A>(value: Schema<A>): Parser<Conc<A>> {
       const t = value.decode(v);
       Either.concrete(t);
       if (t.isLeft()) {
-        errors.push(ParseError.IndexError(i, t.left));
+        errors.push(ParseError.IndexError(i, t.left.errors));
         if (!allErrors) {
           return ParseResult.failures(errors);
         }

package/_src/Schema/api/hashMap.ts

@@ -78,7 +78,7 @@ function hashMapParser<K, V>(key: Schema<K>, value: Schema<V>): Parser<HashMap<K
       const tk = key.decode(k, options);
       Either.concrete(tk);
       if (tk.isLeft()) {
-        errors.push(ParseError.KeyError(key.ast, k, tk.left));
+        errors.push(ParseError.KeyError(key.ast, k, tk.left.errors));
         if (!allErrors) {
           return ParseResult.failures(errors);
         }

package/_src/Schema/api/immutableArray.ts

@@ -59,7 +59,7 @@ function parser<A>(value: Schema<A>): Parser<ImmutableArray<A>> {
       const t = value.decode(v, options);
       Either.concrete(t);
       if (t.isLeft()) {
-        errors.push(ParseError.IndexError(index, t.left));
+        errors.push(ParseError.IndexError(index, t.left.errors));
         if (allErrors) {
           continue;
         }

package/_src/Schema/api/list.ts

@@ -54,7 +54,7 @@ function parser<A>(value: Schema<A>): Parser<List<A>> {
       const t = value.decode(v, options);
       Either.concrete(t);
       if (t.isLeft()) {
-        errors.push(ParseError.IndexError(index, t.left));
+        errors.push(ParseError.IndexError(index, t.left.errors));
         if (allErrors) {
           continue;
         }

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/_src/global.ts

@@ -39,6 +39,10 @@ import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
  * @tsplus global
  */
 import { ParseError } from "@fncts/schema/ParseError";
+/**
+ * @tsplus global
+ */
+import { ParseFailure } from "@fncts/schema/ParseFailure";
 /**
  * @tsplus global
  */

package/global.d.ts

@@ -38,6 +38,10 @@ import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
  * @tsplus global
  */
 import { ParseError } from "@fncts/schema/ParseError";
+/**
+ * @tsplus global
+ */
+import { ParseFailure } from "@fncts/schema/ParseFailure";
 /**
  * @tsplus global
  */

package/package.json

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