anchor.diff:  
   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.
  -But, if the strictly secuential model is not mandatory, `mlet` does not take
  -the advantage of concurrency.
  -
  -For solve this problem, it there `alet` macro. It is almost identical to `mlet`
  -from the user experience but internally it is based in very different abstractions.
  -
  -Now, we will try to do the same example but using the `alet` macro:
  +
  +But, if the strictly secuential model is not mandatory, `alet` macro can be used
  +as drop-in-replacement for `mlet` that automatically exploits the concurrency:
   
   [source, clojure]
   ----
  
positive.code: 
  === Install
  
  The simplest way to use _promesa_ library in a ClojureScript project is by including
  it as a dependency in your *_project.clj_*:
  
  [source,clojure]
  ----
  [funcool/promesa "0.5.1"]
  ----
  
  
  == User guide
  
  === Introduction
  
  The promise consists in a container that eventually will contain a value with
  builtin support for error handling. So the promise has three different states:
  
  - `resolved`: means that the promise contains a value.
  - `rejected`: means thet the promise contains an error.
  
  In summary: is the abstraction that represents the result of an asynchronous
  operation that will be eventually available.
  
  
  === Creating a promise
  
  It there several different ways to create a promise in _promissum_ library. You can
  create it already resolved with initial value or already rejected with an exception.
  
  Let start creating a promise from a plain value:
  
negative.code: 
  (defn sleep-promise
    [wait]
    (p/promise (fn [resolve reject]
                 (p/schedule wait #(resolve wait)))))
  ----
  
  Let's see an example using `mlet` macro:
  
  [source, clojure]
  ----
  