malli.core — metosin/malli 0.19.2

-->-schema clj/s

(-->-schema _)

Experimental simple schema for :=> schema. AST and explain results subject to change.

-=>-schema clj/s

(-=>-schema)

-and-schema clj/s

(-and-schema)

-any-schema clj/s

(-any-schema)

-ast clj/s

(-ast acc properties options)

-ast? clj/s

(-ast? x)

-boolean-fn clj/s

(-boolean-fn x)

-boolean-schema clj/s

(-boolean-schema)

-cached clj/s

(-cached s k f)

-cached? clj/s

(-cached? x)

-check-children! clj/s

(-check-children! type properties children props)

(-check-children! type properties children min max)

-collection-schema clj/s

(-collection-schema props)

-collection-transformer clj/s

(-collection-transformer t empty)

-comp clj/s≠

clj

(-comp)

(-comp f)

(-comp f g)

(-comp f g h)

(-comp f1 f2 f3 f4)

(-comp f1 f2 f3 f4 f5)

(-comp f1 f2 f3 f4 f5 f6)

(-comp f1 f2 f3 f4 f5 f6 f7)

(-comp f1 f2 f3 f4 f5 f6 f7 f8)

(-comp f1 f2 f3 f4 f5 f6 f7 f8 & fs)

cljs

(-comp)

(-comp f)

(-comp f g)

(-comp f g h)

(-comp f1 f2 f3 & fs)

-create-cache clj/s

(-create-cache _options)

-create-entry-form clj/s

(-create-entry-form parent properties entry-parser options)

-create-entry-parser clj/s

(-create-entry-parser ?children props options)

-create-form clj/s

(-create-form type properties children options)

-default-entry clj/s

(-default-entry e)

-default-entry-schema clj/s

(-default-entry-schema children)

-default-sci-options clj/s

(-default-sci-options)

-delayed-registry clj/s

(-delayed-registry m f)

-deprecated! clj/s

(-deprecated! x)

-deregister-function-schemas! clj/s

(-deregister-function-schemas! key)

-deregister-metadata-function-schemas! clj/s

(-deregister-metadata-function-schemas! key)

-double-schema clj/s

(-double-schema)

-eager-entry-parser clj/s

(-eager-entry-parser children props options)

-entry-ast clj/s

(-entry-ast schema keyset)

-entry-parser? clj/s

(-entry-parser? x)

-entry-schema? clj/s

(-entry-schema? x)

-enum-schema clj/s

(-enum-schema)

-equals clj/s

(-equals x y)

-exception clj/s

(-exception type data)

-fail! clj/s

(-fail! type)

(-fail! type data)

-float-schema clj/s

(-float-schema)

-fn-schema clj/s

(-fn-schema)

-from-child-ast clj/s

(-from-child-ast parent ast options)

-from-entry-ast clj/s

(-from-entry-ast parent ast options)

-from-type-ast clj/s

(-from-type-ast parent ast options)

-from-value-ast clj/s

(-from-value-ast parent ast options)

-function-schema clj/s

(-function-schema _)

-get-entries clj/s

(-get-entries schema key default)

-group-by-arity! clj/s

(-group-by-arity! infos)

-guard clj/s

(-guard pred tf)

-infer clj/s

(-infer children)

-inner-entries clj/s

(-inner-entries walker path entries options)

-inner-indexed clj/s

(-inner-indexed walker path children options)

-instrument clj/s

(-instrument props)

(-instrument props f)

(-instrument props f options)

Takes an instrumentation properties map and a function and returns a wrapped function, which will validate function arguments and return values based on the function schema definition. The following properties are used:

key	description
:schema	function schema
:scope	optional set of scope definitions, defaults to #{:input :output :guard}
:report	optional side-effecting function of key data -> any to report problems, defaults to m/-fail!
:gen	optional function of schema -> schema -> value to be invoked on the args to get the return value

-int-schema clj/s

(-int-schema)

-intercepting clj/s

(-intercepting interceptor)

(-intercepting {:keys [enter leave]} f)

-into-transformer clj/s

(-into-transformer x)

-keyword->string clj/s

(-keyword->string x)

-keyword-schema clj/s

(-keyword-schema)

-lazy clj/s

(-lazy ref options)

-lazy-entry-parser clj/s

(-lazy-entry-parser ?children props options)

-map-of-schema clj/s

(-map-of-schema)

(-map-of-schema opts)

-map-schema clj/s

(-map-schema)

(-map-schema opts)

-map-transformer clj/s

(-map-transformer ts)

-maybe-schema clj/s

(-maybe-schema)

-memoize clj/s

(-memoize f)

-min-max-pred clj/s

(-min-max-pred f)

-multi-schema clj/s

(-multi-schema)

(-multi-schema opts)

-needed-bounded-checks clj/s

(-needed-bounded-checks min max options)

-nil-schema clj/s

(-nil-schema)

-no-op-transformer clj/s

(-no-op-transformer)

-not-schema clj/s

(-not-schema)

-or-schema clj/s

(-or-schema)

-or-transformer clj/s

(-or-transformer this transformer child-schemas method options)

-orn-schema clj/s

(-orn-schema)

-parent-children-transformer clj/s

(-parent-children-transformer parent children transformer method options)

-parse-entry-ast clj/s

(-parse-entry-ast ast options)

-pointer clj/s

(-pointer id schema options)

-properties-and-options clj/s

(-properties-and-options properties options f)

-property-registry clj/s

(-property-registry m options f)

-proxy-schema clj/s

(-proxy-schema {:keys [type min max childs type-properties fn]})

-qualified-keyword-pred clj/s

(-qualified-keyword-pred properties)

-qualified-keyword-schema clj/s

(-qualified-keyword-schema)

-qualified-symbol-schema clj/s

(-qualified-symbol-schema)

-raw-form clj/s

(-raw-form type properties children)

-re-schema clj/s

(-re-schema class?)

-ref-schema clj/s

(-ref-schema)

(-ref-schema {:keys [lazy type-properties]})

-ref-schema? clj/s

(-ref-schema? x)

-reference? clj/s

(-reference? ?schema)

-register-function-schema! clj/s

(-register-function-schema! ns name ?schema data)

(-register-function-schema! ns name ?schema data key f)

-registry clj/s

(-registry)

(-registry {:keys [registry]})

-safe-pred clj/s

(-safe-pred f)

-schema-schema clj/s

(-schema-schema {:keys [id raw]})

-sequence-entry-schema clj/s

(-sequence-entry-schema {:keys [type re-validator re-explainer re-parser
                                re-unparser re-transformer re-min-max]
                         {:keys [min max keep]} :child-bounds
                         :as opts})

-sequence-schema clj/s

(-sequence-schema {:keys [type re-validator re-explainer re-parser re-unparser
                          re-transformer re-min-max]
                   {:keys [min max]} :child-bounds})

-set-assoc-children clj/s

(-set-assoc-children schema key value)

-set-children clj/s

(-set-children schema children)

-set-entries clj/s

(-set-entries schema ?key value)

-set-properties clj/s

(-set-properties schema properties)

-simple-entry-parser clj/s

(-simple-entry-parser keyset children forms)

-simple-form clj/s

(-simple-form parent properties children f options)

-simple-schema clj/s

(-simple-schema props)

-some-schema clj/s

(-some-schema)

-string-schema clj/s

(-string-schema)

-symbol-schema clj/s

(-symbol-schema)

-to-child-ast clj/s

(-to-child-ast schema)

-to-type-ast clj/s

(-to-type-ast schema)

-to-value-ast clj/s

(-to-value-ast schema)

-transformer? clj/s

(-transformer? x)

-tuple-schema clj/s

(-tuple-schema)

(-tuple-schema opts)

-tuple-transformer clj/s

(-tuple-transformer ts)

-unlift-keys clj/s

(-unlift-keys m prefix)

-update clj/s

(-update x k f)

-update-options clj/s

(-update-options schema f)

-update-properties clj/s

(-update-properties schema f & args)

-uuid-schema clj/s

(-uuid-schema)

-val-schema clj/s

(-val-schema)

(-val-schema schema properties)

-validate-bounded-limits clj/s

(-validate-bounded-limits needed min max)

-validate-limits clj/s

(-validate-limits min max)

-vmap clj/s

(-vmap os)

(-vmap f os)

-walk-entries clj/s

(-walk-entries schema walker path options)

-walk-indexed clj/s

(-walk-indexed schema walker path options)

-walk-leaf clj/s

(-walk-leaf schema walker path options)

=> clj/s macro

(=> given-sym value)

assert clj/s macro

(assert ?schema value)

(assert ?schema value options)

Assert that value validates against schema ?schema, or throws ExceptionInfo. The var clojure.core/assert determines whether assertion are checked.

AST clj/s protocol

-from-ast clj/s

(-from-ast this ast options)

ast to schema

-to-ast clj/s

(-to-ast this options)

schema to ast

ast clj/s

(ast ?schema)

(ast ?schema options)

Returns the Schema AST

base-schemas clj/s

(base-schemas)

Cached clj/s protocol

-cache clj/s

(-cache this)

children clj/s

(children ?schema)

(children ?schema options)

Returns the Schema children with all Child Schemas resolved. For MapEntry Schemas, returns a always tuple3 of key ?properties child

children-schema clj/s

(children-schema ?schema)

(children-schema ?schema options)

Returns children schema for Schema or IntoSchema.

class-schemas clj/s

(class-schemas)

coerce clj/s

(coerce ?schema value)

(coerce ?schema value transformer)

(coerce ?schema value transformer options)

(coerce ?schema value transformer respond raise)

(coerce ?schema value transformer respond raise options)

Decode and validate a value, throws on validation error.

coercer clj/s

(coercer ?schema)

(coercer ?schema transformer)

(coercer ?schema transformer options)

(coercer ?schema transformer respond raise)

(coercer ?schema transformer respond raise options)

Creates a function to decode and validate a value, throws on validation error.

comparator-schemas clj/s

(comparator-schemas)

decode clj/s

(decode ?schema value t)

(decode ?schema value options t)

Transforms a value with a given decoding transformer against a schema.

decoder clj/s

(decoder ?schema t)

(decoder ?schema options t)

Creates a value decoding function given a transformer and a schema.

default-registry clj/s

default-schema clj/s

(default-schema ?schema)

(default-schema ?schema options)

Returns the default (::m/default) schema from EntrySchema

default-schemas clj/s

(default-schemas)

deref clj/s

(deref ?schema)

(deref ?schema options)

Derefs top-level RefSchemas or returns original Schema.

deref-all clj/s

(deref-all ?schema)

(deref-all ?schema options)

Derefs top-level RefSchemas recursively or returns original Schema.

deref-recursive clj/s

(deref-recursive ?schema)

(deref-recursive ?schema {:malli.core/keys [ref-key] :as options})

Derefs all schemas at all levels. Does not walk over :refs.

DistributiveSchema clj/s protocol

-distribute-to-children clj/s

(-distribute-to-children this f options)

-distributive-schema? clj/s

(-distributive-schema? this)

encode clj/s

(encode ?schema value t)

(encode ?schema value options t)

Transforms a value with a given encoding transformer against a schema.

encoder clj/s

(encoder ?schema t)

(encoder ?schema options t)

Creates a value encoding transformer given a transformer and a schema.

entries clj/s

(entries ?schema)

(entries ?schema options)

Returns EntrySchema children as a sequence of clojure.lang/MapEntrys where the values child schemas wrapped in :malli.core/val Schemas, with the entry properties as properties.

Using entries enable usage of entry properties in walking and value transformation.

(def schema [:map [:x int?] [:y {:optional true} int?]])

(m/children schema) ; [[:x nil int?] ; [:y {:optional true} int?]]

(m/entries schema) ; [[:x [:malli.core/val int?]] ; [:y [:malli.core/val {:optional true} int?]]]

(map key (m/entries schema)) ; (:x :y)

EntryParser clj/s protocol

-entry-children clj/s

(-entry-children this)

-entry-entries clj/s

(-entry-entries this)

-entry-forms clj/s

(-entry-forms this)

-entry-keyset clj/s

(-entry-keyset this)

EntrySchema clj/s protocol

-entries clj/s

(-entries this)

returns sequence of key -val-schema entries

-entry-parser clj/s

(-entry-parser this)

eval clj/s

(eval ?code)

(eval ?code options)

explain clj/s

(explain ?schema value)

(explain ?schema value options)

Explains a value against a given schema. Creates the explainer for every call. When performance matters, (re-)use explainer instead.

explainer clj/s

(explainer ?schema)

(explainer ?schema options)

Returns an pure explainer function of type x -> explanation for a given Schema. Caches the result for Cached Schemas with key :explainer.

explicit-keys clj/s

(explicit-keys ?schema)

(explicit-keys ?schema options)

Returns a vector of explicit (not ::m/default) keys from EntrySchema

form clj/s

(form ?schema)

(form ?schema options)

Returns the Schema form

from-ast clj/s

(from-ast ?ast)

(from-ast ?ast options)

Creates a Schema from AST

function-schema clj/s

(function-schema ?schema)

(function-schema ?schema options)

function-schemas clj/s

(function-schemas)

(function-schemas key)

FunctionSchema clj/s protocol

-function-info clj/s

(-function-info this)

-function-schema-arities clj/s

(-function-schema-arities this)

-function-schema? clj/s

(-function-schema? this)

-instrument-f clj/s

(-instrument-f schema props f options)

into-schema clj/s

(into-schema type properties children)

(into-schema type properties children options)

Creates a Schema instance out of type, optional properties map and children

into-schema? clj/s

(into-schema? x)

Checks if x is a IntoSchema instance

IntoSchema clj/s protocol

-children-schema clj/s

(-children-schema this options)

maybe returns sequence schema describing schema children

-into-schema clj/s

(-into-schema this properties children options)

creates a new schema instance

-properties-schema clj/s

(-properties-schema this options)

maybe returns :map schema describing schema properties

-type clj/s

(-type this)

returns type of the schema

-type-properties clj/s

(-type-properties this)

returns schema type properties

LensSchema clj/s protocol

-get clj/s

(-get this key default)

returns schema at key

-keep clj/s

(-keep this)

returns truthy if schema contributes to value path

-set clj/s

(-set this key value)

returns a copy with key having new value

old-parse-format clj/s

(old-parse-format parsed)

Transform the new parsing format to the old one by replacing Tag and Tags objects with their content.

options clj/s

(options ?schema)

(options ?schema options)

Returns options used in creating the Schema

parent clj/s

(parent ?schema)

(parent ?schema options)

Returns the IntoSchema instance that created the Schema

parse clj/s

(parse ?schema value)

(parse ?schema value options)

parses a value against a given schema. Creates the parser for every call. When performance matters, (re-)use parser instead.

parser clj/s

(parser ?schema)

(parser ?schema options)

Returns an pure parser function of type x -> either parsed-x ::invalid for a given Schema. Caches the result for Cached Schemas with key :parser.

predicate-schemas clj/s

(predicate-schemas)

properties clj/s

(properties ?schema)

(properties ?schema options)

Returns the Schema properties

properties-schema clj/s

(properties-schema ?schema)

(properties-schema ?schema options)

Returns properties schema for Schema or IntoSchema.

RefSchema clj/s protocol

-deref clj/s

(-deref this)

returns the referenced schema

-ref clj/s

(-ref this)

returns the reference name

RegexSchema clj/s protocol

-regex-explainer clj/s

(-regex-explainer this path)

returns the raw internal regex explainer implementation

-regex-min-max clj/s

(-regex-min-max this nested?)

returns size of the sequence as {:min min :max max}. nil max means unbounded. nested? is true when this schema is nested inside an outer regex schema.

-regex-op? clj/s

(-regex-op? this)

is this a regex operator (e.g. :cat, :*...)

-regex-parser clj/s

(-regex-parser this)

returns the raw internal regex parser implementation

-regex-transformer clj/s

(-regex-transformer this transformer method options)

returns the raw internal regex transformer implementation

-regex-unparser clj/s

(-regex-unparser this)

returns the raw internal regex unparser implementation

-regex-validator clj/s

(-regex-validator this)

returns the raw internal regex validator implementation

Schema clj/s protocol

-validator clj/s

(-validator this)

returns a predicate function that checks if the schema is valid

-options clj/s

(-options this)

returns original options

-transformer clj/s

(-transformer this transformer method options)

returns a function to transform the value for the given schema and method. Can also return nil instead of identity so that more no-op transforms can be elided.

-walk clj/s

(-walk this walker path options)

walks the schema and it's children, ::m/walk-entry-vals, ::m/walk-refs, ::m/walk-schema-refs options effect how walking is done.

-parser clj/s

(-parser this)

return a function of x -> parsed-x | ::m/invalid to explain how schema is valid.

-properties clj/s

(-properties this)

returns original schema properties

-children clj/s

(-children this)

returns schema children

-form clj/s

(-form this)

returns original form of the schema

-explainer clj/s

(-explainer this path)

returns a function of x in acc -> maybe errors to explain the errors for invalid values

-unparser clj/s

(-unparser this)

return the inverse (partial) function wrt. -parser; parsed-x -> x | ::m/invalid

-parent clj/s

(-parent this)

returns the IntoSchema instance

schema clj/s

(schema ?schema)

(schema ?schema options)

Creates a Schema object from any of the following:

• Schema instance (just returns it)
• IntoSchema instance
• Schema vector syntax, e.g. [:string {:min 1}]
• Qualified Keyword or String, using a registry lookup

schema-walker clj/s

(schema-walker f)

schema? clj/s

(schema? x)

Checks if x is a Schema instance

sequence-schemas clj/s

(sequence-schemas)

tag clj/s

(tag key value)

A tagged value, used eg. for results of parse for :orn schemas.

tag? clj/s

(tag? x)

Is this a value constructed with tag?

tags clj/s

(tags values)

A collection of tagged values. values should be a map from tag to value. Used eg. for results of parse for :catn schemas.

tags? clj/s

(tags? x)

Is this a value constructed with tags?

Transformer clj/s protocol

-transformer-chain clj/s

(-transformer-chain this)

returns transformer chain as a vector of maps with :name, :encoders, :decoders and :options

-value-transformer clj/s

(-value-transformer this schema method options)

returns a value transforming interceptor for the given schema and method

type clj/s

(type ?schema)

(type ?schema options)

Returns the Schema type.

type-properties clj/s

(type-properties ?schema)

(type-properties ?schema options)

Returns the Schema type properties

type-schemas clj/s

(type-schemas)

unparse clj/s

(unparse ?schema value)

(unparse ?schema value options)

Unparses a value against a given schema. Creates the unparser for every call. When performance matters, (re-)use unparser instead.

unparser clj/s

(unparser ?schema)

(unparser ?schema options)

Returns an pure unparser function of type parsed-x -> either x ::invalid for a given Schema. Caches the result for Cached Schemas with key :unparser.

validate clj/s

(validate ?schema value)

(validate ?schema value options)

Returns true if value is valid according to given schema. Creates the validator for every call. When performance matters, (re-)use validator instead.

validator clj/s

(validator ?schema)

(validator ?schema options)

Returns an pure validation function of type x -> boolean for a given Schema. Caches the result for Cached Schemas with key :validator.

walk clj/s

(walk ?schema f)

(walk ?schema f options)

Postwalks recursively over the Schema and it's children. The walker callback is a arity4 function with the following arguments: schema, path, (walked) children and options.

Walker clj/s protocol

-accept clj/s

(-accept this schema path options)

-inner clj/s

(-inner this schema path options)

-outer clj/s

(-outer this schema path children options)