Search documentation

Search by topic, API name, or import path.

GitHub ↗

variable / @typed/fx/Fx

gen

Builds an Fx by yielding Effects and returning the Fx to run afterward.

Package version
2.0.0-beta.7
Category
Generator composition
Since
1.0.0

Follow one execution

Yield setup Effects once per run, then run the returned Fx. A yielded failure prevents selection.

Fx timelinegen(function* () { return selected })gen
Operatorgen(function* () { return selected })
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.

The generator is lazy: it runs for each subscription. Yielded Effects run first; only their returned Fx is then subscribed. A setup failure prevents the Fx from starting, and interruption cancels the active phase. Resources acquired by yielded Effects must not escape unless managed independently; use genScoped when setup and the returned Fx share a Scope.

Source implementation · Learn the surrounding model

Compare all Fx timelines →

Import

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

Signatures

export declare const gen: <Yield extends Effect.Effect<any, any, any>, Return extends Fx.Any>(f: () => Generator<Yield, Return, any>) => Fx<Fx.Success<Return>, Fx.Error<Return> | ([
    Yield
] extends [
    never
] ? never : Effect.Error<Yield>), Fx.Services<Return> | ([
    Yield
] extends [
    never
] ? never : Effect.Services<Yield>)>;

Why

Setup logic often needs Effect services or failures before it can choose a push producer. Generator notation keeps that dependency-aware setup linear while preserving the returned Fx’s success, error, and service channels.

Ownership and lifetime

The generator is lazy: it runs for each subscription. Yielded Effects run first; only their returned Fx is then subscribed. A setup failure prevents the Fx from starting, and interruption cancels the active phase. Resources acquired by yielded Effects must not escape unless managed independently; use {@link genScoped } when setup and the returned Fx share a Scope.

Examples

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

const greeting = gen(function* () {
  const name = yield* Effect.succeed("Typed")
  return succeed(`Hello, ${name}`)
})

Other public imports

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

Source