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: 
  This section intends to explain the different kind of builting handler types.
  
  === Asynchronous
  
  Asynchronous handlers are handlers that return a value in an asynchronous way using one
  
negative.code: 
  ;; It will return a chunked response to the client with "HELLO WORLD" string.
  ----
  
  One of the best parts of the reactive-strams is that them comes with backpressure
  support out of the box and it native support in ratpack makes them a great glue
  abstraction for similar async primitives. In fact, the support for all stream like
  primitives explained until now are implemented in terms of _reactive-streams_ publisher.
  
  
  === WebSockets
  