throw-in-mergemap.js

function epic(actions){
  return actions.ofType('FOO')
    .mergeMap(action => {
      const transformed = transform(action); // may throw collapsing the pipe
      return makeThingDoAsyncy(transform)
        .catch(e => [foo(e)]); // won't catch above
    });
}

// imperative
function epic(actions){
  return actions.ofType('FOO')
    .mergeMap(action => {
      try {
        const transformed = transform(action);
      } catch(e) {
        return Observable.of(foo(e)); // have to handle errors twice
      }
      return makeThingDoAsyncy(transform)
        .catch(e => [foo(e)]); // won't catch above
    });
}

// declarative
function epic(actions){
  return actions.ofType('FOO')
    .mergeMap(action => {
      return Observable.defer(() => {
        const transformed = transform(action); //errors are thrown in subpipe
        return makeThingDoAsyncy(transform);
      })
        .catch(e => [foo(e)]); // catches all errors
    });
}

Ah, nice. I like this.

In this case, is there any difference between defer and chaining of/map/mergeMap?

      return Observable.defer(() => {
        const transformed = transform(action); //errors are thrown in subpipe
        return makeThingDoAsyncy(transform);
      })
        .catch(e => [foo(e)]); // catches all errors

and

      return Observable.of(action)
        .map(transform)
        .mergeMap(makeThingDoAsyncy)
        .catch(e => [foo(e)]); // catches all errors

Both accomplish the same thing. You second example is much more declarative, though

Gotcha. Thanks, this is great