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: 
  == Entity Maps
  
  Clojure programs rely heavily on passing around maps of data and this is one of the areas where spec takes a novel approach
  compared to other libs. Rather than defining attribute (key+value) specifications at the map level, specs assign meaning to individual attributes,
  then collect them into maps using set semantics (on the keys). This approach allows us to start assigning (and sharing)
  semantics at the attribute level across our libraries and applications.
  
  
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
  
  