anchor.diff:  -> [1 2]
   ----
   
  -
  +[[keyword-arguments]]
  +==== Keyword Arguments
  +
  +Keyword arguments are optional trailing variadic arguments of the form `(fun key value key value)` that can be accessed in the function body via associative destructuring. To define a function that accepts keyword arguments you supply a map destructuring form in the __rest-param__ declaration position. For example, a function that takes a sequence and optional keyword arguments and returns a vector containing the values is defined as:
  +
  +[source,clojure]
  +----
  +(defn destr [a & {:keys [b c] :as opts}]
  +  [a b c opts])
  +
  +(destr 1 :c 3)
  +->[1 nil 3 {:c 3}]
  +----
  +
  +The map __binding-form__ to the right of the `&` in `destr` is an associative destructuring __binding-form__ <<special_forms#associative-destructuring,detailed above>>.
  +
  +In `destr` you may have noticed that the __binding-form__ `{:keys [b c] :as opts}` received the __rest-param__ sequence resulting in the map `opts`. While sequences are not associative structures, they are treated as such on the right-hand side of a map binding form where the components of the sequence are alternating key->value pairs. This is highlighted in the following definition of `destr2`:
  +
  +[source,clojure]
  +----
  +(defn destr2 [a & opts]
  +  (let [{:keys [b c]} opts]
  +    [a b c opts]))
  +
  +(destr2 0 :b 1 :c 2)
  +->[0 1 2 (:b 1 :c 2)]
  +----
  +
  +[[nested-destructuring]]
   === Nested destructuring
   
   Since binding forms can be nested within one another arbitrarily, you can pull apart just about anything:
  
positive.code: ->[1 2 3 (4 5 6 7) [1 2 3 4 5 6 7]]
  ----
  
  These forms can be nested:
  
  [source,clojure]
  ----
  
negative.code: ->[1 2 3 4]
  ----
  
  In all of the sequential cases the __binding-form__s in the destructure binding will match the places in the target data structure where the desired values reside.
  
  [[associative-destructuring]]
  === Associative destructuring
  
  Map __binding-form__s create bindings by looking up values in collections like maps, sets, vectors, strings, and arrays (the latter three have integer keys). It consists of a map of __binding-form->key__ pairs, each __binding-form__ bound to the value in the _init-expr_ at the key provided. In addition, and optionally, an `:as` key in the binding form followed by a symbol binds that symbol to the entire __init-expr__. Also optionally, an `:or` key in the binding form followed by another map may be used to supply default values for some or all of the keys if they are not found in the __init-expr__:
  
  [source,clojure]
  ----
  