anchor.diff:  [source, clojure]
   ----
   (def stream
  -  (rx/create (fn [sick]
  -               (sick 1)          ;; next with `1` as value
  -               (sick (rx/end 2)) ;; next with `2` as value and end the stream
  +  (rx/create (fn [sink]
  +               (sink 1)          ;; next with `1` as value
  +               (sink (rx/end 2)) ;; next with `2` as value and end the stream
                  (fn []
                    ;; function called on unsubscription
                    ))))
  
positive.code: ;; ==> on-end
  ----
  
  === Zip
  
  This combinator combines two observable sequences in one.
  
negative.code: This is implemented using protocols for make it flexible and easy extensible
  by the user. This is how the default impl behaves:
  
  - Exceptions or exception instances triggers the error termination of stream.
  - `(rx/end value)` sends the unwrapped value to the stream, then terminate stream.
  - `rx/end` as value triggers the stream termination.
  - `nil` triggers stream validation.
  - any other value are valid values for send to the stream.
  
  On the JVM, there are other factory method that allow create backpressure-aware
  observables:
  
  [source, clojure]
  ----
  (def stream
    (rx/generate (fn [state sink]
                   (let [nextval (inc state)]
                     (sink nextval)
                     nextval))
                 (constantly 0)))
  ----
  
  The difference with the `create` function, the `generate` executes the
  factory function multiple and you need to call sink *once* for each
  execution. Additionally, you can maintain state between executions
  retuning the desired value, that value will passed as first argument
  on the next execution. You can provide an initial state using the
  second argument and dispose callback as third argument.
  
  Many simple observables can be converted to be backpressure-aware using
  the `to-flowable` function. Take cara that there are no magic, the buffering
  strategy is used by default for handle backpressure (over production).
  
  [source, clojure]
  ----
  (->> (rx/from-coll [1 2 3])
       (rx/to-flowable))
  ----
  
  Optionally, you can specify the strategy to use for handle backpressure
  using the first argument:
  
  [source, clojure]
  ----
  (->> (rx/from-coll [1 2 3])
       (rx/to-flowable :error))
  ----
  
  This is a list of available strategies:
  
  - `:buffer` - Buffers all values until the downstream consumes it.
  - `:error` - Signals a `MissingBackpressureException` in case the downstream can't keep up.
  - `:drop` - Drops the most recent value if the downstream can't keep up.
  - `:latest` - Keeps only the latest value, overwriting any previous value if the downstream can't keep up.
  
  
  == Consuming streams
  