anchor.diff:  completable future as underlying implementation and and all promises can be easily coerced to
   jdk future or completable future.
   
  -
  -=== Creating a promise.
  +The promise consists in a container that eventually will contain a value with builtin support for
  +error handling. So the promise has three different states:
  +
  +- `pending`: means that the promise does not contains any value.
  +- `resolved`: means that the promise contains a value.
  +- `rejected`: means thet the promise contains an error.
  +
  +
  +
  +==== Creating a promise.
   
   It there several different ways to create a promise in _futura_ library. You can create it inmediatelly
  -resolved with initial value, inmediatelly rejected with some exception, use a "javascript" like approach
  -creating it from a callback or use the clojure's approach with `deliver` like function.
  +resolved with initial value, inmediatelly rejected with some exception.
   
   Let start with a basic example using the commonly known promise delivering in clojure:
   
  
positive.code: The return value of `take!` function is also a promise and will be resolved with a value when the first
  one will be available.
  
  You should known that everything in this implementation is lazy. Creatin susbscrion does not
  automatically request all items from publisher. A subscription will only request a item to the publisher
  when you are request it.
  
  
negative.code: ;; It will print 4.
  ----
  
  It also exposes a chain method for error handling:
  
  [source, clojure]
  ----
  (def pr (-> (p/promise 2)
              (p/then (fn [v] (throw (ex-info "foobar" {}))))))
  
  (p/catch pr (fn [error]
                (println "Error:" (.getMessage error))))
  ;; Will print something like "Error: foobar"
  ----
  
  The `catch` chain function also return a promise. Promise that will be resolved or rejected
  depending on that will happen inside the catch handler.
  
  
  ==== Collections of promises
  
  In some circumstances you will want wait a completion of few promises at same time, and _futura_
  also provides helpers for that:
  