Betterlol/moon_zod/core

README
U
ConstraintInfo
U
JsonSchemaRenderer
U
ObjectMode
U
Rule
U
Schema
U
SchemaResult
U
SchemaType
U
StreamParseResult
U
StreamParser
U
StringRenderer
U
TransformClosure
U
ValidationError
V
any
V
append_rule
V
append_rule_with_annotation
V
array
V
bigint
V
boolean
V
collect_named_schemas
V
constraint_comment
V
constraint_info_default
V
constraint_info_to_array_comment
V
constraint_info_to_fallback_comment
V
constraint_info_to_number_comment
V
constraint_info_to_string_comment
V
discriminated_union
V
enum_values
V
escape_ident
V
escape_mbt_string
V
escape_variable_name
V
extract_constraints
V
filter_named_schemas
V
format_double_simple
V
format_path
V
indent_str
V
inner_type
V
intersection
V
is_optional_schema
V
join_parts
V
json_infer_schema
V
json_schema_to_moon_zod
V
json_schema_to_prompt
V
json_schema_to_schema
V
literal
V
null
V
number
V
object
V
parse_json
V
peel_optional
V
preprocess
V
recursive
V
schema_to_moon_zod_code
V
schema_to_moon_zod_code_inline_with_refs
V
schema_to_moon_zod_code_named
V
schema_to_moonbit_struct
V
schema_to_moonbit_struct_full
V
schema_to_prompt
V
schema_to_prompt_named
V
string
V
sub_index
V
sub_path
V
to_json_schema
V
to_json_schema_named
V
to_json_schema_skeleton
V
topological_sort_schemas
V
tuple
V
union
V
unknown
V
unwrap_schema
V
value_in_array

Betterlol/moon_zod/core does not have a README file

ErrorMap

type ErrorMap = (IssueCode, String, Json) -> String?

Error map function: contextual override for error messages. Returns Some(msg) to override, None to fall through to the pre-resolved message.

RawSchemaResult

source

type RawSchemaResult = Result[Json, Array[RawIssue]]

Internal result type used during parsing before error message finalization.

SchemaResult

source

type SchemaResult = Result[Json, Array[ValidationError]]

Result type returned by Schema::parse. Ok(json) on success, Err(errors) with all collected errors on failure.

ConstraintInfo

source

pub(all) struct ConstraintInfo {
  min_value : Double
  max_value : Double
  format : String
  pattern : String
  is_int : Bool
  is_positive : Bool
  is_negative : Bool
  multiple_of : Double
  custom_messages : Array[String]
}

Unified constraint information extracted from Rule annotations. This data structure consolidates all constraint metadata across different types.

IssueCode

source

pub(all) enum IssueCode {
  InvalidType(String)
  TooBig(String, Double, Bool)
  TooSmall(String, Double, Bool)
  InvalidFormat(String)
  NotMultipleOf(Double)
  UnrecognizedKeys(Array[String])
  InvalidUnion(Array[String])
  MissingRequired(String)
  InvalidKey(String)
  InvalidElement(String, Int)
  InvalidValue(Array[Json])
  Custom
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Machine-readable issue code for structured error classification.

IssueCode::equal

source

#deprecated("`IssueCode::equal` is deprecated, use `Eq::equal` instead.")
fn IssueCode::equal(IssueCode, IssueCode) -> Bool

IssueCode::not_equal

source

#deprecated("`IssueCode::not_equal` is deprecated, use `Eq::not_equal` instead.")
fn IssueCode::not_equal(x : IssueCode, y : IssueCode) -> Bool

IssueCode::to_repr

source

#deprecated("`IssueCode::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn IssueCode::to_repr(IssueCode) -> @moonbitlang/core/debug.Repr
Repr

ObjectMode

source

pub(all) enum ObjectMode {
  Passthrough
  Strict
  Strip
} derive(@moonbitlang/core/debug.Debug
Debug)

Object validation mode.

ObjectMode::to_repr

source

#deprecated("`ObjectMode::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ObjectMode::to_repr(ObjectMode) -> @moonbitlang/core/debug.Repr
Repr

ParseParams

source

pub(all) struct ParseParams {
  path : String
  error_map : (IssueCode, String, Json) -> String??
}

Parameters for Schema::safe_parse.

ParseParams::default

source

fn ParseParams::default() -> ParseParams

RawIssue

source

pub(all) struct RawIssue {
  code : IssueCode
  path : String
  message : String
  input : Json
}

A raw validation issue with the message pre-resolved at the generation site. No Schema reference needed — messages are resolved immediately from rule.message / schema.invalid_type_error / schema.required_error / hardcoded default.

Rule

source

pub(all) struct Rule {
  check : (Json) -> Bool
  message : String
  code : IssueCode
  annotation : Json
} derive(@moonbitlang/core/debug.Debug
Debug)

A single validation rule: a predicate + error message + optional JSON Schema annotation.

Rule::to_repr

source

#deprecated("`Rule::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Rule::to_repr(Rule) -> @moonbitlang/core/debug.Repr
Repr

Schema

source

pub(all) struct Schema {
  schema_type : SchemaType
  rules : Array[Rule]
  description : String
  required_error : String
  invalid_type_error : String
  name : String
  brand : String
} derive(@moonbitlang/core/debug.Debug
Debug)

A schema defines the shape and constraints of JSON data.

Schema::brand

source

fn Schema::brand(self : Schema, text : String) -> Schema

Assign a brand to a schema for nominal typing. Branded schemas carry a type-level marker that distinguishes structurally identical schemas (e.g., UserId vs string). The brand is rendered in prompt and JSON Schema exports.

Schema::cuid

source

fn Schema::cuid(self : Schema, msg? : String) -> Schema

Require the string to be a valid CUID (25 chars, starts with 'c', alphanumeric).

Schema::datetime

source

fn Schema::datetime(self : Schema, msg? : String) -> Schema

Require the string to be a valid ISO 8601 datetime.

Schema::default

source

fn Schema::default(self : Schema, value : Json) -> Schema

Provide a default value when the input is null. Rules chained after .default() are pushed through to the inner schema via append_rule.

Schema::describe

source

fn Schema::describe(self : Schema, text : String) -> Schema

Attach a human-readable description to a schema. The description is rendered by schema_to_prompt() alongside type and constraints, helping LLMs understand the semantic meaning of each field.

Schema::email

source

fn Schema::email(self : Schema, msg? : String) -> Schema

Require the string to be a valid email.

Schema::endsWith

source

fn Schema::endsWith(self : Schema, suffix : String, msg? : String) -> Schema

Require the string to end with the given suffix.

Schema::exclude

source

fn Schema::exclude(self : Schema, values : Array[String]) -> Schema

Exclude specific values from an enum schema. Returns a new schema with the remaining values. Aborts if called on a non-enum schema.

Example

let colors = enum_values(["red", "green", "blue"])

let no_green = colors.exclude(["green"])
// now accepts only "red" and "blue"

Schema::extend_with

source

fn Schema::extend_with(self : Schema, extension : Map[String, Schema]) -> Schema

Extend an object schema with additional fields. Fields in extension override fields with the same name in the base schema.

Schema::extract

source

fn Schema::extract(self : Schema, values : Array[String]) -> Schema

Extract specific values from an enum schema. Returns a new schema that only accepts the specified values. Aborts if called on a non-enum schema.

Example

let colors = enum_values(["red", "green", "blue"])

let warm = colors.extract(["red", "orange"]) // "orange" ignored, only "red" kept
// now accepts only "red"

Schema::finite

source

fn Schema::finite(self : Schema, msg? : String) -> Schema

Require the number to be finite (reject Infinity and NaN).

Schema::includes

source

fn Schema::includes(self : Schema, substring : String, msg? : String) -> Schema

Require the string to contain the given substring.

Schema::int

source

fn Schema::int(self : Schema, msg? : String) -> Schema

Require the number to be an integer (no fractional part).

Schema::intersect

source

fn Schema::intersect(self : Schema, other : Schema) -> Schema

Combine two schemas with intersection (both must match). Equivalent to intersection([self, other]).

Schema::invalid_type_error

source

fn Schema::invalid_type_error(self : Schema, text : String) -> Schema

Override the error message when the input type does not match.

Schema::ip

source

fn Schema::ip(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv4 or IPv6 address.

Schema::ipv4

source

fn Schema::ipv4(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv4 address.

Schema::ipv6

source

fn Schema::ipv6(self : Schema, msg? : String) -> Schema

Require the string to be a valid IPv6 address.

Schema::length

source

fn Schema::length(self : Schema, n : Int, msg? : String) -> Schema

Require the string or array to have exactly n items.

Schema::max

source

fn Schema::max(self : Schema, n : Int, msg? : String) -> Schema

Require the string length to be at most n.

Schema::merge

source

fn Schema::merge(self : Schema, other : Schema) -> Schema

Merge two object schemas. Fields from other override fields with the same name in self. The merged schema inherits the right schema's object mode.

Schema::message

source

fn Schema::message(self : Schema, text : String) -> Schema

Override the error message of the last rule in the chain. Peels through OptionalType / DefaultType / TransformType wrappers to find the base schema with the rules array.

Example

string().min(2).message("姓名至少需要 2 个字符")

Schema::min

source

fn Schema::min(self : Schema, n : Int, msg? : String) -> Schema

Require the string length to be at least n.

Schema::multipleOf

source

fn Schema::multipleOf(self : Schema, n : Int, msg? : String) -> Schema

Require the number to be a multiple of n.

Schema::name

source

fn Schema::name(self : Schema, text : String) -> Schema

Give a schema a name for export. When used with schema_to_prompt_named(), named schemas are extracted as separate interface/type definitions in the generated prompt, supporting Object and Enum types.

Schema::negative

source

fn Schema::negative(self : Schema, msg? : String) -> Schema

Require the number to be negative (< 0).

Schema::nonempty

source

fn Schema::nonempty(self : Schema, msg? : String) -> Schema

Require the string to be non-empty (or array to be non-empty).

Schema::omit

source

fn Schema::omit(self : Schema, keys : Array[String]) -> Schema

Omit the specified fields from an object schema. Returns a new object schema with the same mode (Strip/Passthrough/Strict).

Example

let s = object({"a": string(), "b": number()}).omit(["b"])
s.parse(json)  // validates only field "a"

Schema::optional

source

fn Schema::optional(self : Schema) -> Schema

Make a field optional: null or missing values pass validation. Rules chained after .optional() are pushed through to the inner schema via append_rule, so string().optional().min(3) works correctly.

Schema::parse

source

fn Schema::parse(self : Schema, json : Json, path? : String) -> Result[Json, Array[ValidationError]]

Validate json against this schema. Public API — accepts an optional root path string. Internally converts to a mutable path stack to avoid string allocations on the success path.

Schema::parse_array

source

fn Schema::parse_array(self : Schema, element_schema : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_default

source

fn Schema::parse_default(_self : Schema, inner : Schema, default_val : Json, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_discriminated_union

source

fn Schema::parse_discriminated_union(self : Schema, discriminator : String, options : Map[String, Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_enum

source

fn Schema::parse_enum(_self : Schema, values : Array[String], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_intersection

source

fn Schema::parse_intersection(_self : Schema, schemas : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_lazy

source

fn Schema::parse_lazy(self : Schema, f : () -> Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_literal

source

fn Schema::parse_literal(_self : Schema, expected : Json, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_object

source

fn Schema::parse_object(self : Schema, spec : Map[String, Schema], mode : ObjectMode, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_optional

source

fn Schema::parse_optional(_self : Schema, inner : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_pipe

source

fn Schema::parse_pipe(_self : Schema, input_schema : Schema, bridge : TransformClosure, output_schema : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_preprocess

source

fn Schema::parse_preprocess(self : Schema, closure : TransformClosure, inner : Schema, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_stream

source

fn Schema::parse_stream(self : Schema, path? : String, max_length? : Int, max_depth? : Int) -> StreamParser

Start validating one JSON value from an incremental text stream.

Each call to StreamParser::feed() may contain one LLM token, part of a token, or multiple tokens. JSON strings and escape sequences may cross chunk boundaries. Continue feeding until EOF, then call finish() to run schema rules exactly once and confirm that no trailing content was received.

max_length bounds all input in UTF-16 code units (default 1 Mi units). max_depth bounds object/array nesting (default 128, range 1..=1024). max_length must be positive. Text is buffered until the root closes; whitespace after it is not retained.

Schema::parse_transform

source

fn Schema::parse_transform(_self : Schema, inner : Schema, closure : TransformClosure, json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_tuple

source

fn Schema::parse_tuple(self : Schema, items : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::parse_union

source

fn Schema::parse_union(_self : Schema, schemas : Array[Schema], json : Json, path_stack : Array[String]) -> Result[Json, Array[RawIssue]]

Schema::partial

source

fn Schema::partial(self : Schema) -> Schema

Make all fields of an object schema optional. Useful for partial updates (e.g., PATCH operations). Existing optional fields remain optional.

Example

let s = object({"name": string(), "age": number()}).partial()
s.parse(json)  // all fields are now optional

Schema::passthrough

source

fn Schema::passthrough(self : Schema) -> Schema

Allow fields not defined in the schema spec.

Schema::pick

source

fn Schema::pick(self : Schema, keys : Array[String]) -> Schema

Select only the specified fields from an object schema. Returns a new object schema with the same mode (Strip/Passthrough/Strict). Keys not present in the original spec are silently ignored.

Example

let s = object({"a": string(), "b": number()}).pick(["a"])
s.parse(json)  // validates only field "a"

Schema::pipe

source

fn Schema::pipe(self : Schema, output : Schema) -> Schema

Chain two schemas: validate the input against self, then validate the result against output. Errors from each stage are reported independently.

Unlike .transform(), .pipe() creates a clear two-stage pipeline where the output schema can have its own rules — errors are attributed to the correct stage.

Example

let s = string()
  .transform(fn(s) { Ok(Json::string(s.length().to_string())) })
  .pipe(number().min(5))
// string check → transform → number check(.min(5))

Schema::positive

source

fn Schema::positive(self : Schema, msg? : String) -> Schema

Require the number to be positive (> 0).

Schema::refine

source

fn Schema::refine(self : Schema, check : (Json) -> Bool, message : String) -> Schema

Add a custom validation rule.

check is a predicate on the JSON value; message is the error message shown when the predicate returns false.

Schema::regex

source

fn Schema::regex(self : Schema, pattern : String, msg? : String) -> Schema

Require the string to match the given regex pattern.

Schema::required_error

source

fn Schema::required_error(self : Schema, text : String) -> Schema

Override the error message when a required field is missing. Only effective when this schema is used as an object field value.

Schema::safe

source

fn Schema::safe(self : Schema, msg? : String) -> Schema

Require the number to be a safe integer (within ±2^53-1).

Schema::safe_parse

source

fn Schema::safe_parse(self : Schema, json : Json, params : ParseParams) -> Result[Json, Array[ValidationError]]

Validate json against this schema with extended parameters. Supports contextual error map override.

Example

schema.safe_parse(json, { error_map: fn(code, path, input) {
  match code { InvalidType(expected) => Some("必须是: " + expected) _ => None }
}})

Schema::startsWith

source

fn Schema::startsWith(self : Schema, prefix : String, msg? : String) -> Schema

Require the string to start with the given prefix.

Schema::strict

source

fn Schema::strict(self : Schema) -> Schema

Reject fields not defined in the schema spec.

Schema::strip

source

fn Schema::strip(self : Schema) -> Schema

Silently strip extra fields not defined in the schema spec. This is the default mode.

Schema::to_lower

source

fn Schema::to_lower(self : Schema) -> Schema

Convert the string to lowercase.

Schema::to_repr

source

#deprecated("`Schema::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn Schema::to_repr(Schema) -> @moonbitlang/core/debug.Repr
Repr

Schema::to_upper

source

fn Schema::to_upper(self : Schema) -> Schema

Convert the string to uppercase.

Schema::transform

source

fn Schema::transform(self : Schema, f : (Json) -> Result[Json, String]) -> Schema

Apply a transformation function to the validated JSON value.

The schema is first validated normally. If validation succeeds, f is called with the validated JSON. The transform can modify the value or return an error.

Rules chained after .transform() are applied to the transformed value.

Example

let s = string().transform(fn(json) {
  match json {
    String(s) => Ok(Json::string(s + "!"))
    _ => Err("expected string")
  }
})

Schema::trim

source

fn Schema::trim(self : Schema) -> Schema

Trim leading and trailing whitespace from the string.

Schema::ulid

source

fn Schema::ulid(self : Schema, msg? : String) -> Schema

Require the string to be a valid ULID (26 chars, Crockford Base32).

Schema::url

source

fn Schema::url(self : Schema, msg? : String) -> Schema

Require the string to be a valid URL with http:// or https:// scheme.

Schema::uuid

source

fn Schema::uuid(self : Schema, msg? : String) -> Schema

Require the string to be a valid UUID v4. Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx

SchemaType

source

pub(all) enum SchemaType {
  StringType
  NumberType
  BooleanType
  NullType
  AnyType
  UnknownType
  ObjectType(Map[String, Schema], ObjectMode)
  ArrayType(Schema)
  TupleType(Array[Schema])
  OptionalType(Schema)
  DefaultType(Schema, Json)
  EnumType(Array[String])
  UnionType(Array[Schema])
  IntersectionType(Array[Schema])
  PreprocessType(TransformClosure, Schema)
  TransformType(Schema, TransformClosure)
  LiteralType(Json)
  LazyType(() -> Schema)
  DiscriminatedUnionType(String, Map[String, Schema])
  PipeType(Schema, TransformClosure, Schema)
} derive(@moonbitlang/core/debug.Debug
Debug)

Internal tag for runtime type dispatch.

SchemaType::to_repr

source

#deprecated("`SchemaType::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn SchemaType::to_repr(SchemaType) -> @moonbitlang/core/debug.Repr
Repr

StreamParseResult

source

pub(all) enum StreamParseResult {
  StreamPending
  StreamValid(Json)
  StreamInvalidJson(String)
  StreamInvalidSchema(Array[ValidationError])
}

The result of advancing a single-JSON streaming parser.

StreamPending means the document has not been finalized. Only finish() returns success; feed() can reject malformed input early. Other variants are terminal and subsequent calls return the same result.

StreamParser

source

pub struct StreamParser {
  // private fields
}

Mutable state for incrementally parsing and validating one JSON value.

Create this value with Schema::parse_stream(), feed arbitrary text chunks with feed(), then call finish() when the upstream token stream ends.

StreamParser::feed

source

fn StreamParser::feed(self : StreamParser, token : String) -> StreamParseResult

Feed the next text chunk into this parser.

A StreamInvalidJson result is reported as soon as an unmatched closing delimiter or trailing non-whitespace is seen. Other JSON syntax errors are reported when the root value closes or when finish() is called.

StreamParser::finish

source

fn StreamParser::finish(self : StreamParser) -> StreamParseResult

Mark the upstream token stream as finished and return its final result.

Required for every root type: success is final only at end of input.

TransformClosure

source

pub(all) struct TransformClosure {
  f : (Json) -> Result[Json, String]
  is_builtin : Bool
} derive(@moonbitlang/core/debug.Debug
Debug)

Internal wrapper for a transform function stored in TransformType.

TransformClosure::to_repr

source

#deprecated("`TransformClosure::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn TransformClosure::to_repr(TransformClosure) -> @moonbitlang/core/debug.Repr
Repr

ValidationError

source

pub(all) struct ValidationError {
  code : IssueCode
  path : String
  message : String
  got : Json
} derive(@moonbitlang/core/debug.Debug
Debug)

Represents a single validation failure.

code is the structured issue code for machine-readable error classification. path is the field path (e.g. "name", "address.city"). message describes what went wrong. got is the actual JSON value that failed validation.

ValidationError::to_repr

source

#deprecated("`ValidationError::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
fn ValidationError::to_repr(ValidationError) -> @moonbitlang/core/debug.Repr
Repr

ValidationError::to_string

source

fn ValidationError::to_string(self : ValidationError) -> String

Format a validation error as a human-readable string. Uses Debug for the received value to avoid Show deprecation.

any

source

fn any(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any JSON value.

append_rule

source

fn append_rule(schema : Schema, check : (Json) -> Bool, message : String, code : IssueCode) -> Schema

Append a rule through decoration wrappers.

append_rule_with_annotation

source

fn append_rule_with_annotation(schema : Schema, check : (Json) -> Bool, message : String, code : IssueCode, annotation : Json) -> Schema

Append a rule with a JSON Schema annotation fragment. The annotation is merged into the JSON Schema output when to_json_schema() is called, enabling constraint export (minLength, maximum, pattern, etc.).

array

source

fn array(element_schema : Schema, required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON arrays.

Each element in the array is validated against element_schema.

bigint

source

fn bigint(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON integer values as big integers.

This is a convenience alias for number().int() that expresses semantic intent. Useful for financial amounts, large IDs, and other scenarios where the semantic type is "big integer" rather than "number that is an integer".

boolean

source

fn boolean(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON booleans.

collect_named_schemas

source

fn collect_named_schemas(schema : Schema) -> Array[Schema]

Collect all named schemas from the input schema tree.

collect_named_schemas_impl

source

fn collect_named_schemas_impl(schema : Schema, visited : Array[String], result : Array[Schema]) -> Unit

collect_raw_errors

source

fn collect_raw_errors(out : Array[RawIssue], path_stack : Array[String], json : Json, rules : Array[Rule]) -> Unit

Collect raw issues from rule failures.

constraint_comment

source

fn constraint_comment(schema : Schema) -> String

Extract and format constraint comment for a schema (without description). Dispatches to type-appropriate formatter based on the unwrapped schema type.

constraint_info_default

source

fn constraint_info_default() -> ConstraintInfo

Create a default empty ConstraintInfo

constraint_info_to_array_comment

source

fn constraint_info_to_array_comment(info : ConstraintInfo) -> String

Convert ConstraintInfo to prompt comment string for arrays.

constraint_info_to_fallback_comment

source

fn constraint_info_to_fallback_comment(info : ConstraintInfo) -> String

Convert ConstraintInfo to prompt comment string (fallback for unknown types).

constraint_info_to_number_comment

source

fn constraint_info_to_number_comment(info : ConstraintInfo) -> String

Convert ConstraintInfo to prompt comment string for numbers.

constraint_info_to_string_comment

source

fn constraint_info_to_string_comment(info : ConstraintInfo) -> String

Convert ConstraintInfo to prompt comment string for strings.

dfs_topo_sort

source

fn dfs_topo_sort(name : String, deps_list : Array[(String, Array[String])], visited : Array[(String, Int)], sorted : Array[Schema], schema_map : Array[Schema]) -> Unit

DFS for topological sorting. Adds schemas to sorted list in dependency order.

discriminated_union

source

fn discriminated_union(discriminator : String, options : Map[String, Schema]) -> Schema

Create a schema that dispatches to one of several options based on a discriminator field value. Unlike union(), this directly selects the matching schema in O(1) instead of trying each branch in order.

Example

let pet = @moon_zod.discriminated_union("type", {
  "dog": @moon_zod.object({ "bark": @moon_zod.boolean() }),
  "cat": @moon_zod.object({ "meow": @moon_zod.boolean() }),
})

enum_values

source

fn enum_values(values : Array[String], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts one of a fixed set of string values.

escape_function_name

source

fn escape_function_name(name : String) -> String

escape a string to be a valid MoonBit function name (lowercase first letter, valid identifier).

escape_ident

source

fn escape_ident(name : String) -> String

escape a string to be a valid MoonBit identifier by replacing invalid characters with underscores.

escape_mbt_string

source

fn escape_mbt_string(s : String) -> String

Escape a string for use in MoonBit code, handling backslashes, quotes, newlines, and tabs.

escape_type_name

source

fn escape_type_name(name : String) -> String

escape a string to be a valid MoonBit type name (uppercase first letter, valid identifier).

escape_variable_name

source

fn escape_variable_name(name : String) -> String

escape a string to be a valid MoonBit variable name (lowercase first letter, valid identifier).

extract_constraints

source

fn extract_constraints(rules : Array[Rule]) -> ConstraintInfo

Extract all constraint information from a Rule array. Unified extraction that works across all types.

filter_named_schemas

source

fn filter_named_schemas(all_named : Array[Schema], include_names : Array[String]?) -> Array[Schema]

Filter named schemas based on include_names optional parameter. If include_names is None, returns all schemas. If Some(names), returns only schemas whose names are in the list.

finalize_issue

source

fn finalize_issue(raw : RawIssue, params : ParseParams) -> ValidationError

Resolve an error message using the error map priority chain. Priority: error_map (contextual) → pre-resolved message.

finalize_issues

source

fn finalize_issues(raw_issues : Array[RawIssue], params : ParseParams) -> Array[ValidationError]

Convert raw issues to validation errors using finalize_issue.

find_schema_dependencies

source

fn find_schema_dependencies(schema : Schema, schema_map : Array[Schema]) -> Array[String]

Find all named schema dependencies within a schema.

find_schema_dependencies_impl

source

fn find_schema_dependencies_impl(schema : Schema, schema_map : Array[Schema], deps : Array[String], visited_names : Array[String]) -> Unit

format_double_simple

source

fn format_double_simple(v : Double) -> String

Format a Double as a string, stripping ".0" for whole numbers.

format_path

source

fn format_path(stack : Array[String]) -> String

indent_str

source

fn indent_str(n : Int) -> String

Generate n * 2 spaces.

inner_type

source

fn inner_type(t : SchemaType) -> SchemaType

Peel OptionalType / DefaultType wrappers to find the effective base type.

intersection

source

fn intersection(schemas : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that requires all given schemas to match (intersection / and). For objects, fields from all schemas are merged into one.

is_keyword

source

fn is_keyword(name : String) -> Bool

Check if a name is a reserved keyword in MoonBit.

is_optional_schema

source

fn is_optional_schema(s : Schema) -> Bool

join_parts

source

fn join_parts(parts : Array[String]) -> String

Join constraint parts with ", ".

json_infer_schema

source

fn json_infer_schema(json : Json) -> Schema

Generate a schema from a JSON value. Simple heuristics are used to infer types and constraints from the value.

literal

source

fn literal(value : Json, required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts a specific literal JSON value. The value must match exactly (String, Number, Boolean, or Null).

Example

let schema = @moon_zod.literal(Json::string("hello"))
schema.parse(Json::string("hello")) // Ok
schema.parse(Json::string("world")) // Err

null

source

fn null(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON null.

number

source

fn number(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON numbers.

object

source

fn object(spec : Map[String, Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON objects.

Each key in spec defines a required field and its schema. By default, extra fields in the input JSON are silently stripped (Strip mode). Use .passthrough() to allow extra fields, or .strict() to reject them.

parse_json

source

fn parse_json(input : String) -> Json

peel_optional

source

fn peel_optional(schema : Schema) -> Schema

Peel OptionalType / DefaultType wrappers to check optionality.

preprocess

source

fn preprocess(f : (Json) -> Result[Json, String], inner : Schema, required_error? : String, invalid_type_error? : String) -> Schema

Preprocess a JSON value before validating it with inner.

This is the inverse order of .transform(): f runs on raw input first, then the returned JSON value is validated against inner.

recursive

source

fn recursive(f : () -> Schema) -> Schema

Create a schema that defers resolution to parse time. Required for recursive/self-referencing schemas (trees, linked lists, etc.).

Example

fn tree_schema() -> @moon_zod.Schema {
  @moon_zod.recursive(fn() {
    @moon_zod.object({
      "value": @moon_zod.number(),
      "children": @moon_zod.array(@moon_zod.recursive(tree_schema)).optional(),
    })
  })
}

string

source

fn string(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates JSON strings.

sub_index

source

fn sub_index(path : String, i : Int) -> String

sub_path

source

fn sub_path(path : String, name : String) -> String

topological_sort_schemas

source

fn topological_sort_schemas(named_schemas : Array[Schema]) -> Array[Schema]

Topologically sort named schemas so dependents come before dependees.

tuple

source

fn tuple(items : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that validates fixed-length JSON arrays.

Each item in items validates the array element at the same index.

type_origin

source

fn type_origin(t : SchemaType) -> String

Map SchemaType to its origin string for IssueCode payloads.

union

source

fn union(schemas : Array[Schema], required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any of the given schemas (union / or). Schemas are tried in order; the first match succeeds.

unknown

source

fn unknown(required_error? : String, invalid_type_error? : String) -> Schema

Create a schema that accepts any JSON value as unknown.

Runtime behavior matches any(); the distinction is semantic for consumers.

unwrap_schema

source

fn unwrap_schema(schema : Schema) -> Schema

Peel OptionalType / DefaultType / TransformType wrappers to find the innermost schema that carries the actual rules.

value_in_array

source

fn value_in_array(value : String, arr : Array[String]) -> Bool

Check if a value is in an array of strings.

visited_contains

source

fn visited_contains(visited_list : Array[(String, Int)], name : String) -> Bool

Helper: check if a name is in visited list

visited_get_status

source

fn visited_get_status(visited_list : Array[(String, Int)], name : String) -> Int

Helper: get status from visited list (0 = unvisited by default)

visited_set_status

source

fn visited_set_status(visited_list : Array[(String, Int)], name : String, status : Int) -> Unit

Helper: set status in visited list

Site source Report issue Packages Build queue Skills Statistics

#ErrorMap

#RawSchemaResult

#SchemaResult

#ConstraintInfo

#IssueCode

#IssueCode::equal

#IssueCode::not_equal

#IssueCode::to_repr

#ObjectMode

#ObjectMode::to_repr

#ParseParams

#ParseParams::default

#RawIssue

#Rule

#Rule::to_repr

#Schema

#Schema::brand

#Schema::cuid

#Schema::datetime

#Schema::default

#Schema::describe

#Schema::email

#Schema::endsWith

#Schema::exclude

Example

#Schema::extend_with

#Schema::extract

Example

#Schema::finite

#Schema::includes

#Schema::int

#Schema::intersect

#Schema::invalid_type_error

#Schema::ip

#Schema::ipv4

#Schema::ipv6

#Schema::length

#Schema::max

#Schema::merge

#Schema::message

Example

#Schema::min

#Schema::multipleOf

#Schema::name

#Schema::negative

#Schema::nonempty

#Schema::omit

Example

#Schema::optional

#Schema::parse

#Schema::parse_array

#Schema::parse_default

#Schema::parse_discriminated_union

#Schema::parse_enum

#Schema::parse_intersection

#Schema::parse_lazy

#Schema::parse_literal

#Schema::parse_object

#Schema::parse_optional

#Schema::parse_pipe

#Schema::parse_preprocess

#Schema::parse_stream

#Schema::parse_transform

#Schema::parse_tuple

#Schema::parse_union

#Schema::partial

Example

#Schema::passthrough

#Schema::pick

Example

#Schema::pipe

Example

#Schema::positive

#Schema::refine

#Schema::regex

#Schema::required_error

#Schema::safe

#Schema::safe_parse

Example

#Schema::startsWith

ErrorMap

RawSchemaResult

SchemaResult

ConstraintInfo

IssueCode

IssueCode::equal

IssueCode::not_equal

IssueCode::to_repr

ObjectMode

ObjectMode::to_repr

ParseParams

ParseParams::default

RawIssue

Rule

Rule::to_repr

Schema

Schema::brand

Schema::cuid

Schema::datetime

Schema::default

Schema::describe

Schema::email

Schema::endsWith

Schema::exclude

Schema::extend_with

Schema::extract

Schema::finite

Schema::includes

Schema::int

Schema::intersect

Schema::invalid_type_error

Schema::ip

Schema::ipv4

Schema::ipv6

Schema::length

Schema::max

Schema::merge

Schema::message

Schema::min

Schema::multipleOf

Schema::name

Schema::negative

Schema::nonempty

Schema::omit

Schema::optional

Schema::parse

Schema::parse_array

Schema::parse_default

Schema::parse_discriminated_union

Schema::parse_enum

Schema::parse_intersection

Schema::parse_lazy

Schema::parse_literal

Schema::parse_object

Schema::parse_optional

Schema::parse_pipe

Schema::parse_preprocess

Schema::parse_stream

Schema::parse_transform

Schema::parse_tuple

Schema::parse_union

Schema::partial

Schema::passthrough

Schema::pick

Schema::pipe

Schema::positive

Schema::refine

Schema::regex

Schema::required_error

Schema::safe

Schema::safe_parse

Schema::startsWith

Schema::strict

Schema::strip

Schema::to_lower

Schema::to_repr

Schema::to_upper

Schema::transform

Schema::trim

Schema::ulid