anchor.diff:  ----
   
   
  -The responsibility of the `watch` function is to perform an asynchronous
  -operation and return a stream of one or more events. In the example, you can
  -observe, that it just returns a stream of one `Increment` event instance delayed
  -100 milliseconds (thus emulating some latency).
  -
  -That stream will be re-injected into the main stream and those events will be
  -processed in the same way as if you emitted them with `potok.core/emit!`
  -function.
  -
  -The additional `stream` parameter to the `watch` function represents the main
  -stream where all events will arrive, so you can build logic needed for a
  -synchronization with other events or just a handling of some kind of a
  -cancellation.
  +The responsibility of the `watch` function is to perform an
  +asynchronous operation and return a stream of one or more events. In
  +the example, you can observe, that it just returns a stream of one
  +`Increment` event instance delayed 100 milliseconds (thus emulating
  +some latency).
  +
  +That stream will be re-injected into the main stream and those events
  +will be processed in the same way as if you emitted them with
  +`potok.core/emit!` function.
  +
  +The additional `stream` parameter to the `watch` function represents
  +the main stream where all events will arrive, so you can build logic
  +needed for a synchronization with other events or just a handling of
  +some kind of a cancellation.
   
   
   ==== Effect Event
   
  -The *effect* event represents a side effectfull action. In the same way as the
  -*watch* event, it receives the current state and the main stream as arguments.
  +The *effect* event represents a side effectfull action. In the same
  +way as the *watch* event, it receives the current state and the main
  +stream as arguments.
   
   Let's see how it look:
   
  
positive.code:   (rx/to-atom store))
  ----
  
  Now that we have created a store, and a materialized view of the state. Let's
  start to emit events:
  
  [source, clojure]
  ----
  (ptk/emit! store (->Increment))
  ----
  
  Now if you observe the state dereferencing the `state-view` atom, you will see
  it transformed:
  
  [source, clojure]
  ----
  
negative.code: 
  === Error Handling
  
  In many circumstances we found, that exception is raised inside the
  event. For this case *potok* comes with the built-in mechanism for
  handling errors.
  
  Let's see some code:
  
  