anchor.diff:  Maybe
   ~~~~~
   
  -Two most common wrapper is "Maybe" (commonly named Optional on not functional programming
  +
  +This is one of the two most used monad types (commonly named Optional on not functional programming
   languages).
   
   Maybe/Optional is a polymorphic type that represents encapsulation of an optional value; e.g. it is
  
positive.code:   (mplus [mv mv'] "An associative addition operation."))
  ----
  
  `mplus` is an associative binary operation for which the value that `mzero` gives is the identity element. The `mplus` version contained in the core namespace is variadic.
  
  [source, clojure]
  ----
  
negative.code: that not acts like containers. As example, clojure keywords are values but can not be containers, so
  that, their should not extend previously explained protocols.
  
  
  .Summary of clojure types and implemented protocols
  [options="header"]
  |=============================================================
  | Name    | Implemented protocols
  | vector  | Functor, Applicative, Monad, MonadZero, MonadPlus
  | has-set | Functor, Applicative, Monad, MonadZero, MonadPlus
  | list    | Functor, Applicative, Monad, MonadZero, MonadPlus
  | atom    | No one (in future)
  |=============================================================
  
  
  Special use case of monads
  --------------------------
  
  State monad
  ~~~~~~~~~~~
  
  State monad in one of the special use case of mode most used in haskell. It has different
  purposes including: lazy computation composition, mantain state without state.
  
  The de facto monadic type of state monad is a plain function. Function represents a computation
  as is (without executig it). Obviously, a function should have some special characteristics for work
  in monad state composition.
  
  .Valid function for valid state monad
  [source, clojure]
  ----
  (fn [state]
    "Takes state as argument and return a vector
    with first argument with procesed value and
    second argument the transformed new state."
    (let [newvalue (first state)
          newstate (next state)]
      [newvalue newstate]))
  ----
  
  Right, you just see an example of the low level primitive of state monad but for basic usage
  you do not need build your own functions, just use some helpers that _cats_ library gives you.
  
  Let see one example before explaining anything:
  
  .Lazy composition of computations
  [source, clojure]
  ----
  (m/mlet [state (m/get-state)
           _     (m/put-state (next state))]
    (return (first state)))
  ;;=> #<State cats.types.State@2eebabb6>
  ----
  
  At the momment of evaluating the previous expression, anything that we have defined
  is executed. Instead of it, a strange/unknown object is returned of type *State*.
  
  State is a simple wrapper for clojure function, nothing more.
  
  Now, it time to execute the composed computation, for this we can use one of the following
  functions exposed by _cats_: `run-state`, `eval-state` and `exec-state`.
  
  - `run-state` function executes the composed computation and return both, the value and the
    result state.
  - `eval-state` function executes the composed computation and returns the resulting value
    discarding the state.
  - `exec-state` function executes the composed computation and return only the resulting
    state, ignoring the resulting value.
  
  .This is happens when we execute these three functions over previously generated `State` instance
  [source, clojure]
  ----
  (m/run-state s [1 2 3])
  ;;=> #<Pair [1 (2 3)]>
  (m/eval-state s [1 2 3])
  ;;=> 1
  (m/exec-state s [1 2 3])
  ;;=> (2 3)
  ----
  
  NOTE: the pair instance returned by `run-state` functions works like any other seq of clojure, with
  difference that pair only can have two slots.
  
  This is a very basic example of state monad, it has a lot of use cases and explaining all them
  seems out of the scope of this document.
  
  However, if you have better example for explain state monad, documentation for an other monad or 
  any other contribution is always welcome.
  
  License
  -------
  