anchor.diff:  ;; => (2 3 4)
   ----
   
  -This happens because clojure's map works over seq abstraction and always return seqs, independently
  -of input value.
  -
  -
  -Applicative Functors
  -~~~~~~~~~~~~~~~~~~~~
  +You can see more information and examples of clojure types that implements this protocol
  +on the last section of this documentation.
  +
  +
  +Applicative Functor
  +~~~~~~~~~~~~~~~~~~~
   
   Represents an abstraction lying in between Functor and Monad in expressivity.
   
  -It encapsulates certain sorts of "effectful" computations in a functionally pure way.
  -
  -Recall that Functor allows us to lift a "normal" function to a function on computational contexts.
  -But `fmap` doesn't allow us to apply a function which is itself in a context to a value in a context.
  -Applicative gives us just such a tool.
  -
  -
  -Definition
  -^^^^^^^^^^
  -
  +.Applicative protocol definition
   [source, clojure]
   ----
   (defprotocol Applicative
  
positive.code: Functor
  ~~~~~~~
  
  The Functor class is the most basic and ubiquitous type class in the _cats_ libraries. A simple
  intuition is that a Functor represents a "container" of some sort, along with the ability to apply a
  function uniformly to every element in the container. For example, a list is a container of elements,
  and we can apply a function to every element of a list, using map. As another example, a binary tree
  is also a container of elements, and it’s not hard to come up with a way to recursively apply a
  function to every element in a tree.
  
  Another intuition is that a Functor represents some sort of "computational context". This intuition is
  generally more useful, but is more difficult to explain, precisely because it is so general. Some
  examples later should help to clarify the Functor-as-context point of view.
  
  Definition
  ^^^^^^^^^^
  
  [source, clojure]
  ----
  (defprotocol Functor
  
negative.code:      the value v in the most minimal context of same type of ctx"))
  ----
  
  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
  