anchor.diff:  ;;=> {:names-kw :names, :names ["a" "b"], :nums-kw :nums, :nums [1 2 3]}
   ----
   
  -If the `spec`s were removed this spec would instead match a sequence like `[:names "a" "b" :nums 1 2 3]`.
  +If the specs were removed this spec would instead match a sequence like `[:names "a" "b" :nums 1 2 3]`.
   
   [source,clojure]
   ----
  
positive.code: ;;=> (* (cat :opt keyword? :val boolean?))
  ----
  
  Spec also defines one additional regex operator, http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/&[`&`], which takes a regex operator and constrains it with one or more additional predicates. This can be used to create regular expressions with additional custom constraints that would otherwise require custom predicates. For example, consider wanting to match only sequences with an even number of strings:
  
  [source,clojure]
  ----
  
negative.code: 
  Instrumentation of spec'ed functions can also be turned on more widely using `instrument-ns` or `instrument-all` functions. Instrumentation can be turned off using the complementary functions `unstrument`, `unstrument-ns`, and `unstrument-all`. It's up to you when to use instrumentation and how much. You may want a lot of instrumentation when working at the REPL and little at runtime. It's even possible to create more than one version of a function spec - an intensive one that runs during development and a lighter check that happens at runtime.
  
  == Higher order functions
  
  Higher order functions are common in Clojure and spec provides http://clojure.github.io/clojure/branch-master/clojure.spec-api.html#clojure.spec/fspec[`fspec`] to support spec'ing them.
  
  For example, consider the `adder` function:
  
  [source,clojure]
  ----
  (defn adder [x] #(+ x %))
  ----
  
  `adder` returns a function that adds x. We can declare a function spec for `adder` using `fspec` for the return value:
  
  [source,clojure]
  ----
  (s/fdef adder
    :args (s/cat :x number?)
    :ret (s/fspec :args (s/cat :y number?)
                  :ret number?)
    :fn #(= (-> % :args :x)
            ((:ret %) 0)))
  ----
  
  The `:ret` spec uses `fspec` to declare that the returning function takes and returns a number. Even more interesting, the `:fn` spec can state a general property that relates the `:args` (where we know x) and the result we get from invoking the function returned from `adder`, namely that adding 0 to it should return x.
  
  == Macros
  
  