anchor.diff:      (http/ok promise {:content-type "text/plain"})))
   ----
   
  -Thanks to the link:https://github.com/funcool/cats[cats] `mlet` macro, that allows us
  -structure pure async code in a synchronous way:
  +Like as usual, you can return an instance of `CompletableFuture` as response:
  +
  +[source, clojure]
  +----
  +(require '[promissum.core :as p])
  +
  +(defn my-async-handler
  +  [context]
  +  (p/promise (fn [resolve]
  +               (future
  +                 (Thread/sleep 100)
  +                 (resolve (http/ok "hello world"))))))
  +----
  +
  +One of the advantages of using `CompletableFuture` abstraction with _promissum_ and
  +_cats_ libraries is that them both exposes additional sugar syntax that work with
  +promises in a more painless way.
  +
  +Let see an example that thaks to the link:https://github.com/funcool/cats[cats] `mlet`
  +macro composes few async compitations in a very clojure familiar syntax:
   
   [source, clojure]
   ----
  
positive.code: 
  (defn my-async-handler
    [context]
    (m/mlet [a (something-that-returns-promise context)
             b (do-something-with a)]
      (m/return (do-other-thing-with b)))
  ----
  
  The result of `mlet` macro expression will be a *promise* with the eventually available
  result from `(do-other-thing-with b)` expression.
  
  
  ==== Body as deferred (manifold)
  
  The link:https://github.com/ztellman/manifold[manifold] library offers different kind of
  deferred and stream abstractions for Clojure and you can use both them as response or body
  of the response for sending data to the client asynchronously.
  
  [source, clojure]
  ----
  (require '[manifold.deferred :as d])
  
  (defn my-async-handler
    [context]
    (let [result (d/future (Thread/sleep 1000) "hello world")]
      (http/ok result {"content-type" "text/plain"})))
  ----
  
  
  ==== Body as reactive-stream
  
  This is the core of all abstractions, and support for it comes out of the box from
  *ratpack*. All other abstractions that we have seen are always coerced to a *Publisher*
  instance before sending it to the client.
  
  Here there isn't anything  new to explain, if you have a function that return some kind
  of *Publisher*, you can return it as response or send it as body like as usual.
  
  Let see an example:
  
  [source, clojure]
  ----
  
negative.code:     (http/ok ch)))
  ----
  
  Do not worry about how much data you can send to the client, if you are using channels in
  a right way (in a go block), you will send data to the client as fast as the client can
  consume it. This technique is also called backpressure, and is fully supported for
  chunked responses.
  
  Additionaly, you also can return a channel as the handler response. The main difference
  is that in this case you should put a complete response into the channel:
  
  [source, clojure]
  ----
  (defn my-async-handler
    [context]
    (go
      (let [result (<! (do-some-async-task))]
        (http/ok (:data result)))))
  ----
  
  
  ==== CompletableFuture
  
  Sometimes, you do not need send a chunked stream to the client, but your "bussines logic"
  is defined in an asynchronous friendly API using promises (or something similar). In this
  case, with _catacumba_ you can return a promise as a body or as a response and the data
  will be sent to the client when the promise has been resolved successfully.
  
  The `CompletableFuture` is an other asynchronous primitive supported out of the box by
  _catacumba_; so you can return it as body or as response.
  
  For more pleasant usage of `CompletableFuture` in clojure, the link:https://github.com/funcool/promissum[promissum library]
  is used. That library provides a more clojure friendly api on top of JDK8
  `CompletableFuture` and a great sugar syntax for composing them thanks to the
  link:https://github.com/funcool/cats[cats library].
  
  
  .A example using the _promissum_ library api for create a `CompletableFuture` instance and return it as body.
  [source, clojure]
  ----
  (require '[promissum.core :as p])
  