malli.core — metosin/malli 0.5.1

-=>-schema clj/s

(-=>-schema)

-and-schema clj/s

(-and-schema)

-any-schema clj/s

(-any-schema)

-boolean-fn clj/s

(-boolean-fn x)

-boolean-schema clj/s

(-boolean-schema)

-check-children! clj/s

(-check-children! type properties children {:keys [min max] :as opts})

-collection-schema clj/s

(-collection-schema ?props)

-comp clj/s

(-comp)

(-comp f)

(-comp f g)

(-comp f g h)

(-comp f1 f2 f3 & fs)

-create-form clj/s

(-create-form type properties children)

-default-sci-options clj/s

(-default-sci-options)

-double-schema clj/s

(-double-schema)

-enum-schema clj/s

(-enum-schema)

-fn-schema clj/s

(-fn-schema)

-function-info clj/s

(-function-info schema)

-function-schema clj/s

(-function-schema _)

-get-entries clj/s

(-get-entries schema key default)

-guard clj/s

(-guard pred tf)

-inner-entries clj/s

(-inner-entries walker path entries options)

-inner-indexed clj/s

(-inner-indexed walker path children options)

-int-schema clj/s

(-int-schema)

-intercepting clj/s

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

(-intercepting {:keys [enter leave] :as interceptor} 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)

-map-of-schema clj/s

(-map-of-schema)

-map-schema clj/s

(-map-schema)

(-map-schema opts)

-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)

-nil-schema clj/s

(-nil-schema)

-not-schema clj/s

(-not-schema)

-or-schema clj/s

(-or-schema)

-orn-schema clj/s

(-orn-schema)

-parent-children-transformer clj/s

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

-parse-entries clj/s

(-parse-entries children {:keys [naked-keys lazy-refs]} options)

-pointer clj/s

(-pointer id schema options)

-properties-and-options clj/s

(-properties-and-options properties options f)

-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)

-re-schema clj/s

(-re-schema class?)

-ref-schema clj/s

(-ref-schema)

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

-reference? clj/s

(-reference? ?schema)

-register-function-schema! clj/s

(-register-function-schema! ns name value)

-registry clj/s

(-registry)

(-registry {:keys [registry]})

-safe-pred clj/s

(-safe-pred f)

-schema-schema clj/s

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

-sequence-entry-schema clj/s

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

-sequence-schema clj/s

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

-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)

-simple-schema clj/s

(-simple-schema ?props)

-string-schema clj/s

(-string-schema)

-symbol-schema clj/s

(-symbol-schema)

-tuple-schema clj/s

(-tuple-schema)

-update clj/s

(-update m k f)

-uuid-schema clj/s

(-uuid-schema)

-val-schema clj/s

(-val-schema)

(-val-schema schema properties)

=> clj/s macro

(=> name value)

base-schemas clj/s

(base-schemas)

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)

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-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.

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 MapSchema 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)

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

form clj/s

(form ?schema)

(form ?schema options)

Returns the Schema form

function-schema clj/s

(function-schema ?schema)

(function-schema ?schema options)

function-schemas clj/s

(function-schemas)

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

MapSchema clj/s protocol

-entries clj/s

(-entries this)

returns sequence of key -val-schema MapEntries

options clj/s

(options ?schema)

(options ?schema options)

Returns options used in creating 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

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)

returns size of the sequence as [min max] vector. nil max means unbuond.

-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

Schemas clj/s protocol

-into-schema? clj/s

(-into-schema? this)

-schema? clj/s

(-schema? this)

sequence-schemas clj/s

(sequence-schemas)

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 an 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

validate clj/s

(validate ?schema value)

(validate ?schema value options)

Validates a value againsta a 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

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)