FiberSet
Manages many fibers together inside one scope.
A FiberSet<A, E> tracks running fibers, removes each fiber when it completes, and interrupts all still-running fibers when the owning scope closes. This module includes scoped runtime constructors plus helpers for adding, clearing, running, counting, joining, and waiting for managed fibers.
Combinators
Signature
declare const add: {
<A, E, XE, XA>(
fiber: Fiber<XA, XE>,
options?: {
readonly propagateInterruption?: boolean;
},
): (self: FiberSet<A, E>) => Effect<void>;
<A, E, XE, XA>(
self: FiberSet<A, E>,
fiber: Fiber<XA, XE>,
options?: {
readonly propagateInterruption?: boolean;
},
): Effect<void>;
};Adds an existing fiber to the FiberSet using a synchronous, unsafe mutation.
When to use
Use when an already forked fiber must be registered immediately and synchronous interruption on a closed set is acceptable.
Details
When the fiber completes, it is removed from the set. If the set is already closed, the supplied fiber is interrupted immediately. Non-interruption failures are recorded for FiberSet.join.
Signature
declare const addUnsafe: {
<A, E, XE, XA>(
fiber: Fiber<XA, XE>,
options?: {
readonly propagateInterruption?: boolean;
},
): (self: FiberSet<A, E>) => void;
<A, E, XE, XA>(
self: FiberSet<A, E>,
fiber: Fiber<XA, XE>,
options?: {
readonly propagateInterruption?: boolean;
},
): void;
};awaitEmpty
Waits until the fiber set is empty.
Signature
declare function awaitEmpty<A, E>(self: FiberSet<A, E>): Effect<void>;Interrupts all fibers in the FiberSet and clears the set.
Signature
declare function clear<A, E>(self: FiberSet<A, E>): Effect<void>;Joins all fibers in the FiberSet. If any fiber in the set terminates with a failure, the returned Effect will terminate with the first failure that occurred.
Signature
declare function join<A, E>(self: FiberSet<A, E>): Effect<void, E>;Forks an Effect and add the forked fiber to the FiberSet. When the fiber completes, it will be removed from the FiberSet.
Signature
declare const run: {
<A, E>(
self: FiberSet<A, E>,
options?: {
readonly propagateInterruption?: boolean;
readonly startImmediately?: boolean;
},
): <R, XE, XA>(effect: Effect<XA, XE, R>) => Effect<Fiber<XA, XE>, never, R>;
<A, E, R, XE, XA>(
self: FiberSet<A, E>,
effect: Effect<XA, XE, R>,
options?: {
readonly propagateInterruption?: boolean;
readonly startImmediately?: boolean;
},
): Effect<Fiber<XA, XE>, never, R>;
};Captures a Runtime and uses it to fork effects into the FiberSet.
Signature
declare const runtime: <A, E>(
self: FiberSet<A, E>,
) => <R = never>() => Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?: Effect.RunOptions & {
readonly propagateInterruption?: boolean;
},
) => Fiber.Fiber<XA, XE>,
never,
R
>;runtimePromise
Captures a Runtime and returns a Promise-based runner that forks effects into the FiberSet.
When to use
Use when you need to bridge effects to Promise values while still tracking their fibers in a FiberSet.
Details
The returned run function returns a Promise for each effect result.
See
runtimefor a runner that returns the forkedFiber
Signature
declare function runtimePromise<A, E>(
self: FiberSet<A, E>,
): <R = never>() => Effect<
<XE, XA>(
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly propagateInterruption?: boolean;
},
) => Promise<XA>,
never,
R
>;Gets the number of fibers currently in the FiberSet.
Signature
declare function size<A, E>(self: FiberSet<A, E>): Effect<number>;Constructors
Creates a scoped FiberSet for storing fibers.
Details
When the associated Scope is closed, all fibers in the set will be interrupted. You can add fibers to the set using FiberSet.add or FiberSet.run, and the fibers will be automatically removed from the FiberSet when they complete.
Signature
declare function make<A = unknown, E = unknown>(): Effect<FiberSet<A, E>, never, Scope>;makeRuntime
Creates a scoped run function that forks effects into a new FiberSet.
Details
Each call returns the forked fiber and adds it to the set. Managed fibers are removed when they complete and are interrupted when the set's scope closes.
Signature
declare function makeRuntime<R = never, A = unknown, E = unknown>(): Effect<
<XE, XA>(
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly propagateInterruption?: boolean;
},
) => Fiber<XA, XE>,
never,
Scope | R
>;makeRuntimePromise
Creates a scoped run function that forks effects into a new FiberSet and returns a Promise for each effect result.
When to use
Use when many scoped fibers should be tracked as a set while exposing each result through Promise-based APIs.
Details
Managed fibers are removed when they complete and are interrupted when the set's scope closes. Each Promise resolves with the effect's success value or rejects with the squashed failure cause.
Signature
declare function makeRuntimePromise<R = never, A = unknown, E = unknown>(): Effect<
<XE, XA>(
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly propagateInterruption?: boolean;
},
) => Promise<XA>,
never,
Scope | R
>;Guards
isFiberSet
Checks whether a value is a FiberSet.
Signature
declare function isFiberSet(u: unknown): u is FiberSet<unknown, unknown>;Models
A FiberSet is a collection of fibers that can be managed together. When the associated Scope is closed, all fibers in the set will be interrupted.
Signature
interface FiberSet<out A = unknown, out E = unknown> extends Pipeable, Inspectable, "/home/runner/work/website/website/.effect-source-v4/packages/effect/src/Iterable"<Fiber.Fiber<A, E>> {
readonly "~effect/FiberSet": "~effect/FiberSet";
readonly deferred: Deferred<void, unknown>;
state: {
readonly _tag: "Open";
readonly backing: Set<Fiber<A, E>>;
} | {
readonly _tag: "Closed";
};
}
Adds a fiber to the FiberSet. When the fiber completes, it will be removed.