<R, E = unknown, A = unknown>(): Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| {
readonly signal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefined
readonly onlyIfMissing?: boolean | undefined
readonly propagateInterruption?: boolean | undefined
}
| undefined
) => Fiber.Fiber<XA, XE>,
never,
Scope.Scope | R
>Creates a scoped run function that forks effects into a new FiberHandle.
Details
Each call returns the forked fiber, stores it in the handle, and interrupts
the previous fiber unless onlyIfMissing is set. The managed fiber is
interrupted when the handle's scope closes.
Example (Running effects with a fiber handle)
import { Effect, Fiber, FiberHandle } from "effect"
Effect.gen(function*() {
const run = yield* FiberHandle.makeRuntime<never>()
// Run effects and get fibers back
const fiberA = run(Effect.succeed("first"))
const fiberB = run(Effect.succeed("second"))
// The second fiber will interrupt the first
const resultA = yield* Fiber.await(fiberA)
const resultB = yield* Fiber.await(fiberB)
}).pipe(Effect.scoped)constructors
Source effect/FiberHandle.ts:18419 lines
export const const makeRuntime: <
R,
E = unknown,
A = unknown
>() => Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| {
readonly signal?:
| AbortSignal
| undefined
readonly scheduler?:
| Scheduler
| undefined
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
) => Fiber.Fiber<XA, XE>,
never,
Scope.Scope | R
>
Creates a scoped run function that forks effects into a new FiberHandle.
Details
Each call returns the forked fiber, stores it in the handle, and interrupts
the previous fiber unless onlyIfMissing is set. The managed fiber is
interrupted when the handle's scope closes.
Example (Running effects with a fiber handle)
import { Effect, Fiber, FiberHandle } from "effect"
Effect.gen(function*() {
const run = yield* FiberHandle.makeRuntime<never>()
// Run effects and get fibers back
const fiberA = run(Effect.succeed("first"))
const fiberB = run(Effect.succeed("second"))
// The second fiber will interrupt the first
const resultA = yield* Fiber.await(fiberA)
const resultB = yield* Fiber.await(fiberB)
}).pipe(Effect.scoped)
makeRuntime = <function (type parameter) R in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) E in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) A in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
<function (type parameter) XE in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
function (type parameter) E in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) XA in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
function (type parameter) A in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
effect: Effect.Effect<XA, XE, R>(parameter) effect: {
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;
}
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<function (type parameter) XA in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
function (type parameter) XE in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
function (type parameter) R in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
options: | {
readonly signal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefined
readonly onlyIfMissing?: boolean | undefined
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
signal?: AbortSignal | undefinedsignal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefinedscheduler?: Scheduler | undefined
readonly onlyIfMissing?: boolean | undefinedonlyIfMissing?: boolean | undefined
readonly propagateInterruption?: boolean | undefinedpropagateInterruption?: boolean | undefined
}
| undefined
) => import FiberFiber.type Fiber.Fiber = /*unresolved*/ anyFiber<function (type parameter) XA in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
function (type parameter) XE in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Fiber.Fiber<XA, XE>
import ScopeScope.Scope | function (type parameter) R in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
import EffectEffect.flatMap(
const make: <
A = unknown,
E = unknown
>() => Effect.Effect<
FiberHandle<A, E>,
never,
Scope.Scope
>
Creates a scoped FiberHandle that can store a single fiber.
Details
When the associated Scope is closed, the contained fiber will be
interrupted. You can add a fiber to the handle using FiberHandle.run, and
the fiber will be automatically removed from the FiberHandle when it
completes.
Example (Creating a scoped fiber handle)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
// run some effects
yield* FiberHandle.run(handle, Effect.never)
// this will interrupt the previous fiber
yield* FiberHandle.run(handle, Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fiber will be interrupted when the scope is closed
)
make<function (type parameter) A in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) E in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
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;
}
const runtime: <A, E>(
self: FiberHandle<A, E>
) => <R = never>() => Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| {
readonly signal?:
| AbortSignal
| undefined
readonly scheduler?:
| Scheduler
| undefined
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
) => Fiber.Fiber<XA, XE>,
never,
R
>
Captures the current runtime and returns a function for forking effects into
an existing FiberHandle.
Details
Each call returns the forked fiber, stores it in the handle, and interrupts
the previous fiber unless onlyIfMissing is set.
Example (Capturing a runtime for fiber handles)
import { Context, Effect, FiberHandle } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.Service<Users, {
getAll: Effect.Effect<Array<unknown>>
}>("Users")
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
const run = yield* FiberHandle.runtime(handle)<Users>()
// run an effect and set the fiber in the handle
run(Effect.andThen(Users, (_) => _.getAll))
// this will interrupt the previous fiber
run(Effect.andThen(Users, (_) => _.getAll))
}).pipe(
Effect.scoped // The fiber will be interrupted when the scope is closed
)
runtime(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;
}
function (type parameter) R in <R, E = unknown, A = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>