anchor.diff:  | vector   | Functor, Applicative, Monad, MonadZero, MonadPlus
   | hash-set | Functor, Applicative, Monad, MonadZero, MonadPlus
   | list     | Functor, Applicative, Monad, MonadZero, MonadPlus
  -| atom     | No one (in future)
   |=============================================================
   
  -Use cases
  ----------
  -
  -State monad
  -~~~~~~~~~~~
  -
  -State monad in one of the special use cases of monads most used in haskell. It has different
  -purposes including: lazy computation composition and maintaining state without explicit state.
  -
  -The de facto monadic type of the state monad is a plain function. Function represents a computation
  -as is (without executing it). Obviously, a function should have some special characteristics to 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 saw an example of the low level primitive of state monad but for basic usage
  -you do not need to build your own functions, just use some helpers that _cats_ gives you.
  -
  -Let's look at one example before explaining the details:
  -
  -.Lazy composition of computations
  -[source, clojure]
  -----
  -(m/mlet [state (m/get-state)
  -         _     (m/put-state (next state))]
  -  (return (first state)))
  -;;=> #<State cats.monad.state.State@2eebabb6>
  -----
  -
  -At the moment of evaluating the previous expression, anything that we have defined
  -is executed. Instead of the finished value of the computation, a strange/unknown object is returned of type *State*.
  -
  -State is a simple wrapper for clojure functions, 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 returns 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 what 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
  -the difference that pairs can only have two slots.
  -
  -This is a very basic example of the 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 examples to explain the state monad, documentation for another monad or
  -any other contribution is always welcome.
   
   License
   -------
  
positive.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
  
negative.code: ;; => #<Either [:bar :right]>
  ----
  
  If you not understand the purpose of **pure** function, it is possible that the next section
  can clarify the real purpose of it.
  
  
  Monad
  ~~~~~
  