If the s/defprotocol instrumentation strategy is problematic
for your platform, set atom to true and instrumentation will not
be performed.

Atom defaults to false.

Convenience macro for defining function schemas with a single arity; like =>*, but
there is no vector around the argument schemas for this arity.

Produce a function schema from an output schema and a list of arity input schema specs,
each of which is a vector of argument schemas, ending with an optional '& more-schema'
specification where more-schema must be a sequence schema.

Currently function schemas are purely descriptive; there is no validation except for
functions defined directly by s/fn or s/defn

Any value, including nil.

An atom containing a value matching 'schema'.

Boolean true or false

A value that must satisfy every schema in schemas.

DEPRECATED: prefer 'conditional' with a single condition
instead, or `constrained`.

When used with coercion, coerces each schema in sequence.

Return nil if x matches schema; otherwise, returns a value that looks like the
'bad' parts of x with ValidationErrors at the leaves describing the failures.

If you will be checking many datums, it is much more efficient to create
a 'checker' once and call it on each of them.

Compile an efficient checker for schema, which returns nil for valid values and
error descriptions otherwise.

A replacement for `either` that constructs a conditional schema
based on the schema spec preconditions of the component schemas.

Given a datum, the preconditions for each schema (which typically
check just the outermost class) are tested against the datum in turn.
The first schema whose precondition matches is greedily selected,
and the datum is validated against that schema.  Unlike `either`,
a validation failure is final (and there is no backtracking to try
other schemas that might match).

Thus, `cond-pre` is only suitable for schemas with mutually exclusive
preconditions (e.g., s/Int and s/Str).  If this doesn't hold
(e.g. {:a s/Int} and {:b s/Str}), you must use `conditional` instead
and provide an explicit condition for distinguishing the cases.

EXPERIMENTAL

Define a conditional schema.  Takes args like cond,
(conditional pred1 schema1 pred2 schema2 ...),
and checks the first schemaX where predX (an ordinary Clojure function
that returns true or false) returns true on the value.
Unlike cond, throws if the value does not match any condition.
:else may be used as a final condition in the place of (constantly true).
More efficient than either, since only one schema must be checked.
An optional final argument can be passed, a symbol to appear in
error messages when none of the conditions match.

A schema with an additional post-condition.  Differs from `conditional`
with a single schema, in that the predicate checked *after* the main
schema.  This can lead to better error messages, and is often better
suited for coercion.

Like def, but takes a schema on the var name (with the same format
as the output schema of s/defn), requires an initial value, and
asserts that the initial value matches the schema on the var name
(regardless of the status of with-fn-validation).  Due to
limitations of add-watch!, cannot enforce validation of subsequent
rebindings of var.  Throws at compile-time for clj, and client-side
load-time for cljs.

Example:

(s/def foo :- long "a long" 2)

Like clojure.core/defmethod, except that schema-style typehints can be given on
the argument symbols and after the dispatch-val (for the return value).

See (doc s/defn) for details.

Examples:

  (s/defmethod mymultifun :a-dispatch-value :- s/Num [x :- s/Int y :- s/Num] (* x y))

  ;; You can also use meta tags like ^:always-validate by placing them
  ;; before the multifunction name:

  (s/defmethod ^:always-validate mymultifun :a-dispatch-value [x y] (* x y))

Like clojure.core/defn, except that schema-style typehints can be given on
the argument symbols and on the function name (for the return value).

You can call s/fn-schema on the defined function to get its schema back, or
use with-fn-validation to enable runtime checking of function inputs and
outputs.

(s/defn foo :- s/Num
 [x :- s/Int
  y :- s/Num]
 (* x y))

(s/fn-schema foo)
==> (=> java.lang.Number Int java.lang.Number)

(s/with-fn-validation (foo 1 2))
==> 2

(s/with-fn-validation (foo 1.5 2))
==> Input to foo does not match schema: [(named (not (integer? 1.5)) x) nil]

See (doc schema.core) for details of the :- syntax for arguments and return
schemas.

The overhead for checking if run-time validation should be used is very
small -- about 5% of a very small fn call.  On top of that, actual
validation costs what it costs.

You can also turn on validation unconditionally for this fn only by
putting ^:always-validate metadata on the fn name.

Gotchas and limitations:
 - The output schema always goes on the fn name, not the arg vector. This
   means that all arities must share the same output schema. Schema will
   automatically propagate primitive hints to the arg vector and class hints
   to the fn name, so that you get the behavior you expect from Clojure.
 - All primitive schemas will be passed through as type hints to Clojure,
   despite their legality in a particular position.  E.g.,
     (s/defn foo [x :- int])
   will fail because Clojure does not allow primitive ints as fn arguments;
   in such cases, use the boxed Classes instead (e.g., Integer).
 - Schema metadata is only processed on top-level arguments.  I.e., you can
   use destructuring, but you must put schema metadata on the top-level
   arguments, not the destructured variables.

   Bad:  (s/defn foo [{:keys [x :- s/Int]}])
   Good: (s/defn foo [{:keys [x]} :- {:x s/Int}])
 - Only a specific subset of rest-arg destructuring is supported:
   - & rest works as expected
   - & [a b] works, with schemas for individual elements parsed out of the binding,
     or an overall schema on the vector
   - & {} is not supported.
 - Unlike clojure.core/defn, a final attr-map on multi-arity functions
   is not supported.

Like clojure.core/defprotocol, except schema-style typehints can be provided for
the argument symbols and after method names (for output schemas).

^:always-validate and ^:never-validate metadata can be specified for all
methods on the protocol name. If specified on the method name, ignores
the protocol name metadata and uses the method name metadata.

Examples:

  (s/defprotocol MyProtocol
    "Docstring"
    :extend-via-metadata true
    (^:always-validate method1 :- s/Int
      [this a :- s/Bool]
      [this a :- s/Any, b :- s/Str]
      "Method doc2")
    (^:never-validate method2 :- s/Int
      [this]
      "Method doc2"))

There is a performance penalty compared to `clojure.core/defprotocol`, even
if instrumentation is disabled. It may be useful to set *elide-defprotocol-instrumentation*
to `true` in production if you do not plan to check methods.

Gotchas and limitations:
- Implementation details are used to instrument protocol methods for schema
  checking. This is tested against a variety of platforms and versions,
  however if this is problematic for your environment, use
  *elide-defprotocol-instrumentation* to disable such instrumentation
  (either at compile-time or runtime depending on your needs).
  In ClojureScript, method var metadata will be overwritten unless disabled
  at compile-time. 
- :schema metadata on protocol method vars is only supported in Clojure.
- The Clojure compiler normally rewrites protocol method invocations to direct
  method calls if the target is type hinted as a class that directly extends the protocol's interface.
  This is disabled in s/defprotocol, as :inline metadata is added to protocol
  methods designed to defeat potential short-circuiting of schema checks. This also means
  compile-time errors for arity errors are suppressed (eg., `No single method` errors).
  Setting *elide-defprotocol-instrumentation* to true will restore the default behavior.
- Methods cannot be instrumented in babashka due to technical limitations.

Define a record with a schema.

In addition to the ordinary behavior of defrecord, this macro produces a schema
for the Record, which will automatically be used when validating instances of
the Record class:

(m/defrecord FooBar
 [foo :- Int
  bar :- String])

(schema.utils/class-schema FooBar)
==> (record user.FooBar {:foo Int, :bar java.lang.String})

(s/check FooBar (FooBar. 1.2 :not-a-string))
==> {:foo (not (integer? 1.2)), :bar (not (instance? java.lang.String :not-a-string))}

See (doc schema.core) for details of the :- syntax for record elements.

Moreover, optional arguments extra-key-schema? and extra-validator-fn? can be
passed to augment the record schema.
 - extra-key-schema is a map schema that defines validation for additional
   key-value pairs not in the record base (the default is to not allow extra
    mappings).
 - extra-validator-fn? is an additional predicate that will be used as part
   of validating the record value.

The remaining opts+specs (i.e., protocol and interface implementations) are
passed through directly to defrecord.

Finally, this macro replaces Clojure's map->name constructor with one that is
more than an order of magnitude faster (as of Clojure 1.5), and provides a
new strict-map->name constructor that throws or drops extra keys not in the
record base.

DEPRECATED -- canonical version moved to schema.potemkin
Like defrecord, but emits a record using potemkin/defrecord+.  You must provide
your own dependency on potemkin to use this.

Convenience macro to make it clear to reader that body is meant to be used as a schema.
The name of the schema is recorded in the metadata.

A value that must satisfy at least one schema in schemas.
Note that `either` does not work properly with coercion

DEPRECATED: prefer `conditional` or `cond-pre`

WARNING: either does not work with coercion.  It is also slow and gives
bad error messages.  Please consider using `conditional` and friends
instead; they are more efficient, provide better error messages,
and work with coercion.

A value that must be = to some element of vs.

A value that must be (= v).

s/fn : s/defn :: clojure.core/fn : clojure.core/defn

See (doc s/defn) for details.

Additional gotchas and limitations:
 - Like s/defn, the output schema must go on the fn name. If you
   don't supply a name, schema will gensym one for you and attach
   the schema.
 - Unlike s/defn, the function schema is stored in metadata on the
   fn. The implications of this differ per platform:
   :clj   The resulting function has the same performance characteristics
          as clojure.core/fn. Additionally, the following invariant
          holds for all parameters and schema annotations:
            (let [f (s/fn this ... [...] this)]
              (assert (identical? f (f ...))))
   :cljs  Returns a wrapper function that forwards arguments positionally
          up to 20 arguments, and then via `apply` beyond 20 arguments.
          See `cljs.core/with-meta` and `cljs.core.MetaFn`.

Produce the schema for a function defined with s/fn or s/defn.

Get the current global schema validation setting.

A var that can be rebound to a function to customize the behavior
of fn validation. When fn validation is on and `fn-validator` is
bound to a function, normal argument and return value checks will
be substituted with a call to this function with five arguments:

  direction   - :input or :output
  fn-name     - a symbol, the function's name
  schema      - the schema for the arglist or the return value
  checker     - a precompiled checker to check a value against
                the schema
  value       - the actual arglist or return value

The function's return value will be ignored.

if the predicate returns truthy, use the if-schema, otherwise use the else-schema

The local representation of #inst ...

If true, elide s/defprotocol instrumentation.

Instrumentation is elided for any of the following cases:
*   `@*elide-defprotocol-instrumentation*` is true during s/defprotocol macroexpansion
*   `@*elide-defprotocol-instrumentation*` is true during s/defprotocol evaluation

Any integral number

A value that must be a child of parent.

A keyword

s/letfn : s/fn :: clojure.core/letfn : clojure.core/fn

Gotchas:
- s/fn-schema will only work on direct references to the bindings
  inside the body. It will not work on intermediate calls between bindings.

A function outputting a value in output schema, whose argument vector must match one of
input-schemas, each of which should be a sequence schema.
Currently function schemas are purely descriptive; they validate against any function,
regardless of actual input and output types.

A value that must either be nil or satisfy schema

A value that must satisfy schema, and has a name for documentation purposes.

Any number

A single required element of a sequence (not repeated, the implicit default)

A single optional element of a sequence (not repeated, the implicit default)

An optional key in a map

A schema for a pair of schemas and their names

Parses and validates a sequence schema, returning a vector in the form
[singles multi] where singles is a sequence of 'one' and 'optional' schemas
and multi is the rest-schema (which may be nil). A valid sequence schema is
a vector in the form [one* optional* rest-schema?].

A value for which p? returns true (and does not throw).
Optional pred-name can be passed for nicer validation errors.

A value that must satisfy? protocol p.

Internally, we must make sure not to capture the value of the protocol at
schema creation time, since that's impossible in cljs and breaks later
extends in Clojure.

A macro for cljs sake, since `satisfies?` is a macro in cljs.

Defines a schema satisfied by instances of clojure.lang.PersistentQueue
(clj.core/PersistentQueue in ClojureScript) whose values satisfy x.

A Record instance of type klass, whose elements match map schema 'schema'.

The final argument is the map constructor of the record type; if you do
not pass one, an attempt is made to find the corresponding function
(but this may fail in exotic circumstances).

Support for (mutually) recursive schemas by passing a var that points to a schema,
e.g (recursive #'ExampleRecursiveSchema).

A regular expression

A required key in a map

Returns the name of a schema attached via schema-with-name (or defschema).

Returns the namespace of a schema attached via defschema.

Records name in schema's metadata.

Attach the schema to fn f at runtime, extractable by fn-schema.

Globally turn on (or off) schema validation for all s/fn and s/defn instances.

Sets the maximum length of value to be output before it is contracted to a prettier name.

Satisfied only by String.
Is (pred string?) and not js/String in cljs because of keywords.

A symbol

The local representation of #uuid ...

Throw an exception if value does not satisfy schema; otherwise, return value.
If you will be validating many datums, it is much more efficient to create
a 'validator' once and call it on each of them.

Compile an efficient validator for schema.

Execute body with input and output schema validation turned on for
all s/defn and s/fn instances globally (across all threads). After
all forms have been executed, resets function validation to its
previously set value. Not concurrency-safe.

Execute body with input and output schema validation turned off for
all s/defn and s/fn instances globally (across all threads). After
all forms have been executed, resets function validation to its
previously set value. Not concurrency-safe.