<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"
})combinators
Source effect/FiberMap.ts:90335 lines
export const 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 = <function (type parameter) K in <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>
function (type parameter) A in <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>
function (type parameter) E in <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>
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;
}
interface FiberMap<in out K, out A = unknown, out E = unknown>A FiberMap is a collection of fibers, indexed by a key. When the associated
Scope is closed, all fibers in the map will be interrupted. Fibers are
automatically removed from the map when they complete.
Example (Managing fibers in a map)
import { Effect, FiberMap } from "effect"
// Create a FiberMap with string keys
const program = Effect.gen(function*() {
const map = yield* FiberMap.make<string>()
// Add some fibers to the map
yield* FiberMap.run(map, "task1", Effect.never)
yield* FiberMap.run(map, "task2", Effect.never)
// Get the size of the map
const size = yield* FiberMap.size(map)
console.log(size) // 2
})
FiberMap<function (type parameter) K in <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>
function (type parameter) A in <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>
function (type parameter) E in <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>
function (type parameter) R in <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>
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;
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) E in <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>
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;
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) A in <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>
key: Kkey: function (type parameter) K in <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>
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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<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;
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) R in <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>
options: | (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
import EffectEffect.type Effect.RunOptions = /*unresolved*/ anyRunOptions & {
readonly onlyIfMissing?: boolean | undefinedonlyIfMissing?: boolean | undefined
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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) R in <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>
function (type parameter) R in <R>(): anyR>() =>
import EffectEffect.map(
const runtime: <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
) => Fiber.Fiber<XA, XE>,
never,
R
>
Captures the current runtime and returns a function for forking effects into
an existing FiberMap.
Details
Each call stores the forked fiber under the supplied key. If that key already
has a fiber, the previous fiber is interrupted unless onlyIfMissing is set.
Example (Capturing a runtime)
import { Context, Effect, FiberMap } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.Service<Users, {
getAll: Effect.Effect<Array<unknown>>
}>("Users")
Effect.gen(function*() {
const map = yield* FiberMap.make<string>()
const run = yield* FiberMap.runtime(map)<Users>()
// run some effects and add the fibers to the map
run("effect-a", Effect.andThen(Users, (_) => _.getAll))
run("effect-b", Effect.andThen(Users, (_) => _.getAll))
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
runtime(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;
}
function (type parameter) R in <R>(): anyR>(),
(runFork: (
key: K,
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
) => Fiber.Fiber<XA, XE>
function (type parameter) XE in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) E in <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>
function (type parameter) XA in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) A in <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>
key: Kkey: function (type parameter) K in <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>
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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) XE in <XE extends E, XA extends A>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
function (type parameter) R in <R>(): anyR>,
options: | (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
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>(key: K, effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Promise<XA>
var Promise: PromiseConstructor
new <XA>(executor: (resolve: (value: XA | PromiseLike<XA>) => void, reject: (reason?: any) => void) => void) => Promise<XA>
Creates a new Promise.
Promise((resolve: (value: XA | PromiseLike<XA>) => voidresolve, reject: (reason?: any) => voidreject) =>
runFork: (
key: K,
effect: Effect.Effect<XA, XE, R>,
options?:
| (Effect.RunOptions & {
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
) => Fiber.Fiber<XA, XE>
key: Kkey, 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;
}
options: | (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
exit: Exit.Exit<XA, XE>exit) => {
if (import ExitExit.isSuccess(exit: Exit.Exit<XA, XE>exit)) {
resolve: (value: XA | PromiseLike<XA>) => voidresolve(exit: Exit.Success<XA, XE>(parameter) exit: {
_tag: "Success";
value: A;
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;
}
reject: (reason?: any) => voidreject(import CauseCause.squash(exit: Exit.Failure<XA, XE>(parameter) exit: {
_tag: "Failure";
cause: Cause.Cause<E>;
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;
}
Referenced by 1 symbols