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

package/src/internal/request.ts

@@ -1,10 +1,12 @@
+import type * as Cause from "../Cause.js"
 import type * as Effect from "../Effect.js"
 import { dual } from "../Function.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Request from "../Request.js"
+import type * as Types from "../Types.js"
 import * as completedRequestMap from "./completedRequestMap.js"
 import * as core from "./core.js"
-import * as Data from "./data.js"
+import { StructuralPrototype } from "./effectable.js"
 
 /** @internal */
 const RequestSymbolKey = "effect/Request"
@@ -14,34 +16,60 @@ export const RequestTypeId: Request.RequestTypeId = Symbol.for(
   RequestSymbolKey
 ) as Request.RequestTypeId
 
-/** @internal */
 const requestVariance = {
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 
+const RequestPrototype = {
+  ...StructuralPrototype,
+  [RequestTypeId]: requestVariance
+}
+
 /** @internal */
 export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> => hasProperty(u, RequestTypeId)
 
 /** @internal */
 export const of = <R extends Request.Request<any, any>>(): Request.Request.Constructor<R> => (args) =>
-  // @ts-expect-error
-  Data.struct({
-    [RequestTypeId]: requestVariance,
-    ...args
-  })
+  Object.assign(Object.create(RequestPrototype), args)
 
 /** @internal */
 export const tagged = <R extends Request.Request<any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Request.Request.Constructor<R, "_tag"> =>
-(args) =>
-  // @ts-expect-error
-  Data.struct({
-    [RequestTypeId]: requestVariance,
-    _tag: tag,
-    ...args
-  })
+(args) => {
+  const request = Object.assign(Object.create(RequestPrototype), args)
+  request._tag = tag
+  return request
+}
+
+/** @internal */
+export const Class: new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
+) => Request.Request<Error, Success> & Readonly<A> = (function() {
+  function Class(this: any, args: any) {
+    if (args) {
+      Object.assign(this, args)
+    }
+  }
+  Class.prototype = RequestPrototype
+  return Class as any
+})()
+
+/** @internal */
+export const TaggedClass = <Tag extends string>(
+  tag: Tag
+): new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends "_tag" | keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
+) => Request.Request<Error, Success> & Readonly<A> & { readonly _tag: Tag } => {
+  return class TaggedClass extends Class<any, any, any> {
+    readonly _tag = tag
+  } as any
+}
 
 /** @internal */
 export const complete = dual<
@@ -93,6 +121,17 @@ export const fail = dual<
   ) => Effect.Effect<never, never, void>
 >(2, (self, error) => complete(self, core.exitFail(error) as any))
 
+/** @internal */
+export const failCause = dual<
+  <A extends Request.Request<any, any>>(
+    cause: Cause.Cause<Request.Request.Error<A>>
+  ) => (self: A) => Effect.Effect<never, never, void>,
+  <A extends Request.Request<any, any>>(
+    self: A,
+    cause: Cause.Cause<Request.Request.Error<A>>
+  ) => Effect.Effect<never, never, void>
+>(2, (self, cause) => complete(self, core.exitFailCause(cause) as any))
+
 /** @internal */
 export const succeed = dual<
   <A extends Request.Request<any, any>>(

package/src/internal/resource.ts

@@ -16,10 +16,11 @@ export const ResourceTypeId: Resource.ResourceTypeId = Symbol.for(
   ResourceSymbolKey
 ) as Resource.ResourceTypeId
 
-/** @internal */
-const cachedVariance = {
-  _E: (_: never) => _,
-  _A: (_: never) => _
+const resourceVariance = {
+  /* c8 ignore next */
+  _E: (_: any) => _,
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */
@@ -46,7 +47,7 @@ export const manual = <R, E, A>(
     pipe(
       scopedRef.fromAcquire(core.exit(acquire)),
       core.map((ref) => ({
-        [ResourceTypeId]: cachedVariance,
+        [ResourceTypeId]: resourceVariance,
         scopedRef: ref,
         acquire: core.provideContext(acquire, env)
       }))

package/src/internal/ringBuffer.ts

@@ -3,7 +3,7 @@ import { constUndefined } from "../Function.js"
 import * as Option from "../Option.js"
 
 /** @internal */
-export class RingBuffer<A> {
+export class RingBuffer<out A> {
   private array: Array<A | undefined>
   private size = 0
   private current = 0

package/src/internal/runtime.ts

@@ -7,14 +7,13 @@ import * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
 import * as FiberRefs from "../FiberRefs.js"
 import { pipe } from "../Function.js"
-import { NodeInspectSymbol, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as _scheduler from "../Scheduler.js"
-import { NoSuchElementException } from "./cause.js"
 import * as InternalCause from "./cause.js"
 import * as core from "./core.js"
 import * as FiberRuntime from "./fiberRuntime.js"
@@ -178,7 +177,7 @@ export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure =>
     }
   }
   error.toString = () => {
-    return toString(error.toJSON())
+    return format(error.toJSON())
   }
   error[NodeInspectSymbol] = () => {
     return error.toJSON()
@@ -208,7 +207,7 @@ const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | un
     }
     case "None": {
       // @ts-expect-error
-      return core.exitFail(NoSuchElementException())
+      return core.exitFail(core.NoSuchElementException())
     }
   }
 }
@@ -258,7 +257,7 @@ export const unsafeRunPromiseExit =
     })
 
 /** @internal */
-export class RuntimeImpl<R> implements Runtime.Runtime<R> {
+export class RuntimeImpl<in R> implements Runtime.Runtime<R> {
   constructor(
     readonly context: Context.Context<R>,
     readonly runtimeFlags: RuntimeFlags.RuntimeFlags,

package/src/internal/schedule.ts

@@ -17,7 +17,6 @@ import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
-import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as ref from "./ref.js"
@@ -38,16 +37,21 @@ export const ScheduleDriverTypeId: Schedule.ScheduleDriverTypeId = Symbol.for(
   ScheduleDriverSymbolKey
 ) as Schedule.ScheduleDriverTypeId
 
-/** @internal */
 const scheduleVariance = {
+  /* c8 ignore next */
   _Env: (_: never) => _,
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
 const scheduleDriverVariance = {
+  /* c8 ignore next */
   _Env: (_: never) => _,
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _Out: (_: never) => _
 }
 
@@ -85,7 +89,7 @@ class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, I
     return core.flatMap(ref.get(this.ref), ([element, _]) => {
       switch (element._tag) {
         case "None": {
-          return core.failSync(() => internalCause.NoSuchElementException())
+          return core.failSync(() => new core.NoSuchElementException())
         }
         case "Some": {
           return core.succeed(element.value)
@@ -422,7 +426,7 @@ export const dayOfMonth = (day: number): Schedule.Schedule<never, unknown, numbe
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 31 < day) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: dayOfMonth(${day}). Must be in range 1...31`
           )
         )
@@ -451,7 +455,7 @@ export const dayOfWeek = (day: number): Schedule.Schedule<never, unknown, number
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 7 < day) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: dayOfWeek(${day}). Must be in range 1 (Monday)...7 (Sunday)`
           )
         )
@@ -745,7 +749,7 @@ export const hourOfDay = (hour: number): Schedule.Schedule<never, unknown, numbe
     (now, _, state) => {
       if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: hourOfDay(${hour}). Must be in range 0...23`
           )
         )
@@ -1001,7 +1005,7 @@ export const minuteOfHour = (minute: number): Schedule.Schedule<never, unknown,
     (now, _, state) => {
       if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: minuteOfHour(${minute}). Must be in range 0...59`
           )
         )
@@ -1314,7 +1318,7 @@ export const secondOfMinute = (second: number): Schedule.Schedule<never, unknown
     (now, _, state) => {
       if (!Number.isInteger(second) || second < 0 || 59 < second) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: secondOfMinute(${second}). Must be in range 0...59`
           )
         )

package/src/internal/scopedCache.ts

@@ -25,7 +25,7 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export interface CacheState<Key, Error, Value> {
+export interface CacheState<in out Key, out Error, out Value> {
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
   keys: _cache.KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
@@ -80,7 +80,7 @@ export type MapValue<Key, Error, Value> =
   | Refreshing<Key, Error, Value>
 
 /** @internal */
-export interface Complete<Key, Error, Value> {
+export interface Complete<out Key, out Error, out Value> {
   readonly _tag: "Complete"
   readonly key: _cache.MapKey<Key>
   readonly exit: Exit.Exit<Error, readonly [Value, Scope.Scope.Finalizer]>
@@ -90,14 +90,14 @@ export interface Complete<Key, Error, Value> {
 }
 
 /** @internal */
-export interface Pending<Key, Error, Value> {
+export interface Pending<out Key, out Error, out Value> {
   readonly _tag: "Pending"
   readonly key: _cache.MapKey<Key>
   readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
 }
 
 /** @internal */
-export interface Refreshing<Key, Error, Value> {
+export interface Refreshing<out Key, out Error, out Value> {
   readonly _tag: "Refreshing"
   readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
   readonly complete: Complete<Key, Error, Value>
@@ -177,12 +177,17 @@ export const ScopedCacheTypeId: ScopedCache.ScopedCacheTypeId = Symbol.for(
 ) as ScopedCache.ScopedCacheTypeId
 
 const scopedCacheVariance = {
+  /* c8 ignore next */
   _Key: (_: unknown) => _,
+  /* c8 ignore next */
   _Error: (_: never) => _,
+  /* c8 ignore next */
   _Value: (_: never) => _
 }
 
-class ScopedCacheImpl<Key, Environment, Error, Value> implements ScopedCache.ScopedCache<Key, Error, Value> {
+class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
+  implements ScopedCache.ScopedCache<Key, Error, Value>
+{
   readonly [ScopedCacheTypeId] = scopedCacheVariance
   readonly cacheState: CacheState<Key, Error, Value>
   constructor(
@@ -322,9 +327,10 @@ class ScopedCacheImpl<Key, Environment, Error, Value> implements ScopedCache.Sco
   }
 
   get invalidateAll(): Effect.Effect<never, never, void> {
-    return fiberRuntime.forEachParUnboundedDiscard(
+    return fiberRuntime.forEachConcurrentDiscard(
       HashSet.fromIterable(Array.from(this.cacheState.map).map(([key]) => key)),
       (key) => this.invalidate(key),
+      false,
       false
     )
   }
@@ -567,9 +573,10 @@ class ScopedCacheImpl<Key, Environment, Error, Value> implements ScopedCache.Sco
   }
 
   ensureMapSizeNotExceeded(key: _cache.MapKey<Key>): Effect.Effect<never, never, void> {
-    return fiberRuntime.forEachParUnboundedDiscard(
+    return fiberRuntime.forEachConcurrentDiscard(
       this.trackAccess(key),
       (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),
+      false,
       false
     )
   }

package/src/internal/scopedRef.ts

@@ -22,7 +22,8 @@ export const ScopedRefTypeId: ScopedRef.ScopedRefTypeId = Symbol.for(
 
 /** @internal */
 const scopedRefVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal  */

package/src/internal/sink.ts

@@ -28,17 +28,21 @@ import * as core from "./core-stream.js"
 /** @internal */
 export const SinkTypeId: Sink.SinkTypeId = Symbol.for("effect/Sink") as Sink.SinkTypeId
 
-/** @internal */
 const sinkVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _L: (_: never) => _,
+  /* c8 ignore next */
   _Z: (_: never) => _
 }
 
 /** @internal */
-export class SinkImpl<R, E, In, L, Z> implements Sink.Sink<R, E, In, L, Z> {
+export class SinkImpl<out R, out E, in In, out L, out Z> implements Sink.Sink<R, E, In, L, Z> {
   readonly [SinkTypeId] = sinkVariance
   constructor(
     readonly channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
@@ -195,7 +199,10 @@ export const collectAllUntilEffect = <In, R, E>(p: (input: In) => Effect.Effect<
 }
 
 /** @internal */
-export const collectAllWhile = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
+export const collectAllWhile: {
+  <In, Out extends In>(refinement: Refinement<In, Out>): Sink.Sink<never, never, In, In, Chunk.Chunk<Out>>
+  <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>>
+} = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
   fromChannel(collectAllWhileReader(predicate, Chunk.empty()))
 
 /** @internal */
@@ -432,7 +439,7 @@ export const die = (defect: unknown): Sink.Sink<never, never, unknown, never, ne
 
 /** @internal */
 export const dieMessage = (message: string): Sink.Sink<never, never, unknown, never, never> =>
-  failCause(Cause.die(Cause.RuntimeException(message)))
+  failCause(Cause.die(new Cause.RuntimeException(message)))
 
 /** @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): Sink.Sink<never, never, unknown, never, never> =>

package/src/internal/stack.ts

@@ -1,4 +1,4 @@
 /** @internal */
-export class Stack<A> {
+export class Stack<out A> {
   constructor(readonly value: A, readonly previous?: Stack<A>) {}
 }

package/src/internal/stm/core.ts

@@ -136,10 +136,12 @@ interface STMInterrupt extends
   }>
 {}
 
-/** @internal */
 const stmVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 
@@ -417,7 +419,7 @@ export const contextWithSTM = <R0, R, E, A>(
 ): STM.STM<R0 | R, E, A> => flatMap(context<R0>(), f)
 
 /** @internal */
-export class STMDriver<R, E, A> {
+export class STMDriver<in out R, out E, out A> {
   private contStack: Array<Continuation> = []
   private env: Context.Context<unknown>
 
@@ -483,7 +485,7 @@ export class STMDriver<R, E, A> {
               break
             }
             case "None": {
-              curr = fail(Cause.NoSuchElementException()) as Primitive
+              curr = fail(new Cause.NoSuchElementException()) as Primitive
               break
             }
             case "Right": {
@@ -616,7 +618,7 @@ export const die = (defect: unknown): STM.STM<never, never, never> => dieSync(()
 
 /** @internal */
 export const dieMessage = (message: string): STM.STM<never, never, never> =>
-  dieSync(() => Cause.RuntimeException(message))
+  dieSync(() => new Cause.RuntimeException(message))
 
 /** @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): STM.STM<never, never, never> => {

package/src/internal/stm/stm/stmState.ts

@@ -20,7 +20,7 @@ export type STMStateTypeId = typeof STMStateTypeId
 export type STMState<E, A> = Done<E, A> | Interrupted | Running
 
 /** @internal */
-export interface Done<E, A> extends Equal.Equal {
+export interface Done<out E, out A> extends Equal.Equal {
   readonly [STMStateTypeId]: STMStateTypeId
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<E, A>

package/src/internal/stm/stm/tExit.ts

@@ -3,6 +3,7 @@ import type * as FiberId from "../../../FiberId.js"
 import { pipe } from "../../../Function.js"
 import * as Hash from "../../../Hash.js"
 import { hasProperty } from "../../../Predicate.js"
+import type * as Types from "../../../Types.js"
 import * as OpCodes from "../opCodes/tExit.js"
 
 /** @internal */
@@ -20,22 +21,23 @@ export type TExit<E, A> = Fail<E> | Die | Interrupt | Succeed<A> | Retry
 /** @internal */
 export declare namespace TExit {
   /** @internal */
-  export interface Variance<E, A> {
+  export interface Variance<out E, out A> {
     readonly [TExitTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 }
 
-/** @internal */
 const variance = {
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 
 /** @internal */
-export interface Fail<E> extends TExit.Variance<E, never>, Equal.Equal {
+export interface Fail<out E> extends TExit.Variance<E, never>, Equal.Equal {
   readonly _tag: OpCodes.OP_FAIL
   readonly error: E
 }
@@ -53,7 +55,7 @@ export interface Interrupt extends TExit.Variance<never, never>, Equal.Equal {
 }
 
 /** @internal */
-export interface Succeed<A> extends TExit.Variance<never, A>, Equal.Equal {
+export interface Succeed<out A> extends TExit.Variance<never, A>, Equal.Equal {
   readonly _tag: OpCodes.OP_SUCCEED
   readonly value: A
 }

package/src/internal/stm/stm/tryCommit.ts

@@ -6,7 +6,7 @@ import type * as Journal from "./journal.js"
 export type TryCommit<E, A> = Done<E, A> | Suspend
 
 /** @internal */
-export interface Done<E, A> {
+export interface Done<out E, out A> {
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<E, A>
 }

package/src/internal/stm/stm/versioned.ts

@@ -1,4 +1,4 @@
 /** @internal */
-export class Versioned<A> {
+export class Versioned<out A> {
   constructor(readonly value: A) {}
 }

package/src/internal/stm/stm.ts

@@ -1250,11 +1250,11 @@ export const partition = dual<
     f: (a: A) => STM.STM<R, E, A2>
   ) => (
     elements: Iterable<A>
-  ) => STM.STM<R, never, [Array<E>, Array<A2>]>,
+  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>,
   <R, E, A, A2>(
     elements: Iterable<A>,
     f: (a: A) => STM.STM<R, E, A2>
-  ) => STM.STM<R, never, [Array<E>, Array<A2>]>
+  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
 >(2, (elements, f) =>
   pipe(
     forEach(elements, (a) => either(f(a))),

package/src/internal/stm/tArray.ts

@@ -16,13 +16,13 @@ const TArraySymbolKey = "effect/TArray"
 /** @internal */
 export const TArrayTypeId: TArray.TArrayTypeId = Symbol.for(TArraySymbolKey) as TArray.TArrayTypeId
 
-/** @internal */
 const tArrayVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */
-export class TArrayImpl<A> implements TArray.TArray<A> {
+export class TArrayImpl<in out A> implements TArray.TArray<A> {
   readonly [TArrayTypeId] = tArrayVariance
   constructor(readonly chunk: Array<TRef.TRef<A>>) {}
 }

package/src/internal/stm/tDeferred.ts

@@ -18,12 +18,12 @@ export const TDeferredTypeId: TDeferred.TDeferredTypeId = Symbol.for(
 
 /** @internal */
 const tDeferredVariance = {
-  _E: (_: never) => _,
-  _A: (_: never) => _
+  _E: (_: any) => _,
+  _A: (_: any) => _
 }
 
 /** @internal */
-class TDeferredImpl<E, A> implements TDeferred.TDeferred<E, A> {
+class TDeferredImpl<in out E, in out A> implements TDeferred.TDeferred<E, A> {
   readonly [TDeferredTypeId] = tDeferredVariance
   constructor(readonly ref: TRef.TRef<Option.Option<Either.Either<E, A>>>) {}
 }

package/src/internal/stm/tMap.ts

@@ -25,14 +25,15 @@ export const TMapTypeId: TMap.TMapTypeId = Symbol.for(
   TMapSymbolKey
 ) as TMap.TMapTypeId
 
-/** @internal */
 const tMapVariance = {
-  _K: (_: never) => _,
-  _V: (_: never) => _
+  /* c8 ignore next */
+  _K: (_: any) => _,
+  /* c8 ignore next */
+  _V: (_: any) => _
 }
 
 /** @internal */
-class TMapImpl<K, V> implements TMap.TMap<K, V> {
+class TMapImpl<in out K, in out V> implements TMap.TMap<K, V> {
   readonly [TMapTypeId] = tMapVariance
   constructor(
     readonly tBuckets: TRef.TRef<TArray.TArray<Chunk.Chunk<readonly [K, V]>>>,

package/src/internal/stm/tPriorityQueue.ts

@@ -19,13 +19,13 @@ export const TPriorityQueueTypeId: TPriorityQueue.TPriorityQueueTypeId = Symbol.
   TPriorityQueueSymbolKey
 ) as TPriorityQueue.TPriorityQueueTypeId
 
-/** @internal */
 const tPriorityQueueVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /** @internal */
-export class TPriorityQueueImpl<A> implements TPriorityQueue.TPriorityQueue<A> {
+export class TPriorityQueueImpl<in out A> implements TPriorityQueue.TPriorityQueue<A> {
   readonly [TPriorityQueueTypeId] = tPriorityQueueVariance
   constructor(readonly ref: TRef.TRef<SortedMap.SortedMap<A, [A, ...Array<A>]>>) {}
 }