anchor.diff:   :data {:id 1}}
   ----
   
  -The `:type` and `:dest` keys are mandatory to be present in the frame.
  +NOTE: The `:type` and `:dest` keys are mandatory to be present in the frame.
  +
  +The messages are by default serialized using transit+json serialization format
  +but the system is open to be extended with other formats. The serialization is
  +completelly transparent to the user, the catacumba will do all the hard work for
  +you.
   
   Knowing the frame structure, the best way to define a postal handler is using
   multimethods, because they allow easy dispatch by value:
  
positive.code: 
  (defmethod myhandler [:subscribe :timeupdate]
    [context frame]
    (pc/stream context
               (fn [context out]
                 (a/go-loop []
                   (when-let [_ (a/>! out (pc/response :message {:time (now)}))]
                     (a/<! (a/timeout 100))
                     (recur))))))
  ----
  
  The `catacumba.handlers.postal/stream` function is analgous to the
  `catacumba.core/sse` with the difference that it encodes the messages properly
  using *postal* protocol.
  
  
  [NOTE]
  ====
  This documention will explain only the backend related stuff. For client usage,
  please refer to the link:https://github.com/funcool/postal[client documentation].
  ====
  
  [NOTE]
  ====
  Take care that this not analogous to websockets emulation on top of http. Is
  just a message protocol that allows take aside the REST api and build your own
  one based on your own messages and your own semantics.
  
  It can be considered a low-level layer for build graphql like endpoints.
  ====
  
  
  
negative.code:   [context {:keys [data] :as frame}]
    (let [id (:id data)
          user (repo/get-user-by-id id)]
      (pc/frame user)))
  
  (defmethod myhandler [:novelty :users]
    [context frame]
    (let [status (create-new-user frame)]
      (pc/frame user)))
  ----
  
  The `message` function is just a helper for create response hashmaps:
  
  [source, clojure]
  ----
  (pc/frame {:foo 1})
  ;; => {:type :response :data {:foo 1}}
  ----
  
  In addition to plain return value, you can freely return a promise or deferred
  (from *promissum* and *manifold* libraries respecively). And if that abstractions
  dors not satisfies you, the system is completly open to be extended with your
  own abstractions.
  
  And finally, attach the handler on the router:
  
  