anchor.diff:  
   === Promise Chaining
   
  -The most common way to apply a function to a promise (or in other
  -words, to chain its execution) is using the well-known `map` function:
  -
  -[source, clojure]
  -----
  -(def result
  -  (->> (p/resolved 1)
  -       (p/map inc)))
  -
  -@result
  -;; => 2
  -----
  -
  -For people coming from the JS world, there is also the `then` function
  -that works in very similar way to `map` with the exception that the
  -parameters have different order and flatten automatically.
  +The most common way to chain a transformation to a promise is using the general
  +purpose `then` function:
   
   [source, clojure]
   ----
  
positive.code: 
  ==== `plet`
  
  The `plet` macro combines syntax of `let` with `all`. It enables a simple
  declaration of parallel operations followed by a body expression that
  will be executed when all parallel operations have successfully
  resolved.
  
  [source, clojure]
  ----
  
negative.code: ;; => 3
  ----
  
  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
  another `inc` is executed (in the same thread). In total only one thread is
  involved.
  
  This default execution model is usually preferrable because it don't abuse the
  task scheduling and leverages function inlining on the JVM.
  
  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:
  