anchor.diff:  [source,clojure]
   ----
   (declare 100)
  -CompilerException java.lang.IllegalArgumentException: Call to clojure.core/declare did not conform to spec:
  -At: [:args] val: (100) fails predicate: (cat :names (* symbol?)),  Extra input
  -:clojure.spec/args  ((declare 100) nil 100)
  -, compiling:(user:320:3)
  -----
  -
  -This is an area that may change further before final release.
  +;; CompilerException java.lang.IllegalArgumentException: Call to clojure.core/declare did not conform to spec:
  +;; In: [0] val: (100) fails at: [:args] predicate: (cat :names (* symbol?)),  Extra input
  +;; :clojure.spec/args  (100)
  +;; , compiling:(user:320:3)
  +----
   
   == Conformers
   
  
positive.code: 
  As macros are functions that take code and produce code, they can also be spec'ed like functions. One special consideration however is that you must keep in mind that you are receiving code as data, not evaluated arguments, and that you are most commonly producing new code as data, so often it's not helpful to spec the :ret value of a function (as it's just code).
  
  Also, macros take two implicit arguments: `&form` and `&env` that must be included in the `:args` spec. For example, we could spec the `clojure.core/declare` macro like this:
  
  [source,clojure]
  ----
  (s/fdef clojure.core/declare
      :args (s/cat
              :form ::s/any
              :env ::s/any
              :names (s/* symbol?))
      :ret ::s/any)
  ----
  
  
negative.code: ;;=> {:quantity 2, :unit :teaspoon}
  ----
  
  The data is conformed as a map with the tags as keys. We can use `explain` to examine non-conforming data.
  
  [source,clojure]
  ----
  ;; pass string for unit instead of keyword
  (s/explain ::ingredient [11 "peaches"])
  ;; In: [1] val: \"peaches\" fails at: [:unit] predicate: keyword?
  
  ;; leave out the unit
  (s/explain ::ingredient [2])
  ;; val: () fails at: [:unit] predicate: keyword?,  Insufficient input
  ----
  
  Let's now see the various occurence operators `*`, `+`, and `?`:
  