malli.util — metosin/malli 0.9.0

-applying clj/s

(-applying f)

-map-syntax-walker clj/s

(-map-syntax-walker schema _ children _)

-merge clj/s

(-merge)

-reducing clj/s

(-reducing f)

-required-map-entry? clj/s

(-required-map-entry? [_ ?p])

-select-keys clj/s

(-select-keys)

-simplify-map-entry clj/s

(-simplify-map-entry [k ?p s])

-union clj/s

(-union)

-util-schema clj/s

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

assoc clj/s

(assoc ?schema key value)

(assoc ?schema key value options)

Like [[clojure.core/assoc]], but for LensSchemas.

assoc-in clj/s

(assoc-in ?schema ks value)

(assoc-in ?schema [k & ks] value options)

Like [[clojure.core/assoc-in]], but for LensSchemas.

closed-schema clj/s

(closed-schema ?schema)

(closed-schema ?schema options)

Maps are implicitly open by default. They can be explicitly closed or open by specifying the {:closed (true|false)} property.

This function converts implicitly open maps to explicitly closed maps, recursively. Explicitly open maps are left untouched.

See open-schema

data-explainer clj/s

(data-explainer ?schema)

(data-explainer ?schema options)

Like m/explainer but output is pure clojure data. Schema objects have been replaced with their m/form. Useful when you need to serialise errrors.

dissoc clj/s

(dissoc ?schema key)

(dissoc ?schema key options)

Like [[clojure.core/dissoc]], but for EntrySchemas.

distinct-by clj/s

(distinct-by f coll)

Returns a sequence of distinct (f x) values)

explain-data clj/s

(explain-data ?schema value)

(explain-data ?schema value options)

Explains a value against a given schema. Like m/explain but output is pure clojure data. Schema objects have been replaced with their m/form. Useful when you need to serialise errrors.

Creates the mu/data-explainer for every call. When performance matters, (re-)use mu/data-explainer instead.

find clj/s

(find ?schema k)

(find ?schema k options)

Like [[clojure.core/find]], but for EntrySchemas.

find-first clj/s

(find-first ?schema f)

(find-first ?schema f options)

Prewalks the Schema recursively with a 3-arity fn [schema path options], returns with and as soon as the function returns non-null value.

from-map-syntax clj/s

(from-map-syntax m)

(from-map-syntax {:keys [type properties children] :as m} options)

get clj/s

(get ?schema k)

(get ?schema k default)

(get ?schema k default options)

Like [[clojure.core/get]], but for LensSchemas.

get-in clj/s

(get-in ?schema ks)

(get-in ?schema ks default)

(get-in ?schema [k & ks] default options)

Like [[clojure.core/get-in]], but for LensSchemas.

in->paths clj/s

(in->paths schema in)

Returns a vector of schema paths for a given Schema and value path

keys clj/s

(keys ?schema)

Like [[clojure.core/keys]], but for EntrySchemas.

merge clj/s

(merge ?schema1 ?schema2)

(merge ?schema1 ?schema2 options)

Merges two schemas into one with the following rules:

• if either schemas is nil, the other one is used, regardless of value
• with two :map schemas, both keys and values are merged
• for :and schemas, the first child is used in merge, rest kept as-is
• with two :map entries, :merge-entries fn is used (default last one wins)
• with any other schemas, :merge-default fn is used (default last one wins)

key	description
:merge-default	schema1 schema2 options -> schema fn to merge unknown entries
:merge-required	boolean boolean -> boolean fn to resolve how required keys are merged

open-schema clj/s

(open-schema ?schema)

(open-schema ?schema options)

Maps are implicitly open by default. They can be explicitly closed or open by specifying the {:closed (true|false)} property.

This function converts explicitly closed maps to implicitly open maps, recursively. Explicitly open maps are left untouched.

See closed-schema

optional-keys clj/s

(optional-keys ?schema)

(optional-keys ?schema ?keys)

(optional-keys ?schema keys options)

Makes map keys optional.

path->in clj/s

(path->in schema path)

Returns a value path for a given Schema and schema path

rename-keys clj/s

(rename-keys ?schema kmap)

(rename-keys ?schema kmap options)

Like [[clojure.set/rename-keys]], but for EntrySchemas. Collisions are resolved in favor of the renamed key, like assoc-ing.

required-keys clj/s

(required-keys ?schema)

(required-keys ?schema ?keys)

(required-keys ?schema keys options)

Makes map keys required.

schemas clj/s

(schemas)

select-keys clj/s

(select-keys ?schema keys)

(select-keys ?schema keys options)

Like [[clojure.core/select-keys]], but for EntrySchemas.

subschemas clj/s

(subschemas ?schema)

(subschemas ?schema options)

Returns all subschemas for unique paths as a vector of maps with :schema, :path and :in keys. Walks over :schema references and top-level :refs. See [[malli.core/-walk]] for all options.

to-map-syntax clj/s

(to-map-syntax ?schema)

(to-map-syntax ?schema options)

transform-entries clj/s

(transform-entries ?schema f)

(transform-entries ?schema f options)

Transforms entries with f.

union clj/s

(union ?schema1 ?schema2)

(union ?schema1 ?schema2 options)

Union of two schemas. See merge for more details.

update clj/s

(update schema key f & args)

Like [[clojure.core/update]], but for LensSchema instances.

update-in clj/s

(update-in schema ks f & args)

Like [[clojure.core/update-in]], but for LensSchemas.

update-properties clj/s

(update-properties ?schema f & args)

Returns a Schema instance with updated properties.