anchor.diff:  ;; => 4
   ----
   
  -NOTE: they are analogous to the `then` and `then'` but that accepts multiple
  +NOTE: these are analogous to `then` and `then'` but accept multiple
   transformation functions.
   
   If you want to handle rejected and resolved callabacks in one unique callback,
  -then you can use `handler` chain function:
  +then you can use the `handler` chain function:
   
   [source, clojure]
   ----
  
positive.code: ;; => :resolved
  ----
  
  And finally if you want to attach a (potentially side-efectful) callback to be
  exectuted always independently if promise is rejected or resolved, there is a
  `finally` function (very similar to try/finally):
  
  [source, clojure]
  
negative.code: ;; => 2
  ----
  
  As you can observe in the example, it handles functions that return plain values as
  well as functions that return promise instances (which will automatically be
  flattened).
  
  NOTE: If you know that the chained function will always return plain values, you
  can use the `then'` more performant variant of this function.
  
  
  In the same line as the `then'` function, there is a `map`. It works identically to
  it, the unique difference is the order of arguments:
  
  [source, clojure]
  