even-number-of-forms?

Usage: (even-number-of-forms? forms)

Returns true if there are an even number of forms in a binding vector

::as

(and simple-symbol? (not= '& %))

::as-alias

simple-symbol?

::binding

(cat :form ::binding-form :init-expr any?)

::binding-form

(or
 :local-symbol ::local-name
 :seq-destructure ::seq-binding-form
 :map-destructure ::map-binding-form)

::bindings

(and vector? even-number-of-forms? (* ::binding))

::class-ident

(or :class simple-symbol? :class-name string?)

::constructors

(map-of ::signature ::signature)

::defn-args

(cat
 :fn-name simple-symbol?
 :docstring (? string?)
 :meta (? map?)
 :fn-tail (alt
           :arity-1 ::params+body
           :arity-n (cat
                     :bodies (+ (spec ::params+body))
                     :attr-map (? map?))))

::exclude

(coll-of simple-symbol?)

::expose

(keys :opt-un [::get ::set])

::exposes

(map-of simple-symbol? ::expose)

::extends

simple-symbol?

::factory

simple-symbol?

::filters

(&
  (* (cat :clojure.spec.alpha/k keyword? :clojure.spec.alpha/v any?))
  :clojure.spec.alpha/kvs->map
  mspec__2540__auto__)

::get

simple-symbol?

::impl-ns

simple-symbol?

::implements

(coll-of simple-symbol? :kind vector?)

::import-list

(* (alt :class simple-symbol? :package-list ::package-list))

::init

symbol?

::keys

(coll-of ident? :kind vector?)

::libspec

(alt
 :lib simple-symbol?
 :lib+opts (spec
             (cat
              :lib simple-symbol?
              :options (keys* :opt-un [::as ::refer ::as-alias]))))

::load-impl-ns

boolean?

::local-name

(and simple-symbol? (not= '& %))

::main

boolean?

::map-binding

(tuple ::binding-form any?)

::map-binding-form

(merge ::map-bindings ::map-special-binding)

::map-bindings

(every
  (or
   :map-binding ::map-binding
   :qualified-keys-or-syms ::ns-keys
   :special-binding (tuple #{:as :or :syms :keys :strs} any?))
  :kind
  map?)

::map-special-binding

(keys :opt-un [::as ::or ::keys ::syms ::strs])

::method

(and
  vector?
  (cat
   :method-name simple-symbol?
   :param-types ::signature
   :return-type ::class-ident))

::methods

(coll-of ::method :kind vector?)

::name

simple-symbol?

::ns-clauses

(*
  (alt
   :refer-clojure ::ns-refer-clojure
   :require ::ns-require
   :import ::ns-import
   :use ::ns-use
   :refer ::ns-refer
   :load ::ns-load
   :gen-class ::ns-gen-class))

::ns-form

(cat
 :ns-name simple-symbol?
 :docstring (? string?)
 :attr-map (? map?)
 :ns-clauses ::ns-clauses)

::ns-gen-class

(cat
 :clause #{:gen-class}
 :options (keys*
            :opt-un
            [::name
             ::extends
             ::implements
             ::init
             ::constructors
             ::post-init
             ::methods
             ::main
             ::factory
             ::state
             ::exposes
             ::prefix
             ::impl-ns
             ::load-impl-ns]))

::ns-import

(cat :clause #{:import} :classes ::import-list)

::ns-keys

(tuple
  (and qualified-keyword? #(-> % name #{"syms" "keys"}))
  (coll-of simple-symbol? :kind vector?))

::ns-load

(cat :clause #{:load} :libs (* string?))

::ns-refer

(cat :clause #{:refer} :lib simple-symbol? :refer-filters ::filters)

::ns-refer-clojure

(cat :clause #{:refer-clojure} :refer-filters ::filters)

::ns-require

(cat
 :clause #{:require}
 :body (+
         (alt
          :libspec ::libspec
          :prefix-list ::prefix-list
          :flag #{:verbose :reload :reload-all})))

::ns-use

(cat
 :clause #{:use}
 :libs (+
         (alt
          :libspec ::use-libspec
          :prefix-list ::use-prefix-list
          :flag #{:verbose :reload :reload-all})))

::only

(coll-of simple-symbol?)

::or

(map-of simple-symbol? any?)

::package-list

(cat :package simple-symbol? :classes (+ simple-symbol?))

::param-list

(and
  vector?
  (cat
   :params (* ::binding-form)
   :var-params (? (cat :ampersand #{'&} :var-form ::binding-form))))

::params+body

(cat
 :params ::param-list
 :body (alt
        :prepost+body (cat :prepost map? :body (+ any?))
        :body (* any?)))

::post-init

symbol?

::prefix

string?

::prefix-list

(cat :prefix simple-symbol? :libspecs (+ ::libspec))

::quotable-import-list

(*
  (alt
   :class (quotable simple-symbol?)
   :package-list (quotable ::package-list)))

::refer

(or :all #{:all} :syms (coll-of simple-symbol?))

::rename

(map-of simple-symbol? simple-symbol?)

::seq-binding-form

(and
  vector?
  (cat
   :forms (* ::binding-form)
   :rest-forms (? (cat :ampersand #{'&} :form ::binding-form))
   :as-form (? (cat :as #{:as} :as-sym ::local-name))))

::set

simple-symbol?

::signature

(coll-of ::class-ident :kind vector?)

::state

simple-symbol?

::strs

(coll-of simple-symbol? :kind vector?)

::syms

(coll-of symbol? :kind vector?)

::use-libspec

(alt
 :lib simple-symbol?
 :lib+opts (spec
             (cat
              :lib simple-symbol?
              :options (keys*
                         :opt-un
                         [::as ::refer ::exclude ::only ::rename]))))

::use-prefix-list

(cat :prefix simple-symbol? :libspecs (+ ::use-libspec))