`rights`, `lefts` & `separated`

Operadores conscientes de Either sobre una cadena de eventos de valores Either — desenrolla un lado, o divide ambos a la vez.

FxEvents<R> FxEvents<Either<L, R>>.rights() FxEvents<L> FxEvents<Either<L, R>>.lefts() (FxEvents<L> failures, FxEvents<R> successes) FxEvents<Either<L, R>>.separated()

Lección

Una vez que una cadena es FxEvents<Either<L, R>> — desde attempt o mapEither — estos tres operadores son las contrapartes del lado push de FxEitherOps. rights() conserva solo los éxitos, desenrollados; lefts() conserva solo los fallos, desenrollados; separated() divide en (failures, successes) — la forma Either de partition.

Aquí no viven terminales. pull() entrega la cadena a FxAsync, donde sequence() y flattenOrAccumulate() ya existen. Estos operadores se quedan en la capa de eventos para que una UI pueda escuchar éxitos y fallos como dos feeds.

separated() hereda las reglas de vida de partition: el record se devuelve de inmediato, escuchar cualquiera de los lados arranca la fuente, cancelar ambos la cancela, y un valor que pertenece a un lado al que nadie escucha se descarta en vez de almacenarse en búfer.

También hereda el fan-out de errores de partition: un evento de error no es un Either, así que va a cada lado que esté escuchando — un fallo aguas arriba aparece en ambas mitades. Llama a attempt aguas arriba cuando un fallo deba contarse una sola vez, como un Left en la mitad failures.

Demo 1 · rights y lefts

Demo 2 · separated divide ambas mitades

Pruébalo tú

Ejercicio: un evento de error se propaga a ambas mitades; attempt aguas arriba lo cuenta una sola vez.

import 'dart:async';

import 'package:fxdart/fxdart.dart';

Future<List<String>> drain(FxEvents<Object?> src) {
  final out = <String>[];
  final done = Completer<void>();
  src.listen(
    (v) => out.add('data $v'),
    onError: (Object e) => out.add('error $e'),
    onDone: done.complete,
  );
  return done.future.then((_) => out);
}

Future<void> main() async {
  // Exercise: an error *event* is not an Either, so separated fans it
  // out to every side currently listening. attempt upstream counts the
  // failure once, as a Left on the failures half.

final raw = StreamController<Either<String, int>>();
  final (rawFail, rawOk) = fxEvents(raw.stream).separated();
  final rawFailD = drain(rawFail);
  final rawOkD = drain(rawOk);
  raw
    ..add(const Right(1))
    ..addError('boom')
    ..add(const Right(2));
  await raw.close();
  print('without attempt');
  print(await rawFailD); // [error boom]
  print(await rawOkD); // [data 1, error boom, data 2]

final src = StreamController<int>();
  final (failures, successes) = fxEvents(
    src.stream,
  ).attempt<String>((e, _) => 'E:$e').separated();
  final failD = drain(failures);
  final okD = drain(successes);
  src
    ..add(1)
    ..addError('boom')
    ..add(2);
  await src.close();
  print('with attempt');
  print(await failD); // [data E:boom]
  print(await okD); // [data 1, data 2]
}

Relacionado: Either × pipelines — los gemelos del lado pull, más sequence y flattenOrAccumulate · partition — el primo predicado de separated() · attempt — convierte un evento de error para que cuente una sola vez, en la mitad failures

rights, lefts & separated

Lección

Demo 1 · rights y lefts

Demo 2 · separated divide ambas mitades

Pruébalo tú

`rights`, `lefts` & `separated`