anchor.diff:  Functor
   ~~~~~~~
   
  -The Functor represents some sort of "computational context".
  -
  -.Functor protocol
  -[source, clojure]
  -----
  -(defprotocol Functor
  -  (fmap [fv f]
  -    "Applies function f to the value(s) inside
  -    the context of the functor fv."))
  -----
  -
  -`fmap` takes one wrapped value in functor context fv (ex: `Just 2`) and a plain function,
  -unwraps the value and applies a function to the plain value returning it wrapped in a new context
  -of *the same type* as the first argument.
  -
  -Some examples can explain it better:
  -
  -[source, clojure]
  -----
  -(require '[cats.core :refer :all])
  -(require '[cats.monad.maybe :refer :all])
  -
  -(fmap inc (just 1))
  +Let start with functor. The Functor represents some sort of "computational context", and the
  +abstraction consists in one unique function: **fmap**.
  +
  +.Signature of **fmap** function
  +[source, clojure]
  +----
  +(fmap [f fv])
  +----
  +
  +**fmap** takes a plain function as first parameter and and value wrapped in functor
  +context/wrapper. It, extracts the inner value apply the function to it, and return
  +the result wrapped in same type as the second parameter.
  +
  +But, what is the **functor context wrapper*? It sonds more complex that it is. Functor
  +wrapper is any type that acts as "Box" and implements the `Context` and `Functor` protocol.
  +
  +One good example of functor wrapper is the **Maybe** type:
  +
  +[source, clojure]
  +----
  +(require '[cats.monad.maybe :as maybe])
  +
  +(maybe/just 2)
   ;; => #<Just [2]>
   ----
   
  -Same example but applying function over **Nothing**:
  +**just** is one of two constructors of **Maybe** type and it's only wraps the real 
  +value. Now, let see one example using **fmap** over **just** instance:
  +
  +[source, clojure]
  +----
  +(require '[cats.core :as m])
  +
  +(m/fmap inc (just 1))
  +;; => #<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.
  +
  +Let see that is happens if we make same operation of previous example over
  +*nothing* instance:
   
   [source, clojure]
   ----
  
positive.code: ;; => #<Nothing >
  ----
  
  [NOTE]
  ====
  The real fmap signature is `(a -> b) -> f a -> f b` that can be translated to clojure `[f fv]`.
  
  The changed order of the protocol parameters definition is required because of clojure's protocols
  limitation that only allow dispatching on the first argument.
  
  You should never use a protocol function directly. Instead use `cats.core/fmap`. It has
  the correct signature.
  
  All examples in this documentation uses `cats.core/fmap` instead of a function defined in the
  protocol.
  ====
  
  Some of the native clojure types, like Vector, also implements the Functor protocol and can
  work like a functor context/container:
  
  [source, clojure]
  ----
  
negative.code: git clone https://github.com/niwibe/cats
  ----
  
  User Guide
  ----------
  
  This section introduces almost all category theory abstractios that cats library
  supports.
  