anchor.diff:  
   [source, clojure]
   ----
  -(l/foci (l/only odd?)
  +(t/foci (t/only odd?)
           [1 2 3 4 5])
   ;; => (1 3 5)
   
  -(l/over (l/only odd?)
  +(t/over (t/only odd?)
           inc
           [1 2 3 4 5])
   ;; => [2 2 4 4 6]
   
  -(l/put (l/only odd?)
  +(t/put (t/only odd?)
          42
          [1 2 3 4 5])
   ;; => [42 2 42 4 42]
  
positive.code: ;; => 120
  ----
  
  
  ==== Traversals
  
  A traversal is similar to a lens but it focuses on multiple values instead of one.
  Therefore, we use the `foci` function for viewing the focused elements of a
  traversal.
  
  Traversals should be composed with other traversals. You can compose lenses
  with a traversal but it will become a traversal and you will have to use `foci`
  for viewing its values.
  
  Let's look at the identity traversal, it's called `it`:
  
  [source, clojure]
  ----
  (l/foci l/it 42)
  ;; => (42)
  
  (l/foci l/it [0 1 2 3])
  ;; => ([0 1 2 3])
  
  (l/put l/it 42 [0 1 2 3])
  ;; => 42
  
  (l/over l/it count [0 1 2 3])
  ;; => 4
  ----
  
  The `each` traversal focuses every value in a collection, allowing us to map
  preservering structure. The `cat` traversal flattens a nested collection:
  
  [source, clojure]
  ----
  (l/foci l/each [0 1 2 3])
  ;; => (0 1 2 3)
  
  (l/over l/each inc [0 1 2 3])
  ;; => [1 2 3 4]
  
  (l/put l/each 42 [0 1 2 3])
  ;; => [42 42 42 42]
  
  (l/foci l/cat [[0 1 2] [3 4 5]])
  ;; => (0 1 2 3 4 5)
  
  (l/over l/cat inc [[0 1 2] [3 4 5]])
  ;; => [[1 2 3] [4 5 6]]
  
  (l/put l/cat 42 [[0 1 2] [3 4 5]])
  ;; => [[42 42 42] [42 42 42]]
  ----
  
  The `filter` traversal can be used to filter can be used to filter the results
  of another by composition:
  
  [source, clojure]
  ----
  (l/foci (comp l/each (l/filter odd?))
          [1 2 3 4 5])
  ;; => (1 3 5)
  
  (l/over (comp l/each (l/filter odd?))
          inc
          [1 2 3 4 5])
  ;; => [2 2 4 4 6]
  
  (l/put (comp l/each (l/filter odd?))
         42
         [1 2 3 4 5])
  ;; => [42 2 42 4 42]
  
negative.code: 
  [source, clojure]
  ----
  [org.clojure/core.async "0.2.374"]
  ----
  
  Now, let see some code. This will allow you understand how it can be used and
  