anchor.diff:      (http/ok ch)))
   ----
   
  -Returning a channel as the body has the advantage that you have the ability of setting
  -additional headers and HTTP status in your function body code. But, if you are return a
  -channel as a response value, the default status code will be set for you. The behavior of
  -two approaches is the same, resulting in a chunked encoded response to the client.
  -
  -And this is an example of an async handler returning a channel as response:
  -
  -[source, clojure]
  -----
  -(defn my-async-handler
  -  [context]
  -  (go
  -    (let [result (<! (do-some-async-task))]
  -      (:message result)))
  -----
  -
   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.
   
  -
  -==== Body as promise (CompletableFuture)
  -
  -Promises are another abstraction supported out of the box in _catacumba_. It comes from
  -the link:https://github.com/funcool/promissum[promissum library] and is build on top of
  -JDK8 _CompletableFuture_.
  +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])
  
positive.code: (explained below).
  
  
  ==== Body as channel
  
  The `core.async` channel is one of the supported abstractions that comes with _catacumba_
  out of the box. It consists of a handler that returns a body as a channel or response as
  a channel.
  
  This is the aspect of async handler returning the channel as a body:
  
  [source, clojure]
  ----
  
negative.code:     (http/ok promise {:content-type "text/plain"})))
  ----
  
  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]
  ----
  