schema.macros

Macros and macro helpers used in schema.core.

*compile-fn-validation*

dynamic

apply-prepost-conditions

(apply-prepost-conditions body)
Replicate pre/postcondition logic from clojure.core/fn.

assert!

macro

(assert! form & format-args)
Like assert, but throws a RuntimeException (in Clojure) and takes args to format.

cljs-env?

(cljs-env? env)
Take the &env from a macro, and tell whether we are expanding into cljs.

compile-fn-validation?

(compile-fn-validation? env fn-name)
Returns true if validation should be included at compile time, otherwise false.
Validation is elided for any of the following cases:
*   function has :never-validate metadata
*   *compile-fn-validation* is false
*   *assert* is false AND function is not :always-validate

emit-defrecord

(emit-defrecord defrecord-constructor-sym env name field-schema & more-args)

error!

macro

(error! s)(error! s m)
Generate a cross-platform exception appropriate to the macroexpansion context

extract-arrow-schematized-element

(extract-arrow-schematized-element env s)
Take a nonempty seq, which may start like [a ...] or [a :- schema ...], and return
a list of [first-element-with-schema-attached rest-elements]

extract-schema-form

(extract-schema-form symbol)
Pull out the schema stored on a thing.  Public only because of its use in a public macro.

if-cljs

macro

(if-cljs then else)
Return then if we are generating cljs code and else for Clojure code.
https://groups.google.com/d/msg/clojurescript/iBY5HaQda4A/w1lAQi9_AwsJ

input-schema-form

(input-schema-form regular-args rest-arg)

maybe-split-first

(maybe-split-first pred s)

normalized-defn-args

(normalized-defn-args env macro-args)
Helper for defining defn-like macros with schemas.  Env is &env
from the macro body.  Reads optional docstring, return type and
attribute-map and normalizes them into the metadata of the name,
returning the normalized arglist.  Based on
clojure.tools.macro/name-with-attributes.

normalized-metadata

(normalized-metadata env imeta explicit-schema)
Take an object with optional metadata, which may include a :tag,
plus an optional explicit schema, and normalize the
object to have a valid Clojure :tag plus a :schema field.

parse-arity-spec

(parse-arity-spec spec)
Helper for schema.core/=>*.

primitive-sym?

process-arrow-schematized-args

(process-arrow-schematized-args env args)
Take an arg vector, in which each argument is followed by an optional :- schema,
and transform into an ordinary arg vector where the schemas are metadata on the args.

process-fn-

(process-fn- env name fn-body)
Process the fn args into a final tag proposal, schema form, schema bindings, and fn form

process-fn-arity

(process-fn-arity env fn-name output-schema-sym bind-meta [bind & body])
Process a single (bind & body) form, producing an output tag, schema-form,
and arity-form which has asserts for validation purposes added that are
executed when turned on, and have very low overhead otherwise.
tag? is a prospective tag for the fn symbol based on the output schema.
schema-bindings are bindings to lift eval outwards, so we don't build the schema
every time we do the validation.

rest-arg-schema-form

(rest-arg-schema-form arg)

safe-get

macro

(safe-get m k)
Like get but throw an exception if not found.  A macro just to work around cljx function
placement restrictions. 

set-compile-fn-validation!

(set-compile-fn-validation! on?)
Globally turn on or off function validation from being compiled into s/fn and s/defn.
Enabled by default.
See (doc compile-fn-validation?) for all conditions which control fn validation compilation

simple-arglist-schema-form

(simple-arglist-schema-form rest? regular-args)

single-arg-schema-form

(single-arg-schema-form rest? [index arg])

split-rest-arg

(split-rest-arg env bind)

try-catchall

macro

(try-catchall & body)
A cross-platform variant of try-catch that catches all exceptions.
Does not (yet) support finally, and does not need or want an exception class.

valid-tag?

(valid-tag? env tag)

validation-error

macro

(validation-error schema value expectation & [fail-explanation])