anchor.diff:  [[difference-with-aleph]]
   === What is the difference between _catacumba_ and Aleph?
   
  -First of all, Aleph is one of the most robust libraries in the Clojure ecosystem for building asynchronous
  -servers. Here is an incomplete list of differences and motivations why I wrote _catacumba_ instead
  -of using _aleph_ directly in my applications:
  -
  -- Aleph with manifold offers good abstractions for creating async servers but they are much too
  -  low level and only provide the basic building blocks. _catacumba_ intends to be a toolkit that is highly
  -  focused on web development by providing a good collection of features that matter to web developers.
  -- I wrote _catacumba_ to have an alternative to ring and _Aleph_ that uses ring's abstractions for
  -  handling web requests.
  +First of all, Aleph is one of the most robust libraries in the Clojure ecosystem for 
  +building asynchronous servers. Here is an incomplete list of differences and motivations 
  +why I wrote _catacumba_ instead of using _aleph_ directly in my applications:
  +
  +- Aleph with manifold offers good abstractions for creating async servers but they are 
  +  much too low level and only provide the basic building blocks. _catacumba_ intends to be
  +  a toolkit that is highly focused on web development by providing a good collection of 
  +  features that matter to web developers.
  +- I wrote _catacumba_ to have an alternative to ring and _Aleph_ that uses ring's 
  +  abstractions for handling web requests.
   - Aleph has a good path to have an easily readable  and user friendly documentation.
   - Aleph is build on manifold streams and _catacumba_ uses reactive-streams abstractions.
   
  
positive.code: 
  == 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 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]
  ----
  
negative.code: Here a incomplete list of things that _catacumba_ aims to achieve:
  
  * Have a flexible and extensible way to setup different kind of handlers
  * Provide a simple and lightweight approach for defining asynchronous web services with
    support for different abstractions, such as promises, futures, core.async, manifold,
    reactive-streams, ...
  * Build almost everything up on abstractions for simple and easy extensibility.
  * Provide a built-in, data-based routing.
  * To be flexible and not very opinionated.
  