anchor.diff:  ----
   
   
  -==== Watch event
  -
  -The *watch* event represents an asynchronous operation that ends on
  -posible state transformation. Let's define one:
  +==== Watch Event
  +
  +Apart of the simple state transformations, the applications usually
  +need perform asynchronous operations such as call remote api, access
  +to local database, etc. There are where the *watch* event plays they
  +role. They are designed to handle asynchronous operations.
  +
  +Let's see how it looks:
   
   [source, clojure]
   ----
  
positive.code:          (rx/delay 100))))       ; delay the stream for 100ms
  ----
  
  As you can obseve, the watch event also reveives the current state and
  should return a stream of other events. With this approach the event
  always has one responsability: or doing async operation of performing
  state transformation.
  
  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. Let's see how it look:
  
  [source, clojure]
  ----
  
negative.code:       (js/Notification. title params))))
  ----
  
  The return value of the `effect` function is completly ignored.
  
  
  === Store
  
  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
  