<R = never, A = unknown, E = unknown>(): Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined
})
| undefined
) => Fiber.Fiber<XA, XE>,
never,
Scope.Scope | R
>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.
Example (Creating a scoped runtime)
import { Effect, Fiber, FiberSet } from "effect"
const program = Effect.gen(function*() {
const runFork = yield* FiberSet.makeRuntime()
// Fork effects using the runtime
const fiber1 = runFork(Effect.succeed("hello"))
const fiber2 = runFork(Effect.succeed("world"))
const result1 = yield* Fiber.await(fiber1)
const result2 = yield* Fiber.await(fiber2)
console.log(result1, result2) // "hello" "world"
})constructors
Source effect/FiberSet.ts:18912 lines
export const const makeRuntime: <
R = never,
A = unknown,
E = unknown
>() => Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
) => Fiber.Fiber<XA, XE>,
never,
Scope.Scope | R
>
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.
Example (Creating a scoped runtime)
import { Effect, Fiber, FiberSet } from "effect"
const program = Effect.gen(function*() {
const runFork = yield* FiberSet.makeRuntime()
// Fork effects using the runtime
const fiber1 = runFork(Effect.succeed("hello"))
const fiber2 = runFork(Effect.succeed("world"))
const result1 = yield* Fiber.await(fiber1)
const result2 = yield* Fiber.await(fiber2)
console.log(result1, result2) // "hello" "world"
})
makeRuntime = <function (type parameter) R in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) A in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) E in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
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?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Fiber.Fiber<XA, XE>
function (type parameter) E in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
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?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Fiber.Fiber<XA, XE>
function (type parameter) A in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
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?: (Effect.RunOptions & {
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?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Fiber.Fiber<XA, XE>
function (type parameter) R in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
options: | (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
import EffectEffect.type Effect.RunOptions = /*unresolved*/ anyRunOptions & { 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?: (Effect.RunOptions & {
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?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Fiber.Fiber<XA, XE>
import ScopeScope.Scope | function (type parameter) R in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
import EffectEffect.flatMap(
const make: <
A = unknown,
E = unknown
>() => Effect.Effect<
FiberSet<A, E>,
never,
Scope.Scope
>
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.
Example (Creating a scoped FiberSet)
import { Effect, FiberSet } from "effect"
Effect.gen(function*() {
const set = yield* FiberSet.make()
// run some effects and add the fibers to the set
yield* FiberSet.run(set, Effect.never)
yield* FiberSet.run(set, Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
make<function (type parameter) A in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
function (type parameter) E in <R = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>
self: FiberSet<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; readonly backing: Set<Fiber.Fiber<A, E>> } | { 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: 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
| undefined
})
| undefined
) => Fiber.Fiber<XA, XE>,
never,
R
>
Captures a Runtime and uses it to fork effects into the FiberSet.
Example (Capturing a runtime)
import { Context, Effect, FiberSet } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.Service<Users, {
getAll: Effect.Effect<Array<unknown>>
}>("Users")
Effect.gen(function*() {
const set = yield* FiberSet.make()
const run = yield* FiberSet.runtime(set)<Users>()
// run some effects and add the fibers to the set
run(Effect.andThen(Users, (_) => _.getAll))
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
runtime(self: FiberSet<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; readonly backing: Set<Fiber.Fiber<A, E>> } | { 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 = never, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, Scope.Scope | R>