<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
) => Promise<XA>,
never,
R | Scope.Scope
>Creates a scoped run function that forks effects into a new FiberSet and
returns a Promise for each effect result.
When to use
Use when many scoped fibers should be tracked as a set while exposing each result through Promise-based APIs.
Details
Managed fibers are removed when they complete and are interrupted when the set's scope closes. Each Promise resolves with the effect's success value or rejects with the squashed failure cause.
Example (Creating a promise runtime)
import { Effect, FiberSet } from "effect"
const program = Effect.gen(function*() {
const runPromise = yield* FiberSet.makeRuntimePromise()
// Run effects as promises
const promise1 = runPromise(Effect.succeed("hello"))
const promise2 = runPromise(Effect.succeed("world"))
const result1 = yield* Effect.promise(() => promise1)
const result2 = yield* Effect.promise(() => promise2)
console.log(result1, result2) // "hello" "world"
})export const const makeRuntimePromise: <
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
) => Promise<XA>,
never,
R | Scope.Scope
>
Creates a scoped run function that forks effects into a new FiberSet and
returns a Promise for each effect result.
When to use
Use when many scoped fibers should be tracked as a set while exposing each
result through Promise-based APIs.
Details
Managed fibers are removed when they complete and are interrupted when the
set's scope closes. Each Promise resolves with the effect's success value or
rejects with the squashed failure cause.
Example (Creating a promise runtime)
import { Effect, FiberSet } from "effect"
const program = Effect.gen(function*() {
const runPromise = yield* FiberSet.makeRuntimePromise()
// Run effects as promises
const promise1 = runPromise(Effect.succeed("hello"))
const promise2 = runPromise(Effect.succeed("world"))
const result1 = yield* Effect.promise(() => promise1)
const result2 = yield* Effect.promise(() => promise2)
console.log(result1, result2) // "hello" "world"
})
makeRuntimePromise = <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) => Promise<XA>), never, R | Scope.Scope>
R = never, 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) => Promise<XA>), never, R | Scope.Scope>
A = unknown, 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) => Promise<XA>), never, R | Scope.Scope>
E = unknown>(): 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): Promise<XA>
XE extends 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) => Promise<XA>), never, R | Scope.Scope>
E, 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): Promise<XA>
XA extends 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) => Promise<XA>), never, R | Scope.Scope>
A>(
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;
}
effect: 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): Promise<XA>
XA, 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): Promise<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) => Promise<XA>), never, R | Scope.Scope>
R>,
options: | (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
options?: (import EffectEffect.type Effect.RunOptions = /*unresolved*/ anyRunOptions & { readonly propagateInterruption?: boolean | undefinedpropagateInterruption?: boolean | undefined }) | undefined
) => interface Promise<T>Represents the completion of an asynchronous operation
Promise<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): Promise<XA>
XA>),
never,
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) => Promise<XA>), never, R | Scope.Scope>
R | import ScopeScope.Scope
> =>
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) => Promise<XA>), never, R | Scope.Scope>
A, 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) => Promise<XA>), never, R | Scope.Scope>
E>(),
(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;
}
self) => const runtimePromise: <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
) => Promise<XA>,
never,
R
>
Captures a Runtime and returns a Promise-based runner that forks effects
into the FiberSet.
When to use
Use when you need to bridge effects to Promise values while still tracking
their fibers in a FiberSet.
Details
The returned run function returns a Promise for each effect result.
Example (Running effects as promises)
import { Effect, FiberSet } from "effect"
const program = Effect.gen(function*() {
const set = yield* FiberSet.make()
const runPromise = yield* FiberSet.runtimePromise(set)()
// Run effects as promises
const promise1 = runPromise(Effect.succeed("hello"))
const promise2 = runPromise(Effect.succeed("world"))
const result1 = yield* Effect.promise(() => promise1)
const result2 = yield* Effect.promise(() => promise2)
console.log(result1, result2) // "hello" "world"
})
runtimePromise(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;
}
self)<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) => Promise<XA>), never, R | Scope.Scope>
R>()
)