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: ;= Jane Doe
  ----
  
  You get the same output with a much more concise and readable input.
  
  We've been consistently binding keys to their corresponding symbol, `:frist-name` to `first-name`,  `:last-name` to `last-name`, etc... You aren't limited to this practice though, you are free to bind the values to whatever symbols you choose.
  
  [source,clojure]
  ----
  (def game-state {:player "Ryan"
            :class "Wizard"
            :score 150
            :current-weapon "Mystic's Staff"})
  (let [{p :player
         c :class
         s :score
         w :weapon} game-state]
    (println "The player" p "is a" c "wielding a" w "with a score of" s))
  ;= The player Ryan is a Wizard wielding a Mystic's staff with a score of 150
  ----
  
  Associative destructuring also supports nested maps, similarly to sequential destructuring.
  
  [source,clojure]
  ----
  (def multiplayer-game-state {:joe {:class "Ranger"
                                     :weapon "Long Bow"
                                     :score 100}
                               :jane {:class "Knight"
                                      :weapon "Great sword"
                                      :score 140}
                               :ryan {:class "Wizard"
                                      :weapon "Mystic's Staff"
                                      :score 150}})
  (let [{{:keys [class weapon]} :joe} multiplayer-game-state]
    (prn "Joe is a" class "wielding a" weapon))
  ;= Joe is a Ranger wielding a Long bow
  ----
  
  Associative destrucuturing also works with lists since they support key value pairs.
  
  [source,clojure]
  ----
  (def key-list '("A", "B", :c "C", :d "D"))
  (let [a b & {:keys [c d]} key-list]
    (pintln a b c d))
  ;= A B C D
  ----
  
  You can also use destructuring to create local bindings with namespaced keys.
  
  Say you have two vars, each in separate namespaces. In the `people` namespace, you have `person`, a map describing someone.
  
  [source,Clojure]
  ----
  (ns destructuring.people)
  (def human {:name "Franklin"
               :age 25
               :hobbies "running"})
  ----
  
  In a separate namespace you have a map describing a dog called `pet`.
  
  [source,Clojure]
  ----
  (ns destructuring.pets)
  (def dog {:species "dog"
            :name "Rover"
            :age 4
            :hobbies "running"})
  ----
  
  Rover is a foster puppy looking for his forever home and Franklin is looking to adopt a puppy to keep him company. In a third namespace, you would like to compare their hobbies to see if they would be a good match.
  
  [source,Clojure]
  ----
  (ns destructuring.match-making
    (require [destructuring.people :as ppl])
    (require [destructuring.pets :as pets]))
  
  (let [human-hobbies {:keys [hobbies]} ppl/human
        pet-hobbies   {:keys [hobbies]} pets/dog]
    (if (= human-hobbies pet-hobbies)
      (println "It's a perfect match! They both love " human-hobbies "!")
      (println "Aw... It looks like our human likes" human-hobbies "but our pet likes" pet-hobbies)))
  ----
  
  In our `let` here, we bind to the symbol `human-hobbies`, Franklin's hobbies and to `pet-hobbies`, Rover's hobbies. This creates a local binding for both, rather than having to refer to their respective namespaces in order to use them. In our case, Franklin and Rover are a perfect match because they both love running, so this will print out the first line.
  
  You can also destructure auto-resolved keywords:
  
  [source,Clojure]
  ----
  (let [pet-store {::best-pet "dog"}
        {:keys [pets-available]} pet-store]
    (println "We think the best pet for you is a" best-pet "!")
  
  ;= We think the best pet for you is a dog !
  ----
  
  
  == Where to destructure
  
  You can utilize destructuring anywhere that there is an explicit or implicit let binding.
  
  === Function Declarations
  
  Passing a collection of information into a function is common practice in Clojure, so the ability to separate those parameters' information is important. When you define a function in Clojure you can utilize destructuring to make the function definition very concise.
  
  Here we have the standard let x equal this, let y equal that, etc... Again, this is perfectly valid code, it's just verbose.
  
  
negative.code: 
  (print-contact-info john-smith)
  ;= John Smith is the Sith Lord of Git at Functional Industries
  ;= You can reach him at 215-004-1776
  ;= He lives at 452 Lisp Ln. Macroville Kentucky 81321
  ;= Maybe you can write to him about running or hiking
  ----
  