anchor.diff:  <2> ...the rest of the loops is skipped...
   <3> ...and the execution goes straight to here.
   
  -Now that we've established a parallel, you may be familiar with several ways of
  -dealing with exceptions in a try/catch block. Most notably:
  -
  - 1. catch and return a default value
  - 2. catch and execute an alternative path (fallback method)
  - 3. catch, wrap to a `BusinessException` and re-throw
  - 4. catch, log an error specific message and re-throw
  - 5. the `finally` block to clean up resources, or a Java 7's "try-with-resource" construct
  -
  -All of these have equivalent in Reactor, in the form of error handling operators.
  -
  -==== Default value
  +Now that we've established a parallel, we'll look at the different error handling
  +cases and their equivalent operators.
  +
  +==== Static fallback value
   The equivalent of **(1)** is `onErrorReturn`:
   [source,java]
   ----
  
positive.code: ==== Using resources and the finally block
  The last parallel to draw with the imperative world is the cleaning up that can
  be done either via a Java 7 "try-with-resources" construct or the use of the
  `finally` block (*(5)*). Both have their Reactor equivalent, actually: `using`
  and `doFinally`:
  [source,java]
  ----
  
negative.code: ==== Log or react on the side
  For cases where you want the error to continue propagating, but you still want
  to react to it without modifying the sequence (for instance logging it like in
  item *(5)*), there is the `doOnError` operator. This operator as well as all
  `doOn` prefixed operators are sometimes referred to as a "side-effect". That is
  because they allow to peek inside the sequence's events without modifying them.
  
  