anchor.diff:      (println "x:" x ", y:" y ", z:" z)))
   ----
   
  -When defining a function in clojure, there is an implicit `let` binding used on the parameters in order to create the local scope of the function. We can leverage this to whittle our function definition down even more.
  +When defining a function in clojure, destructuring can be applied on the incoming parameters, just like in a let:
   
   [source,clojure]
   ----
  
positive.code: 
  (print-contact-info john-smith)
  ;= John Smith is the Sith Lord of Git at Functional Industries
  ;= You can reach him at 2150041776
  ----
  
  This function will associatively destructure the the input using the `:keys` shortcut and then print out the contact information that we provided.
  
negative.code: 
  == Associative Destructuring
  
  Associative destructuring is similar to sequential destructuring, but applied instead to associative (key-value) structures. The associative bindings are concerned with concisely extracting values of the map by key.
  
  Let's first consider an example that extracts values from a map without destructuring:
  
  [source,clojure]
  ----
  (def client {:name "Super Co."
               :location "Philadelphia"
               :description "The worldwide leader in plastic tableware."})
  
  (let [name (:name client)
        location (:location client)
        description (:description client)]
    (println name location "-" description))
  ;= Super Co. Philadelphia - The worldwide leader in plastic tableware.
  ----
  
  Note that each line of the let binding is essentially the same - it extracts a value from the map by the name of the key, then binds it to a local with the same name.
  
  Below is a first example of doing the same thing with associative destructuring:
  
  [source,clojure]
  ----
  (let [{name :name
         location :location
         description :description} client]
    (println name location "-" description))
  ;= Super Co. Philadelphia - The worldwide leader in plastic tableware.
  ----
  
  The destructuring form is now a map rather than a vector, and instead of a symbol on the left side of the let, we have a map. The keys of the map are the symbols we want to bind in the let and the right side are the keys we will look up in the associative value.
  
  Similar to sequential destructuring, if you try to bind a key that is not present in the map, the binding value will be nil. 
  
  [source,clojure]
  ----
  (let [{category :category} client]
    (println category))
  ;= nil
  ----
  
  Associative destructuring, however, also allows you to supply a default value if the key is not present in the associative value with the `:or` key. 
  
  [source,clojure]
  ----
  (let [{category :category, :or {category "Category not found"}} client]
    (println category))
  ;= Category not found
  ----
  
  The value for `:or` is a map where the bound symbol (here `category`) is bound to the expression `"Category not found"`. When category is not found in `client`, it is instead found in the `:or` map and bound to that value instead.
  
  In sequential destructuring, you generally bind unneeded values with an `_`. Since associative destructuring doesn't require traversing the entire structure, you can simply omit any keys you don't plan on using from the destructuring form.
  
  If you need access to the entire map, you can use the `:as` key to bind the entire incoming value, just as in sequential destructuring.
  
  [source,clojure]
  ----
  