FiberMap
Other
awaitEmpty
Signature
declare function awaitEmpty<K, A, E>(self: FiberMap<K, A, E>): Effect<void, E>;Signature
declare function clear<K, A, E>(self: FiberMap<K, A, E>): Effect<void>;Signature
interface FiberMap<in out K, out A = unknown, out E = unknown> extends Pipeable, Inspectable, "/home/runner/work/website/website/.effect-source-v3/packages/effect/src/Iterable"<[K, Fiber.RuntimeFiber<A, E>]> {
readonly [TypeId]: typeof TypeId;
readonly deferred: Deferred<void, unknown>;
}Retrieve a fiber from the FiberMap.
Signature
declare const get: {
<K>(
key: K,
): <A, E>(self: FiberMap<K, A, E>) => Effect<RuntimeFiber<A, E>, NoSuchElementException>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Effect<RuntimeFiber<A, E>, NoSuchElementException>;
};Check if a key exists in the FiberMap.
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>;
};isFiberMap
Signature
declare function isFiberMap(u: unknown): u is FiberMap<unknown, unknown, unknown>;Join all fibers in the FiberMap. If any of the Fiber's in the map terminate with a failure, the returned Effect will terminate with the first failure that occurred.
Signature
declare function join<K, A, E>(self: FiberMap<K, A, E>): Effect<void, E>;A FiberMap can be used to store a collection of fibers, indexed by some key. 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
Create an Effect run function that is backed by a FiberMap.
Signature
declare function makeRuntime<R, K, E = unknown, A = unknown>(): Effect<
<XE, XA>(
key: K,
effect: Effect<XA, XE, R>,
options?: RunForkOptions & {
readonly onlyIfMissing?: boolean;
},
) => RuntimeFiber<XA, XE>,
never,
Scope | R
>;makeRuntimePromise
Create an Effect run function that is backed by a FiberMap.
Signature
declare function makeRuntimePromise<R, K, A = unknown, E = unknown>(): Effect<
<XE, XA>(
key: K,
effect: Effect<XA, XE, R>,
options?: RunForkOptions & {
readonly onlyIfMissing?: boolean;
},
) => Promise<XA>,
never,
Scope | R
>;Remove 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>;
};Run an Effect and add the forked fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
Signature
declare const run: {
<K, A, E>(
self: FiberMap<K, A, E>,
key: K,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): <R, XE, XA>(effect: Effect<XA, XE, R>) => Effect<RuntimeFiber<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;
},
): Effect<RuntimeFiber<XA, XE>, never, R>;
};Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
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?: Runtime.RunForkOptions & {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
) => Fiber.RuntimeFiber<XA, XE>,
never,
R
>;Example
import { Context, Effect, FiberMap } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.GenericTag<
Users,
{
getAll: Effect.Effect<Array<unknown>>
}
>("Users")
Effect.gen(function* () {
const map = yield* FiberMap.make<string>()
const run = yield* FiberMap.runtime(map)<Users>()
// run some effects and add the fibers to the map
run(
"effect-a",
Effect.andThen(Users, (_) => _.getAll),
)
run(
"effect-b",
Effect.andThen(Users, (_) => _.getAll),
)
}).pipe(
Effect.scoped, // The fibers will be interrupted when the scope is closed
)runtimePromise
Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberMap.
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?: RunForkOptions & {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
) => Promise<XA>,
never,
R
>;Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. If the key already exists in the FiberMap, the previous fiber will be interrupted.
Signature
declare const set: {
<K, A, E, XE, XA>(
key: K,
fiber: RuntimeFiber<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: RuntimeFiber<XA, XE>,
options?: {
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): Effect<void>;
};Signature
declare function size<K, A, E>(self: FiberMap<K, A, E>): Effect<number>;Signature
declare const TypeId: unique symbol;Signature
type TypeId = typeof TypeId;Retrieve a fiber from the FiberMap.
Signature
declare const unsafeGet: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option<RuntimeFiber<A, E>>;
<K, A, E>(self: FiberMap<K, A, E>, key: K): Option<RuntimeFiber<A, E>>;
};Check if a key exists in the FiberMap.
Signature
declare const unsafeHas: {
<K>(key: K): <A, E>(self: FiberMap<K, A, E>) => boolean;
<K, A, E>(self: FiberMap<K, A, E>, key: K): boolean;
};Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap. If the key already exists in the FiberMap, the previous fiber will be interrupted.
Signature
declare const unsafeSet: {
<K, A, E, XE, XA>(
key: K,
fiber: RuntimeFiber<XA, XE>,
options?: {
readonly interruptAs?: FiberId.FiberId;
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: RuntimeFiber<XA, XE>,
options?: {
readonly interruptAs?: FiberId.FiberId;
readonly onlyIfMissing?: boolean;
readonly propagateInterruption?: boolean;
},
): void;
};
Wait for the FiberMap to be empty.