anchor.diff:  returned. It there also can be rejected with an exception object if something
   foreign to transport is happens (message serialization error as example).
   
  -
  -== Server Push
  +Additionally to query, it 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, postal library only implements `query` and `novelty` specialiezed
  +functions for send corresponding kind of frames. Surelly, you may want to use
  +own messages if the provided are not enough.
  +
  +For that purposes, *postal* library exposes a `send!` function that just exposes
  +a low level api for define your own helpers for send frames. Let imagine you want
  +to send a `:take` type message; for that let define a helper that uses `send!`
  +function for send that frame:
  +
  +[source, clojure]
  +----
  +(defn take
  +  "Sends a query message to a server."
  +  ([client dest]
  +   (take client dest nil {}))
  +  ([client dest data]
  +   (take client dest data {}))
  +  ([client dest data opts]
  +   (send! client (merge {:type :query
  +                         :dest dest
  +                         :data data}
  +                        opts))))
  +----
  +
  +Now, you can use the new defined `take` function in the same way as you will use
  +the `query` and `novelty` functions.
  +
  +
  +=== Server Push
   
   In some curcumstances the request/response patterns is not enough and you want
   get notifications from the backend in a server-push manener or full bi-directional
  
positive.code: connection handle all required context, completly eliminating the overhead of
  creating and destroyng connectons. With that you can make multiple and repeated
  http connections without performance issues.
  
  
  == Developers Guide
  
negative.code: This will close the connection and the stream, removing all existing stream
  subscriptions.
  
  
  === Bi-directional sockets with server
  
  You also can open a bi-directional socket to the backend using `socket` function:
  
  [source, clojure]
  