anchor.diff:       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.
  +With the same idea of data inside a context (like `Functor`), what is happens if a wrapped value is
  +one function/computation? Applicative functors works like plain functors but additionally
  +can apply function wrapped in some context similar to input value.
  +
  +Let see one example:
  +
  +[source, clojure]
  +----
  +(defn make-greeter
  +  [^String lang]
  +  (condp = lang
  +    "es" (just (fn [name] (str "Hola " name)))
  +    "en" (just (fn [name] (str "Hello " name)))
  +    (nothing)))
  +
  +(fapply (make-greeter "es") (just "Alex"))
  +;; => #<Just [Hola Alex]>
  +
  +(fapply (make-greeter "en") (just "Alex"))
  +;; => #<Just [Hello Alex]>
  +
  +(fapply (make-greeter "it") (just "Alex"))
  +;; => #<Nothing >
  +----
  +
  +Moreover, applicative functor protocol comes with an other function: `pure`. The main purpose of
  +it, is given any value in a context and new value, wraps the new value in a minimal context of same
  +type as first argument.
  +
  +To understand it better, see some examples:
  +
  +[source, clojure]
  +----
  +(pure (just 1) 5)
  +;; => #<Just [5]>
  +
  +(pure (right :foo) :bar)
  +;; => #<Either [:bar :right]>
  +----
  +
  +The real purpose of this function you will see in a following `Monad` section.
  +
  +
  +Monad
  +~~~~~
  +
  +Monads are the most discussed programming concept to come from category theory. Like functors and
  +applicatives, monads deal with data in contexts.
  +
  +Additionaly, monads can also transform context by unwrapping data, applying functions to it and
  +put new value in a completely different context.
  +
  +.This is aspect of Monad protocol
  +[source, clojure]
  +----
  +(defprotocol Monad
  +  "Incomplete monad type definition."
  +  (bind [mv f] "Applies the function f to the value(s) inside mv's context."))
  +----
  +
  +NOTE: In diference with haskel type class, _cats_ protocol only defines one method: `bind`. Other
  +related methods like `return` are defined as auxiliar functions in `cats.core` namespace.
  +
  +`bind` function, takes a monadic value (any container that implements a `Monad` protocol) and one
  +function, applies the function with unwrapped value as first parameter and return a result. In this
  +case, is a function respoisability of function wrap the result in a corresponding context.
  +
  +One of the key features of bind function, that everythig insined a monad context known the context
  +type. Having this, if you apply some computation over a monad and you want return the result
  +in the same container context but you don't know that contaier is it, you can use `return` or `pure`
  +function for it.
  +
  +[source, clojure]
  +----
  +(bind (just 1) (fn [v] (return (inc v))))
  +;; => #<Just [2]>
  +----
  +
  +`return` or `pure` function with one argument, try takes a context value from dynamic scope collected
  +internaly by `bind` function, so that, you can not use them with one argument out of `bind` context.
  +
  +And finally, for make more powerful monadic compositions, _cats_ comes with `mlet` macro that
  +if you coming from haskell, represents a `do-syntax`:
  +
  +[source, clojure]
  +----
  +(mlet [x (just 1)
  +       y (just 2)
  +       z (just (+ x y))]
  +  (return z))
  +;; => #<Just [3]>
  +----
  +
  +TODO: document other more advanced options like `:let` and `:when` in a `mlet` context.
   
   
   Data Types Reference
  
positive.code:     the context of the functor fv."))
  ----
  
  [NOTE]
  ====
  The real fmap signature is `(a -> b) -> f a -> f b` that can be traslated to clojure `[f fv]`. The
  changed order on protocol parameters definition is required because of clojure's protocols limitation
  on dispatch on first argument. You should not use protocol function directly. For it, `cats.core/fmap`
  function exists and has the correct signature.
  ====
  
  Use case
  ^^^^^^^^
  
  Let see an example of using fmap over some type that implements the `Functor` protocol: `Just`
  and `Nothing:
  
  .Apply function `inc` to value `1` wrapped in a `Just`
  
  [source, clojure]
  ----
  (require '[cats.core :refer :all])
  (require '[cats.types :refer :all])
  
  (fmap inc (just 1))
  ;; => #<Just [2]>
  ----
  
  `fmap` unwrapps the context, apply the function to inner value, and wrap it in a new context. If you
  repeat the same operation over `Nothing`, instead of raising some strange exception, it again return
  `Nothing` instance:
  
  [source, clojure]
  ----
  (fmap inc (nothing))
  ;; => #<Nothing >
  ----
  
  That allows forward error handlig to the end of the computation pipeline.
  
  One of the main property of *Functors* is that fmap always returns a result wrapped in the same
  context that input value:
  
  .Clojure vectors are also functors and works as container.
  [source, clojure]
  ----
  (fmap inc [1 2 3])
  ;; => [2 3 4]
  ----
  
  If you compare this result with standard clojure `map` function:
  
  [source, clojure]
  ----
  
negative.code: Functor
  ~~~~~~~
  
  The Functor represents some sort of "computational context".
  
  .This is aspect of Functor protocol
  [source, clojure]
  ----
  (defprotocol Functor
  