malli.transform — metosin/malli 0.18.0-alpha1

*max-compile-depth* clj/s

+date->string-format+ clj

+string->date-format+ clj

-any->any clj/s

(-any->any x)

-any->string clj/s

(-any->string x)

-date->string clj/s

(-date->string x)

-infer-child-compiler clj/s

(-infer-child-compiler method)

-interceptor clj/s

(-interceptor ?interceptor schema options)

Utility function to convert input into an interceptor. Works with functions, map and sequence of those.

-json-decoders clj/s

(-json-decoders)

-json-encoders clj/s

(-json-encoders)

-number->double clj/s

(-number->double x)

-number->float clj/s

(-number->float x)

-number->long clj/s

(-number->long x)

-safe clj/s

(-safe f)

-sequential->set clj/s

(-sequential->set x)

-sequential->vector clj/s

(-sequential->vector x)

-sequential-or-set->seq clj/s

(-sequential-or-set->seq x)

-sequential-or-set->vector clj/s

(-sequential-or-set->vector x)

-string->boolean clj/s

(-string->boolean x)

-string->date clj/s

(-string->date x)

-string->decimal clj

(-string->decimal x)

-string->double clj/s

(-string->double x)

-string->float clj/s

(-string->float x)

-string->keyword clj/s

(-string->keyword x)

-string->long clj/s

(-string->long x)

-string->nil clj/s

(-string->nil x)

-string->symbol clj/s

(-string->symbol x)

-string->uri clj

(-string->uri x)

-string->uuid clj/s

(-string->uuid x)

-string-decoders clj/s

(-string-decoders)

-string-encoders clj/s

(-string-encoders)

-transform-if-valid clj/s

(-transform-if-valid f schema)

-transform-map-keys clj/s

(-transform-map-keys f)

(-transform-map-keys ks f)

collection-transformer clj/s

(collection-transformer)

default-value-transformer clj/s

(default-value-transformer)

(default-value-transformer {:keys [key default-fn defaults
                                   :malli.transform/add-optional-keys]
                            :or {key :default default-fn (fn [_ x] x)}})

json-transformer clj/s

(json-transformer)

(json-transformer {:malli.transform/keys [json-vectors keywordize-map-keys
                                          map-of-key-decoders]
                   :or {map-of-key-decoders (-string-decoders)}})

key-transformer clj/s

(key-transformer {:keys [decode encode types] :or {types #{:map}}})

parse-float clj/s

(parse-float s)

string-transformer clj/s

(string-transformer)

strip-extra-keys-transformer clj/s≠

clj

(strip-extra-keys-transformer)

(strip-extra-keys-transformer
  {:keys [accept]
   :or {accept (m/-comp (fn* [p1__13460#]
                             (or (nil? p1__13460#) (true? p1__13460#)))
                        :closed
                        m/properties)}})

cljs

(strip-extra-keys-transformer)

(strip-extra-keys-transformer
  {:keys [accept]
   :or {accept (m/-comp (fn* [p1__18554#]
                             (or (nil? p1__18554#) (true? p1__18554#)))
                        :closed
                        m/properties)}})

transformer clj/s

(transformer & ?transformers)