<R = never, A = unknown, E = unknown>(): Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| {
readonly signal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefined
readonly onlyIfMissing?: boolean | undefined
readonly propagateInterruption?: boolean | undefined
}
| undefined
) => Promise<XA>,
never,
Scope.Scope | R
>Creates a scoped run function that forks effects into a new FiberHandle
and returns a Promise for each effect result.
When to use
Use when integrating a scoped FiberHandle runner with Promise-based APIs
and Promise rejection from squashed failures is the desired boundary.
Details
Each call stores the fiber in the handle and interrupts the previous fiber
unless onlyIfMissing is set. The returned Promise resolves with the
effect's success value or rejects with the squashed failure cause.
Example (Running effects as promises)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const run = yield* FiberHandle.makeRuntimePromise()
// Run effects and get promises back
const promise = run(Effect.succeed("hello"))
const result = yield* Effect.promise(() => promise)
console.log(result) // "hello"
}).pipe(Effect.scoped)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?:
| {
readonly signal?:
| AbortSignal
| undefined
readonly scheduler?:
| Scheduler
| undefined
readonly onlyIfMissing?:
| boolean
| undefined
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
) => Promise<XA>,
never,
Scope.Scope | R
>
Creates a scoped run function that forks effects into a new FiberHandle
and returns a Promise for each effect result.
When to use
Use when integrating a scoped FiberHandle runner with Promise-based APIs
and Promise rejection from squashed failures is the desired boundary.
Details
Each call stores the fiber in the handle and interrupts the previous fiber
unless onlyIfMissing is set. The returned Promise resolves with the
effect's success value or rejects with the squashed failure cause.
Example (Running effects as promises)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const run = yield* FiberHandle.makeRuntimePromise()
// Run effects and get promises back
const promise = run(Effect.succeed("hello"))
const result = yield* Effect.promise(() => promise)
console.log(result) // "hello"
}).pipe(Effect.scoped)
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: 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>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
E, function (type parameter) XA in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
R>,
options: | {
readonly signal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefined
readonly onlyIfMissing?: boolean | undefined
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
options?: {
readonly signal?: AbortSignal | undefinedsignal?: AbortSignal | undefined
readonly scheduler?: Scheduler | undefinedscheduler?: Scheduler | undefined
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>(effect: Effect.Effect<XA, XE, R>, options?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined): Promise<XA>
XA>,
never,
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
R
> =>
import EffectEffect.flatMap(
const make: <
A = unknown,
E = unknown
>() => Effect.Effect<
FiberHandle<A, E>,
never,
Scope.Scope
>
Creates a scoped FiberHandle that can store a single fiber.
Details
When the associated Scope is closed, the contained fiber will be
interrupted. You can add a fiber to the handle using FiberHandle.run, and
the fiber will be automatically removed from the FiberHandle when it
completes.
Example (Creating a scoped fiber handle)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
// run some effects
yield* FiberHandle.run(handle, Effect.never)
// this will interrupt the previous fiber
yield* FiberHandle.run(handle, Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fiber 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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
E>(),
(self: FiberHandle<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; fiber: Fiber.Fiber<A, E> | undefined } | { 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: FiberHandle<A, E>
) => <R = never>() => Effect.Effect<
<XE extends E, XA extends A>(
effect: Effect.Effect<XA, XE, R>,
options?:
| {
readonly signal?:
| AbortSignal
| undefined
readonly scheduler?:
| Scheduler
| undefined
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 FiberHandle as Promises.
Details
Each call stores the forked fiber in the handle and interrupts the previous
fiber unless onlyIfMissing is set. The Promise resolves with the effect's
success value or rejects with the squashed failure cause.
Example (Capturing a runtime for promises)
import { Effect, FiberHandle } from "effect"
Effect.gen(function*() {
const handle = yield* FiberHandle.make()
const runPromise = yield* FiberHandle.runtimePromise(handle)<never>()
// Run an effect and get a promise
const promise = runPromise(Effect.succeed("hello"))
const result = yield* Effect.promise(() => promise)
console.log(result) // "hello"
})
runtimePromise(self: FiberHandle<A, E>(parameter) self: {
deferred: Deferred.Deferred<void, unknown>;
state: { readonly _tag: "Open"; fiber: Fiber.Fiber<A, E> | undefined } | { 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?: {
readonly signal?: AbortSignal | undefined;
readonly scheduler?: Scheduler | undefined;
readonly onlyIfMissing?: boolean | undefined;
readonly propagateInterruption?: boolean | undefined;
} | undefined) => Promise<XA>), never, Scope.Scope | R>
R>()
)