anchor.diff:      (ct/run-server))
   ----
   
  -Ring handlers can be set as standalone handlers (mainly for use them as compojure and all related
  +Ring handlers can be set as standalone handlers (mainly for using them with compojure and all related
   middlewares) or in a _catacumba_'s routing chain.
   
   
  -== Builtin Handlers
  -
  -This section will cover different kind of builtin additional handlers for make the experience of
  +== Built-in Handlers
  +
  +This section will cover different kind of built-in additional handlers to make the experience of
   using _catacumba_ more pleasant.
   
   
   [[body-parsing]]
   === Body parsing
   
  -_Catacumba_ comes with builtin support for conditional body parsing depengin on the incoming
  -content type. It consists in a route chain that adds the `:body` entry in the context with the
  -parsed data or `nil` in case of incoming content type does not has attached parser implementation.
  -
  -For use it, it is simple as prepend the `body-params` handler to your route chain:
  +_Catacumba_ comes with builtin support for conditional body parsing depending on the incoming
  +content type. It consists of a routing chain that adds the `:body` entry in the context with the
  +parsed data or `nil` in case of an incoming content type does not have an attached parser implementation.
  +
  +In order to use it, it is simple as prepending the `body-params` handler to your route chain:
   
   [source, clojure]
   ----
  
positive.code: ----
  
  As we mentioned previously, behind the scenes _buddy_ is used, so almost all auth backends
  defined in buddy can be used with _catacumba_, such as jws and jwe backens.
  
  It there some exceptions, such as the session auth backend, because the sessions works
  slightly different in _catacumba_ and the buddy session auth backend reliad in a ring
  session behavior.
  
  The buddy access rules are not supported because, the _catacumba_ routing chain system
  fullfills that gap. You can define concrete authorization rules and attach them directly
  in a routing chain.
  
  You can see a working example using auth facilties <<website-example,here>>.
  
  
  === Sessions
  
  ==== Getting Started
  
  The http sessions in _catacumba_ are also implemented as chain handler. So, you can add sessions
  to you application just adding the handler to your routing chain:
  
  [source, clojure]
  ----
  
negative.code:   (delete-session [_ key]))
  ----
  
  If you are familiar with the ring based session storages, you can observe that the _catacumba_ session
  storage abstraction is almost identical to the ring session abstraction, so migrating from or
  adapting the ring session storages is really easy. The unique difference is that functions
  should return a promise (from futura library).
  
  To use a concrete session storage, just pass a instance of it as value of the `:storage`
  key in a session handler constructor:
  
  [source, clojure]
  