anchor.diff:  ----
   
   
  -And compose them arbitrarily using function composition:
  -
  -[source, clojure]
  -----
  -;; fst
  -
  -(l/focus (comp l/fst l/fst (l/nth 2))
  -         [[[0 1 2]
  -           [3 4 5]]
  -          [6 7 8]])
  +==== Lenses composition
  +
  +One of the big advantatges of the lenses implementation of cats library is that
  +them are implemented using plain functions:
  +
  +[source, clojure]
  +----
  +(def my-lens (comp l/fst l/fst (l/nth 2)))
  +
  +(def data
  +  [[0 1 2]
  +   [3 4 5]])
  +
  +(l/focus my-lens data)
   ;; => 2
   
  -(l/put (comp l/fst l/fst (l/nth 2))
  -       42
  -       [[[0 1 2]
  -         [3 4 5]]
  -        [6 7 8]])
  -;; => [[[0 1 42] [3 4 5]] [6 7 8]]
  +(l/put my-lens 42 data)
  +;; => [[0 1 42] [3 4 5]]
   ----
   
   Lenses compose with regular function composition and, like transducers, the
   combined lens runs from left to right.
   
  -The `passes` function accepts a predicate and returns a lens that focuses
  -in an element only if it passes the predicate.
  -
  -[source, clojure]
  -----
  -(l/focus (l/passes even?) 2)
  -;; => 2
  -
  -(l/over (l/passes even?) inc 2)
  -;; => 3
  -
  -(l/put (l/passes even?) 42 2)
  -;; => 42
  -
  -(l/focus (l/passes even?) 1)
  -;; => nil
  -
  -(l/over (l/passes even?) inc 1)
  -;; => 1
  -
  -(l/put (l/passes even?) 42 1)
  -;; => 1
  -----
  +
  +==== Builtin lenses
   
   There's `key` and `select-keys` for focusing on one or multiple keys respectively:
   
  +.Example focusing in a specific key/keys of associative data structure
   [source, clojure]
   ----
   (l/focus (l/key :a) {:a 1 :b 2})
  
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: In any case the state of each module will be notified on the start of the
  each section.
  
  
  === test.check
  
  *Status:* Experimental
  