anchor.diff:                             :city "Macroville"
                              :state "Kentucky"
                              :zip "81321"}
  +                 :hobbies ["running" "hiking" "basketball"]
                    :company "Functional Industries"
                    :title "Sith Lord of Git"})
   ----
  
positive.code:   (pintln a b c d))
  ;= A B C D
  ----
  
  === Where to destructure
  
  
negative.code: 
  Associative destructuring is the same idea as sequential destructuring but instead of binding symbols element-by-element, you bind them using keys.
  
  Associative destructuring is usually used on structures made up of key-value pairs such as hash-maps or records. You can also use this on indexed structures such as strings and vectors as well.
  
  [source,clojure]
  ----
  (def client {:name "Super Co."
               :location "Philadelphia"
               :description "The world wide leader in plastic table-ware."})
  
  (let [{name :name
         location :location
         description :description} client]
    (println name location "-" description))
  ;= Super Co. Philadelphia - The world wide leader in plastic table-ware.
  ----
  
  >>>>>>>>>>>>>>>>>>>>>>>>
  The first thing that should stand out to you here is that the destructuring form is no longer a vector, rather it is a map, hence the name associative destructuring.
  The second thing that should stand out is that there are symbols _and_ keywords within the destructuring form. Associative destructuring binds the elements of a map to symbols using the map's keys.
  When performing associative destructuring, you are binding a value from the original structure to a name in the let statement. Within the destructuring form, the keys (the names we are binding to) are _not_ values and should always be symbols therefor.
  <<<<<<<<<<<<<<<<<<<<<<<<
  
  Both types of destructuring act very similarly. If you try to bind a symbol to a key that doesn't exist, you get nil.
  
  [source,clojure]
  ----
  (let [{category :category} client]
    (println name category))
  ;= nil
  ----
  
  Associative destructuring, however, allows you to replace all of the nil values with a default value.
  
  [source,clojure]
  ----
  (let [{category :category, :or {category "Category not found"}} client]
    (println name category))
  ;= Category not found
  ----
  
  In the `:or` map, the `category` key is __not__ a value, rather, it is a name. A symbol should always be used here because of that.
  
  
  In sequential destructuring, you generally bind values that you don't plan on using to an `_`. Since associative destructuring doesn't require traversing the entire structure one element at a time, you can simply omit any values you don't plan on using from the destructuring form.
  
  [source,clojure]
  ----
  (let [{name :name
         description :description} my-map]
    (println name description))
  ;= Super Co. The world wide leader in plastic table-ware production.
  ----
  
  If you need access to the entire map, you can use the `:as` shortcut like in sequential destructuring.
  
  [source,clojure]
  ----
  (let [{name :name :as all} client]
    (println "The name from" all "is" name))
  ;= The name from {:name Super Co., :location Philadelphia, :description The world wide leader in plastic table-ware.} is Super Co.
  ----
  
  The `:as` and `:or` keywords can be combined in a single destructuring.
  