<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.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<
<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.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<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.RunOptions & {
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.const flatMap: {
<A, B, E1, R1>(
f: (a: A) => Effect<B, E1, R1>
): <E, R>(
self: Effect<A, E, R>
) => Effect<B, E1 | E, R1 | R>
<A, E, R, B, E1, R1>(
self: Effect<A, E, R>,
f: (a: A) => Effect<B, E1, R1>
): Effect<B, E | E1, R | R1>
}
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>()
)