Search documentation

Search by topic, API name, or import path.

GitHub ↗

variable / @typed/fx/Fx

loopEffect

Effectfully loops over an Fx with an accumulator, producing a new value for each element.

Package version
2.0.0-beta.13
Category
Stateful transforms
Since
1.0.0

Follow one execution

Effectfully loops over an Fx with an accumulator, producing a new value for each element.

Fx timelineloopEffect emits after each one-turn state transition resolvesloopEffect
OperatorloopEffect(position, oneTurnLabel)
Read this diagram

Follow each lane from left to right. Events stacked vertically share a tick; the green cursor marks the current time across every lane.

  • A value
    The text inside the pill is the emitted value.
  • Work starts
    The raised chevron starts an inner run (^ in the source).
  • The run returns
    The vertical bar ends this lane’s run.
  • A cause is delivered
    The exclamation mark belongs to this lane.
  • Work is interrupted
    The cross marks cancellation of this run.
  • Current time
    The line and diamond move together across all lanes.
  • Happening now
    A highlighted event is at the current tick.
  • Still ahead
    Muted, dashed values have not happened yet.
  • Time continues
    The lane’s arrow is not a return marker. An empty stretch can be quiet work that is still running.

Illustrated ticks start at 0. At 1×, one illustrated tick takes one second; captions specify real durations when timing matters. A cause or interruption belongs to its lane, and other work may continue. Scroll horizontally to inspect the rest of a long timeline.

One mutable seed is retained per run. Each callback Effect follows its invoking delivery; failure is sent to the Sink, services remain required, and interruption does not provide a global lock.

Source implementation · Learn the surrounding model

Compare all Fx timelines →

Import

import { loopEffect } from "@typed/fx/Fx";

Signatures

export declare const loopEffect: {
    <B, A, E2, R2, C>(seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [
        C,
        B
    ], E2, R2>): <E, R>(self: Fx<A, E | E2, R>) => Fx<C, E | E2, R | R2>;
    <A, E, R, B, C>(self: Fx<A, E, R>, seed: B, f: (acc: B, a: A) => Effect.Effect<readonly [
        C,
        B
    ], E, R>): Fx<C, E, R>;
};

Why

loopEffect models an Effectful state transition without nested Fx values. It does not serialize producer callbacks: overlapping deliveries can read the same seed, complete out of order, and overwrite one another’s next state. Use a serialized producer when atomic accumulation matters.

Ownership and lifetime

One mutable seed is retained per run. Each callback Effect follows its invoking delivery; failure is sent to the Sink, services remain required, and interruption does not provide a global lock.

Examples

import { Effect } from "effect"
import { Fx } from "@typed/fx"

const concurrent = Fx.make<number>((sink) =>
  Effect.all([sink.onSuccess(1), sink.onSuccess(2)], { concurrency: "unbounded", discard: true })
)
const program = Fx.collectAll(
  concurrent.pipe(Fx.loopEffect(0, (sum, n) => Effect.succeed([sum + n, sum + n])))
) // both overlapping transitions may observe sum === 0

Other public imports

These import paths expose the same declaration. Each page retains its own public name and signature.

Source