anchor.diff:  [source, clojure]
   ----
   (def pr (-> (p/promise 1)
  -            (p/then inc inc inc))
  +            (p/chain inc inc inc))
   (p/then pr (fn [v]
                (println v)))
   
   ;; => Stdout: 4
   ----
   
  -This library also plays in the link:https://github.com/funcool/cats[cats] library
  -protocols so you can use the *Functor* interface for apply a function to a promise
  -value:
  -
  -[source, clojure]
  -----
  -(require '[cats.core :as m])
  -
  -(-> (m/fmap inc (p/promise 10))
  -    (p/then (fn [v]
  -              (println v))))
  -
  -;; => Stdout: 11
  -----
  -
   
   === Advanced chaining
   
   Until now, we have seen a very simple promise compositions that does not depends
  -on previous results. The `cats.core/mlet` and `cats.core/alet`  macro allows us
  -build more complex and more powerfull promise compositions.
  +on previous results. The `alet` macro allows us build more complex and more
  +powerfull promise compositions using ES7 async/await like syntax.
   
   For demostration purposes, imagine that you have this function that emulates async
   operation and return a promise:
   
   [source, clojure]
   ----
  -(require '[cats.core :as m])
   (require '[promesa.core :as p])
   
   (defn sleep-promise
  
positive.code: 
  [source,clojure]
  ----
  [funcool/promesa "0.7.0"]
  ----
  
  This package requires JDK8 if you are using it on the JVM platform and
  
negative.code:                (p/schedule wait #(resolve wait)))))
  ----
  
  Let's see an example using `alet` (async let) macro:
  
  [source, clojure]
  ----
  (def pr
    (p/alet [x (p/await (sleep-promise 42))
             y (p/await (sleep-promise 41))
             z 2]
      (+ x y z)))
  
  (p/then pr (fn [v]
               (println v)))
  
  ;; => Stdout: 85
  ----
  
  The `alet` macro behaves identical to the `let` with the exception that it
  always return a promise and allows mark async operations with `await` placeholder
  making it looks like synchronous opetation.
  
  If an error occurs at any step the entire composition will be short-circuited,
  returning exceptionally resolved promise.
  
  If you are not familiar with `async`/`await` syntax, you can read more
  about it link:http://jakearchibald.com/2014/es7-async-functions/[here].
  
  
  === Error handling
  