<A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>Waits for the FiberHandle to fail or close.
Details
The returned Effect fails with the first managed fiber failure that is not
ignored by the handle's interruption rules. Normal successful completion of
a managed fiber only removes it from the handle; use awaitEmpty to wait
for the current fiber to finish.
Example (Propagating fiber failures)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
yield* FiberHandle.set(handle, Effect.runFork(Effect.fail("error")))
// parent fiber will fail with "error"
yield* FiberHandle.join(handle)
})export const const join: <A, E>(
self: FiberHandle<A, E>
) => Effect.Effect<void, E>
Waits for the FiberHandle to fail or close.
Details
The returned Effect fails with the first managed fiber failure that is not
ignored by the handle's interruption rules. Normal successful completion of
a managed fiber only removes it from the handle; use awaitEmpty to wait
for the current fiber to finish.
Example (Propagating fiber failures)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
yield* FiberHandle.set(handle, Effect.runFork(Effect.fail("error")))
// parent fiber will fail with "error"
yield* FiberHandle.join(handle)
})
join = <function (type parameter) A in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>A, function (type parameter) E in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>E>(self: FiberHandle<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; fiber: Fiber.Fiber<A, E> | undefined } | { readonly _tag: "Closed" };
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface FiberHandle<out A = unknown, out E = unknown>Scoped handle that manages at most one fiber, interrupts the current fiber
when the handle's scope closes, and removes managed fibers from the handle
when they complete.
Example (Managing a single fiber)
import { Effect, Fiber, FiberHandle } from "effect"
Effect.gen(function*() {
// Create a FiberHandle that can hold fibers producing strings
const handle = yield* FiberHandle.make<string, never>()
// The handle can store and manage a single fiber
const fiber = yield* FiberHandle.run(handle, Effect.succeed("hello"))
const result = yield* Fiber.await(fiber)
console.log(result) // "hello"
})
FiberHandle<function (type parameter) A in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>A, function (type parameter) E in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>E>): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<void, function (type parameter) E in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>E> =>
import DeferredDeferred.await(self: FiberHandle<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; fiber: Fiber.Fiber<A, E> | undefined } | { readonly _tag: "Closed" };
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
FiberHandle<out A = unknown, out E = unknown>.deferred: Deferred.Deferred<void, unknown>(property) FiberHandle<out A = unknown, out E = unknown>.deferred: {
effect: Effect<A, E>;
resumes: Array<(effect: Effect<A, E>) => void> | undefined;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import DeferredDeferred.type Deferred.Deferred = /*unresolved*/ anyDeferred<void, function (type parameter) E in <A, E>(self: FiberHandle<A, E>): Effect.Effect<void, E>E>)