anchor.diff:  ->[1 2 3 4]
   ----
   
  -Strings work too:
  -
  -[source,clojure]
  -----
  -(let [[a b & c :as str] "asdjhhfdas"]
  -  [a b c str])
  -
  -->[\a \s (\d \j \h \h \f \d \a \s) "asdjhhfdas"]
  -----
  -
  -=== Map binding destructuring
  -
  -Map __binding-form__s allow you to bind names to parts of associative things, like maps, vectors, strings, and arrays (the latter three have integer keys). It consists of a map of __binding-form-key__ pairs, each symbol being bound to the value in the _init-expr_ at the key. In addition, and optionally, an `:as` key in the binding form followed by a symbol will cause that symbol to be bound to the entire __init-expr__. Also optionally, an `:or` key in the binding form followed by another map may be used to supply default values for some or all of the keys if they are not found in the __init-expr__:
  +In all of the sequential cases the __binding-form__s in the destructure binding will match the places in the target data structure where the desired values reside.
  +
  +[[associative-destructuring]]
  +=== Associative destructuring
  +
  +Map __binding-form__s create bindings by looking up values in collections like maps, sets, vectors, strings, and arrays (the latter three have integer keys). It consists of a map of __binding-form->key__ pairs, each __binding-form__ bound to the value in the _init-expr_ at the key provided. In addition, and optionally, an `:as` key in the binding form followed by a symbol binds that symbol to the entire __init-expr__. Also optionally, an `:or` key in the binding form followed by another map may be used to supply default values for some or all of the keys if they are not found in the __init-expr__:
   
   [source,clojure]
   ----
  
positive.code: -> 3
  ----
  
  In the case of using prefixed keys, the bound symbol name will be the same as the right-hand side of the prefixed key. You can also use auto-resolved keyword forms in the `:keys` directive:
  
  [source,clojure]
  ----
  
negative.code: [[binding-forms]]
  == Binding Forms (Destructuring)
  
  The simplest __binding-form__ in Clojure is a symbol. However, Clojure also supports abstract structural binding called destructuring in `let` binding lists, `fn` parameter lists, and by extension any macro that expands into a `let` or `fn`. Destructuring is a way to create a set of bindings to values within a collection by using an analogous collection as a binding form. A vector form specifies bindings by position in a sequential collection, a map form by key in an associative collection. Destructuring forms can appear anywhere __binding-form__s can, and thus nest, yielding code that is clearer than using collection accessors.
  
  __Binding-form__s that don’t match their respective part due to an absence of data (i.e. too few elements in a sequential structure, no key in an associative structure, etc) bind to `nil`.
  
  [[sequential-destructuring]]
  === Sequential destructuring
  
  Vector __binding_form__s sequentially bind values in collections like vectors, lists, seqs, strings, arrays, and anything that supports https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/nth[`nth`]. The sequential destructuring form is a vector of __binding-form__s, which will be bound to successive elements from the __init-expr__, looked up via `nth`. In addition, and optionally, a __binding-form__ following a `&` will be  bound to the remainder of the sequence, i.e. that part not yet bound, and looked up via https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/nthnext[`nthnext`].
  
  Finally, also optionally, `:as` followed by a symbol binds that symbol to the entire __init-expr__:
  
  [source,clojure]
  ----
  