anchor.diff:  
   NOTE: Maybe types are: Functors, Applicative Functors and Monads
   
  -
   Either
  -~~~~~~
  +++++++
   
   Either is another type that represents a result of computation, but in contrast with maybe
   it can return some data with a failed computation result.
  
positive.code: | atom     | No one (in future)
  |=============================================================
  
  
  Special use cases of monads
  --------------------------
  
  State monad
  ~~~~~~~~~~~
  
negative.code: ;; => (2 3 4)
  ----
  
  But why fmap works with vectors? Some "container" types of clojure like vectors, lists or sets
  also implements the functor abstraction.
  
  
  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]
  ----
  