call method

Effect call(
  1. Iterable<Bloom> targets,
  2. void action(
    1. EffectScope scope
    ), {
  3. bool guard()?,
  4. int? take,
  5. void onUncaughtError(
    1. Object error,
    2. StackTrace stackTrace
    )?,
})

Creates a manifest Effect attached strictly to explicit targets providing an EffectScope.

  • Skips initial evaluation (0 runs upon construction/mount).

  • Executes action with an injected EffectScope in an untracked environment when any of targets mutate.

  • Prior to subsequent evaluations or deactivation, the previous turn's EffectScope is marked cancelled and its registered cleanup callbacks are executed in LIFO order.

  • If guard is provided and returns false, execution is skipped and take tickets are preserved.

  • If take is provided, executes at most take times and then automatically deactivates (Early Teardown).

  • If onUncaughtError is provided, it is invoked on uncaught exceptions.

  • targets: The reactive Bloom nodes to monitor for mutations.

  • action: The untracked callback receiving an EffectScope to invoke upon mutation.

  • guard: Optional boolean predicate gating execution.

  • take: Optional limit on execution count before automatic deactivation.

  • onUncaughtError: Optional error recovery handler.

Requires:

  • If take is provided, it must be greater than or equal to 0.

Ensures:

  • Returns a scoped Effect bound to targets.

Throws:

Examples

final room = blooming('lobby');
final e = Effect.scoped([room.bloom], (scope) {
  final timer = Timer.periodic(const Duration(seconds: 5), (_) => ping());
  scope.onCleanup(timer.cancel);
});

Implementation

@pragma('vm:prefer-inline')
Effect call(
  Iterable<Bloom> targets,
  void Function(EffectScope scope) action, {
  bool Function()? guard,
  int? take,
  void Function(Object error, StackTrace stackTrace)? onUncaughtError,
}) =>
    _HandledManifestEffect(
      targets,
      action,
      guard: guard,
      take: take,
      onUncaughtError: onUncaughtError,
    );