<A = unknown, E = unknown>(): Effect.Effect<
FiberSet<A, E>,
never,
Scope.Scope
>Creates a scoped FiberSet for storing fibers.
Details
When the associated Scope is closed, all fibers in the set will be
interrupted. You can add fibers to the set using FiberSet.add or
FiberSet.run, and the fibers will be automatically removed from the
FiberSet when they complete.
Example (Creating a scoped FiberSet)
import { Effect, FiberSet } from "effect"
Effect.gen(function*() {
const set = yield* FiberSet.make()
// run some effects and add the fibers to the set
yield* FiberSet.run(set, Effect.never)
yield* FiberSet.run(set, Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)constructors
Source effect/FiberSet.ts:14414 lines
export const const make: <
A = unknown,
E = unknown
>() => Effect.Effect<
FiberSet<A, E>,
never,
Scope.Scope
>
Creates a scoped FiberSet for storing fibers.
Details
When the associated Scope is closed, all fibers in the set will be
interrupted. You can add fibers to the set using FiberSet.add or
FiberSet.run, and the fibers will be automatically removed from the
FiberSet when they complete.
Example (Creating a scoped FiberSet)
import { Effect, FiberSet } from "effect"
Effect.gen(function*() {
const set = yield* FiberSet.make()
// run some effects and add the fibers to the set
yield* FiberSet.run(set, Effect.never)
yield* FiberSet.run(set, Effect.never)
yield* Effect.sleep(1000)
}).pipe(
Effect.scoped // The fibers will be interrupted when the scope is closed
)
make = <function (type parameter) A in <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope>A = unknown, function (type parameter) E in <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope>E = unknown>(): import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<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 = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope>A, function (type parameter) E in <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope>E>, never, import ScopeScope.Scope> =>
import EffectEffect.acquireRelease(
import EffectEffect.sync(() => const makeUnsafe: <A, E>(
backing: Set<Fiber.Fiber<A, E>>,
deferred: Deferred.Deferred<void, unknown>
) => FiberSet<A, E>
var Set: SetConstructor
new <Fiber.Fiber<A, E>>(iterable?: Iterable<Fiber.Fiber<A, E>> | null | undefined) => Set<Fiber.Fiber<A, E>> (+1 overload)
import DeferredDeferred.makeUnsafe())),
(set: FiberSet<A, E>(parameter) set: {
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;
}
import EffectEffect.suspend(() => {
const const state: anystate = set: FiberSet<A, E>(parameter) set: {
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 state: anystate._tag === "Closed") return import EffectEffect.void
set: FiberSet<A, E>(parameter) set: {
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;
}
_tag: string_tag: "Closed" }
const const fibers: Set<Fiber.Fiber<A, E>>fibers = const state: anyconst state: {
_tag: "Open";
backing: Set<Fiber.Fiber<A, E>>;
}
import FiberFiber.interruptAll(const fibers: Set<Fiber.Fiber<A, E>>fibers).pipe(
import DeferredDeferred.into(set: FiberSet<A, E>(parameter) set: {
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;
}
Referenced by 2 symbols