anchor.diff:  ;; => 3
   ----
   
  -This will create a promise that will be resolved to 1 in 100ms (in a
  +This will create a promise that will resolve to `1` in 100ms (in a
   separated thread); then the first `inc` will be executed (in the same
  -thread) and then the an other `inc` is executed (in the same
  +thread) and then another `inc` is executed (in the same
   thread). In total only one thread is involved.
   
  -This is the best execution model default because it don't abuses on
  +This default execution model is usually preferrable because it don't abuse
   task scheduling and leverages function inlining on the JVM.
   
  -But it also has drawbacks: this approach will block the thread until
  -all the chained callbacks are executed. For small chains it is not a
  -problem, but if you your chain has a lot of functions and requires a
  -lot of computation time, this may cause unexpected latencies (blocking
  -other thread in the thread pool to do other maybe more priority
  -tasks).
  -
  -For this cases, **promesa** exposes an additional arity for provide an
  -user defined executor where to execute the chained callbacks:
  +But it does have drawbacks: this approach will block the thread until
  +all of the chained callbacks are executed. For small chains this is not a
  +problem. However, if your chain has a lot of functions and requires a
  +lot of computation time, this might cause unexpected latency. It may block
  +other threads in the thread pool from doing other, maybe more important,
  +tasks.
  +
  +For such cases, **promesa** exposes an additional arity for provide a
  +user-defined executor to control where the chained callbacks are executed:
   
   [source, clojure]
   ----
  
positive.code:   (expr3))
  ----
  
  And finally, **promesa** exposes a `future` macro (very similar to the
  `clojure.core/future`):
  
  [source, clojure]
  ----
  
negative.code: raised. The `catch` function also returns a promise that will be resolved or
  rejected depending on that will happen inside the catch handler.
  
  If you prefer `map`-like parameters order, the `err` function (and `error`
  alias) works in same way as `catch` but has parameters ordered like `map`:
  
  [source, clojure]
  ----
  