anchor.diff:  (nothing)
   ;; => #<Nothing >
   ----
  +
  +NOTE: Maybe types are: Functors, Applicative Functors and Monads
  +
  +
  +Either
  +~~~~~~
  +
  +Either is an other type that represents a result of computation, but in contrast with maybe
  +it can return something with failed computation result.
  +
  +In _cats_ library it has two constructors:
  +
  +- `(left v)`: represents a failure.
  +- `(right v)`: represents a successful result.
  +
  +[source, clojure]
  +----
  +(require '[cats.types :refer :all])
  +
  +(right :valid-value)
  +;; => #<Right [:valid-value :right]>
  +
  +(left "Error message")
  +;; => #<Either [Error message :left]>
  +----
  +
  +NOTE: Either is also (like Maybe) Functor, Applicative Functor and Monad.
  +
  +Clojure Types
  +-------------
  +
  +Besides the own types, some colojure types has implementations for previously explained
  +category theory abstractions.
  +
  +NOTE: With contrast with other similar libraries in clojure, _cats_ not intends extend clojure types
  +that not acts like containers. As example, clojure keywords are values but can not be containers, so
  +that, their should not extend previously explained protocols.
  +
  +Vector
  +~~~~~~
  +
  +TODO
  +
  +List
  +~~~~
  +
  +TODO
  +
  +Set
  +~~~
  +
  +TODO
  +
   
   License
   -------
  
positive.code:      the value v in the most minimal context of same type of ctx"))
  ----
  
  Use case
  ^^^^^^^^
  
  That is hapens if context value is also an computation and you want safety execute it? Applicative
  functors is the solution for it.
  
  Let see this code:
  
  [source, clojure]
  ----
  (defn get-greeter
    []
    (let [v (rand-int 2)]
      (case v
        0 (fn [x] (println "hello" x))
        1 nil)))
  
  ((get-greeter) "Alex")
  ----
  
  This code in some situations can raise some exception because `get-greeter` in some circumstances
  can return nil (failed result) and for capture it you should constantly check if returned value
  from `get-greeter` function is a valid function.
  
  Using applicative functors, you can avoid that:
  
  [source, clojure]
  ----
  (defn get-greeter
    []
    (let [v (rand-int 2)]
      (case v
        0 (just (fn [x] (println "hello" x)))
        1 (nothing))))
  
  (<*> (get-greeter) (just "hello World"))
  ----
  
  With this code, if `get-greeter` returns nothing, the operation simply return nothing, without
  any need catching exceptions or put additional conditionals for check the returned value.
  
  *TODO:* examples using clojure keywords as applicative context.
  
  
  Data Types Reference
  
negative.code: Functor
  ~~~~~~~
  
  The Functor represents some sort of "computational context".
  
  .This is aspect of Functor protocol
  [source, clojure]
  ----
  (defprotocol Functor
  