@fncts/schema 0.0.5 → 0.0.6

package/_src/ASTAnnotation.ts

@@ -0,0 +1,98 @@
+import type { Validation } from "@fncts/base/data/Branded";
+
+export const ASTAnnotationVariance = Symbol.for("fncts.schema.ASTAnnotation.Variance");
+export type ASTAnnotationVariance = typeof ASTAnnotationVariance;
+
+export const ASTAnnotationTypeId = Symbol.for("fncts.schema.ASTAnnotation");
+export type ASTAnnotationTypeId = typeof ASTAnnotationTypeId;
+
+/**
+ * @tsplus type fncts.schema.ASTAnnotation
+ * @tsplus companion fncts.schema.ASTAnnotationOps
+ */
+export class ASTAnnotation<V> implements Hashable, Equatable {
+  readonly [ASTAnnotationTypeId]: ASTAnnotationTypeId = ASTAnnotationTypeId;
+  declare [ASTAnnotationVariance]: {
+    readonly _V: (_: never) => V;
+  };
+  constructor(readonly tag: Tag<V>, readonly identifier: string, readonly combine: (v1: V, v2: V) => V) {}
+  get [Symbol.hash]() {
+    return Hashable.combine(Hashable.string(this.identifier), Hashable.unknown(this.tag));
+  }
+  [Symbol.equals](that: unknown) {
+    return isASTAnnotation(that) && Equatable.strictEquals(this.tag, that.tag) && this.identifier === that.identifier;
+  }
+}
+
+export function isASTAnnotation(u: unknown): u is ASTAnnotation<unknown> {
+  return isObject(u) && ASTAnnotationTypeId in u;
+}
+
+export const TitleTag = Tag<string>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Title
+ */
+export const Title = new ASTAnnotation(TitleTag, "Title", (_, a) => a);
+
+export const IdentifierTag = Tag<string>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Identifier
+ */
+export const Identifier = new ASTAnnotation(IdentifierTag, "Identifier", (_, a) => a);
+
+export const DescriptionTag = Tag<string>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Description
+ */
+export const Description = new ASTAnnotation(DescriptionTag, "Description", (_, a) => a);
+
+export const MessageTag = Tag<(_: unknown) => string>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Message
+ */
+export const Message = new ASTAnnotation(MessageTag, "Message", (_, a) => a);
+
+export const BrandTag = Tag<Vector<Validation<any, any>>>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Brand
+ */
+export const Brand = new ASTAnnotation(BrandTag, "Brand", (a, b) => a.concat(b));
+
+export const OptionalTag = Tag<boolean>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps Optional
+ */
+export const Optional = new ASTAnnotation(OptionalTag, "Optional", (_, b) => b);
+
+export const ParseOptionalTag = Tag<boolean>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps ParseOptional
+ */
+export const ParseOptional = new ASTAnnotation(ParseOptionalTag, "ParseOptional", (_, b) => b);
+
+export type Hook<A> = (...typeParameters: ReadonlyArray<A>) => A;
+
+export function hook(handler: (...typeParameters: ReadonlyArray<any>) => any): Hook<any> {
+  return handler;
+}
+
+export const ParserHookTag = Tag<Hook<any>>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps ParserHook
+ */
+export const ParserHook = new ASTAnnotation(ParserHookTag, "ParserHook", (_, b) => b);
+
+export const GenHookTag = Tag<Hook<any>>();
+
+/**
+ * @tsplus static fncts.schema.ASTAnnotationOps GenHook
+ */
+export const GenHook = new ASTAnnotation(GenHookTag, "GenHook", (_, b) => b);

package/_src/ASTAnnotationMap.ts

@@ -0,0 +1,38 @@
+import type { ASTAnnotation } from "./ASTAnnotation.js";
+
+export class ASTAnnotationMap {
+  constructor(readonly map: HashMap<ASTAnnotation<any>, any>) {}
+  combine(that: ASTAnnotationMap): ASTAnnotationMap {
+    return new ASTAnnotationMap(
+      Conc.from(this.map)
+        .concat(Conc.from(that.map))
+        .foldLeft(HashMap.empty(), (acc, [k, v]) =>
+          acc.set(
+            k,
+            acc.get(k).match(
+              () => v,
+              (_) => k.combine(_, v),
+            ),
+          ),
+        ),
+    );
+  }
+  get<V>(key: ASTAnnotation<V>): Maybe<V> {
+    return this.map.get(key);
+  }
+  private overwrite<V>(key: ASTAnnotation<V>, value: V): ASTAnnotationMap {
+    return new ASTAnnotationMap(this.map.set(key, value));
+  }
+  private update<V>(key: ASTAnnotation<V>, f: (v: Maybe<V>) => V): ASTAnnotationMap {
+    return this.overwrite(key, f(this.get(key)));
+  }
+  annotate<V>(key: ASTAnnotation<V>, value: V): ASTAnnotationMap {
+    return this.update(key, (v) =>
+      v.match(
+        () => value,
+        (v) => key.combine(v, value),
+      ),
+    );
+  }
+  static empty: ASTAnnotationMap = new ASTAnnotationMap(HashMap.empty());
+}

package/_src/Gen.ts

@@ -0,0 +1,171 @@
+import type { Hook } from "@fncts/schema/ASTAnnotation";
+import type { Sized } from "@fncts/test/control/Sized";
+
+import { ASTTag } from "@fncts/schema/AST";
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+import { InvalidInterpretationError } from "@fncts/schema/InvalidInterpretationError";
+import { memoize } from "@fncts/schema/utils";
+
+/**
+ * @tsplus getter fncts.schema.Schema genFrom
+ */
+export function genFrom<A>(self: Schema<A>): Gen<Sized, unknown> {
+  return go(self.ast.getFrom);
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema genTo
+ */
+export function genTo<A>(self: Schema<A>): Gen<Sized, A> {
+  return go(self.ast);
+}
+
+function getHook(ast: AST): Maybe<Hook<Gen<Sized, any>>> {
+  return ast.annotations.get(ASTAnnotation.GenHook);
+}
+
+function record<K extends PropertyKey, V>(
+  key: Gen<Sized, K>,
+  value: Gen<Sized, V>,
+): Gen<Sized, { readonly [k in K]: V }> {
+  return Gen.tuple(key, value)
+    .arrayWith({ maxLength: 10 })
+    .map((tuples) => {
+      const out: { [k in K]: V } = {} as any;
+      for (const [k, v] of tuples) {
+        out[k] = v;
+      }
+      return out;
+    });
+}
+
+const go = memoize(function go(ast: AST): Gen<Sized, any> {
+  AST.concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.Declaration:
+      return getHook(ast).match(
+        () => go(ast.type),
+        (hook) => hook(...ast.typeParameters.map(go)),
+      );
+    case ASTTag.Literal:
+      return Gen.constant(ast.literal);
+    case ASTTag.UniqueSymbol:
+      return Gen.constant(ast.symbol);
+    case ASTTag.UndefinedKeyword:
+      return Gen.constant(undefined);
+    case ASTTag.VoidKeyword:
+      return Gen.constant(undefined);
+    case ASTTag.NeverKeyword:
+      return Gen.fromIO(IO.haltNow(new InvalidInterpretationError("cannot build a Gen for `never`")));
+    case ASTTag.UnknownKeyword:
+      // TODO: Gen.anything
+      return Gen.constant("unknown");
+    case ASTTag.AnyKeyword:
+      // TODO: Gen.anything
+      return Gen.constant("any");
+    case ASTTag.StringKeyword:
+      return Gen.fullUnicodeString();
+    case ASTTag.NumberKeyword:
+      return Gen.float;
+    case ASTTag.BooleanKeyword:
+      return Gen.boolean;
+    case ASTTag.BigIntKeyword:
+      return Gen.bigInt;
+    case ASTTag.SymbolKeyword:
+      return Gen.fullUnicodeString().map((s) => Symbol.for(s));
+    case ASTTag.ObjectKeyword:
+      // TODO: Gen.anything
+      return Gen.constant({});
+    case ASTTag.TemplateLiteral: {
+      const components: Array<Gen<Sized, string>> = [Gen.constant(ast.head)];
+      for (const span of ast.spans) {
+        components.push(Gen.fullUnicodeString({ maxLength: 5 }));
+        components.push(Gen.constant(span.literal));
+      }
+      return Gen.tuple(...components).map((spans) => spans.join(""));
+    }
+    case ASTTag.Tuple: {
+      const elements = ast.elements.map((e) => go(e.type));
+      const rest     = ast.rest.map((restElement) => restElement.map(go));
+      let output     = Gen.tuple(...elements);
+      if (elements.length > 0 && rest.isNothing()) {
+        const firstOptionalIndex = ast.elements.findIndex((e) => e.isOptional);
+        if (firstOptionalIndex !== -1) {
+          output = output.flatMap((as) =>
+            Gen.intWith({ min: firstOptionalIndex, max: elements.length - 1 }).map((i) => as.slice(0, i)),
+          );
+        }
+      }
+      if (rest.isJust()) {
+        const head = rest.value.unsafeHead!;
+        const tail = rest.value.tail;
+        output     = output.flatMap((as) => head.arrayWith({ maxLength: 5 }).map((rest) => [...as, ...rest]));
+        for (let j = 0; j < tail.length; j++) {
+          output = output.flatMap((as) => tail[j]!.map((a) => [...as, a]));
+        }
+      }
+      return output as Gen<Sized, any>;
+    }
+    case ASTTag.TypeLiteral: {
+      const propertySignatureTypes = ast.propertySignatures.map((ps) => go(ps.type));
+      const indexSignatures        = ast.indexSignatures.map((is) => [go(is.parameter), go(is.type)] as const);
+      const gens: any              = {};
+      const requiredGens: Record<PropertyKey, Gen<any, any>> = {};
+      const optionalGens: Record<PropertyKey, Gen<any, any>> = {};
+      for (let i = 0; i < propertySignatureTypes.length; i++) {
+        const ps   = ast.propertySignatures[i]!;
+        const name = ps.name;
+        if (!ps.isOptional) {
+          requiredGens[name] = propertySignatureTypes[i]!;
+        } else {
+          optionalGens[name] = propertySignatureTypes[i]!;
+        }
+      }
+      let output = Gen.struct(requiredGens).zipWith(Gen.partial(optionalGens), (a, b) => ({ ...a, ...b }));
+      for (let i = 0; i < indexSignatures.length; i++) {
+        const parameter = indexSignatures[i]![0]!;
+        const type      = indexSignatures[i]![1]!;
+        output          = output.flatMap((o) => {
+          return record(parameter, type).map((d) => ({ ...d, ...o }));
+        });
+      }
+      return output;
+    }
+    case ASTTag.Union: {
+      const types = ast.types.map(go);
+      return Gen.oneOf(...types) as Gen<Sized, any>;
+    }
+    case ASTTag.Lazy: {
+      return getHook(ast).match(
+        () => {
+          const f   = () => go(ast.getAST());
+          const get = memoize<typeof f, Gen<any, any>>(f);
+          return Gen.defer(() => get(f));
+        },
+        (handler) => handler(),
+      );
+    }
+    case ASTTag.Enum: {
+      if (ast.enums.length === 0) {
+        return Gen.fromIO(IO.haltNow(new InvalidInterpretationError("cannot build a Gen for an empty enum")));
+      }
+      return Gen.oneOf(...ast.enums.map(([_, value]) => Gen.constant(value))) as Gen<Sized, any>;
+    }
+    case ASTTag.Refinement: {
+      const from = go(ast.from);
+      return getHook(ast).match(
+        () => from.filter((a) => ast.decode(a).isRight()),
+        (handler) => handler(from),
+      );
+    }
+    case ASTTag.Transform:
+      return go(ast.to);
+    case ASTTag.Validation: {
+      const from = go(ast.from);
+      return getHook(ast).match(
+        () => from.filter((a) => ast.validation.every((v) => v.validate(a))),
+        (handler) => handler(from),
+      );
+    }
+  }
+});

package/_src/InvalidInterpretationError.ts

@@ -0,0 +1,6 @@
+export const InvalidInterpretationErrorTypeId = Symbol.for("fncts.schema.InvalidInterpretationError");
+export type InvalidInterpretationErrorTypeId = typeof InvalidInterpretationErrorTypeId;
+
+export class InvalidInterpretationError extends Error {
+  readonly [InvalidInterpretationErrorTypeId]: InvalidInterpretationErrorTypeId = InvalidInterpretationErrorTypeId;
+}

package/_src/ParseError.ts

@@ -0,0 +1,237 @@
+import type { TemplateLiteral, TemplateLiteralSpan, Validation } from "@fncts/schema/AST";
+
+import { showWithOptions } from "@fncts/base/data/Showable";
+import { concrete } from "@fncts/schema/AST";
+import { ASTTag } from "@fncts/schema/AST";
+import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
+
+export const enum ParseErrorTag {
+  Type,
+  Index,
+  Key,
+  Missing,
+  Unexpected,
+  UnionMember,
+}
+
+/**
+ * @tsplus type fncts.schema.ParseError
+ * @tsplus companion fncts.schema.ParseErrorOps
+ */
+export type ParseError =
+  | TypeError
+  | IndexError
+  | KeyError
+  | MissingError
+  | UnexpectedError
+  | UnexpectedError
+  | UnionMemberError;
+
+/**
+ * @tsplus companion fncts.schema.ParseError.TypeError
+ */
+export class TypeError {
+  readonly _tag = ParseErrorTag.Type;
+  constructor(readonly expected: AST, readonly actual: unknown) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.TypeError __call
+ * @tsplus static fncts.schema.ParseErrorOps TypeError
+ */
+export function typeError(expected: AST, actual: unknown): ParseError {
+  return new TypeError(expected, actual);
+}
+
+/**
+ * @tsplus companion fncts.schema.ParseError.IndexError
+ */
+export class IndexError {
+  readonly _tag = ParseErrorTag.Index;
+  constructor(readonly index: number, readonly errors: Vector<ParseError>) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.IndexError __call
+ * @tsplus static fncts.schema.ParseErrorOps IndexError
+ */
+export function indexError(index: number, errors: Vector<ParseError>): ParseError {
+  return new IndexError(index, errors);
+}
+
+/**
+ * @tsplus companion fncts.schema.ParseError.KeyError
+ */
+export class KeyError {
+  readonly _tag = ParseErrorTag.Key;
+  constructor(readonly keyAST: AST, readonly key: any, readonly errors: Vector<ParseError>) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.IndexError __call
+ * @tsplus static fncts.schema.ParseErrorOps KeyError
+ */
+export function keyError(keyAST: AST, key: any, errors: Vector<ParseError>): ParseError {
+  return new KeyError(keyAST, key, errors);
+}
+
+/**
+ * @tsplus companion fncts.schema.ParseError.MissingError
+ */
+export class MissingError {
+  readonly _tag = ParseErrorTag.Missing;
+}
+
+/**
+ * @tsplus static fncts.schema.ParseErrorOps MissingError
+ */
+export const missingError = new MissingError();
+
+/**
+ * @tsplus companion fncts.schema.ParseError.UnexpectedError
+ */
+export class UnexpectedError {
+  readonly _tag = ParseErrorTag.Unexpected;
+  constructor(readonly actual: unknown) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.UnexpectedError __call
+ * @tsplus static fncts.schema.ParseErrorOps UnexpectedError
+ */
+export function unexpectedError(actual: unknown): ParseError {
+  return new UnexpectedError(actual);
+}
+
+/**
+ * @tsplus companion fncts.schema.ParseError.UnionMemberError
+ */
+export class UnionMemberError {
+  readonly _tag = ParseErrorTag.UnionMember;
+  constructor(readonly errors: Vector<ParseError>) {}
+}
+
+/**
+ * @tsplus static fncts.schema.ParseError.UnionMemberError __call
+ * @tsplus static fncts.schema.ParseErrorOps UnionMemberError
+ */
+export function unionMemberError(errors: Vector<ParseError>): ParseError {
+  return new UnionMemberError(errors);
+}
+
+/**
+ * @tsplus static fncts.schema.ParseErrorOps format
+ */
+export function format(errors: Vector<ParseError>): string {
+  return RoseTree(`${errors.length} error(s) found`, errors.map(go)).draw;
+}
+
+function formatActual(actual: unknown): string {
+  return showWithOptions(actual, { colors: false });
+}
+
+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("");
+}
+
+function getExpected(ast: AST): Maybe<string> {
+  return ast.annotations
+    .get(ASTAnnotation.Identifier)
+    .orElse(ast.annotations.get(ASTAnnotation.Title))
+    .flatMap((title) =>
+      ast.annotations.get(ASTAnnotation.Description).match(
+        () => Just(title),
+        (description) => Just(`${title} (${description})`),
+      ),
+    );
+}
+
+function getMissedBrands(ast: Validation): string {
+  return ast.validation.map((validation) => validation.name).join(" & ");
+}
+
+function formatExpected(ast: AST): string {
+  concrete(ast);
+  switch (ast._tag) {
+    case ASTTag.StringKeyword:
+      return getExpected(ast).getOrElse("string");
+    case ASTTag.NumberKeyword:
+      return getExpected(ast).getOrElse("number");
+    case ASTTag.BooleanKeyword:
+      return getExpected(ast).getOrElse("boolean");
+    case ASTTag.BigIntKeyword:
+      return getExpected(ast).getOrElse("bigint");
+    case ASTTag.UndefinedKeyword:
+      return getExpected(ast).getOrElse("undefined");
+    case ASTTag.SymbolKeyword:
+      return getExpected(ast).getOrElse("symbol");
+    case ASTTag.ObjectKeyword:
+      return getExpected(ast).getOrElse("object");
+    case ASTTag.AnyKeyword:
+      return getExpected(ast).getOrElse("any");
+    case ASTTag.UnknownKeyword:
+      return getExpected(ast).getOrElse("unknown");
+    case ASTTag.VoidKeyword:
+      return getExpected(ast).getOrElse("void");
+    case ASTTag.NeverKeyword:
+      return getExpected(ast).getOrElse("never");
+    case ASTTag.Literal:
+      return getExpected(ast).getOrElse(formatActual(ast.literal));
+    case ASTTag.UniqueSymbol:
+      return getExpected(ast).getOrElse(formatActual(ast.symbol));
+    case ASTTag.Union:
+      return ast.types.map(formatExpected).join(" or ");
+    case ASTTag.Refinement:
+      return getExpected(ast).getOrElse("refinement");
+    case ASTTag.TemplateLiteral:
+      return getExpected(ast).getOrElse(formatTemplateLiteral(ast));
+    case ASTTag.Tuple:
+      return getExpected(ast).getOrElse("tuple or array");
+    case ASTTag.TypeLiteral:
+      return getExpected(ast).getOrElse("type literal");
+    case ASTTag.Enum:
+      return getExpected(ast).getOrElse(ast.enums.map(([_, value]) => JSON.stringify(value)).join(" | "));
+    case ASTTag.Lazy:
+      return getExpected(ast).getOrElse("<anonymous lazy schema>");
+    case ASTTag.Declaration:
+      return getExpected(ast).getOrElse("<anonymous Declaration schema>");
+    case ASTTag.Transform:
+      return `a parsable value from ${formatExpected(ast.from)} to ${formatExpected(ast.to)}`;
+    case ASTTag.Validation:
+      return getExpected(ast).match(
+        () => getMissedBrands(ast),
+        (expected) => `${expected} with validation(s) ${getMissedBrands(ast)}`,
+      );
+  }
+}
+
+function go(error: ParseError): RoseTree<string> {
+  switch (error._tag) {
+    case ParseErrorTag.Type:
+      return RoseTree(
+        error.expected.annotations
+          .get(ASTAnnotation.Message)
+          .map((f) => f(error.actual))
+          .getOrElse(`Expected ${formatExpected(error.expected)}, actual ${formatActual(error.actual)}`),
+      );
+    case ParseErrorTag.Index:
+      return RoseTree(`index ${error.index}`, error.errors.map(go));
+    case ParseErrorTag.Unexpected:
+      return RoseTree("is unexpected");
+    case ParseErrorTag.Key:
+      return RoseTree(`key ${formatActual(error.key)}`, error.errors.map(go));
+    case ParseErrorTag.Missing:
+      return RoseTree("is missing");
+    case ParseErrorTag.UnionMember:
+      return RoseTree("union member", error.errors.map(go));
+  }
+}

package/_src/ParseResult.ts

@@ -0,0 +1,26 @@
+/**
+ * @tsplus type fncts.schema.ParseResult
+ * @tsplus companion fncts.schema.ParseResultOps
+ */
+export interface ParseResult<A> extends Either<Vector<ParseError>, A> {}
+
+/**
+ * @tsplus static fncts.schema.ParseResultOps succeed
+ */
+export function succeed<A>(value: A): ParseResult<A> {
+  return Either.right(value);
+}
+
+/**
+ * @tsplus static fncts.schema.ParseResultOps failures
+ */
+export function failures<A = never>(value: Vector<ParseError>): ParseResult<A> {
+  return Either.left(value);
+}
+
+/**
+ * @tsplus static fncts.schema.ParseResultOps fail
+ */
+export function fail<A = never>(value: ParseError): ParseResult<A> {
+  return Either.left(Vector(value));
+}

package/_src/Parser/api.ts

@@ -0,0 +1,71 @@
+import type { ParseOptions } from "../AST.js";
+
+import { parserFor } from "./interpreter.js";
+
+/**
+ * @tsplus getter fncts.schema.Schema decode
+ * @tsplus getter fncts.schema.Parser decode
+ */
+export function decode<A>(schema: Schema<A>): Parser<A> {
+  return parserFor(schema.ast);
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema decodeMaybe
+ * @tsplus getter fncts.schema.Parser decodeMaybe
+ */
+export function decodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => Maybe<A> {
+  return parseMaybe(schema.ast.getTo);
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema encode
+ * @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);
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema encodeMaybe
+ * @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();
+  };
+}
+
+function parseMaybe(ast: AST) {
+  const parse = parserFor(ast);
+  return (input: unknown, options?: ParseOptions): Maybe<any> => {
+    return parse(input, options).toMaybe;
+  };
+}
+
+function parseOrThrow(ast: AST) {
+  const parser = parserFor(ast);
+  return (input: unknown, options?: ParseOptions) => {
+    return parser(input, options).match((errors) => {
+      throw new Error(ParseError.format(errors));
+    }, Function.identity);
+  };
+}
+
+/**
+ * @tsplus getter fncts.schema.Schema asserts
+ * @tsplus getter fncts.schema.Parser asserts
+ */
+export function asserts<A>(schema: Schema<A>) {
+  return (input: unknown, options?: ParseOptions): asserts input is A => {
+    parseOrThrow(schema.ast.getTo)(input, options);
+  };
+}

package/_src/Parser/definition.ts

@@ -0,0 +1,24 @@
+import type { ParseOptions } from "../AST.js";
+
+/**
+ * @tsplus type fncts.schema.Parser
+ * @tsplus companion fncts.schema.ParserOps
+ * @tsplus no-inherit fncts.schema.Schema fncts.schema.SchemaOps
+ */
+export interface Parser<in out A> {
+  (input: unknown, options?: ParseOptions): ParseResult<A>;
+}
+
+/**
+ * @tsplus static fncts.schema.ParserOps make
+ */
+export function make<A>(parse: Parser<A>): Parser<A> {
+  return parse;
+}
+
+/**
+ * @tsplus static fncts.schema.ParserOps fromRefinement
+ */
+export function fromRefinement<A>(ast: AST, refinement: Refinement<unknown, A>): Parser<A> {
+  return (u) => (refinement(u) ? ParseResult.succeed(u) : ParseResult.fail(ParseError.TypeError(ast, u)));
+}