anchor.diff:  
   == Getting Started
   
  -The *postal* interface is really simple. The first step for use it, just define
  +The *postal* interface is simple. The first step for use it, just define
   a client instance:
   
   [source, clojure]
  
positive.code: (def c (pc/client "http://yourser.ver/end/point"))
  ----
  
  The client is stateless, so you can define it globally without any problem. It only
  stores the initial configuration.
  
  By default it uses "PUT" http connection for send messages to backend. Is should be
  also a default value in the backend but you can change it using the second optional
  parameter to the client function:
  
  [source, clojure]
  ----
  (def c (pc/client uri {:method :get}))
  ----
  
  The "GET" method allows send the messages using http GET request using query string
  parameter. This in some circumstances enable more facilities that it can be used
  in cross domain without specially setup CORS.
  
  Additionally, you can setup initial http headers to use, using the `:headers`
  option. And them can be updated or reset after client definition using
  `postal.client/update-headers!` or `postal.client/reset-headers!`.
  
  And finally, just use it using the public api. It there an example performing a
  `:query` request:
  
  [source, clojure]
  
negative.code:           (println "User: " data)))
  ----
  
  Notice that `query` function returns a promise that will be resolved
  with the response message or rejected with a message if an `:error` message is
  returned. The promise may also be rejected with an exception object if something
  foreign to transport happens (message serialization error as an example).
  
  Additionally to query, there is also `novelty` function, that sends `:novelty`
  type frame in the same way as with `query`.
  
  == User Guide
  
  === User defined frames
  
  At this moment, the postal library only implements `query` and `novelty` specialized
  functions for send corresponding kind of frames. Surely, you may want to use
  own messages if the provided are not enough.
  
  For that purpose, *postal* library exposes a `send!` function that just exposes
  as a low level api to define your own helpers for send frames. Let us imagine you want
  to send a `:take` type message; to do so let's define a helper that uses `send!`
  function for send that frame:
  
  [source, clojure]
  