effect 2.0.0-next.55 → 2.0.0-next.57

package/src/Fiber.ts

@@ -19,6 +19,7 @@ import type * as order from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as RuntimeFlags from "./RuntimeFlags.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -56,11 +57,11 @@ export type RuntimeFiberTypeId = typeof RuntimeFiberTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
+export interface Fiber<out E, out A> extends Fiber.Variance<E, A>, Pipeable {
   /**
    * The identity of the fiber.
    */
-  readonly id: () => FiberId.FiberId
+  id(): FiberId.FiberId
 
   /**
    * Awaits the fiber, which suspends the awaiting fiber until the result of the
@@ -90,7 +91,7 @@ export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
    * specified fiber. If the fiber has already exited, the returned effect will
    * resume immediately. Otherwise, the effect will resume when the fiber exits.
    */
-  readonly interruptAsFork: (fiberId: FiberId.FiberId) => Effect.Effect<never, never, void>
+  interruptAsFork(fiberId: FiberId.FiberId): Effect.Effect<never, never, void>
 }
 
 /**
@@ -100,7 +101,7 @@ export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
  * @since 2.0.0
  * @category models
  */
-export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E, A> {
+export interface RuntimeFiber<out E, out A> extends Fiber<E, A>, Fiber.RuntimeVariance<E, A> {
   /**
    * Reads the current number of ops that have occurred since the last yield
    */
@@ -109,12 +110,12 @@ export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E
   /**
    * Reads the current value of a fiber ref
    */
-  readonly getFiberRef: <X>(fiberRef: FiberRef<X>) => X
+  getFiberRef<X>(fiberRef: FiberRef<X>): X
 
   /**
    * The identity of the fiber.
    */
-  readonly id: () => FiberId.Runtime
+  id(): FiberId.Runtime
 
   /**
    * The status of the fiber.
@@ -129,24 +130,24 @@ export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E
   /**
    * Adds an observer to the list of observers.
    */
-  readonly addObserver: (observer: (exit: Exit.Exit<E, A>) => void) => void
+  addObserver(observer: (exit: Exit.Exit<E, A>) => void): void
 
   /**
    * Removes the specified observer from the list of observers that will be
    * notified when the fiber exits.
    */
-  readonly removeObserver: (observer: (exit: Exit.Exit<E, A>) => void) => void
+  removeObserver(observer: (exit: Exit.Exit<E, A>) => void): void
 
   /**
    * Retrieves all fiber refs of the fiber.
    */
-  readonly getFiberRefs: () => FiberRefs.FiberRefs
+  getFiberRefs(): FiberRefs.FiberRefs
 
   /**
    * Unsafely observes the fiber, but returns immediately if it is not
    * already done.
    */
-  readonly unsafePoll: () => Exit.Exit<E, A> | null
+  unsafePoll(): Exit.Exit<E, A> | null
 }
 
 /**
@@ -163,20 +164,20 @@ export declare namespace Fiber {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<out E, out A> {
     readonly [FiberTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 
   /**
    * @since 2.0.0
    */
-  export interface RuntimeVariance<E, A> {
+  export interface RuntimeVariance<out E, out A> {
     readonly [RuntimeFiberTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -491,11 +492,17 @@ export const mapFiber: {
  */
 export const match: {
   <E, A, Z>(
-    options: { readonly onFiber: (fiber: Fiber<E, A>) => Z; readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z }
+    options: {
+      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+    }
   ): (self: Fiber<E, A>) => Z
   <E, A, Z>(
     self: Fiber<E, A>,
-    options: { readonly onFiber: (fiber: Fiber<E, A>) => Z; readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z }
+    options: {
+      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+    }
   ): Z
 } = internal.match
 

package/src/FiberRef.ts

@@ -25,6 +25,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 * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -42,28 +43,28 @@ export type FiberRefTypeId = typeof FiberRefTypeId
  * @since 2.0.0
  * @category model
  */
-export interface FiberRef<A> extends Variance<A>, Pipeable {
+export interface FiberRef<in out A> extends Variance<A>, Pipeable {
   /** @internal */
   readonly initial: A
   /** @internal */
-  readonly diff: (oldValue: A, newValue: A) => unknown
+  diff(oldValue: A, newValue: A): unknown
   /** @internal */
-  readonly combine: (first: unknown, second: unknown) => unknown
+  combine(first: unknown, second: unknown): unknown
   /** @internal */
-  readonly patch: (patch: unknown) => (oldValue: A) => A
+  patch(patch: unknown): (oldValue: A) => A
   /** @internal */
   readonly fork: unknown
   /** @internal */
-  readonly join: (oldValue: A, newValue: A) => A
+  join(oldValue: A, newValue: A): A
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Variance<A> {
+export interface Variance<in out A> {
   readonly [FiberRefTypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: Types.Invariant<A>
   }
 }
 
@@ -270,6 +271,12 @@ export const updateSomeAndGet: {
   <A>(self: FiberRef<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<never, never, A>
 } = core.fiberRefUpdateSomeAndGet
 
+/**
+ * @since 2.0.0
+ * @category fiberRefs
+ */
+export const currentConcurrency: FiberRef<number | "unbounded"> = core.currentConcurrency
+
 /**
  * @since 2.0.0
  * @category fiberRefs

package/src/GroupBy.ts

@@ -7,6 +7,7 @@ import type { Predicate } from "./Predicate.js"
 import type * as Queue from "./Queue.js"
 import type * as Stream from "./Stream.js"
 import type * as Take from "./Take.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -28,7 +29,7 @@ export type GroupByTypeId = typeof GroupByTypeId
  * @since 2.0.0
  * @category models
  */
-export interface GroupBy<R, E, K, V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
+export interface GroupBy<out R, out E, out K, out V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
   readonly grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
 }
 
@@ -40,12 +41,12 @@ export declare namespace GroupBy {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, K, V> {
+  export interface Variance<out R, out E, out K, out V> {
     readonly [GroupByTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _E: (_: never) => E
-      readonly _K: (_: never) => K
-      readonly _V: (_: never) => V
+      readonly _R: Types.Covariant<R>
+      readonly _E: Types.Covariant<E>
+      readonly _K: Types.Covariant<K>
+      readonly _V: Types.Covariant<V>
     }
   }
 }

package/src/HKT.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -37,8 +38,8 @@ export type Kind<F extends TypeLambda, In, Out2, Out1, Target> = F extends {
   })["type"]
   : {
     readonly F: F
-    readonly In: (_: In) => void
-    readonly Out2: () => Out2
-    readonly Out1: () => Out1
-    readonly Target: (_: Target) => Target
+    readonly In: Types.Contravariant<In>
+    readonly Out2: Types.Covariant<Out2>
+    readonly Out1: Types.Covariant<Out1>
+    readonly Target: Types.Invariant<Target>
   }

package/src/Hash.ts

@@ -28,7 +28,7 @@ export const symbol: unique symbol = Symbol.for("effect/Hash")
  * @category models
  */
 export interface Hash {
-  readonly [symbol]: () => number
+  [symbol](): number
 }
 
 /**

package/src/HashMap.ts

@@ -22,7 +22,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface HashMap<Key, Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
+export interface HashMap<out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
 }
 
@@ -381,7 +381,7 @@ export const reduce: {
  */
 export const filter: {
   <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
-  <K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
+  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HashMap<K, B>) => HashMap<K, B>
   <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
   <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
 } = HM.filter
@@ -414,6 +414,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const findFirst: {
-  <K, A>(predicate: (k: K, a: A) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
-  <K, A>(self: HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option<[K, A]>
+  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
+  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HashMap<K, B>) => Option<[K, B]>
+  <K, A, B extends A>(self: HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option<[K, B]>
+  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>
 } = HM.findFirst

package/src/HashSet.ts

@@ -20,7 +20,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface HashSet<A> extends Iterable<A>, Equal, Pipeable, Inspectable {
+export interface HashSet<out A> extends Iterable<A>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
 }
 
@@ -271,10 +271,10 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
-  <A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>
-  <A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): HashSet<B>
-  <A>(self: HashSet<A>, f: Predicate<A>): HashSet<A>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => HashSet<B>
+  <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>
+  <A>(self: HashSet<A>, predicate: Predicate<A>): HashSet<A>
 } = HS.filter
 
 /**
@@ -290,11 +290,11 @@ export const filter: {
 export const partition: {
   <C extends A, B extends A, A = C>(
     refinement: Refinement<A, B>
-  ): (self: HashSet<C>) => [HashSet<Exclude<C, B>>, HashSet<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HashSet<B>) => [HashSet<B>, HashSet<B>]
-  <C extends A, B extends A, A = C>(
-    self: HashSet<C>,
+  ): (self: HashSet<C>) => [excluded: HashSet<Exclude<C, B>>, satisfying: HashSet<B>]
+  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => [excluded: HashSet<B>, satisfying: HashSet<B>]
+  <A, B extends A>(
+    self: HashSet<A>,
     refinement: Refinement<A, B>
-  ): [HashSet<Exclude<C, B>>, HashSet<B>]
-  <B extends A, A = B>(self: HashSet<B>, predicate: (a: A) => boolean): [HashSet<B>, HashSet<B>]
+  ): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A>(self: HashSet<A>, predicate: Predicate<A>): [excluded: HashSet<A>, satisfying: HashSet<A>]
 } = HS.partition

package/src/Inspectable.ts

@@ -21,9 +21,9 @@ export type NodeInspectSymbol = typeof NodeInspectSymbol
  * @category models
  */
 export interface Inspectable {
-  readonly toString: () => string
-  readonly toJSON: () => unknown
-  readonly [NodeInspectSymbol]: () => unknown
+  toString(): string
+  toJSON(): unknown
+  [NodeInspectSymbol](): unknown
 }
 
 /**
@@ -41,7 +41,5 @@ export const toJSON = (x: unknown): unknown => {
   return x
 }
 
-/**
- * @since 2.0.0
- */
-export const toString = (x: unknown): string => JSON.stringify(x, null, 2)
+/** @internal */
+export const format = (x: unknown): string => JSON.stringify(x, null, 2)

package/src/KeyedPool.ts

@@ -6,6 +6,7 @@ import type * as Effect from "./Effect.js"
 import * as internal from "./internal/keyedPool.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Scope from "./Scope.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -26,21 +27,21 @@ export type KeyedPoolTypeId = typeof KeyedPoolTypeId
  * @since 2.0.0
  * @category models
  */
-export interface KeyedPool<K, E, A> extends KeyedPool.Variance<K, E, A>, Pipeable {
+export interface KeyedPool<in K, out E, in out A> extends KeyedPool.Variance<K, E, A>, Pipeable {
   /**
    * Retrieves an item from the pool belonging to the given key in a scoped
    * effect. Note that if acquisition fails, then the returned effect will fail
    * for that same reason. Retrying a failed acquisition attempt will repeat the
    * acquisition attempt.
    */
-  readonly get: (key: K) => Effect.Effect<Scope.Scope, E, A>
+  get(key: K): Effect.Effect<Scope.Scope, E, A>
 
   /**
    * Invalidates the specified item. This will cause the pool to eventually
    * reallocate the item, although this reallocation may occur lazily rather
    * than eagerly.
    */
-  readonly invalidate: (item: A) => Effect.Effect<never, never, void>
+  invalidate(item: A): Effect.Effect<never, never, void>
 }
 
 /**
@@ -51,11 +52,11 @@ export declare namespace KeyedPool {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<K, E, A> {
+  export interface Variance<in K, out E, in out A> {
     readonly [KeyedPoolTypeId]: {
-      readonly _K: (_: K) => void
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _K: Types.Contravariant<K>
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Invariant<A>
     }
   }
 }
@@ -70,7 +71,10 @@ export declare namespace KeyedPool {
  * @category constructors
  */
 export const make: <K, R, E, A>(
-  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: number }
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly size: number
+  }
 ) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.make
 
 /**
@@ -85,7 +89,10 @@ export const make: <K, R, E, A>(
  * @category constructors
  */
 export const makeWith: <K, R, E, A>(
-  options: { readonly acquire: (key: K) => Effect.Effect<R, E, A>; readonly size: (key: K) => number }
+  options: {
+    readonly acquire: (key: K) => Effect.Effect<R, E, A>
+    readonly size: (key: K) => number
+  }
 ) => Effect.Effect<Scope.Scope | R, never, KeyedPool<K, E, A>> = internal.makeWith
 
 /**

package/src/Layer.ts

@@ -41,6 +41,7 @@ import type * as Schedule from "./Schedule.js"
 import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Tracer from "./Tracer.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -58,7 +59,7 @@ export type LayerTypeId = typeof LayerTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Layer<RIn, E, ROut> extends Layer.Variance<RIn, E, ROut>, Pipeable {}
+export interface Layer<out RIn, out E, in ROut> extends Layer.Variance<RIn, E, ROut>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -68,11 +69,11 @@ export declare namespace Layer {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<RIn, E, ROut> {
+  export interface Variance<out RIn, out E, in ROut> {
     readonly [LayerTypeId]: {
-      readonly _RIn: (_: never) => RIn
-      readonly _E: (_: never) => E
-      readonly _ROut: (_: ROut) => void
+      readonly _RIn: Types.Covariant<RIn>
+      readonly _E: Types.Covariant<E>
+      readonly _ROut: Types.Contravariant<ROut>
     }
   }
   /**
@@ -415,24 +416,23 @@ export const memoize: <RIn, E, ROut>(
 ) => Effect.Effect<Scope.Scope, never, Layer<RIn, E, ROut>> = internal.memoize
 
 /**
- * Combines this layer with the specified layer, producing a new layer that
- * has the inputs and outputs of both.
+ * Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
  *
  * @since 2.0.0
- * @category utils
+ * @category zipping
  */
 export const merge: {
   <RIn2, E2, ROut2>(
     that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn2 | RIn, E2 | E, ROut2 | ROut>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
+  ): <RIn, E1, ROut>(self: Layer<RIn, E1, ROut>) => Layer<RIn2 | RIn, E2 | E1, ROut2 | ROut>
+  <RIn, E1, ROut, RIn2, E2, ROut2>(
+    self: Layer<RIn, E1, ROut>,
     that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | RIn2, E | E2, ROut | ROut2>
+  ): Layer<RIn | RIn2, E1 | E2, ROut | ROut2>
 } = internal.merge
 
 /**
- * Merges all the layers together in parallel.
+ * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
  *
  * @since 2.0.0
  * @category zipping
@@ -496,24 +496,6 @@ export const project: {
   ): Layer<RIn, E, Context.Tag.Identifier<B>>
 } = internal.project
 
-/**
- * Feeds the output services of this builder into the input of the specified
- * builder, resulting in a new builder with the inputs of this builder as
- * well as any leftover inputs, and the outputs of the specified builder.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provide: {
-  <RIn2, E2, ROut2>(
-    that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
-    that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
-} = internal.provide
-
 /**
  * @since 2.0.0
  * @category utils
@@ -567,24 +549,6 @@ export const locallyScoped: <A>(self: FiberRef<A>, value: A) => Layer<never, nev
 export const fiberRefLocallyScopedWith: <A>(self: FiberRef<A>, value: (_: A) => A) => Layer<never, never, never> =
   internal.fiberRefLocallyScopedWith
 
-/**
- * Feeds the output services of this layer into the input of the specified
- * layer, resulting in a new layer with the inputs of this layer, and the
- * outputs of both layers.
- *
- * @since 2.0.0
- * @category utils
- */
-export const provideMerge: {
-  <RIn2, E2, ROut2>(
-    that: Layer<RIn2, E2, ROut2>
-  ): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2 | ROut>
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer<RIn, E, ROut>,
-    that: Layer<RIn2, E2, ROut2>
-  ): Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>
-} = internal.provideMerge
-
 /**
  * Retries constructing this layer according to the specified schedule.
  *
@@ -787,7 +751,7 @@ export const toRuntime: <RIn, E, ROut>(
  * @since 2.0.0
  * @category utils
  */
-export const use: {
+export const provide: {
   <RIn, E, ROut>(
     self: Layer<RIn, E, ROut>
   ): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
@@ -795,7 +759,7 @@ export const use: {
     that: Layer<RIn2, E2, ROut2>,
     self: Layer<RIn, E, ROut>
   ): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2>
-} = internal.use
+} = internal.provide
 
 /**
  * Feeds the output services of this layer into the input of the specified
@@ -805,7 +769,7 @@ export const use: {
  * @since 2.0.0
  * @category utils
  */
-export const useMerge: {
+export const provideMerge: {
   <RIn, E, ROut>(
     self: Layer<RIn, E, ROut>
   ): <RIn2, E2, ROut2>(that: Layer<RIn2, E2, ROut2>) => Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut | ROut2>
@@ -813,17 +777,16 @@ export const useMerge: {
     that: Layer<RIn2, E2, ROut2>,
     self: Layer<RIn, E, ROut>
   ): Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut2 | ROut>
-} = internal.useMerge
+} = internal.provideMerge
 
 /**
- * Combines this layer the specified layer, producing a new layer that has the
- * inputs of both, and the outputs of both combined using the specified
- * function.
+ * Combines this layer with the specified layer concurrently, creating a new layer with merged input types and
+ * combined output types using the provided function.
  *
  * @since 2.0.0
  * @category zipping
  */
-export const zipWithPar: {
+export const zipWith: {
   <R2, E2, B, A, C>(
     that: Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -833,7 +796,7 @@ export const zipWithPar: {
     that: Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
   ): Layer<R | R2, E | E2, C>
-} = internal.zipWithPar
+} = internal.zipWith
 
 /**
  * @since 2.0.0