<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
) => Fiber.Fiber<XA, XE>,
never,
R
>Captures a Runtime and uses it to fork effects into the FiberSet.
Example (Capturing a runtime)
import { Context, Effect, FiberSet } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.Service<Users, {
getAll: Effect.Effect<Array<unknown>>
}>("Users")
Effect.gen(function*() {
const set = yield* FiberSet.make()
const run = yield* FiberSet.runtime(set)<Users>()
// run some effects and add the fibers to the set
run(Effect.andThen(Users, (_) => _.getAll))
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)combinators
Source effect/FiberSet.ts:53131 lines
export const const runtime: <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
) => Fiber.Fiber<XA, XE>,
never,
R
>
Captures a Runtime and uses it to fork effects into the FiberSet.
Example (Capturing a runtime)
import { Context, Effect, FiberSet } from "effect"
interface Users {
readonly _: unique symbol
}
const Users = Context.Service<Users, {
getAll: Effect.Effect<Array<unknown>>
}>("Users")
Effect.gen(function*() {
const set = yield* FiberSet.make()
const run = yield* FiberSet.runtime(set)<Users>()
// run some effects and add the fibers to the set
run(Effect.andThen(Users, (_) => _.getAll))
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
runtime: <function (type parameter) A in <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) => Fiber.Fiber<XA, XE>), never, R>
function (type parameter) E in <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) => Fiber.Fiber<XA, XE>), never, R>
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;
}
interface FiberSet<out A = unknown, out E = unknown>A FiberSet is a collection of fibers that can be managed together.
When the associated Scope is closed, all fibers in the set will be interrupted.
Example (Managing fibers in a set)
import { Effect, FiberSet } from "effect"
const program = Effect.gen(function*() {
const set = yield* FiberSet.make<string, string>()
// Add fibers to the set
yield* FiberSet.run(set, Effect.succeed("hello"))
yield* FiberSet.run(set, Effect.succeed("world"))
// Wait for all fibers to complete
yield* FiberSet.awaitEmpty(set)
})
FiberSet<function (type parameter) A in <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) => Fiber.Fiber<XA, XE>), never, R>
function (type parameter) E in <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) => Fiber.Fiber<XA, XE>), never, R>
function (type parameter) R in <R = never>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, R>
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): Fiber.Fiber<XA, XE>
function (type parameter) E in <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) => Fiber.Fiber<XA, XE>), never, R>
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): Fiber.Fiber<XA, XE>
function (type parameter) A in <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) => Fiber.Fiber<XA, XE>), 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>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): Fiber.Fiber<XA, XE>
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): Fiber.Fiber<XA, XE>
function (type parameter) R in <R = never>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, R>
options: | (Effect.RunOptions & {
readonly propagateInterruption?:
| boolean
| undefined
})
| undefined
import EffectEffect.type Effect.RunOptions = /*unresolved*/ anyRunOptions & { readonly propagateInterruption?: boolean | undefinedpropagateInterruption?: boolean | undefined }
| undefined
) => import FiberFiber.type Fiber.Fiber = /*unresolved*/ anyFiber<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): Fiber.Fiber<XA, XE>
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): Fiber.Fiber<XA, XE>
function (type parameter) R in <R = never>(): Effect.Effect<(<XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined) => Fiber.Fiber<XA, XE>), never, R>
function (type parameter) A in <A, E>(self: FiberSet<A, E>): <R>() => anyA, function (type parameter) E in <A, E>(self: FiberSet<A, E>): <R>() => anyE>(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;
}
interface FiberSet<out A = unknown, out E = unknown>A FiberSet is a collection of fibers that can be managed together.
When the associated Scope is closed, all fibers in the set will be interrupted.
Example (Managing fibers in a set)
import { Effect, FiberSet } from "effect"
const program = Effect.gen(function*() {
const set = yield* FiberSet.make<string, string>()
// Add fibers to the set
yield* FiberSet.run(set, Effect.succeed("hello"))
yield* FiberSet.run(set, Effect.succeed("world"))
// Wait for all fibers to complete
yield* FiberSet.awaitEmpty(set)
})
FiberSet<function (type parameter) A in <A, E>(self: FiberSet<A, E>): <R>() => anyA, function (type parameter) E in <A, E>(self: FiberSet<A, E>): <R>() => anyE>) => <function (type parameter) R in <R>(): anyR>() =>
import EffectEffect.map(
import EffectEffect.context<function (type parameter) R in <R>(): anyR>(),
(services: Context<R>(parameter) services: {
mapUnsafe: ReadonlyMap<string, any>;
mutable: boolean;
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;
}
const runFork: (
effect: Effect<A, E, R>,
options?: RunOptions | undefined
) => Fiber<A, E>
import EffectEffect.runForkWith(services: Context<R>(parameter) services: {
mapUnsafe: ReadonlyMap<string, any>;
mutable: boolean;
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) XE in <XE extends E, XA extends A>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): any
function (type parameter) E in <A, E>(self: FiberSet<A, E>): <R>() => anyE, 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): any
function (type parameter) A in <A, E>(self: FiberSet<A, E>): <R>() => anyA>(
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>(effect: Effect.Effect<XA, XE, R>, options?: (Effect.RunOptions & {
readonly propagateInterruption?: boolean | undefined;
}) | undefined): any
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): any
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
) => {
if (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;
}
FiberSet<A, E>.state: { readonly _tag: "Open"; readonly backing: Set<Fiber.Fiber<A, E>> } | { readonly _tag: "Closed" }state._tag: "Open" | "Closed"_tag === "Closed") {
return const constInterruptedFiber: () => anyconstInterruptedFiber()
}
const const fiber: Fiber.Fiber<XA, XE>const fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
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; <…;
}
const runFork: (
effect: Effect<A, E, R>,
options?: RunOptions | undefined
) => Fiber<A, E>
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
const addUnsafe: {
<A, E, XE extends E, XA extends A>(
fiber: Fiber.Fiber<XA, XE>,
options?:
| {
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
): (self: FiberSet<A, E>) => void
<A, E, XE extends E, XA extends A>(
self: FiberSet<A, E>,
fiber: Fiber.Fiber<XA, XE>,
options?:
| {
readonly propagateInterruption?:
| boolean
| undefined
}
| undefined
): void
}
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;
}
const fiber: Fiber.Fiber<XA, XE>const fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
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; <…;
}
const fiber: Fiber.Fiber<XA, XE>const fiber: {
id: number;
currentOpCount: number;
getRef: <A>(ref: Context.Reference<A>) => A;
context: Context.Context<never>;
setContext: (context: Context.Context<never>) => void;
currentScheduler: Scheduler;
currentDispatcher: SchedulerDispatcher;
currentSpan: AnySpan | undefined;
currentLogLevel: LogLevel;
minimumLogLevel: LogLevel;
currentStackFrame: StackFrame | undefined;
maxOpsBeforeYield: number;
currentPreventYield: boolean;
addObserver: (cb: (exit: Exit<A, E>) => void) => () => void;
interruptUnsafe: (fiberId?: number | undefined, annotations?: Context.Context<never> | undefined) => void;
pollUnsafe: () => Exit<A, E> | undefined;
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; <…;
}
Referenced by 2 symbols