anchor.diff:  ;; => (2 3 4)
   ----
   
  -But why fmap works with vectors? Some "container" types of clojure like vectors, lists or sets 
  +But why fmap works with vectors? Some "container" types of clojure like vectors, lists or sets
   also implements the functor abstraction.
   
   
  -Applicative Functor
  -~~~~~~~~~~~~~~~~~~~
  -
  -Represents an abstraction lying in between Functor and Monad in expressivity.
  -
  -.Applicative protocol
  -[source, clojure]
  -----
  -(defprotocol Applicative
  -  (fapply [af av]
  -    "Applies the function(s) inside ag's context to the value(s)
  -     inside av's context while preserving the context.")
  -  (pure [ctx v]
  -    "Takes any context monadic value ctx and any value v, and puts
  -     the value v in the most minimal context of the same type of ctx"))
  -----
  -
  -With the same idea of data inside a context (like `Functor`), what happens if a wrapped value is
  -one function/computation? Applicative functors works like plain functors but additionally
  -can apply a function wrapped in some context similar to input value.
  -
  -Let see one example:
  +Applicative
  +~~~~~~~~~~~
  +
  +Let continue with applicative function. The Applicative Functor represents
  +some sort of "computational context" like plain Functor, but with abilty of
  +execute a function wrapped in same context.
  +
  +Applicative Functor abstraction consists in two functions: **fapply** and
  +**pure**.
  +
  +.Signature of **fapply** function
  +[source, clojure]
  +----
  +(fapply [af av])
  +----
  +
  +NOTE: **pure** function it will be explained later.
  +
  +The use case of Applicative Functors is much same as of plain Functors: safe
  +evaluation of some computation in a context.
  +
  +Let see one exaple for understand better the differences between functor and
  +applicative functor:
  +
  +Imagine, you have some factory function that depending of language, return a
  +greater function and you only has support for few languages.
  +
  +
  +[source, clojure]
  +----
  +(defn make-greeter
  +  [^String lang]
  +  (condp = lang
  +    "es" (fn [name] (str "Hola " name))
  +    "en" (fn [name] (str "Hello " name))
  +    nil))
  +----
  +
  +Now, if you want to use it, you should always defensively check if returned
  +greater is a valid function or is a nil value.
  +
  +Lets go to convert this factory to use Maybe type:
   
   [source, clojure]
   ----
  
positive.code: ;; => #<Just [2]>
  ----
  
  **just** is one of two constructors of **Maybe** type and it's only wraps the real 
  value. Now, let see one example using **fmap** over **just** instance:
  
  [source, clojure]
  
negative.code: ----
  
  NOTE: Either is also (like Maybe) Functor, Applicative Functor and Monad.
  
  State
  +++++
  
  TODO
  
  Reader
  ++++++
  
  TODO
  
  Writer
  ++++++
  
  TODO
  
  Continuation
  ++++++++++++
  
  TODO
  
  Lazy
  ++++
  
  TODO
  
  Vector
  ++++++
  
  TODO
  
  Monad Transformers
  ^^^^^^^^^^^^^^^^^^
  
  With small examples we could use simple monadic compositions, but in some circumstances
  we would combine the effects of two or more monads in one composition. For this purpose
  exists monad transformers.
  
  Almost each monad supported in _cats_ library has it monad transformer for combine
  it with any other monad.
  
  TODO
  
  
  Clojure Types
  -------------
  