anchor.diff:  Additionaly, monads can also transform context by unwrapping data, applying functions to it and
   put new values in a completely different context.
   
  -.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: As opposed to haskell type classes, _cats_ protocols only define one method: `bind`. Other
  -related methods like `return` are defined as auxiliar functions in `cats.core`.
  -
  -`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 returns a result. In this
  -case, the function is responsible for wrapping the result in a corresponding context.
  -
  -One of the key features of the bind function is that everything inside a monad context knows the context
  -type. Having this, if you apply some computation over a monad and you want to return the result
  -in the same container context but you don't know that container is it, you can use `return` or `pure`.
  -
  -[source, clojure]
  -----
  -(bind (just 1) (fn [v] (return (inc v))))
  +The monad abstraction consists on two functions: **bind** and **return**
  +
  +**bind** function has the following signature:
  +
  +[source,clojure]
  +----
  +(bind [mv f])
  +----
  +
  +Let see one example:
  +
  +[source,clojure]
  +----
  +(bind (just 1)
  +      (fn [v] (just (inc v))))
  +----
  +
  +As you can observe, it works much like Functor but with inverted arguments, the main deference is
  +that in monad, the function is a responsible of wrapping a retuned value in a context.
  +
  +One of the key features of the bind function is that any computation executed inside of context of
  +bind (monad) knows the context type implicitly. Having this, if you apply some computation over some 
  +monadic value  and you want to return the result in the same container context but you don't know 
  +that container is it, you can use `return` or `pure` functions:
  +
  +[source,clojure]
  +----
  +(bind (just 1)
  +      (fn [v]
  +        (return (inc v))))
   ;; => #<Just [2]>
   ----
   
  -The `return` or `pure` functions, when called with one argument, try to use the dynamic scope context value
  -that's set internally by the `bind` function. Therefore you can't use them with one argument out of a `bind` context.
  -
  -And finally, to make more powerful monadic compositions, _cats_ comes with the `mlet` macro that
  -if you are coming from haskell, represents a `do-syntax`:
  -
  -[source, clojure]
  -----
  -(mlet [x (just 1)
  -       y (just 2)
  -       z (just (+ x y))]
  -  (return z))
  -;; => #<Just [3]>
  +The `return` or `pure` functions, when called with one argument, try to use the dynamic scope context
  +value that's set internally by the `bind` function. Therefore you can't use them with one argument out
  +of a `bind` context.
  +
  +At this time, everything is fine, we not can compose any number of computations using monad **bind*
  +functions. But that is happens where the number of computations increases:
  +
  +[source, clojure]
  +----
  +(bind (just 1)
  +      (fn [a]
  +        (bind (just (inc a))
  +              (fn [b]
  +                (return (* b 2))))))
  +----
  +
  +This easy grows to very beatiful callback hell. For solve this, _cats_ comes with powerful
  +macro: **mlet**
  +
  +NOTE: If you are coming from haskell, it represents the `do-syntax` of haskell.
  +
  +Let see the same example but translated to more clear code using mlet macto:
  +
  +[source, clojure]
  +----
  +(mlet [a (just 1)
  +       b (just (inc b))]
  +  (return (* b 2)))
   ----
   
   If you want to use regular (non-monadic) let bindings inside a `mlet` block, you can do so using
  
positive.code: ;; => #<Just [2]>
  ----
  
  But **Maybe** has another constructor: `maybe/nothing`. This constructor makes 
  empty object that not wraps anything. It represents the failure. Is the safe
  substitute of `nil` and represents the failure.
  
  
negative.code: 
  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.
  