Patrón de uso de Observable<void> en Typescript

Cuando un servicio asíncrono no tiene valor de retorno pero quiero usar Observables, tiendo a usar Observable<boolean>. Pero no tengo un significado para este valor booleano porque el servicio o bien falla o bien tiene éxito, y si falla quiero que el Observable esté en estado de error. Esto deja solo valores 'true' para el booleano observado.

¿Es el siguiente uso de Observable<void> un buen patrón para estas situaciones? ¿O son previsibles problemas con el uso de Observable<void>?

const asyncFuncWithoutResult = (): Observable<void> => {
  // fake something async that has no return value

  const itWorked = true; // or not
  if (itWorked) {
    return Observable.of();
  } else {
    return Observable.throw(Error('It did not work'));
  }
}

// call the service
asyncFuncWithoutResult()
  .subscribe(
    undefined, // nothing will be emitted when using Observable.of()
    (err: any) => console.error(err), // handle error state
    () => console.log('Success'),     // handle success state
  );

Respuesta #1

Solo para ser más preciso, cuando defines un Subject con tipo genérico void, hay dos formas de llamar a su método next() y eso es sin ningún argumento:

const subject = new Subject<void>();
subject.next();

...o con void 0:

subject.next(void 0);

De hecho, el argumento value de next es opcional, así que si no lo especificas enviará undefined, lo que significa que incluso si tienes Subject<void> todavía recibirás notificaciones de next:

asyncFuncWithoutResult().subscribe(alawaysUndefined => {
  /* ... */
});

También tenga en cuenta que puede convertir cualquier Observable en <void> (esto es necesario cuando desea combinar múltiples Observables) mediante map:

source.pipe(map(() => void 0))
   ...