effect 2.4.18 → 3.0.0

package/src/Brand.ts

@@ -16,11 +16,11 @@
  *
  * @since 2.0.0
  */
+import * as Array from "./Array.js"
 import * as Either from "./Either.js"
 import { identity } from "./Function.js"
 import * as Option from "./Option.js"
 import type { Predicate } from "./Predicate.js"
-import * as ReadonlyArray from "./ReadonlyArray.js"
 import type * as Types from "./Types.js"
 
 /**
@@ -69,7 +69,7 @@ export declare namespace Brand {
    * @since 2.0.0
    * @category models
    */
-  export interface BrandErrors extends ReadonlyArray<RefinementError> {}
+  export interface BrandErrors extends Array<RefinementError> {}
 
   /**
    * Represents an error that occurs when the provided value of the branded type does not pass the refinement predicate.
@@ -183,7 +183,7 @@ export const error = (message: string, meta?: unknown): Brand.BrandErrors => [{
  */
 export const errors: (...errors: Array<Brand.BrandErrors>) => Brand.BrandErrors = (
   ...errors: Array<Brand.BrandErrors>
-): Brand.BrandErrors => ReadonlyArray.flatten(errors)
+): Brand.BrandErrors => Array.flatten(errors)
 
 /**
  * Returns a `Brand.Constructor` that can construct a branded type from an unbranded value using the provided `refinement`

package/src/Cache.ts

@@ -43,7 +43,7 @@ export type CacheTypeId = typeof CacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Cache<in out Key, out Error, out Value> extends ConsumerCache<Key, Error, Value> {
+export interface Cache<in out Key, out Value, out Error = never> extends ConsumerCache<Key, Value, Error> {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise computes the value with the lookup function, puts it in the
@@ -83,7 +83,7 @@ export interface Cache<in out Key, out Error, out Value> extends ConsumerCache<K
  * @since 2.0.0
  * @category models
  */
-export interface ConsumerCache<in out Key, out Error, out Value> extends Cache.Variance<Key, Error, Value> {
+export interface ConsumerCache<in out Key, out Value, out Error = never> extends Cache.Variance<Key, Value, Error> {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
@@ -156,7 +156,7 @@ export declare namespace Cache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<in out Key, out Error, out Value> {
+  export interface Variance<in out Key, out Value, out Error> {
     readonly [CacheTypeId]: {
       readonly _Key: Types.Invariant<Key>
       readonly _Error: Types.Covariant<Error>
@@ -172,13 +172,13 @@ export declare namespace Cache {
  * @since 2.0.0
  * @category constructors
  */
-export const make: <Key, Environment, Error, Value>(
+export const make: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
   }
-) => Effect.Effect<Cache<Key, Error, Value>, never, Environment> = internal.make
+) => Effect.Effect<Cache<Key, Value, Error>, never, Environment> = internal.make
 
 /**
  * Constructs a new cache with the specified capacity, time to live, and
@@ -188,13 +188,13 @@ export const make: <Key, Environment, Error, Value>(
  * @since 2.0.0
  * @category constructors
  */
-export const makeWith: <Key, Environment, Error, Value>(
+export const makeWith: <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Lookup<Key, Environment, Error, Value>
+    readonly lookup: Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-) => Effect.Effect<Cache<Key, Error, Value>, never, Environment> = internal.makeWith
+) => Effect.Effect<Cache<Key, Value, Error>, never, Environment> = internal.makeWith
 
 /**
  * `CacheStats` represents a snapshot of statistics for the cache as of a
@@ -249,4 +249,6 @@ export const makeEntryStats: (loadedMillis: number) => EntryStats = internal.mak
  * @since 2.0.0
  * @category models
  */
-export type Lookup<Key, Environment, Error, Value> = (key: Key) => Effect.Effect<Value, Error, Environment>
+export type Lookup<Key, Value, Error = never, Environment = never> = (
+  key: Key
+) => Effect.Effect<Value, Error, Environment>

package/src/Cause.ts

@@ -36,7 +36,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as Sink from "./Sink.js"
 import type * as Stream from "./Stream.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant } from "./Types.js"
 
 /**
  * @since 2.0.0

package/src/Channel.ts

@@ -236,9 +236,9 @@ export const as: {
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+export const asVoid: <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-) => Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> = channel.asUnit
+) => Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> = channel.asVoid
 
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel
@@ -2049,11 +2049,14 @@ export const toStream: <OutElem, OutErr, OutDone, Env>(
   self: Channel<Chunk.Chunk<OutElem>, unknown, OutErr, unknown, OutDone, unknown, Env>
 ) => Stream.Stream<OutElem, OutErr, Env> = stream.channelToStream
 
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Channel<never> = core.unit
+const void_: Channel<never> = core.void
+export {
+  /**
+   * @since 2.0.0
+   * @category constructors
+   */
+  void_ as void
+}
 
 /**
  * Makes a channel from an effect that returns a channel in case of success.
@@ -2107,7 +2110,7 @@ export const withSpan: {
     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
@@ -2120,7 +2123,7 @@ export const withSpan: {
     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

package/src/Chunk.ts

@@ -1,6 +1,8 @@
 /**
  * @since 2.0.0
  */
+import * as RA from "./Array.js"
+import type { NonEmptyReadonlyArray } from "./Array.js"
 import type { Either } from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as Equivalence from "./Equivalence.js"
@@ -15,9 +17,7 @@ import * as Order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "./Predicate.js"
-import * as RA from "./ReadonlyArray.js"
-import type { NonEmptyReadonlyArray } from "./ReadonlyArray.js"
-import type { Covariant, NoInfer } from "./Types.js"
+import type { Covariant } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/Chunk") as TypeId
 

package/src/ConfigError.ts

@@ -39,6 +39,7 @@ export declare namespace ConfigError {
    * @category models
    */
   export interface Proto {
+    readonly _tag: "ConfigError"
     readonly [ConfigErrorTypeId]: ConfigErrorTypeId
   }
 
@@ -72,7 +73,7 @@ export interface ConfigErrorReducer<in C, in out Z> {
  * @category models
  */
 export interface And extends ConfigError.Proto {
-  readonly _tag: "And"
+  readonly _op: "And"
   readonly left: ConfigError
   readonly right: ConfigError
 }
@@ -82,7 +83,7 @@ export interface And extends ConfigError.Proto {
  * @category models
  */
 export interface Or extends ConfigError.Proto {
-  readonly _tag: "Or"
+  readonly _op: "Or"
   readonly left: ConfigError
   readonly right: ConfigError
 }
@@ -92,7 +93,7 @@ export interface Or extends ConfigError.Proto {
  * @category models
  */
 export interface InvalidData extends ConfigError.Proto {
-  readonly _tag: "InvalidData"
+  readonly _op: "InvalidData"
   readonly path: Array<string>
   readonly message: string
 }
@@ -102,7 +103,7 @@ export interface InvalidData extends ConfigError.Proto {
  * @category models
  */
 export interface MissingData extends ConfigError.Proto {
-  readonly _tag: "MissingData"
+  readonly _op: "MissingData"
   readonly path: Array<string>
   readonly message: string
 }
@@ -112,7 +113,7 @@ export interface MissingData extends ConfigError.Proto {
  * @category models
  */
 export interface SourceUnavailable extends ConfigError.Proto {
-  readonly _tag: "SourceUnavailable"
+  readonly _op: "SourceUnavailable"
   readonly path: Array<string>
   readonly message: string
   readonly cause: Cause.Cause<unknown>
@@ -123,7 +124,7 @@ export interface SourceUnavailable extends ConfigError.Proto {
  * @category models
  */
 export interface Unsupported extends ConfigError.Proto {
-  readonly _tag: "Unsupported"
+  readonly _op: "Unsupported"
   readonly path: Array<string>
   readonly message: string
 }

package/src/Cron.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import * as Array from "./Array.js"
 import * as Either from "./Either.js"
 import * as Equal from "./Equal.js"
 import * as equivalence from "./Equivalence.js"
@@ -10,7 +11,6 @@ import { format, type Inspectable, NodeInspectSymbol } from "./Inspectable.js"
 import * as N from "./Number.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import { hasProperty } from "./Predicate.js"
-import * as ReadonlyArray from "./ReadonlyArray.js"
 import * as String from "./String.js"
 import type { Mutable } from "./Types.js"
 
@@ -46,11 +46,11 @@ const CronProto: Omit<Cron, "minutes" | "hours" | "days" | "months" | "weekdays"
   },
   [Hash.symbol](this: Cron): number {
     return pipe(
-      Hash.array(ReadonlyArray.fromIterable(this.minutes)),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.hours))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.days))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.months))),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.weekdays))),
+      Hash.array(Array.fromIterable(this.minutes)),
+      Hash.combine(Hash.array(Array.fromIterable(this.hours))),
+      Hash.combine(Hash.array(Array.fromIterable(this.days))),
+      Hash.combine(Hash.array(Array.fromIterable(this.months))),
+      Hash.combine(Hash.array(Array.fromIterable(this.weekdays))),
       Hash.cached(this)
     )
   },
@@ -60,11 +60,11 @@ const CronProto: Omit<Cron, "minutes" | "hours" | "days" | "months" | "weekdays"
   toJSON(this: Cron) {
     return {
       _id: "Cron",
-      minutes: ReadonlyArray.fromIterable(this.minutes),
-      hours: ReadonlyArray.fromIterable(this.hours),
-      days: ReadonlyArray.fromIterable(this.days),
-      months: ReadonlyArray.fromIterable(this.months),
-      weekdays: ReadonlyArray.fromIterable(this.weekdays)
+      minutes: Array.fromIterable(this.minutes),
+      hours: Array.fromIterable(this.hours),
+      days: Array.fromIterable(this.days),
+      months: Array.fromIterable(this.months),
+      weekdays: Array.fromIterable(this.weekdays)
     }
   },
   [NodeInspectSymbol](this: Cron) {
@@ -107,11 +107,11 @@ export const make = ({
   readonly weekdays: Iterable<number>
 }): Cron => {
   const o: Mutable<Cron> = Object.create(CronProto)
-  o.minutes = new Set(ReadonlyArray.sort(minutes, N.Order))
-  o.hours = new Set(ReadonlyArray.sort(hours, N.Order))
-  o.days = new Set(ReadonlyArray.sort(days, N.Order))
-  o.months = new Set(ReadonlyArray.sort(months, N.Order))
-  o.weekdays = new Set(ReadonlyArray.sort(weekdays, N.Order))
+  o.minutes = new Set(Array.sort(minutes, N.Order))
+  o.hours = new Set(Array.sort(hours, N.Order))
+  o.days = new Set(Array.sort(days, N.Order))
+  o.months = new Set(Array.sort(months, N.Order))
+  o.weekdays = new Set(Array.sort(weekdays, N.Order))
   return o
 }
 
@@ -364,7 +364,7 @@ export const Equivalence: equivalence.Equivalence<Cron> = equivalence.make((self
 
 const restrictionsArrayEquals = equivalence.array(equivalence.number)
 const restrictionsEquals = (self: ReadonlySet<number>, that: ReadonlySet<number>): boolean =>
-  restrictionsArrayEquals(ReadonlyArray.fromIterable(self), ReadonlyArray.fromIterable(that))
+  restrictionsArrayEquals(Array.fromIterable(self), Array.fromIterable(that))
 
 /**
  * Checks if two `Cron`s are equal.

package/src/Duration.ts

@@ -128,7 +128,7 @@ export const decode = (input: DurationInput): Duration => {
       }
     }
   }
-  throw new Error("Invalid duration input")
+  throw new Error("Invalid DurationInput")
 }
 
 /**
@@ -515,6 +515,59 @@ export const clamp: {
     })
 )
 
+/**
+ * @since 2.4.19
+ * @category math
+ */
+export const divide: {
+  (by: number): (self: DurationInput) => Option.Option<Duration>
+  (self: DurationInput, by: number): Option.Option<Duration>
+} = dual(
+  2,
+  (self: DurationInput, by: number): Option.Option<Duration> =>
+    match(self, {
+      onMillis: (millis) => {
+        if (by === 0 || isNaN(by) || !Number.isFinite(by)) {
+          return Option.none()
+        }
+        return Option.some(make(millis / by))
+      },
+      onNanos: (nanos) => {
+        if (isNaN(by) || by <= 0 || !Number.isFinite(by)) {
+          return Option.none()
+        }
+        try {
+          return Option.some(make(nanos / BigInt(by)))
+        } catch (e) {
+          return Option.none()
+        }
+      }
+    })
+)
+
+/**
+ * @since 2.4.19
+ * @category math
+ */
+export const unsafeDivide: {
+  (by: number): (self: DurationInput) => Duration
+  (self: DurationInput, by: number): Duration
+} = dual(
+  2,
+  (self: DurationInput, by: number): Duration =>
+    match(self, {
+      onMillis: (millis) => make(millis / by),
+      onNanos: (nanos) => {
+        if (isNaN(by) || by < 0 || Object.is(by, -0)) {
+          return zero
+        } else if (Object.is(by, 0) || !Number.isFinite(by)) {
+          return infinity
+        }
+        return make(nanos / BigInt(by))
+      }
+    })
+)
+
 /**
  * @since 2.0.0
  * @category math

package/src/Effect.ts

@@ -55,7 +55,7 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
-import type { Concurrency, Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
+import type { Concurrency, Covariant, MergeRecord, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 // -------------------------------------------------------------------------------------
@@ -1466,11 +1466,14 @@ export const suspend: <A, E, R>(effect: LazyArg<Effect<A, E, R>>) => Effect<A, E
  */
 export const sync: <A>(evaluate: LazyArg<A>) => Effect<A> = core.sync
 
-/**
- * @since 2.0.0
- * @category constructors
- */
-export const unit: Effect<void> = core.unit
+const _void: Effect<void> = core.void
+export {
+  /**
+   * @since 2.0.0
+   * @category constructors
+   */
+  _void as void
+}
 
 /**
  * @since 2.0.0
@@ -2103,7 +2106,7 @@ export const asSomeError: <A, E, R>(self: Effect<A, E, R>) => Effect<A, Option.O
  * @since 2.0.0
  * @category mapping
  */
-export const asUnit: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R> = core.asUnit
+export const asVoid: <A, E, R>(self: Effect<A, E, R>) => Effect<void, E, R> = core.asVoid
 
 /**
  * Returns an effect that swaps the error/success cases. This allows you to
@@ -3340,16 +3343,12 @@ export const option: <A, E, R>(self: Effect<A, E, R>) => Effect<Option.Option<A>
 
 const if_: {
   <A1, E1, R1, A2, E2, R2>(
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
+    options: { readonly onTrue: LazyArg<Effect<A1, E1, R1>>; readonly onFalse: LazyArg<Effect<A2, E2, R2>> }
   ): <E = never, R = never>(self: boolean | Effect<boolean, E, R>) => Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
-  <A1, E1, R1, A2, E2, R2>(
-    self: boolean,
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
-  ): Effect<A1 | A2, E1 | E2, R1 | R2>
-  <E, R, A1, E1, R1, A2, E2, R2>(
-    self: Effect<boolean, E, R>,
-    options: { readonly onTrue: Effect<A1, E1, R1>; readonly onFalse: Effect<A2, E2, R2> }
-  ): Effect<A1 | A2, E | E1 | E2, R | R1 | R2>
+  <A1, E1, R1, A2, E2, R2, E = never, R = never>(
+    self: boolean | Effect<boolean, E, R>,
+    options: { readonly onTrue: LazyArg<Effect<A1, E1, R1>>; readonly onFalse: LazyArg<Effect<A2, E2, R2>> }
+  ): Effect<A1 | A2, E1 | E2 | E, R1 | R2 | R>
 } = core.if_
 
 export {
@@ -4340,10 +4339,18 @@ export const matchEffect: {
  * @since 2.0.0
  * @category logging
  */
-export const log: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.log
+export const log: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.log
+
+/**
+ * Logs the specified message or cause at the specified log level.
+ *
+ * @since 2.0.0
+ * @category logging
+ */
+export const logWithLevel = (
+  level: LogLevel,
+  ...message: ReadonlyArray<any>
+): Effect<void> => effect.logWithLevel(level)(...message)
 
 /**
  * Logs the specified message or cause at the Trace log level.
@@ -4351,10 +4358,7 @@ export const log: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logTrace: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logTrace
+export const logTrace: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logTrace
 
 /**
  * Logs the specified message or cause at the Debug log level.
@@ -4362,10 +4366,7 @@ export const logTrace: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logDebug: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logDebug
+export const logDebug: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logDebug
 
 /**
  * Logs the specified message or cause at the Info log level.
@@ -4373,10 +4374,7 @@ export const logDebug: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logInfo: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logInfo
+export const logInfo: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logInfo
 
 /**
  * Logs the specified message or cause at the Warning log level.
@@ -4384,10 +4382,7 @@ export const logInfo: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logWarning: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logWarning
+export const logWarning: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logWarning
 
 /**
  * Logs the specified message or cause at the Error log level.
@@ -4395,10 +4390,7 @@ export const logWarning: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logError: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logError
+export const logError: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logError
 
 /**
  * Logs the specified message or cause at the Fatal log level.
@@ -4406,10 +4398,7 @@ export const logError: <A>(
  * @since 2.0.0
  * @category logging
  */
-export const logFatal: <A>(
-  messageOrCause: A,
-  supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>
-) => Effect<void> = effect.logFatal
+export const logFatal: (...message: ReadonlyArray<any>) => Effect<void, never, never> = effect.logFatal
 
 /**
  * Adjusts the label for the current logging span.
@@ -5140,7 +5129,7 @@ export const currentSpan: Effect<Tracer.Span, Cause.NoSuchElementException> = ef
  * @since 2.0.0
  * @category tracing
  */
-export const currentParentSpan: Effect<Tracer.ParentSpan, Cause.NoSuchElementException> = effect.currentParentSpan
+export const currentParentSpan: Effect<Tracer.AnySpan, Cause.NoSuchElementException> = effect.currentParentSpan
 
 /**
  * @since 2.0.0
@@ -5162,12 +5151,12 @@ export const spanLinks: Effect<Chunk.Chunk<Tracer.SpanLink>> = effect.spanLinks
  */
 export const linkSpans: {
   (
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
   <A, E, R>(
     self: Effect<A, E, R>,
-    span: Tracer.ParentSpan,
+    span: Tracer.AnySpan,
     attributes?: Record<string, unknown>
   ): Effect<A, E, R>
 } = effect.linkSpans
@@ -5183,7 +5172,7 @@ export const makeSpan: (
   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
   }
@@ -5204,10 +5193,10 @@ export const makeSpanScoped: (
   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
 ) => Effect<Tracer.Span, never, Scope.Scope> = fiberRuntime.makeSpanScoped
 
 /**
@@ -5227,7 +5216,7 @@ export const useSpan: {
     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
     },
@@ -5247,7 +5236,7 @@ export const withSpan: {
     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
@@ -5258,7 +5247,7 @@ export const withSpan: {
     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
@@ -5279,7 +5268,7 @@ export const withSpanScoped: {
     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
     }
@@ -5290,7 +5279,7 @@ export const withSpanScoped: {
     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
     }
@@ -5304,8 +5293,8 @@ export const withSpanScoped: {
  * @category tracing
  */
 export const withParentSpan: {
-  (span: Tracer.ParentSpan): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>
-  <A, E, R>(self: Effect<A, E, R>, span: Tracer.ParentSpan): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  (span: Tracer.AnySpan): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+  <A, E, R>(self: Effect<A, E, R>, span: Tracer.AnySpan): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 } = effect.withParentSpan
 
 // -------------------------------------------------------------------------------------

package/src/Either.ts

@@ -12,7 +12,7 @@ import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import { isFunction } from "./Predicate.js"
-import type { Covariant, MergeRecord, NoInfer, NotFunction } from "./Types.js"
+import type { Covariant, MergeRecord, NotFunction } from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -287,15 +287,15 @@ export const getLeft: <R, L>(self: Either<R, L>) => Option<L> = either.getLeft
  * @category equivalence
  * @since 2.0.0
  */
-export const getEquivalence = <R, L>(
-  EquivalenceL: Equivalence.Equivalence<L>,
-  EquivalenceR: Equivalence.Equivalence<R>
-): Equivalence.Equivalence<Either<R, L>> =>
+export const getEquivalence = <R, L>({ left, right }: {
+  right: Equivalence.Equivalence<R>
+  left: Equivalence.Equivalence<L>
+}): Equivalence.Equivalence<Either<R, L>> =>
   Equivalence.make((x, y) =>
     x === y ||
     (isLeft(x) ?
-      isLeft(y) && EquivalenceL(x.left, y.left) :
-      isRight(y) && EquivalenceR(x.right, y.right))
+      isLeft(y) && left(x.left, y.left) :
+      isRight(y) && right(x.right, y.right))
   )
 
 /**