effect 2.4.17 → 2.4.19

package/src/Readable.ts

@@ -0,0 +1,92 @@
+/**
+ * @since 2.0.0
+ */
+import type { Effect } from "./Effect.js"
+import { dual } from "./Function.js"
+import * as core from "./internal/core.js"
+import { type Pipeable, pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("effect/Readable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Readable<A, E = never, R = never> extends Pipeable {
+  readonly [TypeId]: TypeId
+  readonly get: Effect<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isReadable = (u: unknown): u is Readable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Readable<any>, "get"> = {
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(get: Effect<A, E, R>): Readable<A, E, R> => {
+  const self = Object.create(Proto)
+  self.get = get
+  return self
+}
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Readable<A, E, R>) => Readable<B, E, R>
+  <A, E, R, B>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => B): Readable<B, E, R>
+} = dual(
+  2,
+  <A, E, R, B>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => B): Readable<B, E, R> => make(core.map(self.get, f))
+)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
+  ): <E, R>(fa: Readable<A, E, R>) => Readable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Readable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect<B, E2, R2>
+  ): Readable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Readable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect<B, E2, R2>
+): Readable<B, E | E2, R | R2> => make(core.flatMap(self.get, f)))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect<Readable<A, E, R>, E1, R1>
+): Readable<A, E | E1, R | R1> =>
+  make(
+    core.flatMap(effect, (s) => s.get)
+  )

package/src/Ref.ts

@@ -4,7 +4,7 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
+import type { Readable } from "./Readable.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -23,7 +23,7 @@ export type RefTypeId = typeof RefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Ref<in out A> extends Ref.Variance<A>, Pipeable {
+export interface Ref<in out A> extends Ref.Variance<A>, Readable<A> {
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B>
 }
 

package/src/RegExp.ts

@@ -0,0 +1,17 @@
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+
+/**
+ * Escapes special characters in a regular expression pattern.
+ *
+ * @example
+ * import * as RegExp from "effect/RegExp"
+ *
+ * assert.deepStrictEqual(RegExp.escape("a*b"), "a\\*b")
+ *
+ * @since 2.0.0
+ */
+export const escape = (string: string): string => string.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")

package/src/Subscribable.ts

@@ -0,0 +1,99 @@
+/**
+ * @since 2.0.0
+ */
+import * as Effect from "./Effect.js"
+import { dual } from "./Function.js"
+import { pipeArguments } from "./Pipeable.js"
+import { hasProperty } from "./Predicate.js"
+import * as Readable from "./Readable.js"
+import * as Stream from "./Stream.js"
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("effect/Subscribable")
+
+/**
+ * @since 2.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface Subscribable<A, E = never, R = never> extends Readable.Readable<A, E, R> {
+  readonly [TypeId]: TypeId
+  readonly changes: Stream.Stream<A, E, R>
+}
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSubscribable = (u: unknown): u is Subscribable<unknown, unknown, unknown> => hasProperty(u, TypeId)
+
+const Proto: Omit<Subscribable<any>, "get" | "changes"> = {
+  [Readable.TypeId]: Readable.TypeId,
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make = <A, E, R>(options: {
+  readonly get: Effect.Effect<A, E, R>
+  readonly changes: Stream.Stream<A, E, R>
+}): Subscribable<A, E, R> => Object.assign(Object.create(Proto), options)
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const map: {
+  <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E, R>
+  <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R>
+} = dual(2, <A, E, R, B>(self: Subscribable<A, E, R>, f: (a: NoInfer<A>) => B): Subscribable<B, E, R> =>
+  make({
+    get: Effect.map(self.get, f),
+    changes: Stream.map(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category combinators
+ */
+export const mapEffect: {
+  <A, B, E2, R2>(
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(fa: Subscribable<A, E, R>) => Subscribable<B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Subscribable<A, E, R>,
+    f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): Subscribable<B, E | E2, R | R2>
+} = dual(2, <A, E, R, B, E2, R2>(
+  self: Subscribable<A, E, R>,
+  f: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+): Subscribable<B, E | E2, R | R2> =>
+  make({
+    get: Effect.flatMap(self.get, f),
+    changes: Stream.mapEffect(self.changes, f)
+  }))
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const unwrap = <A, E, R, E1, R1>(
+  effect: Effect.Effect<Subscribable<A, E, R>, E1, R1>
+): Subscribable<A, E | E1, R | R1> =>
+  make({
+    get: Effect.flatMap(effect, (s) => s.get),
+    changes: Stream.unwrap(Effect.map(effect, (s) => s.changes))
+  })

package/src/SubscriptionRef.ts

@@ -4,10 +4,10 @@
 import type * as Effect from "./Effect.js"
 import * as internal from "./internal/subscriptionRef.js"
 import type * as Option from "./Option.js"
-import type { Pipeable } from "./Pipeable.js"
 import type * as PubSub from "./PubSub.js"
 import * as Ref from "./Ref.js"
 import type * as Stream from "./Stream.js"
+import type { Subscribable } from "./Subscribable.js"
 import * as Synchronized from "./SynchronizedRef.js"
 import type * as Types from "./Types.js"
 
@@ -31,7 +31,7 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
  * @category models
  */
 export interface SubscriptionRef<in out A>
-  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable
+  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Subscribable<A>
 {
   /** @internal */
   readonly ref: Ref.Ref<A>

package/src/TestAnnotation.ts

@@ -8,6 +8,7 @@ import type * as Fiber from "./Fiber.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import * as HashSet from "./HashSet.js"
+import { getBugErrorMessage } from "./internal/errors.js"
 import type * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
 import type * as SortedSet from "./SortedSet.js"
@@ -96,7 +97,7 @@ export const compose = <A>(
   if (Either.isLeft(left) && Either.isRight(right)) {
     return right
   }
-  throw new Error("BUG: TestAnnotation.compose - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("TestAnnotation.compose"))
 }
 
 /**

package/src/index.ts

@@ -570,6 +570,11 @@ export * as Random from "./Random.js"
  */
 export * as RateLimiter from "./RateLimiter.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Readable from "./Readable.js"
+
 /**
  * This module provides utility functions for working with arrays in TypeScript.
  *
@@ -594,6 +599,13 @@ export * as RedBlackTree from "./RedBlackTree.js"
  */
 export * as Ref from "./Ref.js"
 
+/**
+ * This module provides utility functions for working with RegExp in TypeScript.
+ *
+ * @since 2.0.0
+ */
+export * as RegExp from "./RegExp.js"
+
 /**
  * @since 2.0.0
  */
@@ -740,6 +752,11 @@ export * as String from "./String.js"
  */
 export * as Struct from "./Struct.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as Subscribable from "./Subscribable.js"
+
 /**
  * @since 2.0.0
  */

package/src/internal/cause.ts

@@ -14,6 +14,7 @@ import type { Predicate, Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type { ParentSpan, Span } from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
+import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 
 // -----------------------------------------------------------------------------
@@ -604,7 +605,7 @@ const flattenCauseLoop = (
     causes = sequential
     flattened = updated
   }
-  throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------
@@ -740,7 +741,7 @@ const evaluateCause = (
       }
     }
   }
-  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"))
 }
 
 // -----------------------------------------------------------------------------

package/src/internal/configProvider.ts

@@ -13,6 +13,7 @@ import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
+import * as regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
@@ -595,7 +596,7 @@ export const within = dual<
 })
 
 const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
-  const split = text.split(new RegExp(`\\s*${escapeRegex(delim)}\\s*`))
+  const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
 
@@ -626,8 +627,6 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-
 const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),

package/src/internal/core-effect.ts

@@ -27,9 +27,11 @@ import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { MergeRecord, NoInfer } from "../Types.js"
 import * as internalCause from "./cause.js"
+import { clockTag } from "./clock.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
 import * as fiberRefsPatch from "./fiberRefs/patch.js"
+import type { FiberRuntime } from "./fiberRuntime.js"
 import * as metricLabel from "./metric/label.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as SingleShotGen from "./singleShotGen.js"
@@ -1072,8 +1074,9 @@ export const mapAccum: {
     let i = 0
     while (!(next = iterator.next()).done) {
       const index = i++
+      const value = next.value
       result = core.flatMap(result, (state) =>
-        core.map(f(state, next.value, index), ([z, b]) => {
+        core.map(f(state, value, index), ([z, b]) => {
           builder.push(b)
           return z
         }))
@@ -2006,13 +2009,6 @@ export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementExceptio
   }
 )
 
-const bigint0 = BigInt(0)
-/** @internal */
-export const currentTimeNanosTracing = core.fiberRefGetWith(
-  core.currentTracerTimingEnabled,
-  (enabled) => enabled ? Clock.currentTimeNanos : core.succeed(bigint0)
-)
-
 /* @internal */
 export const linkSpans = dual<
   (
@@ -2040,8 +2036,11 @@ export const linkSpans = dual<
     )
 )
 
+const bigint0 = BigInt(0)
+
 /** @internal */
-export const makeSpan = (
+export const unsafeMakeSpan = <XA, XE>(
+  fiber: FiberRuntime<XA, XE>,
   name: string,
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
@@ -2050,55 +2049,67 @@ export const makeSpan = (
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }
-): Effect.Effect<Tracer.Span> =>
-  core.flatMap(fiberRefs, (fiberRefs) =>
-    core.sync(() => {
-      const enabled = FiberRefs.getOrDefault(fiberRefs, core.currentTracerEnabled)
-      if (enabled === false) {
-        return core.noopSpan(name)
-      }
+) => {
+  const enabled = fiber.getFiberRef(core.currentTracerEnabled)
+  if (enabled === false) {
+    return core.noopSpan(name)
+  }
 
-      const context = FiberRefs.getOrDefault(fiberRefs, core.currentContext)
-      const services = FiberRefs.getOrDefault(fiberRefs, defaultServices.currentServices)
-
-      const tracer = Context.get(services, internalTracer.tracerTag)
-      const clock = Context.get(services, Clock.Clock)
-      const timingEnabled = FiberRefs.getOrDefault(fiberRefs, core.currentTracerTimingEnabled)
-      const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
-      const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
-
-      const parent = options?.parent
-        ? Option.some(options.parent)
-        : options?.root
-        ? Option.none()
-        : Context.getOption(context, internalTracer.spanTag)
-
-      const links = linksFromEnv._tag === "Some" ?
-        options?.links !== undefined ?
-          [
-            ...Chunk.toReadonlyArray(linksFromEnv.value),
-            ...(options?.links ?? [])
-          ] :
-          Chunk.toReadonlyArray(linksFromEnv.value) :
-        options?.links ?? ReadonlyArray.empty()
-
-      const span = tracer.span(
-        name,
-        parent,
-        options?.context ?? Context.empty(),
-        links,
-        timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0
-      )
+  const context = fiber.getFiberRef(core.currentContext)
+  const services = fiber.getFiberRef(defaultServices.currentServices)
+
+  const tracer = Context.get(services, internalTracer.tracerTag)
+  const clock = Context.get(services, Clock.Clock)
+  const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+
+  const fiberRefs = fiber.getFiberRefs()
+  const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
+  const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
+
+  const parent = options?.parent
+    ? Option.some(options.parent)
+    : options?.root
+    ? Option.none()
+    : Context.getOption(context, internalTracer.spanTag)
+
+  const links = linksFromEnv._tag === "Some" ?
+    options?.links !== undefined ?
+      [
+        ...Chunk.toReadonlyArray(linksFromEnv.value),
+        ...(options?.links ?? [])
+      ] :
+      Chunk.toReadonlyArray(linksFromEnv.value) :
+    options?.links ?? ReadonlyArray.empty()
+
+  const span = tracer.span(
+    name,
+    parent,
+    options?.context ?? Context.empty(),
+    links,
+    timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0
+  )
 
-      if (annotationsFromEnv._tag === "Some") {
-        HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
-      }
-      if (options?.attributes) {
-        Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
-      }
+  if (annotationsFromEnv._tag === "Some") {
+    HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
+  }
+  if (options?.attributes !== undefined) {
+    Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
+  }
 
-      return span
-    }))
+  return span
+}
+
+/** @internal */
+export const makeSpan = (
+  name: string,
+  options?: {
+    readonly attributes?: Record<string, unknown> | undefined
+    readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+    readonly parent?: Tracer.ParentSpan | undefined
+    readonly root?: boolean | undefined
+    readonly context?: Context.Context<never> | undefined
+  }
+): Effect.Effect<Tracer.Span> => core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
 
 /* @internal */
 export const spanAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
@@ -2134,17 +2145,18 @@ export const useSpan: {
   } | undefined = args.length === 1 ? undefined : args[0]
   const evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R> = args[args.length - 1]
 
-  return core.acquireUseRelease(
-    makeSpan(name, options),
-    evaluate,
-    (span, exit) =>
-      span.status._tag === "Ended" ?
-        core.unit :
-        core.flatMap(
-          currentTimeNanosTracing,
-          (endTime) => core.sync(() => span.end(endTime, exit))
-        )
-  )
+  return core.withFiberRuntime<A, E, R>((fiber) => {
+    const span = unsafeMakeSpan(fiber, name, options)
+    const timingEnabled = fiber.getFiberRef(core.currentTracerTimingEnabled)
+    const clock = Context.get(fiber.getFiberRef(defaultServices.currentServices), clockTag)
+    return core.onExit(evaluate(span), (exit) =>
+      core.sync(() => {
+        if (span.status._tag === "Ended") {
+          return
+        }
+        span.end(timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0, exit)
+      }))
+  })
 }
 
 /** @internal */