anchor.diff:  ;; => 85
   ----
   
  -The `let` macro behaves identically to the `let` with the exception
  -that it always return a promise.
  -
  -If an error occurs at any step, the entire composition will be
  -short-circuited, returning exceptionally resolved promise.
  -
  -Under the hood, the previous `let` macro evalutes to something like
  -this:
  +The `let` macro behaves identically to the `let` with the exception that it
  +always return a promise. If an error occurs at any step, the entire composition
  +will be short-circuited, returning exceptionally resolved promise.
  +
  +Under the hood, the previous `let` macro evalutes to something like this:
   
   [source, clojure]
   ----
   (p/then (sleep-promise 42)
           (fn [x] (p/then (sleep-promise 41)
                           (fn [y] (p/then 2 (fn [z]
  -                                            (p/resolved (do (+ x y z)))))))))
  +                                            (p/promise (do (+ x y z)))))))))
   ----
   
   ==== `all`
   
   In some circumstances you will want wait for completion of several promises at
  -the same time. To help with that, _promesa_ also provides helpers.
  -
  -Imagine that you have a collection of promises and you want to wait until all of
  -them are resolved. This can be done using the `all` combinator:
  +the same time. To help with that, _promesa_ also provides the `all` helper.
   
   [source, clojure]
   ----
  
positive.code: environment built-in Promise implementation.
  
  
  === Project Maturity
  
  Since _promesa_ is a young project there may be some API breakage.
  
  
  === Install
  
  Just include the following lines in your dependency vector on *_project.clj_*:
  
  [source,clojure]
  ----
  [funcool/promesa "4.0.0"]
  ----
  
  This package requires JDK >= 8 if you are using it on the JVM.
  
  
  == User guide
  
negative.code: === Scheduling Tasks
  
  In addition to the promise abstraction, this library also comes with a
  lightweight abstraction for scheduling task to be executed at some time in
  future:
  
  .Example using the `schedule` function.
  [source, clojure]
  