effect 2.0.0-next.56 → 2.0.0-next.57

package/src/SynchronizedRef.ts

@@ -7,6 +7,7 @@ import * as ref from "./internal/ref.js"
 import * as internal from "./internal/synchronizedRef.js"
 import type * as Option from "./Option.js"
 import type * as Ref from "./Ref.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -38,7 +39,7 @@ export declare namespace SynchronizedRef {
    */
   export interface Variance<in out A> {
     readonly [SynchronizedRefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/TArray.ts

@@ -7,6 +7,7 @@ import type * as Order from "./Order.js"
 import type { Predicate } from "./Predicate.js"
 import type * as STM from "./STM.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -44,7 +45,7 @@ export declare namespace TArray {
    */
   export interface Variance<in out A> {
     readonly [TArrayTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/TDeferred.ts

@@ -6,6 +6,7 @@ import * as internal from "./internal/stm/tDeferred.js"
 import type * as Option from "./Option.js"
 import type * as STM from "./STM.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -43,8 +44,8 @@ export declare namespace TDeferred {
    */
   export interface Variance<in out E, in out A> {
     readonly [TDeferredTypeId]: {
-      readonly _E: (_: E) => E
-      readonly _A: (_: A) => A
+      readonly _E: Types.Invariant<E>
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/TMap.ts

@@ -9,6 +9,7 @@ import type * as Option from "./Option.js"
 import type * as STM from "./STM.js"
 import type * as TArray from "./TArray.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -51,8 +52,8 @@ export declare namespace TMap {
    */
   export interface Variance<in out K, in out V> {
     readonly [TMapTypeId]: {
-      readonly _K: (_: K) => K
-      readonly _V: (_: V) => V
+      readonly _K: Types.Invariant<K>
+      readonly _V: Types.Invariant<V>
     }
   }
 }

package/src/TPriorityQueue.ts

@@ -9,6 +9,7 @@ import type { Predicate } from "./Predicate.js"
 import type * as SortedMap from "./SortedMap.js"
 import type * as STM from "./STM.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -52,7 +53,7 @@ export declare namespace TPriorityQueue {
    */
   export interface Variance<in out A> {
     readonly [TPriorityQueueTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/TPubSub.ts

@@ -9,6 +9,7 @@ import type * as Scope from "./Scope.js"
 import type * as STM from "./STM.js"
 import type * as TQueue from "./TQueue.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -28,7 +29,7 @@ export type TPubSubTypeId = typeof TPubSubTypeId
  */
 export interface TPubSub<in out A> extends TQueue.TEnqueue<A> {
   readonly [TPubSubTypeId]: {
-    readonly _A: (_: A) => A
+    readonly _A: Types.Invariant<A>
   }
 }
 /**

package/src/TQueue.ts

@@ -5,6 +5,7 @@ import * as internal from "./internal/stm/tQueue.js"
 import type * as Option from "./Option.js"
 import type { Predicate } from "./Predicate.js"
 import type * as STM from "./STM.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -158,7 +159,7 @@ export declare namespace TQueue {
    */
   export interface TEnqueueVariance<in A> {
     readonly [TEnqueueTypeId]: {
-      readonly _In: (_: A) => void
+      readonly _In: Types.Contravariant<A>
     }
   }
 
@@ -168,7 +169,7 @@ export declare namespace TQueue {
    */
   export interface TDequeueVariance<out A> {
     readonly [TDequeueTypeId]: {
-      readonly _Out: (_: never) => A
+      readonly _Out: Types.Covariant<A>
     }
   }
 }

package/src/TRef.ts

@@ -8,6 +8,7 @@ import type * as Versioned from "./internal/stm/stm/versioned.js"
 import * as internal from "./internal/stm/tRef.js"
 import type * as Option from "./Option.js"
 import type * as STM from "./STM.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -59,7 +60,7 @@ export declare namespace TRef {
    */
   export interface Variance<in out A> {
     readonly [TRefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/TSet.ts

@@ -8,6 +8,7 @@ import type * as Option from "./Option.js"
 import type { Predicate } from "./Predicate.js"
 import type * as STM from "./STM.js"
 import type * as TMap from "./TMap.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -47,7 +48,7 @@ export declare namespace TSet {
    */
   export interface Variance<in out A> {
     readonly [TSetTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Take.ts

@@ -8,6 +8,7 @@ import type * as Exit from "./Exit.js"
 import * as internal from "./internal/take.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -44,8 +45,8 @@ export declare namespace Take {
    */
   export interface Variance<out E, out A> {
     readonly [TakeTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 }

package/src/TestAnnotation.ts

@@ -12,7 +12,7 @@ import * as HashSet from "./HashSet.js"
 import type * as MutableRef from "./MutableRef.js"
 import { hasProperty } from "./Predicate.js"
 import type * as SortedSet from "./SortedSet.js"
-
+import type * as Types from "./Types.js"
 /** @internal */
 const TestAnnotationSymbolKey = "effect/TestAnnotation"
 
@@ -31,7 +31,7 @@ export type TestAnnotationTypeId = typeof TestAnnotationTypeId
  */
 export interface TestAnnotation<in out A> extends Equal.Equal {
   readonly [TestAnnotationTypeId]: {
-    readonly _A: (_: A) => A
+    readonly _A: Types.Invariant<A>
   }
   readonly identifier: string
   readonly tag: Context.Tag<A, A>

package/src/TestContext.ts

@@ -15,9 +15,10 @@ export const live: Layer.Layer<DefaultServices.DefaultServices, never, TestServi
   layer.merge(TestServices.liveLayer()),
   layer.merge(TestServices.sizedLayer(100)),
   layer.merge(pipe(
-    TestServices.liveLayer(),
-    layer.merge(TestServices.annotationsLayer()),
-    layer.provideMerge(TestClock.defaultTestClock)
+    TestClock.defaultTestClock,
+    layer.provideMerge(
+      layer.merge(TestServices.liveLayer(), TestServices.annotationsLayer())
+    )
   )),
   layer.merge(TestServices.testConfigLayer({ repeats: 100, retries: 100, samples: 200, shrinks: 1000 }))
 )
@@ -32,4 +33,4 @@ export const LiveContext: Layer.Layer<never, never, DefaultServices.DefaultServi
 /**
  * @since 2.0.0
  */
-export const TestContext: Layer.Layer<never, never, TestServices.TestServices> = layer.provideMerge(LiveContext, live)
+export const TestContext: Layer.Layer<never, never, TestServices.TestServices> = layer.provideMerge(live, LiveContext)

package/src/Types.ts

@@ -150,3 +150,27 @@ export type Mutable<T> = {
  * @category models
  */
 export type NoInfer<A> = [A][A extends any ? 0 : never]
+
+/**
+ * Invariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type Invariant<A> = (_: A) => A
+
+/**
+ * Covariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type Covariant<A> = (_: never) => A
+
+/**
+ * Contravariant helper.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type Contravariant<A> = (_: A) => void

package/src/UpstreamPullRequest.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as internal from "./internal/channel/upstreamPullRequest.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -31,7 +32,7 @@ export declare namespace UpstreamPullRequest {
    */
   export interface Variance<out A> {
     readonly [UpstreamPullRequestTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 }

package/src/UpstreamPullStrategy.ts

@@ -3,6 +3,7 @@
  */
 import * as internal from "./internal/channel/upstreamPullStrategy.js"
 import type * as Option from "./Option.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -32,7 +33,7 @@ export declare namespace UpstreamPullStrategy {
    */
   export interface Variance<out A> {
     readonly [UpstreamPullStrategyTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 }

package/src/Utils.ts

@@ -3,6 +3,7 @@
  */
 import { identity } from "./Function.js"
 import type { Kind, TypeLambda } from "./HKT.js"
+import type * as Types from "./Types.js"
 
 /*
  * Copyright 2014 Thom Chiovoloni, released under the MIT license.
@@ -156,12 +157,12 @@ export const makeGenKind = <F extends TypeLambda, R, O, E, A>(
  * @category models
  * @since 2.0.0
  */
-export interface Variance<F extends TypeLambda, R, O, E> {
+export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
   readonly [GenKindTypeId]: GenKindTypeId
-  readonly _F: (_: F) => F
-  readonly _R: (_: R) => unknown
-  readonly _O: (_: never) => O
-  readonly _E: (_: never) => E
+  readonly _F: Types.Invariant<F>
+  readonly _R: Types.Contravariant<R>
+  readonly _O: Types.Covariant<O>
+  readonly _E: Types.Covariant<E>
 }
 
 /**

package/src/internal/blockedRequests.ts

@@ -11,7 +11,7 @@ import type * as RequestBlock from "../RequestBlock.js"
 import type * as RequestResolver from "../RequestResolver.js"
 
 /** @internal */
-export const empty: RequestBlock.RequestBlock<never> = {
+export const empty: RequestBlock.RequestBlock = {
   _tag: "Empty"
 }
 
@@ -21,10 +21,10 @@ export const empty: RequestBlock.RequestBlock<never> = {
  *
  * @internal
  */
-export const par = <R, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  that: RequestBlock.RequestBlock<R2>
-): RequestBlock.RequestBlock<R | R2> => ({
+export const par = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
   _tag: "Par",
   left: self,
   right: that
@@ -36,10 +36,10 @@ export const par = <R, R2>(
  *
  * @internal
  */
-export const seq = <R, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  that: RequestBlock.RequestBlock<R2>
-): RequestBlock.RequestBlock<R | R2> => ({
+export const seq = (
+  self: RequestBlock.RequestBlock,
+  that: RequestBlock.RequestBlock
+): RequestBlock.RequestBlock => ({
   _tag: "Seq",
   left: self,
   right: that
@@ -51,19 +51,19 @@ export const seq = <R, R2>(
  *
  * @internal
  */
-export const single = <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const single = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-): RequestBlock.RequestBlock<R> => ({
+): RequestBlock.RequestBlock => ({
   _tag: "Single",
   dataSource: dataSource as any,
   blockedRequest
 })
 
 /** @internal */
-export const MapRequestResolversReducer = <R, A, R2>(
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-): RequestBlock.RequestBlock.Reducer<R, RequestBlock.RequestBlock<R | R2>> => ({
+export const MapRequestResolversReducer = <A>(
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock.Reducer<RequestBlock.RequestBlock> => ({
   emptyCase: () => empty,
   parCase: (left, right) => par(left, right),
   seqCase: (left, right) => seq(left, right),
@@ -87,10 +87,10 @@ interface SeqCase {
  *
  * @internal
  */
-export const mapRequestResolvers = <R, A, R2>(
-  self: RequestBlock.RequestBlock<R>,
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-): RequestBlock.RequestBlock<R | R2> => reduce(self, MapRequestResolversReducer(f))
+export const mapRequestResolvers = <A>(
+  self: RequestBlock.RequestBlock,
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+): RequestBlock.RequestBlock => reduce(self, MapRequestResolversReducer(f))
 
 /**
  * Folds over the cases of this collection of blocked requests with the
@@ -98,14 +98,14 @@ export const mapRequestResolvers = <R, A, R2>(
  *
  * @internal
  */
-export const reduce = <R, Z>(
-  self: RequestBlock.RequestBlock<R>,
-  reducer: RequestBlock.RequestBlock.Reducer<R, Z>
+export const reduce = <Z>(
+  self: RequestBlock.RequestBlock,
+  reducer: RequestBlock.RequestBlock.Reducer<Z>
 ): Z => {
-  let input: List.List<RequestBlock.RequestBlock<R>> = List.of(self)
+  let input: List.List<RequestBlock.RequestBlock> = List.of(self)
   let output = List.empty<Either.Either<BlockedRequestsCase, Z>>()
   while (List.isCons(input)) {
-    const current: RequestBlock.RequestBlock<R> = input.head
+    const current: RequestBlock.RequestBlock = input.head
     switch (current._tag) {
       case "Empty": {
         output = List.cons(Either.right(reducer.emptyCase()), output)
@@ -164,16 +164,16 @@ export const reduce = <R, Z>(
  *
  * @internal
  */
-export const flatten = <R>(
-  self: RequestBlock.RequestBlock<R>
-): List.List<SequentialCollection<R>> => {
+export const flatten = (
+  self: RequestBlock.RequestBlock
+): List.List<SequentialCollection> => {
   let current = List.of(self)
-  let updated = List.empty<SequentialCollection<R>>()
+  let updated = List.empty<SequentialCollection>()
   // eslint-disable-next-line no-constant-condition
   while (1) {
     const [parallel, sequential] = List.reduce(
       current,
-      [parallelCollectionEmpty<R>(), List.empty<RequestBlock.RequestBlock<R>>()] as const,
+      [parallelCollectionEmpty(), List.empty<RequestBlock.RequestBlock>()] as const,
       ([parallel, sequential], blockedRequest) => {
         const [par, seq] = step(blockedRequest)
         return [
@@ -199,13 +199,13 @@ export const flatten = <R>(
  * of blocked requests that must be performed sequentially after those
  * requests.
  */
-const step = <R>(
-  requests: RequestBlock.RequestBlock<R>
-): [ParallelCollection<R>, List.List<RequestBlock.RequestBlock<R>>] => {
-  let current: RequestBlock.RequestBlock<R> = requests
-  let parallel = parallelCollectionEmpty<R>()
-  let stack = List.empty<RequestBlock.RequestBlock<R>>()
-  let sequential = List.empty<RequestBlock.RequestBlock<R>>()
+const step = (
+  requests: RequestBlock.RequestBlock
+): [ParallelCollection, List.List<RequestBlock.RequestBlock>] => {
+  let current: RequestBlock.RequestBlock = requests
+  let parallel = parallelCollectionEmpty()
+  let stack = List.empty<RequestBlock.RequestBlock>()
+  let sequential = List.empty<RequestBlock.RequestBlock>()
   // eslint-disable-next-line no-constant-condition
   while (1) {
     switch (current._tag) {
@@ -275,10 +275,10 @@ const step = <R>(
  * are both from the same single data source then the requests can be
  * pipelined while preserving ordering guarantees.
  */
-const merge = <R>(
-  sequential: List.List<SequentialCollection<R>>,
-  parallel: ParallelCollection<R>
-): List.List<SequentialCollection<R>> => {
+const merge = (
+  sequential: List.List<SequentialCollection>,
+  parallel: ParallelCollection
+): List.List<SequentialCollection> => {
   if (List.isNil(sequential)) {
     return List.of(parallelCollectionToSequentialCollection(parallel))
   }
@@ -326,8 +326,8 @@ class EntryImpl<A extends Request.Request<any, any>> implements Request.Entry<A>
   ) {}
 }
 
-/** @internal */
 const blockedRequestVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
@@ -351,10 +351,11 @@ export const RequestBlockParallelTypeId = Symbol.for(
 )
 
 const parallelVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
-class ParallelImpl<out R> implements ParallelCollection<R> {
+class ParallelImpl implements ParallelCollection {
   readonly [RequestBlockParallelTypeId] = parallelVariance
   constructor(
     readonly map: HashMap.HashMap<
@@ -365,19 +366,19 @@ class ParallelImpl<out R> implements ParallelCollection<R> {
 }
 
 /** @internal */
-export const parallelCollectionEmpty = <R>(): ParallelCollection<R> => new ParallelImpl(HashMap.empty())
+export const parallelCollectionEmpty = (): ParallelCollection => new ParallelImpl(HashMap.empty())
 
 /** @internal */
-export const parallelCollectionMake = <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const parallelCollectionMake = <A>(
+  dataSource: RequestResolver.RequestResolver<A>,
   blockedRequest: Request.Entry<A>
-): ParallelCollection<R> => new ParallelImpl(HashMap.make([dataSource, Array.of(blockedRequest)]) as any)
+): ParallelCollection => new ParallelImpl(HashMap.make([dataSource, Array.of(blockedRequest)]) as any)
 
 /** @internal */
-export const parallelCollectionCombine = <R, R2>(
-  self: ParallelCollection<R>,
-  that: ParallelCollection<R2>
-): ParallelCollection<R | R2> =>
+export const parallelCollectionCombine = (
+  self: ParallelCollection,
+  that: ParallelCollection
+): ParallelCollection =>
   new ParallelImpl(HashMap.reduce(self.map, that.map, (map, value, key) =>
     HashMap.set(
       map,
@@ -389,17 +390,17 @@ export const parallelCollectionCombine = <R, R2>(
     )))
 
 /** @internal */
-export const parallelCollectionIsEmpty = <R>(self: ParallelCollection<R>): boolean => HashMap.isEmpty(self.map)
+export const parallelCollectionIsEmpty = (self: ParallelCollection): boolean => HashMap.isEmpty(self.map)
 
 /** @internal */
-export const parallelCollectionKeys = <R>(
-  self: ParallelCollection<R>
-): Array<RequestResolver.RequestResolver<unknown, R>> => Array.from(HashMap.keys(self.map)) as any
+export const parallelCollectionKeys = (
+  self: ParallelCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
 
 /** @internal */
-export const parallelCollectionToSequentialCollection = <R>(
-  self: ParallelCollection<R>
-): SequentialCollection<R> => sequentialCollectionMake(HashMap.map(self.map, (x) => Array.of(x)) as any)
+export const parallelCollectionToSequentialCollection = (
+  self: ParallelCollection
+): SequentialCollection => sequentialCollectionMake(HashMap.map(self.map, (x) => Array.of(x)) as any)
 
 // TODO
 // /** @internal */
@@ -412,12 +413,12 @@ export const SequentialCollectionTypeId = Symbol.for(
   "effect/RequestBlock/RequestBlockSequential"
 )
 
-/** @internal */
 const sequentialVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
-class SequentialImpl<out R> implements SequentialCollection<R> {
+class SequentialImpl implements SequentialCollection {
   readonly [SequentialCollectionTypeId] = sequentialVariance
   constructor(
     readonly map: HashMap.HashMap<
@@ -433,13 +434,13 @@ export const sequentialCollectionMake = <R, A>(
     RequestResolver.RequestResolver<A, R>,
     Array<Array<Request.Entry<A>>>
   >
-): SequentialCollection<R> => new SequentialImpl(map as any)
+): SequentialCollection => new SequentialImpl(map as any)
 
 /** @internal */
-export const sequentialCollectionCombine = <R, R2>(
-  self: SequentialCollection<R>,
-  that: SequentialCollection<R2>
-): SequentialCollection<R | R2> =>
+export const sequentialCollectionCombine = (
+  self: SequentialCollection,
+  that: SequentialCollection
+): SequentialCollection =>
   new SequentialImpl(HashMap.reduce(that.map, self.map, (map, value, key) =>
     HashMap.set(
       map,
@@ -451,24 +452,24 @@ export const sequentialCollectionCombine = <R, R2>(
     )))
 
 /** @internal */
-export const sequentialCollectionIsEmpty = <R>(self: SequentialCollection<R>): boolean => HashMap.isEmpty(self.map)
+export const sequentialCollectionIsEmpty = (self: SequentialCollection): boolean => HashMap.isEmpty(self.map)
 
 /** @internal */
-export const sequentialCollectionKeys = <R>(
-  self: SequentialCollection<R>
-): Array<RequestResolver.RequestResolver<unknown, R>> => Array.from(HashMap.keys(self.map)) as any
+export const sequentialCollectionKeys = (
+  self: SequentialCollection
+): Array<RequestResolver.RequestResolver<unknown>> => Array.from(HashMap.keys(self.map)) as any
 
 /** @internal */
-export const sequentialCollectionToChunk = <R>(
-  self: SequentialCollection<R>
-): Array<[RequestResolver.RequestResolver<unknown, R>, Array<Array<Request.Entry<unknown>>>]> =>
+export const sequentialCollectionToChunk = (
+  self: SequentialCollection
+): Array<[RequestResolver.RequestResolver<unknown>, Array<Array<Request.Entry<unknown>>>]> =>
   Array.from(self.map) as any
 
 /** @internal */
 export type RequestBlockParallelTypeId = typeof RequestBlockParallelTypeId
 
 /** @internal */
-export interface ParallelCollection<out R> extends ParallelCollection.Variance<R> {
+export interface ParallelCollection extends ParallelCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
     Array<Request.Entry<unknown>>
@@ -478,10 +479,8 @@ export interface ParallelCollection<out R> extends ParallelCollection.Variance<R
 /** @internal */
 export declare namespace ParallelCollection {
   /** @internal */
-  export interface Variance<out R> {
-    readonly [RequestBlockParallelTypeId]: {
-      readonly _R: (_: never) => R
-    }
+  export interface Variance {
+    readonly [RequestBlockParallelTypeId]: {}
   }
 }
 
@@ -489,7 +488,7 @@ export declare namespace ParallelCollection {
 export type SequentialCollectionTypeId = typeof SequentialCollectionTypeId
 
 /** @internal */
-export interface SequentialCollection<out R> extends SequentialCollection.Variance<R> {
+export interface SequentialCollection extends SequentialCollection.Variance {
   readonly map: HashMap.HashMap<
     RequestResolver.RequestResolver<unknown, unknown>,
     Array<Array<Request.Entry<unknown>>>
@@ -499,9 +498,7 @@ export interface SequentialCollection<out R> extends SequentialCollection.Varian
 /** @internal */
 export declare namespace SequentialCollection {
   /** @internal */
-  export interface Variance<out R> {
-    readonly [SequentialCollectionTypeId]: {
-      readonly _R: (_: never) => R
-    }
+  export interface Variance {
+    readonly [SequentialCollectionTypeId]: {}
   }
 }

package/src/internal/cache.ts

@@ -269,8 +269,11 @@ export const CacheTypeId: Cache.CacheTypeId = Symbol.for(
 ) as Cache.CacheTypeId
 
 const cacheVariance = {
+  /* c8 ignore next */
   _Key: (_: any) => _,
+  /* c8 ignore next */
   _Error: (_: never) => _,
+  /* c8 ignore next */
   _Value: (_: never) => _
 }