acumulación — `zipOrAccumulate` & compañía

La validación quiere todos los errores, no solo el primero. Estas operaciones ejecutan todas las ramas y concatenan los fallos en un NonEmptyList — el sustituto que Arrow 2.x ofrece en lugar de un tipo Validated aparte.

on Raise<Nel<E>>: R accumulate<R>(R Function(Accumulator<E> acc) block) R zipOrAccumulate2..5(branch1, …, combine) List<B> mapOrAccumulate<A, B>(items, transform) · A bindNel<A>(EitherNel<E, A> e) on Accumulator<E>: accumulating(block) · dependent(block) · hasErrors

Lección

Dentro de either<Nel<E>, _>(...) — cualquier ámbito cuyo tipo de error sea un NonEmptyList — el ámbito gana el vocabulario de acumulación:

r.zipOrAccumulate2..5(branches…, combine) — ejecuta N ramas independientes, informa de todos los fallos y combina los aciertos.
r.accumulate((acc) { … }) — la forma general: ejecuta las ramas con acc.accumulating(block) y después lee el .value de cada resultado. Si algo falló, leer un valor (o llegar al final del bloque) eleva la lista completa de errores.
r.mapOrAccumulate(items, transform) — valida una colección entera en modo fail-slow.
r.bindNel(eitherNel) — desenvuelve un EitherNel, elevando todos sus errores de golpe; someEither.toEitherNel() permite introducir un valor fail-fast.

El contrato es el de Arrow: todas las ramas se ejecutan (los errores se concatenan en el orden de las ramas), una rama que lanza una excepción en vez de elevar un error gana sobre la acumulación y, tras el primer error, los resultados correctos ya no se conservan: la iteración continúa solo para recoger los errores restantes.

Demo 1 · zipOrAccumulate2

Demo 2 · accumulate — la forma general

import 'package:fxdart/fxdart.dart';

// The general form: open an accumulating scope with r.accumulate, run each
// branch with acc.accumulating, combine the .value results at the end.
EitherNel<String, String> validate(Map<String, String> input) =>
    either((r) => r.accumulate((acc) {
          final name = acc.accumulating((r) {
            final v = r.ensureNotNull(input['name'], () => 'name missing');
            r.ensure(v.isNotEmpty, () => 'name is empty');
            return v;
          });
          final age = acc.accumulating((r) {
            final raw = r.ensureNotNull(input['age'], () => 'age missing');
            return r.ensureNotNull(
                int.tryParse(raw), () => 'age is not a number');
          });
          // Reading .value raises the FULL error list if anything failed:
          return '${name.value} (${age.value})';
        }));

void main() {
  print(validate({'name': 'kim', 'age': '30'})); // Right(kim (30))
  print(validate({'name': '', 'age': 'abc'}));
  // Left([name is empty, age is not a number])
}

Demo 3 · mapOrAccumulate, bindNel & toEitherNel

Demo 4 · dependent — reglas que leen valores hermanos

Una rama no puede leer el Accumulated.value de una hermana sin detonar — la única regla dura de la acumulación. Pero la validación real tiene reglas dependientes ("un gasto necesita un importe positivo"), y por eso los formularios acababan bajando a un guard manual if (!acc.hasErrors). acc.dependent(block) le pone nombre a ese guard: el bloque corre solo cuando todas las ramas anteriores tuvieron éxito — así las lecturas de .value hermanas dentro son seguras por construcción — y se salta por completo en caso contrario. (Sin contraparte en Arrow; sus usuarios escriben el mismo guard a mano.)

import 'package:fxdart/fxdart.dart';

/// Two independent branches plus one rule that DEPENDS on both: an expense
/// needs a positive amount. Reading a sibling's .value is only safe once
/// every earlier branch succeeded — dependent runs its block exactly then.
EitherNel<String, String> classify(String type, String rawAmount) =>
    either<Nel<String>, String>((r) => r.accumulate((acc) {
          final t = acc.accumulating((br) => br.ensureNotNull(
              {'expense', 'income'}.contains(type) ? type : null,
              () => 'unknown type: $type'));
          final a = acc.accumulating((br) => br.ensureNotNull(
              double.tryParse(rawAmount), () => 'bad amount: $rawAmount'));

// was: if (!acc.hasErrors) { acc.accumulating((br) => ...); }
          acc.dependent((br) {
            br.ensure(t.value != 'expense' || a.value > 0,
                () => 'an expense needs a positive amount');
            return null;
          });

return '${t.value} of ${a.value}';
        }));

void main() {
  print(classify('expense', '12.5')); // Right(expense of 12.5)
  print(classify('expense', '-3'));
  // Left([an expense needs a positive amount])

// Both independent branches fail — the dependent rule never runs, so
  // the report holds exactly the independent errors:
  print(classify('meal', 'x')); // Left([unknown type: meal, bad amount: x])
}

Pruébalo tú

Ejercicio: completa las dos ramas de signup para que la segunda llamada informe de ambos fallos.

Relacionado: NonEmptyList — el portador de los errores · Either × pipelines — validación fail-slow sobre cadenas fx(), con concurrencia · either & Raise — el ámbito fail-fast que esto extiende · errores tipados — guía completa

acumulación — zipOrAccumulate & compañía

Lección

Demo 1 · zipOrAccumulate2

Demo 2 · accumulate — la forma general

Demo 3 · mapOrAccumulate, bindNel & toEitherNel

Demo 4 · dependent — reglas que leen valores hermanos

Pruébalo tú

acumulación — `zipOrAccumulate` & compañía