anchor.diff:  [source,clojure]
   ----
   (defn print-contact-info [{:keys [f-name l-name phone company title]}]
  -  (do
  -    (println f-name l-name "is the" title "at" company)
  -    (println "You can reach him at" phone)))
  +  (println f-name l-name "is the" title "at" company)
  +  (println "You can reach him at" phone))
   
   (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 associatevly destructure the the input using the `:keys` shortcut and then print out the contact information that we provided.
  -
  -What are we thinking though!? It's 2015, no one uses their cell phones we all hand write personal letters to be delivered via the speedy Pony Express!
  +This function will associatively destructure the the input using the `:keys` shortcut and then print out the contact information that we provided.
  +
  +But what about when we want to send John a nice letter?
   
   [source,clojure]
   ----
  
positive.code: ;= A 3
  ----
  
  You can also use `:strs` and `syms` if the keys in the map aren't actually keywords.
  
  [source,clojure]
  ----
  (def string-keys {"a" "A" "b" "B"})
  
  (let [{:strs [a b]} string-keys]
    (println a b))
  ;= A B
  
  (def symbol-keys {'a "A" 'b "B"})
  
  (let [{:syms [a b]} symbol-keys]
    (println ab))
  ;= A B
  ----
  
  You get the same output with a much more concise and readable input.
  
  We've been consistently binding keys to their corresponding symbol, `:a` to `a` and `:b` to `b`. You aren't limited to this practice though. You are free to bind the values to whatever symbols you choose.
  
  [source,clojure]
  ----
  (let [{first :a third :c} my-map]
    (println first third))
  ;= A 3
  ----
  
  Associative destructuring also supports nested maps, similarly to sequential destructuring.
  
  [source,clojure]
  ----
  (def nested-map {:a {:d 1} :b 2 :c 3})
  (let [{{a :d} :a, b :b, c :c} nested-map]
    (println a b c))
  ;= 1 2 3
  
  (def deeply-nested-maps {:a {:c [1 2]} :b {:d {:e 3}}})
  
  (let [{{[a b] :c} :a, {{c :e} :d} :b} deeply-nested-maps]
    (println a b c))
  ;= 1 2 3
  ----
  
  Associative destrucuturing also works with lists since they support key value pairs.
  
negative.code:                            :city "Macroville"
                             :state "Kentucky"
                             :zip "81321"}
                   :hobbies ["running" "hiking" "basketball"]
                   :company "Functional Industries"
                   :title "Sith Lord of Git"})
  ----
  