anchor.diff:  ;; => #<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:
  +Oh, awesome, instead of raising null pointer exception, it just return *nothing*.
  +
  +
  +An other good advantage of use functor abstraction, is that it always return result
  +in the same type of second argument
  +
  +Let see one example of apply fmap over clojure vector:
   
   [source, clojure]
   ----
  
positive.code: git clone https://github.com/niwibe/cats
  ----
  
  Abstractions
  ------------
  
  This section introduces almost all category theory abstractios that cats library
  supports.
  
negative.code: Functor
  ~~~~~~~
  
  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]>
  ----
  
  **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]
  ----
  