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

package/src/Supervisor.ts

@@ -1,240 +0,0 @@
-/**
- * A `Supervisor<T>` is allowed to supervise the launching and termination of
- * fibers, producing some visible value of type `T` from the supervision.
- *
- * @since 2.0.0
- */
-import type * as Context from "./Context.js"
-import type * as Effect from "./Effect.js"
-import type * as Exit from "./Exit.js"
-import type * as Fiber from "./Fiber.js"
-import * as core from "./internal/core.js"
-import * as circular from "./internal/layer/circular.js"
-import * as internal from "./internal/supervisor.js"
-import type * as Layer from "./Layer.js"
-import type * as MutableRef from "./MutableRef.js"
-import type * as Option from "./Option.js"
-import type * as SortedSet from "./SortedSet.js"
-import type * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const SupervisorTypeId: unique symbol = internal.SupervisorTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type SupervisorTypeId = typeof SupervisorTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface Supervisor<out T> extends Supervisor.Variance<T> {
-  /**
-   * Returns an `Effect` that succeeds with the value produced by this
-   * supervisor. This value may change over time, reflecting what the supervisor
-   * produces as it supervises fibers.
-   */
-  readonly value: Effect.Effect<T>
-
-  /**
-   * Supervises the start of a `Fiber`.
-   */
-  onStart<A, E, R>(
-    context: Context.Context<R>,
-    effect: Effect.Effect<A, E, R>,
-    parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    fiber: Fiber.RuntimeFiber<A, E>
-  ): void
-
-  /**
-   * Supervises the end of a `Fiber`.
-   */
-  onEnd<A, E>(value: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void
-
-  /**
-   * Supervises the execution of an `Effect` by a `Fiber`.
-   */
-  onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<any, any, any>): void
-
-  /**
-   * Supervises the suspension of a computation running within a `Fiber`.
-   */
-  onSuspend<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void
-
-  /**
-   * Supervises the resumption of a computation running within a `Fiber`.
-   */
-  onResume<A, E>(fiber: Fiber.RuntimeFiber<A, E>): void
-
-  /**
-   * Maps this supervisor to another one, which has the same effect, but whose
-   * value has been transformed by the specified function.
-   */
-  map<B>(f: (a: T) => B): Supervisor<B>
-
-  /**
-   * Returns a new supervisor that performs the function of this supervisor, and
-   * the function of the specified supervisor, producing a tuple of the outputs
-   * produced by both supervisors.
-   */
-  zip<A>(right: Supervisor<A>): Supervisor<[T, A]>
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace Supervisor {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<out T> {
-    readonly [SupervisorTypeId]: {
-      readonly _T: Types.Covariant<T>
-    }
-  }
-}
-
-/**
- * @since 2.0.0
- * @category context
- */
-export const addSupervisor: <A>(supervisor: Supervisor<A>) => Layer.Layer<never> = circular.addSupervisor
-
-/**
- * Creates a new supervisor that tracks children in a set.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fibersIn: (
-  ref: MutableRef.MutableRef<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>
-) => Effect.Effect<Supervisor<SortedSet.SortedSet<Fiber.RuntimeFiber<any, any>>>> = internal.fibersIn
-
-/**
- * Creates a new supervisor that constantly yields effect when polled
- *
- * @since 2.0.0
- * @category constructors
- */
-export const fromEffect: <A>(effect: Effect.Effect<A>) => Supervisor<A> = internal.fromEffect
-
-/**
- * A supervisor that doesn't do anything in response to supervision events.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const none: Supervisor<void> = internal.none
-
-/**
- * Creates a new supervisor that tracks children in a set.
- *
- * @since 2.0.0
- * @category constructors
- */
-export const track: Effect.Effect<Supervisor<Array<Fiber.RuntimeFiber<any, any>>>> = internal.track
-
-/**
- * Unsafely creates a new supervisor that tracks children in a set.
- *
- * @since 2.0.0
- * @category unsafe
- */
-export const unsafeTrack: () => Supervisor<Array<Fiber.RuntimeFiber<any, any>>> = internal.unsafeTrack
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export abstract class AbstractSupervisor<T> implements Supervisor<T> {
-  /**
-   * @since 2.0.0
-   */
-  abstract value: Effect.Effect<T>
-
-  /**
-   * @since 2.0.0
-   */
-  onStart<A, E, R>(
-    _context: Context.Context<R>,
-    _effect: Effect.Effect<A, E, R>,
-    _parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
-    _fiber: Fiber.RuntimeFiber<A, E>
-  ): void {
-    //
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  onEnd<A, E>(
-    _value: Exit.Exit<A, E>,
-    _fiber: Fiber.RuntimeFiber<A, E>
-  ): void {
-    //
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  onEffect<A, E>(
-    _fiber: Fiber.RuntimeFiber<A, E>,
-    _effect: Effect.Effect<any, any, any>
-  ): void {
-    //
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  onSuspend<A, E>(
-    _fiber: Fiber.RuntimeFiber<A, E>
-  ): void {
-    //
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  onResume<A, E>(
-    _fiber: Fiber.RuntimeFiber<A, E>
-  ): void {
-    //
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  map<B>(f: (a: T) => B): Supervisor<B> {
-    return new internal.ProxySupervisor(this, core.map(this.value, f))
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  zip<A>(
-    right: Supervisor<A>
-  ): Supervisor<[T, A]> {
-    return new internal.Zip(this, right)
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  onRun<E, A, X>(execution: () => X, _fiber: Fiber.RuntimeFiber<A, E>): X {
-    return execution()
-  }
-
-  /**
-   * @since 2.0.0
-   */
-  readonly [SupervisorTypeId]: {
-    _T: (_: never) => never
-  } = internal.supervisorVariance
-}

package/src/Symbol.ts

@@ -1,29 +0,0 @@
-/**
- * @since 2.0.0
- */
-
-import * as equivalence from "./Equivalence.js"
-import * as predicate from "./Predicate.js"
-
-/**
- * Tests if a value is a `symbol`.
- *
- * @example
- * ```ts
- * import * as assert from "node:assert"
- * import { Predicate } from "effect"
- *
- * assert.deepStrictEqual(Predicate.isSymbol(Symbol.for("a")), true)
- * assert.deepStrictEqual(Predicate.isSymbol("a"), false)
- * ```
- *
- * @category guards
- * @since 2.0.0
- */
-export const isSymbol: (u: unknown) => u is symbol = predicate.isSymbol
-
-/**
- * @category instances
- * @since 2.0.0
- */
-export const Equivalence: equivalence.Equivalence<symbol> = equivalence.symbol

package/src/SynchronizedRef.ts

@@ -1,270 +0,0 @@
-/**
- * @since 2.0.0
- */
-import type * as Effect from "./Effect.js"
-import * as circular from "./internal/effect/circular.js"
-import * as ref from "./internal/ref.js"
-import * as internal from "./internal/synchronizedRef.js"
-import type * as Option from "./Option.js"
-import type * as Ref from "./Ref.js"
-import type * as Types from "./Types.js"
-import type * as Unify from "./Unify.js"
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export const SynchronizedRefTypeId: unique symbol = circular.SynchronizedTypeId
-
-/**
- * @since 2.0.0
- * @category symbols
- */
-export type SynchronizedRefTypeId = typeof SynchronizedRefTypeId
-
-/**
- * @since 2.0.0
- * @category models
- */
-export interface SynchronizedRef<in out A> extends SynchronizedRef.Variance<A>, Ref.Ref<A> {
-  modifyEffect<B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
-  readonly [Unify.typeSymbol]?: unknown
-  readonly [Unify.unifySymbol]?: SynchronizedRefUnify<this>
-  readonly [Unify.ignoreSymbol]?: SynchronizedRefUnifyIgnore
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface SynchronizedRefUnify<A extends { [Unify.typeSymbol]?: any }> extends Ref.RefUnify<A> {
-  SynchronizedRef?: () => Extract<A[Unify.typeSymbol], SynchronizedRef<any>>
-}
-
-/**
- * @category models
- * @since 3.8.0
- */
-export interface SynchronizedRefUnifyIgnore extends Ref.RefUnifyIgnore {
-  Ref?: true
-}
-
-/**
- * @since 2.0.0
- */
-export declare namespace SynchronizedRef {
-  /**
-   * @since 2.0.0
-   * @category models
-   */
-  export interface Variance<in out A> {
-    readonly [SynchronizedRefTypeId]: {
-      readonly _A: Types.Invariant<A>
-    }
-  }
-}
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const make: <A>(value: A) => Effect.Effect<SynchronizedRef<A>> = circular.makeSynchronized
-
-/**
- * @since 2.0.0
- * @category getters
- */
-export const get: <A>(self: SynchronizedRef<A>) => Effect.Effect<A> = ref.get
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndSet: {
-  <A>(value: A): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, value: A): Effect.Effect<A>
-} = ref.getAndSet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdate: {
-  <A>(f: (a: A) => A): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, f: (a: A) => A): Effect.Effect<A>
-} = ref.getAndUpdate
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SynchronizedRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
-} = internal.getAndUpdateEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateSome: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = ref.getAndUpdateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const getAndUpdateSomeEffect: {
-  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: SynchronizedRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R>
-} = internal.getAndUpdateSomeEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modify: {
-  <A, B>(f: (a: A) => readonly [B, A]): (self: SynchronizedRef<A>) => Effect.Effect<B>
-  <A, B>(self: SynchronizedRef<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
-} = internal.modify
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifyEffect: {
-  <A, B, E, R>(f: (a: A) => Effect.Effect<readonly [B, A], E, R>): (self: SynchronizedRef<A>) => Effect.Effect<B, E, R>
-  <A, B, E, R>(self: SynchronizedRef<A>, f: (a: A) => Effect.Effect<readonly [B, A], E, R>): Effect.Effect<B, E, R>
-} = internal.modifyEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifySome: {
-  <B, A>(
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ): (self: Ref.Ref<A>) => Effect.Effect<B>
-  <A, B>(
-    self: Ref.Ref<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<readonly [B, A]>
-  ): Effect.Effect<B>
-} = ref.modifySome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const modifySomeEffect: {
-  <A, B, R, E>(
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
-  ): (self: SynchronizedRef<A>) => Effect.Effect<B, E, R>
-  <A, B, R, E>(
-    self: SynchronizedRef<A>,
-    fallback: B,
-    pf: (a: A) => Option.Option<Effect.Effect<readonly [B, A], E, R>>
-  ): Effect.Effect<B, E, R>
-} = internal.modifySomeEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const set: {
-  <A>(value: A): (self: Ref.Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref.Ref<A>, value: A): Effect.Effect<void>
-} = ref.set
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const setAndGet: {
-  <A>(value: A): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, value: A): Effect.Effect<A>
-} = ref.setAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const update: {
-  <A>(f: (a: A) => A): (self: Ref.Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref.Ref<A>, f: (a: A) => A): Effect.Effect<void>
-} = ref.update
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SynchronizedRef<A>) => Effect.Effect<void, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<void, E, R>
-} = internal.updateEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateAndGet: {
-  <A>(f: (a: A) => A): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, f: (a: A) => A): Effect.Effect<A>
-} = ref.updateAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateAndGetEffect: {
-  <A, R, E>(f: (a: A) => Effect.Effect<A, E, R>): (self: SynchronizedRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, f: (a: A) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
-} = internal.updateAndGetEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSome: {
-  <A>(f: (a: A) => Option.Option<A>): (self: Ref.Ref<A>) => Effect.Effect<void>
-  <A>(self: Ref.Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
-} = ref.updateSome
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeEffect: {
-  <A, R, E>(
-    pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>
-  ): (self: SynchronizedRef<A>) => Effect.Effect<void, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<void, E, R>
-} = internal.updateSomeEffect
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeAndGet: {
-  <A>(pf: (a: A) => Option.Option<A>): (self: Ref.Ref<A>) => Effect.Effect<A>
-  <A>(self: Ref.Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
-} = ref.updateSomeAndGet
-
-/**
- * @since 2.0.0
- * @category utils
- */
-export const updateSomeAndGetEffect: {
-  <A, R, E>(pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): (self: SynchronizedRef<A>) => Effect.Effect<A, E, R>
-  <A, R, E>(self: SynchronizedRef<A>, pf: (a: A) => Option.Option<Effect.Effect<A, E, R>>): Effect.Effect<A, E, R>
-} = circular.updateSomeAndGetEffectSynchronized
-
-/**
- * @since 2.0.0
- * @category unsafe
- */
-export const unsafeMake: <A>(value: A) => SynchronizedRef<A> = circular.unsafeMakeSynchronized