anchor.diff:  
   [source, clojure]
   ----
  -(require 'cats.labs.channel)
  +(require '[clojure.core.async :as a])
  +(require '[cats.labs.channel])
   
   (defn async-call
     "A function that emulates some asynchronous call."
  
positive.code: 
  ==== Interoperability
  
  `cats.labs.lens` implement the `Focus` and `Foci` atom types, which are derived
  atoms with either a lens or a traversal. We can focus on a subpart of the
  structure and change it, reflecting the changes on the original atom:
  
  
  [source, clojure]
  ----
  (require '[cats.labs.lens :as l])
  
  (def a (atom [1 2 3 4]))
  
  (def fa (l/focus-atom l/fst a))
  
  (def fsa (l/foci-atom l/each a))
  
  @fa
  ;; =>1
  
  @fsa
  ;; => (1 2 3 4)
  
  (reset! fa 42)
  ;; => 42
  
  @fa
  ;; => 42
  
  @fsa
  ;; => (42 2 3 4)
  
  @a
  ;; => [42 2 3 4]
  
  (reset! fsa 42)
  ;; => (42 42 42 42)
  
  @a
  ;; => [42 42 42 42]
  
  @fa
  ;; => 42
  ----
  
  `swap!` and watches also work on the derived focus or foci atoms.
  
  
  == Complementary libraries
  
negative.code: ;; => 120
  ----
  
  And conditional lenses that can be defined using a predicate function and
  returns a lens that focuses in an element only if it passes the predicate:
  
  .Example focusing using conditional lenses
  [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
  ----
  
  ==== Interoperability
  
  There are also `Focus` type that allows you to derive atom like objects from
  clojure atoms focusing to a specific portion of it using lenses.
  
  Let see an example focusing on a concrete set of keys on an asociative
  data structure referenced by an atom:
  
  [source, clojure]
  ----
  (def state (atom {:x 1 :y 2 :z 3}))
  
  (def state-d
    (l/focus-atom (l/select-keys [:x :y]) state))
  
  @state-d
  ;; => {:x 1 :y 2}
  ----
  
  The object returned by `focus-atom` function behaves identically to a clojure
  atom and it can be treated as drop in replacement of it:
  
  [source, clojure]
  ----
  (swap! state-d update :x inc)
  
  @state
  ;; => {:x 2 :y 2 :z 3}
  
  @state-d
  ;; => {:x 2 :y 2}
  ----
  
  And do not forget that you also can attach watchers to focused atoms in the same
  way as you will do that with clojure(script) atoms.
  
  
  === Traversals
  
  *Status:* Experimental
  
  A traversal is similar to a lens but it focuses on multiple values instead of one.
  
  
  ==== First steps
  
  Therefore, we use the `foci` function for viewing the focused elements of a
  traversal.
  
  Let's look at the identity traversal, it's called `it`:
  
  [source, clojure]
  ----
  (require '[cats.labs.traversals :as t])
  (t/foci t/it 42)
  ;; => (42)
  
  (t/foci t/it [0 1 2 3])
  ;; => ([0 1 2 3])
  
  (t/put t/it 42 [0 1 2 3])
  ;; => 42
  
  (t/over t/it count [0 1 2 3])
  ;; => 4
  ----
  
  
  ==== Traversals composition
  
  Traversals like lenses are defined in terms of functions so the same approach
  also applies to traversals. Them can be composed just using `comp` or any
  other function composition technique.
  
  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.
  
  
  ==== Builtin traversals
  
  The `each` traversal focuses every value in a collection, allowing us to map
  preservering structure. The `cat` traversal flattens a nested collection:
  
  .Example using `each` traversal
  [source, clojure]
  ----
  (t/foci t/each [0 1 2 3])
  ;; => (0 1 2 3)
  
  (t/over t/each inc [0 1 2 3])
  ;; => [1 2 3 4]
  
  (t/put t/each 42 [0 1 2 3])
  ;; => [42 42 42 42]
  
  (t/foci t/cat [[0 1 2] [3 4 5]])
  ;; => (0 1 2 3 4 5)
  
  (t/over t/cat inc [[0 1 2] [3 4 5]])
  ;; => [[1 2 3] [4 5 6]]
  
  (t/put t/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:
  
  .Example using `filter` traversal
  [source, clojure]
  ----
  (t/foci (comp t/each (t/filter odd?))
          [1 2 3 4 5])
  ;; => (1 3 5)
  
  (t/over (comp t/each (t/filter odd?))
          inc
          [1 2 3 4 5])
  ;; => [2 2 4 4 6]
  
  (t/put (comp t/each (t/filter odd?))
         42
         [1 2 3 4 5])
  ;; => [42 2 42 4 42]
  