anchor.diff:      (+ a b)))
   ----
   
  -`do!` expression work similarly to clojure's `do` block, so you can
  -put any expression but only the last one will be returned and that
  -expression can be a plain value or an other promise.
  +The `do!` expression work similarly to clojure's `do` block, so you can provide
  +any expression, but only the last one will be returned. That expression can be a
  +plain value or an other promise.
   
   If an exception is raised inside the `do!` block, it will return the
   rejected promise instead of re-raising the exception on the stack.
   
  -If the `do!` contains more than one expression, they will be treated
  -as promise expressions and will be executed one after the other,
  -alwais awaiting the resolution of the previous expression.
  -
  -In this case the `do!` macro:
  -
  -[source, clojure]
  -----
  -(p/do! (expr1)
  +If the `do!` contains more than one expression, each expression will be treated
  +as a promise expression and will be executed sequentially, each awaiting the
  +resolution of the prior expression.
  +
  +For example, this `do!` macro:
  +
  +[source, clojure]
  +----
  +(p/do! (expr1nn)
          (expr2)
          (expr3))
   ----
  
positive.code: ;; => 4
  ----
  
  The `chain` uses `then` behind the scenes, so the same rules about
  flattening applies.
  
  NOTE: if you know that your chained functions does not returns
  promises, you can use `chain'` instead for better performance.
  
  
  
negative.code: === Creating a promise
  
  There are several different ways to create a promise instance. Let's
  start by creating promise instances from plain values:
  
  [source, clojure]
  ----
  