FiberMap
Manages fibers by key inside a scope.
A FiberMap<K, A, E> owns a map of running fibers, interrupts them when its scope closes, and automatically removes each entry when the corresponding fiber completes. Use it when a program needs to start, replace, join, or interrupt background work by a stable key while keeping all fibers tied to one scope.
Combinators
awaitEmpty
Signature
declare function awaitEmpty<K, A, E>(self: FiberMap<K, A, E>): Effect<void, E>;Removes all fibers from the FiberMap, interrupting them.
Signature
declare function clear<K, A, E>(self: FiberMap<K, A, E>): Effect<void>;Retrieves a fiber from the FiberMap effectfully.
Details
Returns an Option wrapped in Effect.
Signature
declare const get: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect<Option<Fiber<A, E>>>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Effect<Option<Fiber<A, E>>>;
};Retrieves a fiber from the FiberMap synchronously.
When to use
Use when synchronous keyed lookup of a fiber in a FiberMap is needed and an Option result is enough outside the Effect workflow.
Signature
declare const getUnsafe: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option<Fiber<A, E>>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Option<Fiber<A, E>>;
};Checks whether a key exists in the FiberMap. This is the Effect-wrapped version of hasUnsafe.
Signature
declare const has: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect<boolean>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Effect<boolean>;
};Checks whether a key exists in the FiberMap.
Signature
declare const hasUnsafe: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => boolean;
<K, A, E>(self: FiberMap<K, A, E>, key: K): boolean;
};Waits for the FiberMap to fail or close.
Details
The returned Effect fails with the first managed fiber failure that is not ignored by the map's interruption rules. Normal successful completion removes fibers from the map; use awaitEmpty to wait until the map has no fibers.
Signature
declare function join<K, A, E>(self: FiberMap<K, A, E>): Effect<void, E>;Removes a fiber from the FiberMap, interrupting it if it exists.
Signature
declare const remove: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect<void>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Effect<void>;
};Forks an Effect and stores the resulting fiber in the FiberMap under a key.
Details
When the fiber completes, it is removed from the map. If the key already has a fiber, the previous fiber is interrupted unless onlyIfMissing is set.
Signature
declare const run: {
<K, A, E>(
self: FiberMap<K, A, E>,
key: K,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
readonly startImmediately?: boolean;
},
): <R, XE, XA>(effect: Effect<XA, XE, R>) => Effect<Fiber<XA, XE>, never, R>;
<K, A, E, R, XE, XA>(
self: FiberMap<K, A, E>,
key: K,
effect: Effect<XA, XE, R>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
readonly startImmediately?: boolean;
},
): Effect<Fiber<XA, XE>, never, R>;
};Captures the current runtime and returns a function for forking effects into an existing FiberMap.
Details
Each call stores the forked fiber under the supplied key. If that key already has a fiber, the previous fiber is interrupted unless onlyIfMissing is set.
Signature
declare const runtime: <K, A, E>(
self: FiberMap<K, A, E>,
) => <R = never>() => Effect.Effect<
<XE extends E, XA extends A>(
key: K,
effect: Effect.Effect<XA, XE, R>,
options?: Effect.RunOptions & {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
) => Fiber.Fiber<XA, XE>,
never,
R
>;runtimePromise
Captures the current runtime and returns a function for running effects in an existing FiberMap as Promises.
Details
Each call stores the forked fiber under the supplied key, interrupting any previous fiber for that key unless onlyIfMissing is set. The Promise resolves with the effect's success value or rejects with the squashed failure cause.
Signature
declare function runtimePromise<K, A, E>(
self: FiberMap<K, A, E>,
): <R = never>() => Effect<
<XE, XA>(
key: K,
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
) => Promise<XA>,
never,
R
>;Adds a fiber to the FiberMap under a key.
Details
When the fiber completes, it is removed from the map. If the key already has a fiber, that previous fiber is interrupted unless onlyIfMissing is set; in that case the new fiber is interrupted and the existing entry is kept.
This is the Effect-wrapped version of setUnsafe.
Signature
declare const set: {
<K, A, E, XE, XA>(
key: K,
fiber: Fiber<XA, XE>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): (self: FiberMap<K, A, E>) => Effect<void>;
<K, A, E, XE, XA>(
self: FiberMap<K, A, E>,
key: K,
fiber: Fiber<XA, XE>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): Effect<void>;
};Adds a fiber to the FiberMap under a key using a synchronous, unsafe mutation.
When to use
Use when an existing forked fiber must be installed under a key immediately and synchronous interruption of the replaced fiber is acceptable.
Details
When the fiber completes, it is removed from the map. If the key already has a fiber, that previous fiber is interrupted unless onlyIfMissing is set; in that case the new fiber is interrupted and the existing entry is kept.
Signature
declare const setUnsafe: {
<K, A, E, XE, XA>(
key: K,
fiber: Fiber<XA, XE>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): (self: FiberMap<K, A, E>) => void;
<K, A, E, XE, XA>(
self: FiberMap<K, A, E>,
key: K,
fiber: Fiber<XA, XE>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): void;
};Gets the number of fibers currently in the FiberMap.
Signature
declare function size<K, A, E>(self: FiberMap<K, A, E>): Effect<number>;Constructors
Creates a scoped FiberMap for storing fibers by key.
Details
When the associated Scope is closed, all fibers in the map will be interrupted. You can add fibers to the map using FiberMap.set or FiberMap.run, and the fibers will be automatically removed from the FiberMap when they complete.
Signature
declare function make<K, A = unknown, E = unknown>(): Effect<FiberMap<K, A, E>, never, Scope>;makeRuntime
Creates a scoped run function that forks effects into a new FiberMap.
Details
Each call stores the forked fiber under the supplied key and returns that fiber. If the key already has a fiber, the previous fiber is interrupted unless onlyIfMissing is set. All managed fibers are interrupted when the map's scope closes.
Signature
declare function makeRuntime<R, K, E = unknown, A = unknown>(): Effect<
<XE, XA>(
key: K,
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly onlyIfMissing?: boolean;
},
) => Fiber<XA, XE>,
never,
Scope | R
>;makeRuntimePromise
Creates a scoped run function that forks effects into a new FiberMap and returns a Promise for each effect result.
When to use
Use when keyed fibers must be managed in a scoped map while exposing their results through Promise-based APIs.
Details
Each call stores the fiber under the supplied key, interrupting any previous fiber for that key unless onlyIfMissing is set. The returned Promise resolves with the effect's success value or rejects with the squashed failure cause.
Signature
declare function makeRuntimePromise<R, K, A = unknown, E = unknown>(): Effect<
<XE, XA>(
key: K,
effect: Effect<XA, XE, R>,
options?: RunOptions & {
readonly onlyIfMissing?: boolean;
},
) => Promise<XA>,
never,
Scope | R
>;Guards
isFiberMap
Returns true if a value is a FiberMap.
Details
This is a type guard that checks for the FiberMap runtime marker.
Signature
declare function isFiberMap(u: unknown): u is FiberMap<unknown, unknown, unknown>;Models
A FiberMap is a collection of fibers, indexed by a key. When the associated Scope is closed, all fibers in the map will be interrupted. Fibers are automatically removed from the map when they complete.
Signature
interface FiberMap<in out K, out A = unknown, out E = unknown> extends Pipeable, Inspectable, "/home/runner/work/website/website/.effect-source-v4/packages/effect/src/Iterable"<[K, Fiber.Fiber<A, E>]> {
readonly "~effect/FiberMap": "~effect/FiberMap";
readonly deferred: Deferred<void, unknown>;
state: {
readonly _tag: "Open";
readonly backing: MutableHashMap<K, Fiber<A, E>>;
} | {
readonly _tag: "Closed";
};
}
Waits for the FiberMap to be empty. This will wait for all currently running fibers to complete.