effect 2.4.18 → 3.0.0

package/src/internal/core-effect.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Clock from "../Clock.js"
@@ -21,15 +22,16 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as Option from "../Option.js"
 import * as Predicate from "../Predicate.js"
 import type * as Random from "../Random.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { MergeRecord } 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"
@@ -341,7 +343,7 @@ export const allowInterrupt: Effect.Effect<void> = descriptorWith(
   (descriptor) =>
     HashSet.size(descriptor.interruptors) > 0
       ? core.interrupt
-      : core.unit
+      : core.void
 )
 
 /* @internal */
@@ -510,7 +512,7 @@ export const filterMap = dual<
 >(2, (elements, pf) =>
   core.map(
     core.forEachSequential(elements, identity),
-    ReadonlyArray.filterMap(pf)
+    Array.filterMap(pf)
   ))
 
 /* @internal */
@@ -693,7 +695,7 @@ export const firstSuccessOf = <Eff extends Effect.Effect<any, any, any>>(
     }
     return pipe(
       Chunk.tailNonEmpty(list),
-      ReadonlyArray.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
+      Array.reduce(Chunk.headNonEmpty(list), (left, right) => core.orElse(left, () => right) as Eff)
     )
   })
 
@@ -840,7 +842,7 @@ export const ignore = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<voi
 export const ignoreLogged = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, never, R> =>
   core.matchCauseEffect(self, {
     onFailure: (cause) => logDebug(cause, "An error was silently ignored because it is not anticipated to be useful"),
-    onSuccess: () => core.unit
+    onSuccess: () => core.void
   })
 
 /* @internal */
@@ -885,68 +887,71 @@ export const iterate: {
     return core.succeed(initial)
   })
 
-const logWithLevel = (level?: LogLevel.LogLevel) =>
-<A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
+/** @internal */
+export const logWithLevel = (level?: LogLevel.LogLevel) =>
+(
+  ...message: ReadonlyArray<any>
 ): Effect.Effect<void> => {
   const levelOption = Option.fromNullable(level)
-  let message: unknown
-  let cause: Cause.Cause<unknown>
-  if (internalCause.isCause(messageOrCause)) {
-    cause = messageOrCause
-    message = (supplementary as unknown) ?? ""
-  } else {
-    message = messageOrCause
-    cause = (supplementary as Cause.Cause<unknown>) ?? internalCause.empty
+  let cause: Cause.Cause<unknown> | undefined = undefined
+  for (let i = 0, len = message.length; i < len; i++) {
+    const msg = message[i]
+    if (internalCause.isCause(msg)) {
+      if (cause !== undefined) {
+        cause = internalCause.sequential(cause, msg)
+      } else {
+        cause = msg
+      }
+      message = [...message.slice(0, i), ...message.slice(i + 1)]
+      i--
+    }
+  }
+  if (message.length === 0) {
+    message = "" as any
+  } else if (message.length === 1) {
+    message = message[0]
+  }
+  if (cause === undefined) {
+    cause = internalCause.empty
   }
   return core.withFiberRuntime((fiberState) => {
     fiberState.log(message, cause, levelOption)
-    return core.unit
+    return core.void
   })
 }
 
 /** @internal */
-export const log: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel()
+export const log: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel()
 
 /** @internal */
-export const logTrace: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Trace)
+export const logTrace: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Trace
+)
 
 /** @internal */
-export const logDebug: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Debug)
+export const logDebug: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Debug
+)
 
 /** @internal */
-export const logInfo: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Info)
+export const logInfo: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Info
+)
 
 /** @internal */
-export const logWarning: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Warning)
+export const logWarning: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Warning
+)
 
 /** @internal */
-export const logError: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Error)
+export const logError: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Error
+)
 
 /** @internal */
-export const logFatal: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect.Effect<void> = logWithLevel(LogLevel.Fatal)
+export const logFatal: (...message: ReadonlyArray<any>) => Effect.Effect<void, never, never> = logWithLevel(
+  LogLevel.Fatal
+)
 
 /* @internal */
 export const withLogSpan = dual<
@@ -1015,7 +1020,7 @@ export const loop: {
 ): any =>
   options.discard
     ? loopDiscard(initial, options.while, options.step, options.body)
-    : core.map(loopInternal(initial, options.while, options.step, options.body), Array.from)
+    : core.map(loopInternal(initial, options.while, options.step, options.body), Array.fromIterable)
 
 const loopInternal = <Z, A, E, R>(
   initial: Z,
@@ -1045,7 +1050,7 @@ const loopDiscard = <S, X, E, R>(
         body(initial),
         () => loopDiscard(inc(initial), cont, inc, body)
       )
-      : core.unit
+      : core.void
   )
 
 /* @internal */
@@ -1072,8 +1077,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
         }))
@@ -1140,7 +1146,7 @@ export const none = <A, E, R>(
   core.flatMap(self, (option) => {
     switch (option._tag) {
       case "None":
-        return core.unit
+        return core.void
       case "Some":
         return core.fail(new core.NoSuchElementException())
     }
@@ -1152,7 +1158,7 @@ export const once = <A, E, R>(
 ): Effect.Effect<Effect.Effect<void, E, R>> =>
   core.map(
     Ref.make(true),
-    (ref) => core.asUnit(core.whenEffect(self, Ref.getAndSet(ref, false)))
+    (ref) => core.asVoid(core.whenEffect(self, Ref.getAndSet(ref, false)))
   )
 
 /* @internal */
@@ -1178,7 +1184,7 @@ export const orElseSucceed = dual<
 export const parallelErrors = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Array<E>, R> =>
   core.matchCauseEffect(self, {
     onFailure: (cause) => {
-      const errors = Array.from(internalCause.failures(cause))
+      const errors = Array.fromIterable(internalCause.failures(cause))
       return errors.length === 0
         ? core.failCause(cause as Cause.Cause<never>)
         : core.fail(errors)
@@ -1272,7 +1278,7 @@ export const reduce = dual<
     zero: Z,
     f: (z: Z, a: A, i: number) => Effect.Effect<Z, E, R>
   ) =>
-    ReadonlyArray.fromIterable(elements).reduce(
+    Array.fromIterable(elements).reduce(
       (acc, el, i) => core.flatMap(acc, (a) => f(a, el, i)),
       core.succeed(zero) as Effect.Effect<Z, E, R>
     )
@@ -1292,7 +1298,7 @@ export const reduceRight = dual<
 >(
   3,
   <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect.Effect<Z, E, R>) =>
-    ReadonlyArray.fromIterable(elements).reduceRight(
+    Array.fromIterable(elements).reduceRight(
       (acc, el, i) => core.flatMap(acc, (a) => f(el, a, i)),
       core.succeed(zero) as Effect.Effect<Z, E, R>
     )
@@ -1429,7 +1435,7 @@ export const labelMetrics = dual<
   <A, E, R>(self: Effect.Effect<A, E, R>, labels: Iterable<MetricLabel.MetricLabel>) => Effect.Effect<A, E, R>
 >(
   2,
-  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => ReadonlyArray.union(old, labels))
+  (self, labels) => core.fiberRefLocallyWith(self, core.currentMetricLabels, (old) => Array.union(old, labels))
 )
 
 /* @internal */
@@ -1590,7 +1596,7 @@ export const tapErrorTag = dual<
     if (Predicate.isTagged(e, k)) {
       return f(e as any)
     }
-    return core.unit as any
+    return core.void as any
   }))
 
 /* @internal */
@@ -1773,7 +1779,7 @@ export const updateFiberRefs = (
 ): Effect.Effect<void> =>
   core.withFiberRuntime((state) => {
     state.setFiberRefs(f(state.id(), state.getFiberRefs()))
-    return core.unit
+    return core.void
   })
 
 /* @internal */
@@ -1991,7 +1997,7 @@ export const annotateSpans = dual<
 )
 
 /** @internal */
-export const currentParentSpan: Effect.Effect<Tracer.ParentSpan, Cause.NoSuchElementException> = serviceOptional(
+export const currentParentSpan: Effect.Effect<Tracer.AnySpan, Cause.NoSuchElementException> = serviceOptional(
   internalTracer.spanTag
 )
 
@@ -1999,29 +2005,22 @@ export const currentParentSpan: Effect.Effect<Tracer.ParentSpan, Cause.NoSuchEle
 export const currentSpan: Effect.Effect<Tracer.Span, Cause.NoSuchElementException> = core.flatMap(
   core.context<never>(),
   (context) => {
-    const span = context.unsafeMap.get(internalTracer.spanTag.key) as Tracer.ParentSpan | undefined
+    const span = context.unsafeMap.get(internalTracer.spanTag.key) as Tracer.AnySpan | undefined
     return span !== undefined && span._tag === "Span"
       ? core.succeed(span)
       : core.fail(new core.NoSuchElementException())
   }
 )
 
-const bigint0 = BigInt(0)
-/** @internal */
-export const currentTimeNanosTracing = core.fiberRefGetWith(
-  core.currentTracerTimingEnabled,
-  (enabled) => enabled ? Clock.currentTimeNanos : core.succeed(bigint0)
-)
-
 /* @internal */
 export const linkSpans = dual<
   (
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ) => Effect.Effect<A, E, R>
 >(
@@ -2040,65 +2039,80 @@ 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
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     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 ?? Array.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.AnySpan | 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
@@ -2114,7 +2128,7 @@ export const useSpan: {
   <A, E, R>(name: string, options: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }, evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
@@ -2128,31 +2142,32 @@ export const useSpan: {
   const options: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   } | 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 */
 export const withParentSpan = dual<
   (
-    span: Tracer.ParentSpan
+    span: Tracer.AnySpan
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
-  <A, E, R>(self: Effect.Effect<A, E, R>, span: Tracer.ParentSpan) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Effect.Effect<A, E, R>, span: Tracer.AnySpan) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 >(2, (self, span) => provideService(self, internalTracer.spanTag, span))
 
 /** @internal */
@@ -2160,14 +2175,14 @@ export const withSpan = dual<
   (name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
   <A, E, R>(self: Effect.Effect<A, E, R>, name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>

package/src/internal/core-stream.ts

@@ -981,8 +981,11 @@ export const sync = <OutDone>(
   return op
 }
 
-/** @internal */
-export const unit: Channel.Channel<never> = succeedNow(void 0)
+const void_: Channel.Channel<never> = succeedNow(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const write = <OutElem>(