anchor.diff:  (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
  +;= A B C D
   ----
   
   === Where to destructure
  
positive.code:     (println "The first and thir fruits are," first "and" third)
      (println "These we're taken from" all-fruits)
      (println "The fruits after them are" rest))
  ;;= The first and third fruits are, apple and strawberry
  ;;= These we're taken from [apple orange strawberry peach pear lemon]
  ;;= The fruits after them are (peache pear lemon)
  ----
  
  Destructuring grants you access to vectors nested within vectors as well. While you can penitrate through as many layers as you need, once you get to the fourth or fifth layer this becomes difficult to read.
  
  [source,clojure]
  ----
  (def nested-vector [1 [2 [3 [4 [5]]]]])
  
  (let [a [b [c [d [e]]]]]
    (println a b c d e))
  ;;= 1 2 3 4 5
  ----
  
  When you have nested vectors, you can use `:as` to bind the whole nested vector to a single symbol.
  
  [source,clojure]
  ----
  (let [[[a b :as first] [c d :as second]] nested-vector]
    (do
      (println a b first)
      (println c d second)))
  ;;= 1 2 [1 2]
  ;;= 3 4 [3 4]
  ----
  
  === Associative Destructuring
  
negative.code:   (do
      (println first)
      (println second third fourth fifth sixth)))
  ;= Michael
  ;= Amber Aaron Nick Earl Joe
  ----
  
  This binding works but even using destructuring it's pretty clunky. Here we can use `&` to clump the tail elements into a sequence.
  