anchor.diff:  (s/def :error/code integer?)
   ----
   
  -We then need a multimethod that defines a dispatch function for choosing the selector (here our `:event/type` field) and returning the appropriate spec based on the value:
  -
  -[source,clojure]
  -----
  -(defmulti event-type :event/type :default ::s/invalid)
  -(defmethod event-type ::s/invalid [_] nil)
  +We then need a multimethod that defines a dispatch function for choosing the selector (here our `:event/type` field) and returns the appropriate spec based on the value:
  +
  +[source,clojure]
  +----
  +(defmulti event-type :event/type)
   (defmethod event-type :event/search [_]
     (s/keys :req [:event/type :event/timestamp :search/url]))
   (defmethod event-type :event/error [_]
     (s/keys :req [:event/type :event/timestamp :error/message :error/code]))
   ----
   
  -It is **required** that this multimethod have a nil-returning default method for `::s/invalid`. Other handlers should ignore their argument and return the spec for the specified type. Here we've fully spec'ed two possible events - a "search" event and an "error" event.
  +The methods should ignore their argument and return the spec for the specified type. Here we've fully spec'ed two possible events - a "search" event and an "error" event.
   
   And then finally we are ready to declare our `multi-spec` and try it out.
   
  
positive.code: (s/conform ::odds-then-maybe-even [1])
  ;;=> {:odds [1]}
  (s/explain ::odds-then-maybe-even [100])
  ;; At: [:odds] val: 100 fails spec: ::odds-then-maybe-even predicate: odd?
  
  ;; opts are alternating keywords and booleans
  (defn boolean? [b] (instance? Boolean b))
  
negative.code:    ::players [{::name "Kenny Rogers"
                 ::score 100
                 ::hand [[2 :banana]]}]})
  In: [::players 0 ::hand 0 1] val: :banana fails spec: ::card at: [::players ::hand 1] predicate: suit?
  ----
  
  The error explains the path in the data structure down to the invalid value, the spec part it's trying to match, the path in the specs, and the predicate that failed.
  
  If we have a function `deal` that doles out some cards to the players we can spec that function to verify the arg and return value are both suitable data values. We can also specify a `:fn` spec to verify that the count of cards in the game before the deal equals the count of cards after the deal.
  
  