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

package/src/internal/pubsub.ts

@@ -9,31 +9,33 @@ import { pipeArguments } from "../Pipeable.js"
 import type * as PubSub from "../PubSub.js"
 import type * as Queue from "../Queue.js"
 import type * as Scope from "../Scope.js"
-import * as cause from "./cause.js"
 import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as queue from "./queue.js"
 
+const AbsentValue = Symbol.for("effect/PubSub/AbsentValue")
+type AbsentValue = typeof AbsentValue
+
 /** @internal */
-export interface AtomicPubSub<A> {
+export interface AtomicPubSub<in out A> {
   readonly capacity: number
-  readonly isEmpty: () => boolean
-  readonly isFull: () => boolean
-  readonly size: () => number
-  readonly publish: (value: A) => boolean
-  readonly publishAll: (elements: Iterable<A>) => Chunk.Chunk<A>
-  readonly slide: () => void
-  readonly subscribe: () => Subscription<A>
+  isEmpty(): boolean
+  isFull(): boolean
+  size(): number
+  publish(value: A): boolean
+  publishAll(elements: Iterable<A>): Chunk.Chunk<A>
+  slide(): void
+  subscribe(): Subscription<A>
 }
 
 /** @internal */
-interface Subscription<A> {
-  readonly isEmpty: () => boolean
-  readonly size: () => number
-  readonly poll: <D>(default_: D) => A | D
-  readonly pollUpTo: (n: number) => Chunk.Chunk<A>
-  readonly unsubscribe: () => void
+interface Subscription<out A> {
+  isEmpty(): boolean
+  size(): number
+  poll<D>(default_: D): A | D
+  pollUpTo(n: number): Chunk.Chunk<A>
+  unsubscribe(): void
 }
 
 /** @internal */
@@ -190,7 +192,7 @@ export const unsafeMakeSubscription = <A>(
 }
 
 /** @internal */
-class BoundedPubSubArb<A> implements AtomicPubSub<A> {
+class BoundedPubSubArb<in out A> implements AtomicPubSub<A> {
   array: Array<A>
   publisherIndex = 0
   subscribers: Array<number>
@@ -254,7 +256,7 @@ class BoundedPubSubArb<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex % this.capacity
-      this.array[index] = null as unknown as A
+      this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
     }
@@ -266,7 +268,7 @@ class BoundedPubSubArb<A> implements AtomicPubSub<A> {
   }
 }
 
-class BoundedPubSubArbSubscription<A> implements Subscription<A> {
+class BoundedPubSubArbSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubArb<A>,
     private subscriberIndex: number,
@@ -299,7 +301,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
       const elem = this.self.array[index]!
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       this.subscriberIndex += 1
@@ -325,7 +327,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
       const a = this.self.array[index] as A
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       builder.push(a)
@@ -344,7 +346,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
         const index = this.subscriberIndex % this.self.capacity
         this.self.subscribers[index] -= 1
         if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null as unknown as A
+          this.self.array[index] = AbsentValue as unknown as A
           this.self.subscribersIndex += 1
         }
         this.subscriberIndex += 1
@@ -354,7 +356,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
+class BoundedPubSubPow2<in out A> implements AtomicPubSub<A> {
   array: Array<A>
   mask: number
   publisherIndex = 0
@@ -420,7 +422,7 @@ class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex & this.mask
-      this.array[index] = null as unknown as A
+      this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
     }
@@ -433,7 +435,7 @@ class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
+class BoundedPubSubPow2Subscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubPow2<A>,
     private subscriberIndex: number,
@@ -466,7 +468,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
       const elem = this.self.array[index]!
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       this.subscriberIndex += 1
@@ -492,7 +494,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
       const elem = this.self.array[index] as A
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       builder.push(elem)
@@ -510,7 +512,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
         const index = this.subscriberIndex & this.self.mask
         this.self.subscribers[index] -= 1
         if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null as unknown as A
+          this.self.array[index] = AbsentValue as unknown as A
           this.self.subscribersIndex += 1
         }
         this.subscriberIndex += 1
@@ -520,11 +522,11 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
+class BoundedPubSubSingle<in out A> implements AtomicPubSub<A> {
   publisherIndex = 0
   subscriberCount = 0
   subscribers = 0
-  value: A = null as unknown as A
+  value: A = AbsentValue as unknown as A
 
   readonly capacity = 1
 
@@ -571,7 +573,7 @@ class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.isFull()) {
       this.subscribers = 0
-      this.value = null as unknown as A
+      this.value = AbsentValue as unknown as A
     }
   }
 
@@ -582,7 +584,7 @@ class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
+class BoundedPubSubSingleSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubSingle<A>,
     private subscriberIndex: number,
@@ -609,7 +611,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
     const elem = this.self.value
     this.self.subscribers -= 1
     if (this.self.subscribers === 0) {
-      this.self.value = null as unknown as A
+      this.self.value = AbsentValue as unknown as A
     }
     this.subscriberIndex += 1
     return elem
@@ -622,7 +624,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
     const a = this.self.value
     this.self.subscribers -= 1
     if (this.self.subscribers === 0) {
-      this.self.value = null as unknown as A
+      this.self.value = AbsentValue as unknown as A
     }
     this.subscriberIndex += 1
     return Chunk.of(a)
@@ -635,7 +637,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
       if (this.subscriberIndex !== this.self.publisherIndex) {
         this.self.subscribers -= 1
         if (this.self.subscribers === 0) {
-          this.self.value = null as unknown as A
+          this.self.value = AbsentValue as unknown as A
         }
       }
     }
@@ -643,9 +645,9 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class Node<A> {
+class Node<out A> {
   constructor(
-    public value: A | null,
+    public value: A | AbsentValue,
     public subscribers: number,
     public next: Node<A> | null
   ) {
@@ -653,8 +655,8 @@ class Node<A> {
 }
 
 /** @internal */
-class UnboundedPubSub<A> implements AtomicPubSub<A> {
-  publisherHead = new Node<A>(null, 0, null)
+class UnboundedPubSub<in out A> implements AtomicPubSub<A> {
+  publisherHead = new Node<A>(AbsentValue, 0, null)
   publisherIndex = 0
   publisherTail: Node<A>
   subscribersIndex = 0
@@ -697,7 +699,7 @@ class UnboundedPubSub<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.publisherHead !== this.publisherTail) {
       this.publisherHead = this.publisherHead.next!
-      this.publisherHead.value = null
+      this.publisherHead.value = AbsentValue
       this.subscribersIndex += 1
     }
   }
@@ -714,7 +716,7 @@ class UnboundedPubSub<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class UnboundedPubSubSubscription<A> implements Subscription<A> {
+class UnboundedPubSubSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: UnboundedPubSub<A>,
     private subscriberHead: Node<A>,
@@ -733,7 +735,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
       if (this.subscriberHead === this.self.publisherTail) {
         loop = false
       } else {
-        if (this.subscriberHead.next!.value !== null) {
+        if (this.subscriberHead.next!.value !== AbsentValue) {
           empty = false
           loop = false
         } else {
@@ -763,12 +765,12 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
         loop = false
       } else {
         const elem = this.subscriberHead.next!.value
-        if (elem !== null) {
+        if (elem !== AbsentValue) {
           polled = elem
           this.subscriberHead.subscribers -= 1
           if (this.subscriberHead.subscribers === 0) {
             this.self.publisherHead = this.self.publisherHead.next!
-            this.self.publisherHead.value = null
+            this.self.publisherHead.value = AbsentValue
             this.self.subscribersIndex += 1
           }
           loop = false
@@ -782,7 +784,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
 
   pollUpTo(n: number): Chunk.Chunk<A> {
     const builder: Array<A> = []
-    const default_ = null
+    const default_ = AbsentValue
     let i = 0
     while (i !== n) {
       const a = this.poll(default_ as unknown as A)
@@ -801,11 +803,11 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
       this.unsubscribed = true
       this.self.publisherTail.subscribers -= 1
       while (this.subscriberHead !== this.self.publisherTail) {
-        if (this.subscriberHead.next!.value !== null) {
+        if (this.subscriberHead.next!.value !== AbsentValue) {
           this.subscriberHead.subscribers -= 1
           if (this.subscriberHead.subscribers === 0) {
             this.self.publisherHead = this.self.publisherHead.next!
-            this.self.publisherHead.value = null
+            this.self.publisherHead.value = AbsentValue
             this.self.subscribersIndex += 1
           }
         }
@@ -816,7 +818,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class SubscriptionImpl<A> implements Queue.Dequeue<A> {
+class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
   [queue.DequeueTypeId] = queue.dequeueVariance
 
   constructor(
@@ -993,8 +995,9 @@ const takeRemainderLoop = <A>(
 }
 
 /** @internal */
-class PubSubImpl<A> implements PubSub.PubSub<A> {
+class PubSubImpl<in out A> implements PubSub.PubSub<A> {
   readonly [queue.EnqueueTypeId] = queue.enqueueVariance
+  readonly [queue.DequeueTypeId] = queue.dequeueVariance
 
   constructor(
     readonly pubsub: AtomicPubSub<A>,
@@ -1176,7 +1179,7 @@ const nextPow2 = (n: number): number => {
 /** @internal */
 const ensureCapacity = (capacity: number): void => {
   if (capacity <= 0) {
-    throw cause.InvalidPubSubCapacityException(`Cannot construct PubSub with capacity of ${capacity}`)
+    throw new core.InvalidPubSubCapacityException(`Cannot construct PubSub with capacity of ${capacity}`)
   }
 }
 
@@ -1228,7 +1231,7 @@ const unsafeRemove = <A>(queue: MutableQueue.MutableQueue<A>, value: A): void =>
  *
  * @internal
  */
-export interface PubSubStrategy<A> {
+export interface PubSubStrategy<in out A> {
   /**
    * Describes any finalization logic associated with this strategy.
    */
@@ -1238,42 +1241,42 @@ export interface PubSubStrategy<A> {
    * Describes how publishers should signal to subscribers that they are
    * waiting for space to become available in the `PubSub`.
    */
-  readonly handleSurplus: (
+  handleSurplus(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     elements: Iterable<A>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ) => Effect.Effect<never, never, boolean>
+  ): Effect.Effect<never, never, boolean>
 
   /**
    * Describes how subscribers should signal to publishers waiting for space
    * to become available in the `PubSub` that space may be available.
    */
-  readonly unsafeOnPubSubEmptySpace: (
+  unsafeOnPubSubEmptySpace(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>
-  ) => void
+  ): void
 
   /**
    * Describes how subscribers waiting for additional values from the `PubSub`
    * should take those values and signal to publishers that they are no
    * longer waiting for additional values.
    */
-  readonly unsafeCompletePollers: (
+  unsafeCompletePollers(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
     pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 
   /**
    * Describes how publishers should signal to subscribers waiting for
    * additional values from the `PubSub` that new values are available.
    */
-  readonly unsafeCompleteSubscribers: (
+  unsafeCompleteSubscribers(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>
-  ) => void
+  ): void
 }
 
 /**
@@ -1285,7 +1288,7 @@ export interface PubSubStrategy<A> {
  *
  * @internal
  */
-class BackPressureStrategy<A> implements PubSubStrategy<A> {
+class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
   publishers: MutableQueue.MutableQueue<
     readonly [
       A,
@@ -1299,12 +1302,13 @@ class BackPressureStrategy<A> implements PubSubStrategy<A> {
       core.flatMap(
         core.sync(() => unsafePollAllQueue(this.publishers)),
         (publishers) =>
-          fiberRuntime.forEachParUnboundedDiscard(
+          fiberRuntime.forEachConcurrentDiscard(
             publishers,
             ([_, deferred, last]) =>
               last ?
                 pipe(core.deferredInterruptWith(deferred, fiberId), core.asUnit) :
                 core.unit,
+            false,
             false
           )
       ))
@@ -1410,7 +1414,7 @@ class BackPressureStrategy<A> implements PubSubStrategy<A> {
  *
  * @internal
  */
-export class DroppingStrategy<A> implements PubSubStrategy<A> {
+export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<never, never, void> {
     return core.unit
   }
@@ -1454,7 +1458,7 @@ export class DroppingStrategy<A> implements PubSubStrategy<A> {
  *
  * @internal
  */
-export class SlidingStrategy<A> implements PubSubStrategy<A> {
+export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<never, never, void> {
     return core.unit
   }

package/src/internal/query.ts

@@ -78,7 +78,7 @@ export const fromRequest = <
                               proxy,
                               (entry) => entry.handle === orNew.left.handle
                             ),
-                            () => fromRequest(proxy, dataSource)
+                            () => fromRequest(proxy, ds)
                           )
                         }
                         return ensuring(

package/src/internal/queue.ts

@@ -33,22 +33,37 @@ export const QueueStrategyTypeId: Queue.QueueStrategyTypeId = Symbol.for(
 ) as Queue.QueueStrategyTypeId
 
 /** @internal */
+const BackingQueueSymbolKey = "effect/BackingQueue"
+
+/** @internal */
+export const BackingQueueTypeId: Queue.BackingQueueTypeId = Symbol.for(
+  BackingQueueSymbolKey
+) as Queue.BackingQueueTypeId
+
 const queueStrategyVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
+}
+
+const backingQueueVariance = {
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */
 export const enqueueVariance = {
+  /* c8 ignore next */
   _In: (_: unknown) => _
 }
 
 /** @internal */
 export const dequeueVariance = {
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
 /** @internal */
-class QueueImpl<A> implements Queue.Queue<A> {
+class QueueImpl<in out A> implements Queue.Queue<A> {
   readonly [EnqueueTypeId] = enqueueVariance
   readonly [DequeueTypeId] = dequeueVariance
 
@@ -102,9 +117,10 @@ class QueueImpl<A> implements Queue.Queue<A> {
       core.withFiberRuntime<never, never, void>((state) => {
         pipe(this.shutdownFlag, MutableRef.set(true))
         return pipe(
-          fiberRuntime.forEachParUnboundedDiscard(
+          fiberRuntime.forEachConcurrentDiscard(
             unsafePollAll(this.takers),
             (d) => core.deferredInterruptWith(d, state.id()),
+            false,
             false
           ),
           core.zipRight(this.strategy.shutdown),
@@ -386,7 +402,8 @@ export const make = <A>(
   )
 
 /** @internal */
-export class BackingQueueFromMutableQueue<A> implements Queue.BackingQueue<A> {
+export class BackingQueueFromMutableQueue<in out A> implements Queue.BackingQueue<A> {
+  readonly [BackingQueueTypeId] = backingQueueVariance
   constructor(readonly mutable: MutableQueue.MutableQueue<A>) {}
   poll<Def>(def: Def): A | Def {
     return MutableQueue.poll(this.mutable, def)
@@ -503,7 +520,7 @@ export const droppingStrategy = <A>(): Queue.Strategy<A> => new DroppingStrategy
 export const slidingStrategy = <A>(): Queue.Strategy<A> => new SlidingStrategy()
 
 /** @internal */
-class BackPressureStrategy<A> implements Queue.Strategy<A> {
+class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   readonly putters = MutableQueue.unbounded<readonly [A, Deferred.Deferred<never, boolean>, boolean]>()
@@ -530,13 +547,18 @@ class BackPressureStrategy<A> implements Queue.Strategy<A> {
         pipe(
           core.sync(() => unsafePollAll(this.putters)),
           core.flatMap((putters) =>
-            fiberRuntime.forEachParUnboundedDiscard(putters, ([_, deferred, isLastItem]) =>
-              isLastItem ?
-                pipe(
-                  core.deferredInterruptWith(deferred, fiberId),
-                  core.asUnit
-                ) :
-                core.unit, false)
+            fiberRuntime.forEachConcurrentDiscard(
+              putters,
+              ([_, deferred, isLastItem]) =>
+                isLastItem ?
+                  pipe(
+                    core.deferredInterruptWith(deferred, fiberId),
+                    core.asUnit
+                  ) :
+                  core.unit,
+              false,
+              false
+            )
           )
         )
       )
@@ -605,7 +627,7 @@ class BackPressureStrategy<A> implements Queue.Strategy<A> {
 }
 
 /** @internal */
-class DroppingStrategy<A> implements Queue.Strategy<A> {
+class DroppingStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   surplusSize(): number {
@@ -637,7 +659,7 @@ class DroppingStrategy<A> implements Queue.Strategy<A> {
 }
 
 /** @internal */
-class SlidingStrategy<A> implements Queue.Strategy<A> {
+class SlidingStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   surplusSize(): number {

package/src/internal/redBlackTree/iterator.ts

@@ -11,7 +11,7 @@ export const Direction = {
 } as const
 
 /** @internal */
-export class RedBlackTreeIterator<K, V> implements Iterator<[K, V]> {
+export class RedBlackTreeIterator<in out K, out V> implements Iterator<[K, V]> {
   private count = 0
 
   constructor(

package/src/internal/redBlackTree/node.ts

@@ -11,7 +11,7 @@ export declare namespace Node {
 }
 
 /** @internal */
-export class Node<K, V> {
+export class Node<out K, out V> {
   constructor(
     public color: Node.Color,
     public key: K,

package/src/internal/redBlackTree.ts

@@ -2,7 +2,7 @@ import * as Chunk from "../Chunk.js"
 import * as Equal from "../Equal.js"
 import { dual, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import type * as Order from "../Order.js"
 import type * as Ordering from "../Ordering.js"
@@ -19,13 +19,20 @@ const RedBlackTreeSymbolKey = "effect/RedBlackTree"
 export const RedBlackTreeTypeId: RBT.TypeId = Symbol.for(RedBlackTreeSymbolKey) as RBT.TypeId
 
 /** @internal */
-export interface RedBlackTreeImpl<K, V> extends RBT.RedBlackTree<K, V> {
+export interface RedBlackTreeImpl<in out K, out V> extends RBT.RedBlackTree<K, V> {
   readonly _ord: Order.Order<K>
   readonly _root: Node.Node<K, V> | undefined
 }
 
+const redBlackTreeVariance = {
+  /* c8 ignore next */
+  _Key: (_: any) => _,
+  /* c8 ignore next */
+  _Value: (_: never) => _
+}
+
 const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
-  [RedBlackTreeTypeId]: RedBlackTreeTypeId,
+  [RedBlackTreeTypeId]: redBlackTreeVariance,
   [Hash.symbol](): number {
     let hash = Hash.hash(RedBlackTreeSymbolKey)
     for (const item of this) {
@@ -56,7 +63,7 @@ const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
     return new RedBlackTreeIterator(this, stack, Direction.Forward)
   },
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {

package/src/internal/ref.ts

@@ -11,10 +11,11 @@ export const RefTypeId: Ref.RefTypeId = Symbol.for("effect/Ref") as Ref.RefTypeI
 
 /** @internal */
 export const refVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 
-class RefImpl<A> implements Ref.Ref<A> {
+class RefImpl<in out A> implements Ref.Ref<A> {
   readonly [RefTypeId] = refVariance
   constructor(readonly ref: MutableRef.MutableRef<A>) {}
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> {

package/src/internal/reloadable.ts

@@ -20,9 +20,9 @@ export const ReloadableTypeId: Reloadable.ReloadableTypeId = Symbol.for(
   ReloadableSymbolKey
 ) as Reloadable.ReloadableTypeId
 
-/** @internal */
 const reloadableVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */