anchor.diff:                 (js/setTimeout #(deliver wait) wait))))
   ----
   
  -Now, we will try to use this function together with `mlet` macro and additionally
  -messure the execution time:
  +The `cats.core/fmap` function allows us apply a function to the value
  +into the promise and return an other promise with the result:
  +
  +[source, clojure]
  +----
  +(require '[cats.core :as m])
  +
  +(-> (m/fmap inc (sleep-promise 10))
  +    (p/then (fn [v]
  +              (println v))))
  +
  +;; => Stdout: 11
  +----
  +
  +Until now, we have seen a very simple promise compositions that does not depends
  +on previous results. The `cats.core/mlet` macro allows us build more complex and
  +more powerfull promise compositions.
  +
  +Let's see an example using `mlet` macro and additionally messure the execution time:
   
   [source, clojure]
   ----
  
positive.code: The `mlet` bindings are executed sequentially, waiting in each step for promise
  resolution. If an error occurs in some step, the entire composition will be
  short-circuited, returing exceptionally resolved promise. This is very similar
  to the up coming link:http://jakearchibald.com/2014/es7-async-functions/[ES7 async/await], but built in a generic way and as a library and not language feature.
  
  The main disadvantage of `mlet` is that it's evaluation model is strictly
  secuential. It is ok for some use cases, when the sequential order is mandatory.
  
negative.code: ----
  
  
  === Simple chaining
  
  It there different ways to compose/chain computations using promises. We will start
  with the basic: lineal way of chaining computations.
  