@clayroach/effect 3.19.14-source-capture.7 → 3.19.14-source-capture.8

package/src/FiberRefsPatch.ts

@@ -1,105 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as FiberId from "./FiberId.js"
-import type * as FiberRef from "./FiberRef.js"
-import type * as FiberRefs from "./FiberRefs.js"
-import * as internal from "./internal/fiberRefs/patch.js"
-
-/**
- * A `FiberRefsPatch` captures the changes in `FiberRef` values made by a single
- * fiber as a value. This allows fibers to apply the changes made by a workflow
- * without inheriting all the `FiberRef` values of the fiber that executed the
- * workflow.
- *
- * @since 2.0.0
- * @category models
- */
-export type FiberRefsPatch = Empty | Add | Remove | Update | AndThen
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Empty {
-  readonly _tag: "Empty"
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Add {
-  readonly _tag: "Add"
-  readonly fiberRef: FiberRef.FiberRef<unknown>
-  readonly value: unknown
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Remove {
-  readonly _tag: "Remove"
-  readonly fiberRef: FiberRef.FiberRef<unknown>
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Update {
-  readonly _tag: "Update"
-  readonly fiberRef: FiberRef.FiberRef<unknown>
-  readonly patch: unknown
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface AndThen {
-  readonly _tag: "AndThen"
-  readonly first: FiberRefsPatch
-  readonly second: FiberRefsPatch
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const empty: FiberRefsPatch = internal.empty
-
-/**
- * Constructs a patch that describes the changes between the specified
- * collections of `FiberRef`
- *
- * @since 2.0.0
- * @category constructors
- */
-export const diff: (oldValue: FiberRefs.FiberRefs, newValue: FiberRefs.FiberRefs) => FiberRefsPatch = internal.diff
-
-/**
- * Combines this patch and the specified patch to create a new patch that
- * describes applying the changes from this patch and the specified patch
- * sequentially.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const combine: {
-  (that: FiberRefsPatch): (self: FiberRefsPatch) => FiberRefsPatch
-  (self: FiberRefsPatch, that: FiberRefsPatch): FiberRefsPatch
-} = internal.combine
-
-/**
- * Applies the changes described by this patch to the specified collection
- * of `FiberRef` values.
- *
- * @since 2.0.0
- * @category destructors
- */
-export const patch: {
-  (fiberId: FiberId.Runtime, oldValue: FiberRefs.FiberRefs): (self: FiberRefsPatch) => FiberRefs.FiberRefs
-  (self: FiberRefsPatch, fiberId: FiberId.Runtime, oldValue: FiberRefs.FiberRefs): FiberRefs.FiberRefs
-} = internal.patch

package/src/FiberSet.ts

@@ -1,491 +0,0 @@
-/**
- * @since 2.0.0
- */
-import * as Cause from "./Cause.js"
-import * as Deferred from "./Deferred.js"
-import * as Effect from "./Effect.js"
-import * as Exit from "./Exit.js"
-import * as Fiber from "./Fiber.js"
-import * as FiberId from "./FiberId.js"
-import { constFalse, constVoid, dual } from "./Function.js"
-import * as HashSet from "./HashSet.js"
-import * as Inspectable from "./Inspectable.js"
-import * as Iterable from "./Iterable.js"
-import { type Pipeable, pipeArguments } from "./Pipeable.js"
-import * as Predicate from "./Predicate.js"
-import * as Runtime from "./Runtime.js"
-import type * as Scope from "./Scope.js"
-
-/**
- * @since 2.0.0
- * @categories type ids
- */
-export const TypeId: unique symbol = Symbol.for("effect/FiberSet")
-
-/**
- * @since 2.0.0
- * @categories type ids
- */
-export type TypeId = typeof TypeId
-
-/**
- * @since 2.0.0
- * @categories models
- */
-export interface FiberSet<out A = unknown, out E = unknown>
-  extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>>
-{
-  readonly [TypeId]: TypeId
-  readonly deferred: Deferred.Deferred<void, unknown>
-  /** @internal */
-  state: {
-    readonly _tag: "Open"
-    readonly backing: Set<Fiber.RuntimeFiber<A, E>>
-  } | {
-    readonly _tag: "Closed"
-  }
-}
-
-/**
- * @since 2.0.0
- * @categories refinements
- */
-export const isFiberSet = (u: unknown): u is FiberSet<unknown, unknown> => Predicate.hasProperty(u, TypeId)
-
-const Proto = {
-  [TypeId]: TypeId,
-  [Symbol.iterator](this: FiberSet<unknown, unknown>) {
-    if (this.state._tag === "Closed") {
-      return Iterable.empty()
-    }
-    return this.state.backing[Symbol.iterator]()
-  },
-  toString(this: FiberSet<unknown, unknown>) {
-    return Inspectable.format(this.toJSON())
-  },
-  toJSON(this: FiberSet<unknown, unknown>) {
-    return {
-      _id: "FiberMap",
-      state: this.state
-    }
-  },
-  [Inspectable.NodeInspectSymbol](this: FiberSet<unknown, unknown>) {
-    return this.toJSON()
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const unsafeMake = <A, E>(
-  backing: Set<Fiber.RuntimeFiber<A, E>>,
-  deferred: Deferred.Deferred<void, unknown>
-): FiberSet<A, E> => {
-  const self = Object.create(Proto)
-  self.state = { _tag: "Open", backing }
-  self.deferred = deferred
-  return self
-}
-
-/**
- * A FiberSet can be used to store a collection of fibers.
- * 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
- * ```ts
- * 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
- * )
- * ```
- *
- * @since 2.0.0
- * @categories constructors
- */
-export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    Effect.map(Deferred.make<void, unknown>(), (deferred) => unsafeMake(new Set(), deferred)),
-    (set) =>
-      Effect.withFiberRuntime((parent) => {
-        const state = set.state
-        if (state._tag === "Closed") return Effect.void
-        set.state = { _tag: "Closed" }
-        const fibers = state.backing
-        return Fiber.interruptAllAs(fibers, FiberId.combine(parent.id(), internalFiberId)).pipe(
-          Effect.intoDeferred(set.deferred)
-        )
-      })
-  )
-
-/**
- * Create an Effect run function that is backed by a FiberSet.
- *
- * @since 2.0.0
- * @categories constructors
- */
-export const makeRuntime = <R = never, A = unknown, E = unknown>(): Effect.Effect<
-  <XE extends E, XA extends A>(
-    effect: Effect.Effect<XA, XE, R>,
-    options?: Runtime.RunForkOptions | undefined
-  ) => Fiber.RuntimeFiber<XA, XE>,
-  never,
-  Scope.Scope | R
-> =>
-  Effect.flatMap(
-    make<A, E>(),
-    (self) => runtime(self)<R>()
-  )
-
-/**
- * Create an Effect run function that is backed by a FiberSet.
- *
- * @since 3.13.0
- * @categories constructors
- */
-export const makeRuntimePromise = <R = never, A = unknown, E = unknown>(): Effect.Effect<
-  <XE extends E, XA extends A>(
-    effect: Effect.Effect<XA, XE, R>,
-    options?: Runtime.RunForkOptions | undefined
-  ) => Promise<XA>,
-  never,
-  Scope.Scope | R
-> =>
-  Effect.flatMap(
-    make<A, E>(),
-    (self) => runtimePromise(self)<R>()
-  )
-
-const internalFiberIdId = -1
-const internalFiberId = FiberId.make(internalFiberIdId, 0)
-const isInternalInterruption = Cause.reduceWithContext(undefined, {
-  emptyCase: constFalse,
-  failCase: constFalse,
-  dieCase: constFalse,
-  interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
-  sequentialCase: (_, left, right) => left || right,
-  parallelCase: (_, left, right) => left || right
-})
-
-/**
- * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
- *
- * @since 2.0.0
- * @categories combinators
- */
-export const unsafeAdd: {
-  <A, E, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    options?: {
-      readonly interruptAs?: FiberId.FiberId | undefined
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): (self: FiberSet<A, E>) => void
-  <A, E, XE extends E, XA extends A>(
-    self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    options?: {
-      readonly interruptAs?: FiberId.FiberId | undefined
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): void
-} = dual((args) => isFiberSet(args[0]), <A, E, XE extends E, XA extends A>(
-  self: FiberSet<A, E>,
-  fiber: Fiber.RuntimeFiber<XA, XE>,
-  options?: {
-    readonly interruptAs?: FiberId.FiberId | undefined
-    readonly propagateInterruption?: boolean | undefined
-  } | undefined
-): void => {
-  if (self.state._tag === "Closed") {
-    fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
-    return
-  } else if (self.state.backing.has(fiber)) {
-    return
-  }
-  self.state.backing.add(fiber)
-  fiber.addObserver((exit) => {
-    if (self.state._tag === "Closed") {
-      return
-    }
-    self.state.backing.delete(fiber)
-    if (
-      Exit.isFailure(exit) &&
-      (
-        options?.propagateInterruption === true ?
-          !isInternalInterruption(exit.cause) :
-          !Cause.isInterruptedOnly(exit.cause)
-      )
-    ) {
-      Deferred.unsafeDone(self.deferred, exit as any)
-    }
-  })
-})
-
-/**
- * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
- *
- * @since 2.0.0
- * @categories combinators
- */
-export const add: {
-  <A, E, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    options?: {
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): (self: FiberSet<A, E>) => Effect.Effect<void>
-  <A, E, XE extends E, XA extends A>(
-    self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    options?: {
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): Effect.Effect<void>
-} = dual(
-  (args) => isFiberSet(args[0]),
-  <A, E, XE extends E, XA extends A>(
-    self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    options?: {
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): Effect.Effect<void> =>
-    Effect.fiberIdWith((fiberId) =>
-      Effect.sync(() =>
-        unsafeAdd(self, fiber, {
-          ...options,
-          interruptAs: fiberId
-        })
-      )
-    )
-)
-
-/**
- * @since 2.0.0
- * @categories combinators
- */
-export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
-  Effect.withFiberRuntime((clearFiber) => {
-    if (self.state._tag === "Closed") {
-      return Effect.void
-    }
-    return Effect.forEach(self.state.backing, (fiber) =>
-      // will be removed by the observer
-      Fiber.interruptAs(fiber, FiberId.combine(clearFiber.id(), internalFiberId)))
-  })
-
-const constInterruptedFiber = (function() {
-  let fiber: Fiber.RuntimeFiber<never, never> | undefined = undefined
-  return () => {
-    if (fiber === undefined) {
-      fiber = Effect.runFork(Effect.interrupt)
-    }
-    return fiber
-  }
-})()
-
-/**
- * Fork an Effect and add the forked fiber to the FiberSet.
- * When the fiber completes, it will be removed from the FiberSet.
- *
- * @since 2.0.0
- * @categories combinators
- */
-export const run: {
-  <A, E>(
-    self: FiberSet<A, E>,
-    options?: {
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): <R, XE extends E, XA extends A>(
-    effect: Effect.Effect<XA, XE, R>
-  ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
-  <A, E, R, XE extends E, XA extends A>(
-    self: FiberSet<A, E>,
-    effect: Effect.Effect<XA, XE, R>,
-    options?: {
-      readonly propagateInterruption?: boolean | undefined
-    } | undefined
-  ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
-} = function() {
-  const self = arguments[0] as FiberSet<any, any>
-  if (!Effect.isEffect(arguments[1])) {
-    const options = arguments[1]
-    return (effect: Effect.Effect<any, any, any>) => runImpl(self, effect, options)
-  }
-  return runImpl(self, arguments[1], arguments[2]) as any
-}
-
-const runImpl = <A, E, R, XE extends E, XA extends A>(
-  self: FiberSet<A, E>,
-  effect: Effect.Effect<XA, XE, R>,
-  options?: {
-    readonly propagateInterruption?: boolean | undefined
-  }
-): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R> =>
-  Effect.fiberIdWith((fiberId) => {
-    if (self.state._tag === "Closed") {
-      return Effect.sync(constInterruptedFiber)
-    }
-    return Effect.tap(
-      Effect.forkDaemon(effect),
-      (fiber) =>
-        unsafeAdd(self, fiber, {
-          ...options,
-          interruptAs: fiberId
-        })
-    )
-  })
-
-/**
- * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
- *
- * @example
- * ```ts
- * import { Context, Effect, FiberSet } from "effect"
- *
- * interface Users {
- *   readonly _: unique symbol
- * }
- * const Users = Context.GenericTag<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
- * )
- * ```
- *
- * @since 2.0.0
- * @categories combinators
- */
-export 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?:
-      | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
-      | undefined
-  ) => Fiber.RuntimeFiber<XA, XE>,
-  never,
-  R
-> = <A, E>(self: FiberSet<A, E>) => <R>() =>
-  Effect.map(
-    Effect.runtime<R>(),
-    (runtime) => {
-      const runFork = Runtime.runFork(runtime)
-      return <XE extends E, XA extends A>(
-        effect: Effect.Effect<XA, XE, R>,
-        options?:
-          | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
-          | undefined
-      ) => {
-        if (self.state._tag === "Closed") {
-          return constInterruptedFiber()
-        }
-        const fiber = runFork(effect, options)
-        unsafeAdd(self, fiber)
-        return fiber
-      }
-    }
-  )
-
-/**
- * Capture a Runtime and use it to fork Effect's, adding the forked fibers to the FiberSet.
- *
- * The returned run function will return Promise's.
- *
- * @since 3.13.0
- * @categories combinators
- */
-export const runtimePromise = <A, E>(self: FiberSet<A, E>): <R = never>() => Effect.Effect<
-  <XE extends E, XA extends A>(
-    effect: Effect.Effect<XA, XE, R>,
-    options?:
-      | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
-      | undefined
-  ) => Promise<XA>,
-  never,
-  R
-> =>
-<R>() =>
-  Effect.map(
-    runtime(self)<R>(),
-    (runFork) =>
-    <XE extends E, XA extends A>(
-      effect: Effect.Effect<XA, XE, R>,
-      options?:
-        | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
-        | undefined
-    ): Promise<XA> =>
-      new Promise((resolve, reject) =>
-        runFork(effect, options).addObserver((exit) => {
-          if (Exit.isSuccess(exit)) {
-            resolve(exit.value)
-          } else {
-            reject(Cause.squash(exit.cause))
-          }
-        })
-      )
-  )
-
-/**
- * @since 2.0.0
- * @categories combinators
- */
-export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> =>
-  Effect.sync(() => self.state._tag === "Closed" ? 0 : self.state.backing.size)
-
-/**
- * Join all fibers in the FiberSet. If any of the Fiber's in the set terminate with a failure,
- * the returned Effect will terminate with the first failure that occurred.
- *
- * @since 2.0.0
- * @categories combinators
- * @example
- * ```ts
- * import { Effect, FiberSet } from "effect";
- *
- * Effect.gen(function* (_) {
- *   const set = yield* _(FiberSet.make());
- *   yield* _(FiberSet.add(set, Effect.runFork(Effect.fail("error"))));
- *
- *   // parent fiber will fail with "error"
- *   yield* _(FiberSet.join(set));
- * });
- * ```
- */
-export const join = <A, E>(self: FiberSet<A, E>): Effect.Effect<void, E> =>
-  Deferred.await(self.deferred as Deferred.Deferred<void, E>)
-
-/**
- * Wait until the fiber set is empty.
- *
- * @since 3.13.0
- * @categories combinators
- */
-export const awaitEmpty = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
-  Effect.whileLoop({
-    while: () => self.state._tag === "Open" && self.state.backing.size > 0,
-    body: () => Fiber.await(Iterable.unsafeHead(self)),
-    step: constVoid
-  })

package/src/FiberStatus.ts

@@ -1,108 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Equal from "./Equal.js"
-import type * as FiberId from "./FiberId.js"
-import * as internal from "./internal/fiberStatus.js"
-import type * as RuntimeFlags from "./RuntimeFlags.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const FiberStatusTypeId: unique symbol = internal.FiberStatusTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type FiberStatusTypeId = typeof FiberStatusTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export type FiberStatus = Done | Running | Suspended
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Done extends Equal.Equal {
-  readonly _tag: "Done"
-  readonly [FiberStatusTypeId]: FiberStatusTypeId
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Running extends Equal.Equal {
-  readonly _tag: "Running"
-  readonly [FiberStatusTypeId]: FiberStatusTypeId
-  readonly runtimeFlags: RuntimeFlags.RuntimeFlags
-}
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Suspended extends Equal.Equal {
-  readonly _tag: "Suspended"
-  readonly [FiberStatusTypeId]: FiberStatusTypeId
-  readonly runtimeFlags: RuntimeFlags.RuntimeFlags
-  readonly blockingOn: FiberId.FiberId
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const done: FiberStatus = internal.done
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const running: (runtimeFlags: RuntimeFlags.RuntimeFlags) => FiberStatus = internal.running
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const suspended: (runtimeFlags: RuntimeFlags.RuntimeFlags, blockingOn: FiberId.FiberId) => FiberStatus =
-  internal.suspended
-
-/**
- * Returns `true` if the specified value is a `FiberStatus`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isFiberStatus: (u: unknown) => u is FiberStatus = internal.isFiberStatus
-
-/**
- * Returns `true` if the specified `FiberStatus` is `Done`, `false` otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isDone: (self: FiberStatus) => self is Done = internal.isDone
-
-/**
- * Returns `true` if the specified `FiberStatus` is `Running`, `false`
- * otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isRunning: (self: FiberStatus) => self is Running = internal.isRunning
-
-/**
- * Returns `true` if the specified `FiberStatus` is `Suspended`, `false`
- * otherwise.
- *
- * @since 2.0.0
- * @category refinements
- */
-export const isSuspended: (self: FiberStatus) => self is Suspended = internal.isSuspended