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

package/src/Ref.ts

@@ -0,0 +1,180 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/ref.js"
+import type * as Option from "./Option.js"
+import type * as Readable from "./Readable.js"
+import type * as Types from "./Types.js"
+import type * as Unify from "./Unify.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const RefTypeId: unique symbol = internal.RefTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type RefTypeId = typeof RefTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Ref<in out A> extends Ref.Variance<A>, Effect.Effect<A>, Readable.Readable<A> {
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
+  readonly [Unify.typeSymbol]?: unknown
+  readonly [Unify.unifySymbol]?: RefUnify<this>
+  readonly [Unify.ignoreSymbol]?: RefUnifyIgnore
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
+  Ref?: () => Extract<A[Unify.typeSymbol], Ref<any>>
+}
+
+/**
+ * @category models
+ * @since 3.8.0
+ */
+export interface RefUnifyIgnore extends Effect.EffectUnifyIgnore {
+  Effect?: true
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export declare namespace Ref {
+  /**
+   * @since 2.0.0
+   */
+  export interface Variance<in out A> {
+    readonly [RefTypeId]: {
+      readonly _A: Types.Invariant<A>
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <A>(value: A) => Effect.Effect<Ref<A>> = internal.make
+
+/**
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <A>(self: Ref<A>) => Effect.Effect<A> = internal.get
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndSet: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<A>
+} = internal.getAndSet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdate: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
+} = internal.getAndUpdate
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const getAndUpdateSome: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
+} = internal.getAndUpdateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modify: {
+  <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<B>
+  <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
+} = internal.modify
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const modifySome: {
+  <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<B>
+  <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B>
+} = internal.modifySome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const set: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, value: A): Effect.Effect<void>
+} = internal.set
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const setAndGet: {
+  <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, value: A): Effect.Effect<A>
+} = internal.setAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const update: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<void>
+} = internal.update
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateAndGet: {
+  <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
+} = internal.updateAndGet
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSome: {
+  <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<void>
+  <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
+} = internal.updateSome
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+export const updateSomeAndGet: {
+  <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
+} = internal.updateSomeAndGet
+
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeMake: <A>(value: A) => Ref<A> = internal.unsafeMake

package/src/RegExp.ts

@@ -0,0 +1,38 @@
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+import * as predicate from "./Predicate.js"
+
+/**
+ * Tests if a value is a `RegExp`.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { RegExp } from "effect"
+ *
+ * assert.deepStrictEqual(RegExp.isRegExp(/a/), true)
+ * assert.deepStrictEqual(RegExp.isRegExp("a"), false)
+ * ```
+ *
+ * @category guards
+ * @since 3.9.0
+ */
+export const isRegExp: (input: unknown) => input is RegExp = predicate.isRegExp
+
+/**
+ * Escapes special characters in a regular expression pattern.
+ *
+ * @example
+ * ```ts
+ * import * as assert from "node:assert"
+ * import { RegExp } from "effect"
+ *
+ * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ * ```
+ *
+ * @since 2.0.0
+ */
+export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/Reloadable.ts

@@ -0,0 +1,127 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Context from "./Context.js"
+import type * as Effect from "./Effect.js"
+import * as internal from "./internal/reloadable.js"
+import type * as Layer from "./Layer.js"
+import type * as Schedule from "./Schedule.js"
+import type * as ScopedRef from "./ScopedRef.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const ReloadableTypeId: unique symbol = internal.ReloadableTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type ReloadableTypeId = typeof ReloadableTypeId
+
+/**
+ * A `Reloadable` is an implementation of some service that can be dynamically
+ * reloaded, or swapped out for another implementation on-the-fly.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Reloadable<in out A> extends Reloadable.Variance<A> {
+  /**
+   * @internal
+   */
+  readonly scopedRef: ScopedRef.ScopedRef<A>
+  /**
+   * @internal
+   */
+  readonly reload: Effect.Effect<void, unknown>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Reloadable {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<in out A> {
+    readonly [ReloadableTypeId]: {
+      readonly _A: Types.Invariant<A>
+    }
+  }
+}
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service. The service is automatically reloaded according to the
+ * provided schedule.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const auto: <I, S, E, In, R>(
+  tag: Context.Tag<I, S>,
+  options: { readonly layer: Layer.Layer<I, E, In>; readonly schedule: Schedule.Schedule<unknown, unknown, R> }
+) => Layer.Layer<Reloadable<I>, E, R | In> = internal.auto
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service. The service is automatically reloaded according to a
+ * schedule, which is extracted from the input to the layer.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const autoFromConfig: <I, S, E, In, R>(
+  tag: Context.Tag<I, S>,
+  options: {
+    readonly layer: Layer.Layer<I, E, In>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
+  }
+) => Layer.Layer<Reloadable<I>, E, R | In> = internal.autoFromConfig
+
+/**
+ * Retrieves the current version of the reloadable service.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+export const get: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<S, never, Reloadable<I>> = internal.get
+
+/**
+ * Makes a new reloadable service from a layer that describes the construction
+ * of a static service.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const manual: <I, S, In, E>(
+  tag: Context.Tag<I, S>,
+  options: { readonly layer: Layer.Layer<I, E, In> }
+) => Layer.Layer<Reloadable<I>, E, In> = internal.manual
+
+/**
+ * Reloads the specified service.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const reload: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<void, unknown, Reloadable<I>> = internal.reload
+
+/**
+ * @since 2.0.0
+ * @category context
+ */
+export const tag: <I, S>(tag: Context.Tag<I, S>) => Context.Tag<Reloadable<I>, Reloadable<S>> = internal.reloadableTag
+
+/**
+ * Forks the reload of the service in the background, ignoring any errors.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const reloadFork: <I, S>(tag: Context.Tag<I, S>) => Effect.Effect<void, unknown, Reloadable<I>> =
+  internal.reloadFork

package/src/Request.ts

@@ -0,0 +1,347 @@
+/**
+ * @since 2.0.0
+ */
+import type * as _Cache from "./Cache.js"
+import type { Cause } from "./Cause.js"
+import type { Deferred } from "./Deferred.js"
+import type { DurationInput } from "./Duration.js"
+import type * as Effect from "./Effect.js"
+import type * as Exit from "./Exit.js"
+import type { FiberId } from "./FiberId.js"
+import * as RequestBlock_ from "./internal/blockedRequests.js"
+import * as cache from "./internal/cache.js"
+import * as core from "./internal/core.js"
+import * as fiberRuntime from "./internal/fiberRuntime.js"
+import * as internal from "./internal/request.js"
+import type * as Option from "./Option.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const RequestTypeId: unique symbol = internal.RequestTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type RequestTypeId = typeof RequestTypeId
+
+/**
+ * A `Request<A, E>` is a request from a data source for a value of type `A`
+ * that may fail with an `E`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Request<out A, out E = never> extends Request.Variance<A, E> {}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace Request {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<out A, out E> {
+    readonly [RequestTypeId]: {
+      readonly _A: Types.Covariant<A>
+      readonly _E: Types.Covariant<E>
+    }
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Constructor<R extends Request<any, any>, T extends keyof R = never> {
+    (args: Omit<R, T | keyof (Request.Variance<Request.Success<R>, Request.Error<R>>)>): R
+  }
+
+  /**
+   * A utility type to extract the error type from a `Request`.
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Error<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _E : never
+
+  /**
+   * A utility type to extract the value type from a `Request`.
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Success<T extends Request<any, any>> = [T] extends [Request<infer _A, infer _E>] ? _A : never
+
+  /**
+   * A utility type to extract the result type from a `Request`.
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type Result<T extends Request<any, any>> = T extends Request<infer A, infer E> ? Exit.Exit<A, E> : never
+
+  /**
+   * A utility type to extract the optional result type from a `Request`.
+   *
+   * @since 2.0.0
+   * @category type-level
+   */
+  export type OptionalResult<T extends Request<any, any>> = T extends Request<infer A, infer E>
+    ? Exit.Exit<Option.Option<A>, E>
+    : never
+}
+
+/**
+ * Returns `true` if the specified value is a `Request`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isRequest: (u: unknown) => u is Request<unknown, unknown> = internal.isRequest
+
+/**
+ * Constructs a new `Request`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const of: <R extends Request<any, any>>() => Request.Constructor<R> = internal.of
+
+/**
+ * Constructs a new `Request`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const tagged: <R extends Request<any, any> & { _tag: string }>(
+  tag: R["_tag"]
+) => Request.Constructor<R, "_tag"> = internal.tagged
+
+/**
+ * Provides a constructor for a Request Class.
+ *
+ * @example
+ * ```ts
+ * import { Request } from "effect"
+ *
+ * type Success = string
+ * type Error = never
+ *
+ * class MyRequest extends Request.Class<Success, Error, {
+ *   readonly id: string
+ * }> {}
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Class: new<Success, Error, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
+) => Request<Success, Error> & Readonly<A> = internal.Class as any
+
+/**
+ * Provides a Tagged constructor for a Request Class.
+ *
+ * @example
+ * ```ts
+ * import { Request } from "effect"
+ *
+ * type Success = string
+ * type Error = never
+ *
+ * class MyRequest extends Request.TaggedClass("MyRequest")<Success, Error, {
+ *   readonly name: string
+ * }> {}
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const TaggedClass: <Tag extends string>(
+  tag: Tag
+) => new<Success, Error, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
+) => Request<Success, Error> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any
+
+/**
+ * Complete a `Request` with the specified result.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const complete: {
+  <A extends Request<any, any>>(result: Request.Result<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, result: Request.Result<A>): Effect.Effect<void>
+} = internal.complete
+
+/**
+ * Interrupts the child effect when requests are no longer needed
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const interruptWhenPossible: {
+  (all: Iterable<Request<any, any>>): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, all: Iterable<Request<any, any>>): Effect.Effect<void, E, R>
+} = fiberRuntime.interruptWhenPossible
+
+/**
+ * Complete a `Request` with the specified effectful computation, failing the
+ * request with the error from the effect workflow if it fails, and completing
+ * the request with the value of the effect workflow if it succeeds.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const completeEffect: {
+  <A extends Request<any, any>, R>(
+    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
+  ): (self: A) => Effect.Effect<void, never, R>
+  <A extends Request<any, any>, R>(
+    self: A,
+    effect: Effect.Effect<Request.Success<A>, Request.Error<A>, R>
+  ): Effect.Effect<void, never, R>
+} = internal.completeEffect
+
+/**
+ * Complete a `Request` with the specified error.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const fail: {
+  <A extends Request<any, any>>(error: Request.Error<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<void>
+} = internal.fail
+
+/**
+ * Complete a `Request` with the specified cause.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const failCause: {
+  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<void>
+} = internal.failCause
+
+/**
+ * Complete a `Request` with the specified value.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const succeed: {
+  <A extends Request<any, any>>(value: Request.Success<A>): (self: A) => Effect.Effect<void>
+  <A extends Request<any, any>>(self: A, value: Request.Success<A>): Effect.Effect<void>
+} = internal.succeed
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+export interface Listeners {
+  readonly count: number
+  readonly observers: Set<(count: number) => void>
+  interrupted: boolean
+  addObserver(f: (count: number) => void): void
+  removeObserver(f: (count: number) => void): void
+  increment(): void
+  decrement(): void
+}
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+export interface Cache extends
+  _Cache.ConsumerCache<Request<any, any>, {
+    listeners: Listeners
+    handle: Deferred<unknown, unknown>
+  }>
+{}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export const makeCache = (
+  options: {
+    readonly capacity: number
+    readonly timeToLive: DurationInput
+  }
+): Effect.Effect<Cache> =>
+  cache.make({
+    ...options,
+    lookup: () =>
+      core.map(core.deferredMake<unknown, unknown>(), (handle) => ({ listeners: new internal.Listeners(), handle }))
+  })
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const EntryTypeId: unique symbol = Symbol.for("effect/RequestBlock.Entry")
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type EntryTypeId = typeof EntryTypeId
+
+/**
+ * A `Entry<A>` keeps track of a request of type `A` along with a
+ * `Ref` containing the result of the request, existentially hiding the result
+ * type. This is used internally by the library to support data sources that
+ * return different result types for different requests while guaranteeing that
+ * results will be of the type requested.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface Entry<out R> extends Entry.Variance<R> {
+  readonly request: R
+  readonly result: Deferred<
+    [R] extends [Request<infer _A, infer _E>] ? _A : never,
+    [R] extends [Request<infer _A, infer _E>] ? _E : never
+  >
+  readonly listeners: Listeners
+  readonly ownerId: FiberId
+  readonly state: {
+    completed: boolean
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export declare namespace Entry {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<out R> {
+    readonly [EntryTypeId]: {
+      readonly _R: Types.Covariant<R>
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category guards
+ */
+export const isEntry = RequestBlock_.isEntry
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const makeEntry = RequestBlock_.makeEntry