@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/Supervisor.ts

@@ -0,0 +1,240 @@
+/**
+ * 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

@@ -0,0 +1,29 @@
+/**
+ * @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

@@ -0,0 +1,270 @@
+/**
+ * @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