anchor.diff:        (js/Notification. title params))))
   ----
   
  -As usual, it receives the current state and the stream, in the same
  -way as the *watch* event, with the exception that the return value is
  -completly ignored.
  +The return value of the `effect` function is completly ignored.
   
   
   === Store
   
  -In previous section we have seen about events, and the *store* is the object
  -that processes that events. It has the following responsabilities:
  -
  -- Holding the application state
  -- Process incoming events and emit the changes using reactive streams.
  +In previous section we have seen about events, the *store* is the
  +object that processes them. It has the following responsabilities:
  +
  +- Hold the application state.
  +- Process incoming events.
  +- Emit the changes using reactive streams.
   
   In contrast to other similar approaches to implement store (such that
   re-frame or redux), this approach does not allows to access directly
  
positive.code: 
  Although is very simple to define this kind of events, the type based
  events are more recommended, specially when you want pase arguments to
  the event:
  
  [source, clojure]
  ----
  
negative.code:          (rx/delay 100))))       ; delay the stream for 100ms
  ----
  
  
  The responsability of `watch` function is perform an asyncrhonous
  operation and return a stream of one or more other events. In the
  example you can observe that it just return a stream of one
  `Increment` event instance delayed 100 milliseconds (emulating some
  latency).
  
  That stream will be reinjected into the main stream and that events
  will be processed in the same way as if you emit them with
  `potok.core/emit!` function.
  
  The additional `stream` parameter to `watch` function represents the
  main stream where all events will arrive, so you can build logic that
  need to be synchronized with other events or just handle some kind of
  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.
  
  Let's see how it look:
  
  [source, clojure]
  ----
  