anchor.diff:  ;= 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 can also use `:strs` and `:syms` if the keys in the map aren't actually keywords. I cannot reiterate enough to remember to bind these values to `symbols`, always!
  +
  +[source,clojure]
  +----
  +(def string-keys {"first-name" "Joe" "last-name" "Smith"})
  +
  +(let [{:strs [first-name last-name]} string-keys]
  +  (println first-name last-name))
  +;= Joe Smith
  +
  +(def symbol-keys {'first-name "Jane" 'last-name "Doe"})
  +
  +(let [{:syms [first-name last-name]} symbol-keys]
  +  (println first-name last-name))
  +;= 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, `: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
  +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 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
  +(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.
  
positive.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 works on:
  1. Clojure maps, sets, and vectors
  2. Anything that the `get` function operates on.
  3. Hmm...
  
  [source,clojure]
  ----
  (def my-map {:a "A" :b "B" :c 3 :d 4})
  
  (let [{a :a b :b c :c d :d} my-map]
    (println a b c d))
  ;= A B 3 4
  ----
  
  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.
  
  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 [{a :a x :x} my-map]
    (println a x))
  ;= A nil
  ----
  
  Associative destructuring allows you to replace all of the nil values with a default value.
  
  [source,clojure]
  ----
  (let [{a :a, x :x, :or {x "X not found!" y "Y not found!" z "Z not found!"}} my-map]
    (println x y z))
  ;= X not found! Y not found! Z not found!
  ----
  
  You aren't required to bind any keys that you don't want to bind, just like sequential destructuring.
  
  [source,clojure]
  ----
  (let [{a :a _ :b c :c _ :d} my-map]
    (println a c))
  ;= A 3
  ----
  
  Since associative destructuring isn't sequential, it is more common practice to simply leave out the keys that you aren't planning on using. This prevents the destructuring form from becoming too crowded.
  
  [source,clojure]
  ----
  (let [{a :a c :c} my-map]
    (println a c))
  ;= A 3
  ----
  
  If you need access to the entire map, you can use the `:as all` shortcut like in sequential destructuring.
  
  [source,clojure]
  ----
  (let [{a :a :as all} my-map]
    (println "I got" A "from" all))
  ;= I got A from {:a "A" :b "B" :c 3 :d 4}
  ----
  
  The `:as` and `:or` keywords can be combined in a single destructuring.
  
negative.code:                            :city "Macroville"
                             :state "Kentucky"
                             :zip "81321"}
                   :hobbies ["running" "hiking" "basketball"]
                   :company "Functional Industries"
                   :title "Sith Lord of Git"})
  ----
  