anchor.diff:  
   (let [{a :a b :b c :c d :d} my-map]
     (println a b c d))
  -;;= A B 3 4
  +;= 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.
  
positive.code: (def my-list '(1 2 3))
  (def my-string "abc")
  
  ;; It should come as no surprise that this will print out 1 2 3
  (let [[x y z] my-vector]
    (println x y z))
  ;;= 1 2 3
  
  ;; We can also use a similar technique to destructure a list
  (let [[x y z] my-list]
    (println x y z))
  ;;= 1 2 3
  
  ;; For strings, the elements are destructured by character.
  (let [[x y z] my-string]
    (do
      (println x y z)
      (map type [x y z])))
  ;;= a b c
  ;;= (java.lang.Character java.lang.Character java.lang.Character)
  ----
  
  The key to seuqential destructuring is that you bind the values one-by-one to the symbols of a vector. For instance the vector `[x y z]` will match each element one-by-one with the list `'(1 2 3)`.
  
negative.code: (def small-list '(1 2 3))
  (let [[a b c d e f g] small-list]
    (println a b c d e f g))
  ;= 1 2 3 nil nil nil nil
  ----
  
  On the other hand, if the collection is too large, the extra values are simply ignored.
  