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

package/src/internal/fiberScope.ts

@@ -24,7 +24,7 @@ export type FiberScopeTypeId = typeof FiberScopeTypeId
 export interface FiberScope {
   readonly [FiberScopeTypeId]: FiberScopeTypeId
   get fiberId(): FiberId.FiberId
-  readonly add: (runtimeFlags: RuntimeFlags.RuntimeFlags, child: FiberRuntime.FiberRuntime<any, any>) => void
+  add(runtimeFlags: RuntimeFlags.RuntimeFlags, child: FiberRuntime.FiberRuntime<any, any>): void
 }
 
 /** @internal */

package/src/internal/groupBy.ts

@@ -27,11 +27,14 @@ export const GroupByTypeId: GroupBy.GroupByTypeId = Symbol.for(
   GroupBySymbolKey
 ) as GroupBy.GroupByTypeId
 
-/** @internal */
 const groupByVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _K: (_: never) => _,
+  /* c8 ignore next */
   _V: (_: never) => _
 }
 
@@ -315,7 +318,7 @@ export const bindEffect = dual<
 
 const mapDequeue = <A, B>(dequeue: Queue.Dequeue<A>, f: (a: A) => B): Queue.Dequeue<B> => new MapDequeue(dequeue, f)
 
-class MapDequeue<A, B> implements Queue.Dequeue<B> {
+class MapDequeue<in out A, out B> implements Queue.Dequeue<B> {
   readonly [Queue.DequeueTypeId] = {
     _Out: (_: never) => _
   }

package/src/internal/hashMap/node.ts

@@ -21,7 +21,7 @@ export interface SizeRef {
 }
 
 /** @internal */
-export class EmptyNode<K, V> {
+export class EmptyNode<out K, out V> {
   readonly _tag = "EmptyNode"
 
   modify(
@@ -57,7 +57,7 @@ export function canEditNode<K, V>(node: Node<K, V>, edit: number): boolean {
 }
 
 /** @internal */
-export class LeafNode<K, V> {
+export class LeafNode<out K, out V> {
   readonly _tag = "LeafNode"
 
   constructor(
@@ -103,7 +103,7 @@ export class LeafNode<K, V> {
 }
 
 /** @internal */
-export class CollisionNode<K, V> {
+export class CollisionNode<out K, out V> {
   readonly _tag = "CollisionNode"
 
   constructor(
@@ -180,7 +180,7 @@ export class CollisionNode<K, V> {
 }
 
 /** @internal */
-export class IndexedNode<K, V> {
+export class IndexedNode<out K, out V> {
   readonly _tag = "IndexedNode"
 
   constructor(
@@ -244,7 +244,7 @@ export class IndexedNode<K, V> {
 }
 
 /** @internal */
-export class ArrayNode<K, V> {
+export class ArrayNode<out K, out V> {
   readonly _tag = "ArrayNode"
 
   constructor(

package/src/internal/hashMap.ts

@@ -3,7 +3,7 @@ import * as Dual from "../Function.js"
 import { identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type * as HM from "../HashMap.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -34,7 +34,7 @@ interface VisitResult<K, V, A> {
 }
 
 /** @internal */
-export interface HashMapImpl<K, V> extends HM.HashMap<K, V> {
+export interface HashMapImpl<out K, out V> extends HM.HashMap<K, V> {
   _editable: boolean // mutable by design
   _edit: number // mutable by design
   _root: Node.Node<K, V> // mutable by design
@@ -76,7 +76,7 @@ const HashMapProto: HM.HashMap<unknown, unknown> = {
     return false
   },
   toString<K, V>(this: HashMapImpl<K, V>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {
@@ -106,7 +106,7 @@ const makeImpl = <K, V>(
   return map
 }
 
-class HashMapIterator<K, V, T> implements IterableIterator<T> {
+class HashMapIterator<in out K, in out V, out T> implements IterableIterator<T> {
   v: Option.Option<VisitResult<K, V, T>>
 
   constructor(readonly map: HashMapImpl<K, V>, readonly f: TraversalFn<K, V, T>) {
@@ -485,23 +485,22 @@ export const reduce = Dual.dual<
 })
 
 /** @internal */
-export const filter = Dual.dual<
-  {
-    <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
-    <K, A>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, A>) => HM.HashMap<K, A>
-  },
-  {
-    <K, A, B extends A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => a is B): HM.HashMap<K, B>
-    <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A>
-  }
->(2, <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean) =>
-  mutate(empty(), (map) => {
-    for (const [k, a] of self) {
-      if (f(a, k)) {
-        set(map, k, a)
+export const filter: {
+  <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
+  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, B>) => HM.HashMap<K, B>
+  <K, A, B extends A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => a is B): HM.HashMap<K, B>
+  <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A>
+} = Dual.dual(
+  2,
+  <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A> =>
+    mutate(empty(), (map) => {
+      for (const [k, a] of self) {
+        if (f(a, k)) {
+          set(map, k, a)
+        }
       }
-    }
-  }))
+    })
+)
 
 /** @internal */
 export const compact = <K, A>(self: HM.HashMap<K, Option.Option<A>>) => filterMap(self, identity)
@@ -524,13 +523,15 @@ export const filterMap = Dual.dual<
 
 /** @internal */
 export const findFirst: {
-  <K, A>(predicate: (k: K, a: A) => boolean): (self: HM.HashMap<K, A>) => Option.Option<[K, A]>
-  <K, A>(self: HM.HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option.Option<[K, A]>
+  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => Option.Option<[K, B]>
+  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HM.HashMap<K, B>) => Option.Option<[K, B]>
+  <K, A, B extends A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option.Option<[K, B]>
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option.Option<[K, A]>
 } = Dual.dual(
   2,
-  <K, A>(self: HM.HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option.Option<[K, A]> => {
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option.Option<[K, A]> => {
     for (const ka of self) {
-      if (predicate(ka[0], ka[1])) {
+      if (predicate(ka[1], ka[0])) {
         return Option.some(ka)
       }
     }

package/src/internal/hashSet.ts

@@ -3,7 +3,7 @@ import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type { HashMap } from "../HashMap.js"
 import type * as HS from "../HashSet.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
@@ -15,7 +15,7 @@ const HashSetSymbolKey = "effect/HashSet"
 export const HashSetTypeId: HS.TypeId = Symbol.for(HashSetSymbolKey) as HS.TypeId
 
 /** @internal */
-export interface HashSetImpl<A> extends HS.HashSet<A> {
+export interface HashSetImpl<out A> extends HS.HashSet<A> {
   readonly _keyMap: HashMap<A, unknown>
 }
 
@@ -37,7 +37,7 @@ const HashSetProto: Omit<HashSetImpl<unknown>, "_keyMap"> = {
     return false
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {
@@ -271,16 +271,12 @@ export const reduce = dual<
   ))
 
 /** @internal */
-export const filter = dual<
-  {
-    <A, B extends A>(f: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
-    <A>(f: Predicate<A>): (self: HS.HashSet<A>) => HS.HashSet<A>
-  },
-  {
-    <A, B extends A>(self: HS.HashSet<A>, f: Refinement<A, B>): HS.HashSet<B>
-    <A>(self: HS.HashSet<A>, f: Predicate<A>): HS.HashSet<A>
-  }
->(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+export const filter: {
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
+  <B extends A, A = B>(predicate: Predicate<B>): (self: HS.HashSet<A>) => HS.HashSet<A>
+  <A, B extends A>(self: HS.HashSet<A>, refinement: Refinement<A, B>): HS.HashSet<B>
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): HS.HashSet<A>
+} = dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
   return mutate(empty(), (set) => {
     const iterator = values(self)
     let next: IteratorResult<A, any>
@@ -297,25 +293,27 @@ export const filter = dual<
 export const partition: {
   <C extends A, B extends A, A = C>(
     refinement: Refinement<A, B>
-  ): (self: HS.HashSet<C>) => [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HS.HashSet<B>) => [HS.HashSet<B>, HS.HashSet<B>]
-  <C extends A, B extends A, A = C>(
-    self: HS.HashSet<C>,
+  ): (self: HS.HashSet<C>) => [excluded: HS.HashSet<Exclude<C, B>>, satisfying: HS.HashSet<B>]
+  <A, B extends A>(
+    predicate: Predicate<A>
+  ): (self: HS.HashSet<B>) => [excluded: HS.HashSet<B>, satisfying: HS.HashSet<B>]
+  <A, B extends A>(
+    self: HS.HashSet<A>,
     refinement: Refinement<A, B>
-  ): [HS.HashSet<Exclude<C, B>>, HS.HashSet<B>]
-  <B extends A, A = B>(self: HS.HashSet<B>, predicate: (a: A) => boolean): [HS.HashSet<B>, HS.HashSet<B>]
-} = dual(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {
+  ): [excluded: HS.HashSet<Exclude<A, B>>, satisfying: HS.HashSet<B>]
+  <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>]
+} = dual(2, <A>(self: HS.HashSet<A>, predicate: Predicate<A>): [excluded: HS.HashSet<A>, satisfying: HS.HashSet<A>] => {
   const iterator = values(self)
   let next: IteratorResult<A, any>
   const right = beginMutation(empty<A>())
   const left = beginMutation(empty<A>())
   while (!(next = iterator.next()).done) {
     const value = next.value
-    if (f(value)) {
+    if (predicate(value)) {
       add(right, value)
     } else {
       add(left, value)
     }
   }
-  return [endMutation(left), endMutation(right)] as const
+  return [endMutation(left), endMutation(right)]
 })

package/src/internal/keyedPool.ts

@@ -28,12 +28,15 @@ const KeyedPoolMapValueSymbol = Symbol.for("effect/KeyedPool/MapValue")
 type KeyedPoolMapValueSymbol = typeof KeyedPoolMapValueSymbol
 
 const keyedPoolVariance = {
+  /* c8 ignore next */
   _K: (_: unknown) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
-class KeyedPoolImpl<K, E, A> implements KeyedPool.KeyedPool<K, E, A> {
+class KeyedPoolImpl<in K, out E, in out A> implements KeyedPool.KeyedPool<K, E, A> {
   readonly [KeyedPoolTypeId] = keyedPoolVariance
   constructor(
     readonly getOrCreatePool: (key: K) => Effect.Effect<never, never, Pool.Pool<E, A>>,
@@ -52,7 +55,7 @@ class KeyedPoolImpl<K, E, A> implements KeyedPool.KeyedPool<K, E, A> {
 
 type MapValue<E, A> = Complete<E, A> | Pending<E, A>
 
-class Complete<E, A> implements Equal.Equal {
+class Complete<out E, in out A> implements Equal.Equal {
   readonly _tag = "Complete"
   readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
   constructor(readonly pool: Pool.Pool<E, A>) {}
@@ -70,7 +73,7 @@ class Complete<E, A> implements Equal.Equal {
 const isComplete = (u: unknown): u is Complete<unknown, unknown> =>
   Predicate.isTagged(u, "Complete") && KeyedPoolMapValueSymbol in u
 
-class Pending<E, A> implements Equal.Equal {
+class Pending<in out E, in out A> implements Equal.Equal {
   readonly _tag = "Pending"
   readonly [KeyedPoolMapValueSymbol]: KeyedPoolMapValueSymbol = KeyedPoolMapValueSymbol
   constructor(readonly deferred: Deferred.Deferred<never, Pool.Pool<E, A>>) {}

package/src/internal/layer.ts

@@ -38,10 +38,12 @@ export const LayerTypeId: Layer.LayerTypeId = Symbol.for(
   LayerSymbolKey
 ) as Layer.LayerTypeId
 
-/** @internal */
 const layerVariance = {
+  /* c8 ignore next */
   _RIn: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _ROut: (_: unknown) => _
 }
 
@@ -82,8 +84,8 @@ export interface ExtendScope extends
 export interface Fold extends
   Op<OpCodes.OP_FOLD, {
     readonly layer: Layer.Layer<never, never, unknown>
-    readonly failureK: (cause: Cause.Cause<unknown>) => Layer.Layer<never, never, unknown>
-    readonly successK: (context: Context.Context<unknown>) => Layer.Layer<never, never, unknown>
+    failureK(cause: Cause.Cause<unknown>): Layer.Layer<never, never, unknown>
+    successK(context: Context.Context<unknown>): Layer.Layer<never, never, unknown>
   }>
 {}
 
@@ -111,7 +113,7 @@ export interface Scoped extends
 /** @internal */
 export interface Suspend extends
   Op<OpCodes.OP_SUSPEND, {
-    readonly evaluate: LazyArg<Layer.Layer<never, never, unknown>>
+    evaluate(): Layer.Layer<never, never, unknown>
   }>
 {}
 
@@ -119,13 +121,13 @@ export interface Suspend extends
 export interface Locally extends
   Op<"Locally", {
     readonly self: Layer.Layer<never, never, unknown>
-    readonly f: (_: Effect.Effect<any, any, any>) => Effect.Effect<any, any, any>
+    f(_: Effect.Effect<any, any, any>): Effect.Effect<any, any, any>
   }>
 {}
 
 /** @internal */
 export interface ProvideTo extends
-  Op<OpCodes.OP_PROVIDE_TO, {
+  Op<OpCodes.OP_PROVIDE, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
   }>
@@ -133,25 +135,19 @@ export interface ProvideTo extends
 
 /** @internal */
 export interface ZipWith extends
-  Op<OpCodes.OP_ZIP_WITH, {
+  Op<OpCodes.OP_PROVIDE_MERGE, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
-    readonly zipK: (
-      left: Context.Context<unknown>,
-      right: Context.Context<unknown>
-    ) => Context.Context<unknown>
+    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
   }>
 {}
 
 /** @internal */
 export interface ZipWithPar extends
-  Op<OpCodes.OP_ZIP_WITH_PAR, {
+  Op<OpCodes.OP_ZIP_WITH, {
     readonly first: Layer.Layer<never, never, unknown>
     readonly second: Layer.Layer<never, never, unknown>
-    readonly zipK: (
-      left: Context.Context<unknown>,
-      right: Context.Context<unknown>
-    ) => Context.Context<unknown>
+    zipK(left: Context.Context<unknown>, right: Context.Context<unknown>): Context.Context<unknown>
   }>
 {}
 
@@ -357,7 +353,7 @@ const withScope = <RIn, E, ROut>(
     case "FromEffect": {
       return core.sync(() => (_: MemoMap) => op.effect as Effect.Effect<RIn, E, Context.Context<ROut>>)
     }
-    case "ProvideTo": {
+    case "Provide": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -386,7 +382,7 @@ const withScope = <RIn, E, ROut>(
         )
       )
     }
-    case "ZipWith": {
+    case "ProvideMerge": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -397,7 +393,7 @@ const withScope = <RIn, E, ROut>(
         )
       )
     }
-    case "ZipWithPar": {
+    case "ZipWith": {
       return core.sync(() => (memoMap: MemoMap) =>
         pipe(
           memoMap.getOrElseMemoize(op.first, scope),
@@ -682,17 +678,17 @@ export const memoize = <RIn, E, ROut>(
 export const merge = dual<
   <RIn2, E2, ROut2>(
     that: Layer.Layer<RIn2, E2, ROut2>
-  ) => <RIn, E, ROut>(self: Layer.Layer<RIn, E, ROut>) => Layer.Layer<
+  ) => <RIn, E1, ROut>(self: Layer.Layer<RIn, E1, ROut>) => Layer.Layer<
     RIn | RIn2,
-    E | E2,
+    E1 | E2,
     ROut | ROut2
   >,
-  <RIn, E, ROut, RIn2, E2, ROut2>(self: Layer.Layer<RIn, E, ROut>, that: Layer.Layer<RIn2, E2, ROut2>) => Layer.Layer<
+  <RIn, E1, ROut, RIn2, E2, ROut2>(self: Layer.Layer<RIn, E1, ROut>, that: Layer.Layer<RIn2, E2, ROut2>) => Layer.Layer<
     RIn | RIn2,
-    E | E2,
+    E1 | E2,
     ROut | ROut2
   >
->(2, (self, that) => zipWithPar(self, that, (a, b) => pipe(a, Context.merge(b))))
+>(2, (self, that) => zipWith(self, that, (a, b) => Context.merge(a, b)))
 
 /** @internal */
 export const mergeAll = <Layers extends [Layer.Layer<any, any, never>, ...Array<Layer.Layer<any, any, never>>]>(
@@ -704,7 +700,7 @@ export const mergeAll = <Layers extends [Layer.Layer<any, any, never>, ...Array<
 > => {
   let final = layers[0]
   for (let i = 1; i < layers.length; i++) {
-    final = merge(layers[i])(final)
+    final = merge(final, layers[i])
   }
   return final as any
 }
@@ -743,56 +739,6 @@ export const project = dual<
   ) => Layer.Layer<RIn, E, Context.Tag.Identifier<B>>
 >(4, (self, tagA, tagB, f) => map(self, (context) => Context.make(tagB, f(Context.unsafeGet(context, tagA)))))
 
-/** @internal */
-export const provide = dual<
-  <RIn2, E2, ROut2>(
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => <RIn, E, ROut>(
-    self: Layer.Layer<RIn, E, ROut>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<RIn, E, ROut>,
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E | E2, ROut2>
->(2, <RIn, E, ROut, RIn2, E2, ROut2>(
-  self: Layer.Layer<RIn, E, ROut>,
-  that: Layer.Layer<RIn2, E2, ROut2>
-) =>
-  suspend(() => {
-    const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE_TO
-    provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_ZIP_WITH, enumerable: true },
-      first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
-      second: { value: self },
-      zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => Context.merge(a, b) }
-    })
-    provideTo.second = that
-    return provideTo
-  }))
-
-/** @internal */
-export const provideMerge = dual<
-  <RIn2, E2, ROut2>(that: Layer.Layer<RIn2, E2, ROut2>) => <RIn, E, ROut>(
-    self: Layer.Layer<RIn, E, ROut>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>,
-  <RIn, E, ROut, RIn2, E2, ROut2>(
-    self: Layer.Layer<RIn, E, ROut>,
-    that: Layer.Layer<RIn2, E2, ROut2>
-  ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>
->(2, <RIn, E, ROut, RIn2, E2, ROut2>(
-  self: Layer.Layer<RIn, E, ROut>,
-  that: Layer.Layer<RIn2, E2, ROut2>
-) => {
-  const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_ZIP_WITH
-  zipWith.first = self
-  zipWith.second = pipe(self, provide(that))
-  zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> =>
-    Context.merge(a, b)
-  return zipWith
-})
-
 /** @internal */
 export const retry = dual<
   <RIn2, E, X>(
@@ -1029,7 +975,7 @@ export const toRuntime = <RIn, E, ROut>(
 }
 
 /** @internal */
-export const use = dual<
+export const provide = dual<
   <RIn, E, ROut>(
     self: Layer.Layer<RIn, E, ROut>
   ) => <RIn2, E2, ROut2>(
@@ -1045,9 +991,9 @@ export const use = dual<
 ) =>
   suspend(() => {
     const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE_TO
+    provideTo._tag = OpCodes.OP_PROVIDE
     provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_ZIP_WITH, enumerable: true },
+      _tag: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
       first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
       second: { value: self },
       zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => pipe(a, Context.merge(b)) }
@@ -1057,7 +1003,7 @@ export const use = dual<
   }))
 
 /** @internal */
-export const useMerge = dual<
+export const provideMerge = dual<
   <RIn, E, ROut>(
     self: Layer.Layer<RIn, E, ROut>
   ) => <RIn2, E2, ROut2>(
@@ -1069,9 +1015,9 @@ export const useMerge = dual<
   ) => Layer.Layer<RIn | Exclude<RIn2, ROut>, E2 | E, ROut | ROut2>
 >(2, <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer.Layer<RIn2, E2, ROut2>, self: Layer.Layer<RIn, E, ROut>) => {
   const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_ZIP_WITH
+  zipWith._tag = OpCodes.OP_PROVIDE_MERGE
   zipWith.first = self
-  zipWith.second = pipe(self, provide(that))
+  zipWith.second = provide(that, self)
   zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> => {
     return pipe(a, Context.merge(b))
   }
@@ -1079,7 +1025,7 @@ export const useMerge = dual<
 })
 
 /** @internal */
-export const zipWithPar = dual<
+export const zipWith = dual<
   <R2, E2, B, A, C>(
     that: Layer.Layer<R2, E2, B>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -1091,12 +1037,12 @@ export const zipWithPar = dual<
   ) => Layer.Layer<R | R2, E | E2, C>
 >(3, (self, that, f) =>
   suspend(() => {
-    const zipWithPar = Object.create(proto)
-    zipWithPar._tag = OpCodes.OP_ZIP_WITH_PAR
-    zipWithPar.first = self
-    zipWithPar.second = that
-    zipWithPar.zipK = f
-    return zipWithPar
+    const zipWith = Object.create(proto)
+    zipWith._tag = OpCodes.OP_ZIP_WITH
+    zipWith.first = self
+    zipWith.second = that
+    zipWith.zipK = f
+    return zipWith
   }))
 
 /** @internal */
@@ -1160,7 +1106,7 @@ export const withParentSpan = dual<
     span: Tracer.ParentSpan
   ) => <R, E, A>(self: Layer.Layer<R, E, A>) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>,
   <R, E, A>(self: Layer.Layer<R, E, A>, span: Tracer.ParentSpan) => Layer.Layer<Exclude<R, Tracer.ParentSpan>, E, A>
->(2, (self, span) => provide(succeedContext(Context.make(tracer.spanTag, span)), self))
+>(2, (self, span) => provide(self, succeedContext(Context.make(tracer.spanTag, span))))
 
 // circular with Effect
 

package/src/internal/logger.ts

@@ -18,9 +18,10 @@ export const LoggerTypeId: Logger.LoggerTypeId = Symbol.for(
   LoggerSymbolKey
 ) as Logger.LoggerTypeId
 
-/** @internal */
 const loggerVariance = {
+  /* c8 ignore next */
   _Message: (_: unknown) => _,
+  /* c8 ignore next */
   _Output: (_: never) => _
 }
 

package/src/internal/metric/hook.ts

@@ -20,9 +20,10 @@ export const MetricHookTypeId: MetricHook.MetricHookTypeId = Symbol.for(
   MetricHookSymbolKey
 ) as MetricHook.MetricHookTypeId
 
-/** @internal */
 const metricHookVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 

package/src/internal/metric/key.ts

@@ -22,13 +22,13 @@ export const MetricKeyTypeId: MetricKey.MetricKeyTypeId = Symbol.for(
   MetricKeySymbolKey
 ) as MetricKey.MetricKeyTypeId
 
-/** @internal */
 const metricKeyVariance = {
+  /* c8 ignore next */
   _Type: (_: never) => _
 }
 
 /** @internal */
-class MetricKeyImpl<Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
+class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
   readonly [MetricKeyTypeId] = metricKeyVariance
   constructor(
     readonly name: string,

package/src/internal/metric/keyType.ts

@@ -56,9 +56,10 @@ export const SummaryKeyTypeTypeId: MetricKeyType.SummaryKeyTypeTypeId = Symbol.f
   SummaryKeyTypeSymbolKey
 ) as MetricKeyType.SummaryKeyTypeTypeId
 
-/** @internal */
 const metricKeyTypeVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 

package/src/internal/metric/pair.ts

@@ -12,8 +12,8 @@ export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for(
   MetricPairSymbolKey
 ) as MetricPair.MetricPairTypeId
 
-/** @internal */
 const metricPairVariance = {
+  /* c8 ignore next */
   _Type: (_: never) => _
 }