<R, K, A = unknown, E = unknown>(): Effect.Effect<
<XE extends E, XA extends A>(
key: K,
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined
})
| undefined
) => Promise<XA>,
never,
Scope.Scope | R
>Creates a scoped run function that forks effects into a new FiberMap and
returns a Promise for each effect result.
When to use
Use when keyed fibers must be managed in a scoped map while exposing their results through Promise-based APIs.
Details
Each call stores the fiber under the supplied key, interrupting any previous
fiber for that key unless onlyIfMissing is set. The returned Promise
resolves with the effect's success value or rejects with the squashed failure
cause.
Example (Creating a promise runtime)
import { Effect, FiberMap } from "effect"
const program = Effect.gen(function*() {
const run = yield* FiberMap.makeRuntimePromise<never, string>()
// Run effects and get back promises
const promise1 = run("task1", Effect.succeed("Hello"))
const promise2 = run("task2", Effect.succeed("World"))
// Convert to Effect and await
const result1 = yield* Effect.promise(() => promise1)
const result2 = yield* Effect.promise(() => promise2)
console.log(result1, result2) // "Hello", "World"
})export const const makeRuntimePromise: <
R,
K,
A = unknown,
E = unknown
>() => Effect.Effect<
<XE extends E, XA extends A>(
key: K,
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly onlyIfMissing?:
| boolean
| undefined
})
| undefined
) => Promise<XA>,
never,
Scope.Scope | R
>
Creates a scoped run function that forks effects into a new FiberMap and
returns a Promise for each effect result.
When to use
Use when keyed fibers must be managed in a scoped map while exposing their
results through Promise-based APIs.
Details
Each call stores the fiber under the supplied key, interrupting any previous
fiber for that key unless onlyIfMissing is set. The returned Promise
resolves with the effect's success value or rejects with the squashed failure
cause.
Example (Creating a promise runtime)
import { Effect, FiberMap } from "effect"
const program = Effect.gen(function*() {
const run = yield* FiberMap.makeRuntimePromise<never, string>()
// Run effects and get back promises
const promise1 = run("task1", Effect.succeed("Hello"))
const promise2 = run("task2", Effect.succeed("World"))
// Convert to Effect and await
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, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
R, function (type parameter) K in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
K, function (type parameter) A in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
A = unknown, function (type parameter) E in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
E = unknown>(): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
<function (type parameter) XE in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined): Promise<XA>
XE extends function (type parameter) E in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
E, function (type parameter) XA in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined): Promise<XA>
XA extends function (type parameter) A in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
A>(
key: Kkey: function (type parameter) K in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
K,
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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined): Promise<XA>
XA, function (type parameter) XE in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined): Promise<XA>
XE, function (type parameter) R in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
R>,
options: | (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined
})
| undefined
options?:
| import EffectEffect.type Effect.RunOptions = /*unresolved*/ anyRunOptions & {
readonly onlyIfMissing?: boolean | undefinedonlyIfMissing?: 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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined): Promise<XA>
XA>,
never,
import ScopeScope.Scope | function (type parameter) R in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
R
> =>
import EffectEffect.flatMap(
const make: <
K,
A = unknown,
E = unknown
>() => Effect.Effect<
FiberMap<K, A, E>,
never,
Scope.Scope
>
Creates a scoped FiberMap for storing fibers by key.
Details
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.
Example (Creating a scoped FiberMap)
import { Effect, FiberMap } from "effect"
Effect.gen(function*() {
const map = yield* FiberMap.make<string>()
// run some effects and add the fibers to the map
yield* FiberMap.run(map, "fiber a", Effect.never)
yield* FiberMap.run(map, "fiber b", Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
make<function (type parameter) K in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
K, function (type parameter) A in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
A, function (type parameter) E in <R, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
E>(),
(self: FiberMap<K, A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; readonly backing: MutableHashMap.MutableHashMap<K, 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: <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?:
| (Effect.RunOptions & {
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
) => Promise<XA>,
never,
R
>
Captures the current runtime and returns a function for running effects in
an existing FiberMap as Promises.
Details
Each call stores the forked fiber under the supplied key, interrupting any
previous fiber for that key unless onlyIfMissing is set. The Promise
resolves with the effect's success value or rejects with the squashed failure
cause.
Example (Running effects as promises)
import { Effect, FiberMap } from "effect"
const program = Effect.gen(function*() {
const map = yield* FiberMap.make<string>()
const runPromise = yield* FiberMap.runtimePromise(map)<never>()
// Create promises that will be backed by fibers in the map
const promise1 = runPromise("task1", Effect.succeed("Hello"))
const promise2 = runPromise("task2", Effect.succeed("World"))
// Convert promises back to Effects and await
const result1 = yield* Effect.promise(() => promise1)
const result2 = yield* Effect.promise(() => promise2)
console.log(result1, result2) // "Hello", "World"
})
runtimePromise(self: FiberMap<K, A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; readonly backing: MutableHashMap.MutableHashMap<K, 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, K, A = unknown, E = unknown>(): Effect.Effect<(<XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
}) | undefined) => Promise<XA>), never, Scope.Scope | R>
R>()
)