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

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
@@ -23,12 +24,12 @@ export type TDeferredTypeId = typeof TDeferredTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TDeferred<E, A> extends TDeferred.Variance<E, A> {}
+export interface TDeferred<in out E, in out A> extends TDeferred.Variance<E, A> {}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TDeferred<E, A> {
+export interface TDeferred<in out E, in out A> {
   /** @internal */
   readonly ref: TRef.TRef<Option.Option<Either.Either<E, A>>>
 }
@@ -41,10 +42,10 @@ export declare namespace TDeferred {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<in out E, in out A> {
     readonly [TDeferredTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => 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
@@ -29,12 +30,12 @@ export type TMapTypeId = typeof TMapTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TMap<K, V> extends TMap.Variance<K, V> {}
+export interface TMap<in out K, in out V> extends TMap.Variance<K, V> {}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TMap<K, V> {
+export interface TMap<in out K, in out V> {
   /** @internal */
   readonly tBuckets: TRef.TRef<TArray.TArray<Chunk.Chunk<readonly [K, V]>>>
   /** @internal */
@@ -49,10 +50,10 @@ export declare namespace TMap {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<K, V> {
+  export interface Variance<in out K, in out V> {
     readonly [TMapTypeId]: {
-      readonly _K: (_: never) => K
-      readonly _V: (_: never) => 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
@@ -32,12 +33,12 @@ export type TPriorityQueueTypeId = typeof TPriorityQueueTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TPriorityQueue<A> extends TPriorityQueue.Variance<A> {}
+export interface TPriorityQueue<in out A> extends TPriorityQueue.Variance<A> {}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TPriorityQueue<A> {
+export interface TPriorityQueue<in out A> {
   /** @internal */
   readonly ref: TRef.TRef<SortedMap.SortedMap<A, [A, ...Array<A>]>>
 }
@@ -50,9 +51,9 @@ export declare namespace TPriorityQueue {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [TPriorityQueueTypeId]: {
-      readonly _A: (_: never) => 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
@@ -26,13 +27,16 @@ export type TPubSubTypeId = typeof TPubSubTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TPubSub<A> extends TQueue.TEnqueue<A> {}
+export interface TPubSub<in out A> extends TQueue.TEnqueue<A> {
+  readonly [TPubSubTypeId]: {
+    readonly _A: Types.Invariant<A>
+  }
+}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TPubSub<A> {
-  readonly [TPubSubTypeId]: TPubSubTypeId
+export interface TPubSub<in out A> {
   /** @internal */
   readonly pubsubSize: TRef.TRef<number>
   /** @internal */

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
@@ -34,17 +35,17 @@ export type TEnqueueTypeId = typeof TEnqueueTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TQueue<A> extends TEnqueue<A>, TDequeue<A> {}
+export interface TQueue<in out A> extends TEnqueue<A>, TDequeue<A> {}
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface TEnqueue<A> extends TQueue.TEnqueueVariance<A>, BaseTQueue {
+export interface TEnqueue<in A> extends TQueue.TEnqueueVariance<A>, BaseTQueue {
   /**
    * Places one value in the queue.
    */
-  readonly offer: (value: A) => STM.STM<never, never, boolean>
+  offer(value: A): STM.STM<never, never, boolean>
 
   /**
    * For Bounded TQueue: uses the `BackPressure` Strategy, places the values in
@@ -61,14 +62,14 @@ export interface TEnqueue<A> extends TQueue.TEnqueueVariance<A>, BaseTQueue {
    * For Dropping TQueue: uses `Dropping` Strategy, It places the values in the
    * queue but if there is no room it will not enqueue them and return false.
    */
-  readonly offerAll: (iterable: Iterable<A>) => STM.STM<never, never, boolean>
+  offerAll(iterable: Iterable<A>): STM.STM<never, never, boolean>
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface TDequeue<A> extends TQueue.TDequeueVariance<A>, BaseTQueue {
+export interface TDequeue<out A> extends TQueue.TDequeueVariance<A>, BaseTQueue {
   /**
    * Views the next element in the queue without removing it, retrying if the
    * queue is empty.
@@ -96,7 +97,7 @@ export interface TDequeue<A> extends TQueue.TDequeueVariance<A>, BaseTQueue {
   /**
    * Takes up to max number of values from the queue.
    */
-  readonly takeUpTo: (max: number) => STM.STM<never, never, Array<A>>
+  takeUpTo(max: number): STM.STM<never, never, Array<A>>
 }
 
 /**
@@ -109,7 +110,7 @@ export interface BaseTQueue {
   /**
    * Returns the number of elements the queue can hold.
    */
-  readonly capacity: () => number
+  capacity(): number
 
   /**
    * Retrieves the size of the queue, which is equal to the number of elements
@@ -156,9 +157,9 @@ export declare namespace TQueue {
    * @since 2.0.0
    * @category models
    */
-  export interface TEnqueueVariance<A> {
+  export interface TEnqueueVariance<in A> {
     readonly [TEnqueueTypeId]: {
-      readonly _In: (_: A) => void
+      readonly _In: Types.Contravariant<A>
     }
   }
 
@@ -166,9 +167,9 @@ export declare namespace TQueue {
    * @since 2.0.0
    * @category models
    */
-  export interface TDequeueVariance<A> {
+  export interface TDequeueVariance<out A> {
     readonly [TDequeueTypeId]: {
-      readonly _Out: (_: never) => A
+      readonly _Out: Types.Covariant<A>
     }
   }
 }

package/src/TRandom.ts

@@ -42,16 +42,16 @@ export interface TRandom {
    * Returns the next numeric value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextRange: (min: number, max: number) => STM.STM<never, never, number>
+  nextRange(min: number, max: number): STM.STM<never, never, number>
   /**
    * Returns the next integer value in the specified range from the
    * pseudo-random number generator.
    */
-  readonly nextIntBetween: (min: number, max: number) => STM.STM<never, never, number>
+  nextIntBetween(min: number, max: number): STM.STM<never, never, number>
   /**
    * Uses the pseudo-random number generator to shuffle the specified iterable.
    */
-  readonly shuffle: <A>(elements: Iterable<A>) => STM.STM<never, never, Array<A>>
+  shuffle<A>(elements: Iterable<A>): STM.STM<never, never, Array<A>>
 }
 /**
  * @internal

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
@@ -33,17 +34,17 @@ export type TRefTypeId = typeof TRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TRef<A> extends TRef.Variance<A> {
+export interface TRef<in out A> extends TRef.Variance<A> {
   /**
    * Note: the method is unbound, exposed only for potential extensions.
    */
-  readonly modify: <B>(f: (a: A) => readonly [B, A]) => STM.STM<never, never, B>
+  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<never, never, B>
 }
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TRef<A> {
+export interface TRef<in out A> {
   /** @internal */
   todos: Map<TxnId.TxnId, Journal.Todo>
   /** @internal */
@@ -57,9 +58,9 @@ export declare namespace TRef {
   /**
    * @since 2.0.0
    */
-  export interface Variance<A> {
+  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
@@ -27,12 +28,12 @@ export type TSetTypeId = typeof TSetTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TSet<A> extends TSet.Variance<A> {}
+export interface TSet<in out A> extends TSet.Variance<A> {}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TSet<A> {
+export interface TSet<in out A> {
   /** @internal */
   readonly tMap: TMap.TMap<A, void>
 }
@@ -45,9 +46,9 @@ export declare namespace TSet {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [TSetTypeId]: {
-      readonly _A: (_: never) => 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
@@ -29,7 +30,7 @@ export type TakeTypeId = typeof TakeTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Take<E, A> extends Take.Variance<E, A>, Pipeable {
+export interface Take<out E, out A> extends Take.Variance<E, A>, Pipeable {
   /** @internal */
   readonly exit: Exit.Exit<Option.Option<E>, Chunk.Chunk<A>>
 }
@@ -42,10 +43,10 @@ export declare namespace Take {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  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"
 
@@ -29,17 +29,21 @@ export type TestAnnotationTypeId = typeof TestAnnotationTypeId
 /**
  * @since 2.0.0
  */
-export interface TestAnnotation<A> extends Equal.Equal {
-  readonly [TestAnnotationTypeId]: TestAnnotationTypeId
+export interface TestAnnotation<in out A> extends Equal.Equal {
+  readonly [TestAnnotationTypeId]: {
+    readonly _A: Types.Invariant<A>
+  }
   readonly identifier: string
   readonly tag: Context.Tag<A, A>
   readonly initial: A
-  readonly combine: (a: A, b: A) => A
+  combine(a: A, b: A): A
 }
 
 /** @internal */
 class TestAnnotationImpl<A> implements Equal.Equal {
-  readonly [TestAnnotationTypeId]: TestAnnotationTypeId = TestAnnotationTypeId
+  readonly [TestAnnotationTypeId] = {
+    _A: (_: any) => _
+  }
   constructor(
     readonly identifier: string,
     readonly tag: Context.Tag<A, A>,

package/src/TestAnnotations.ts

@@ -46,13 +46,13 @@ export interface TestAnnotations {
    * Accesses an `Annotations` instance in the context and retrieves the
    * annotation of the specified type, or its default value if there is none.
    */
-  readonly get: <A>(key: TestAnnotation.TestAnnotation<A>) => Effect.Effect<never, never, A>
+  get<A>(key: TestAnnotation.TestAnnotation<A>): Effect.Effect<never, never, A>
 
   /**
    * Accesses an `Annotations` instance in the context and appends the
    * specified annotation to the annotation map.
    */
-  readonly annotate: <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => Effect.Effect<never, never, void>
+  annotate<A>(key: TestAnnotation.TestAnnotation<A>, value: A): Effect.Effect<never, never, void>
 
   /**
    * Returns the set of all fibers in this test.

package/src/TestClock.ts

@@ -76,12 +76,10 @@ import * as Live from "./TestLive.js"
  * @since 2.0.0
  */
 export interface TestClock extends Clock.Clock {
-  readonly adjust: (duration: Duration.DurationInput) => Effect.Effect<never, never, void>
-  readonly adjustWith: (
-    duration: Duration.DurationInput
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  adjust(duration: Duration.DurationInput): Effect.Effect<never, never, void>
+  adjustWith(duration: Duration.DurationInput): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
   readonly save: Effect.Effect<never, never, Effect.Effect<never, never, void>>
-  readonly setTime: (time: number) => Effect.Effect<never, never, void>
+  setTime(time: number): Effect.Effect<never, never, void>
   readonly sleeps: Effect.Effect<never, never, Chunk.Chunk<number>>
 }
 

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/TestLive.ts

@@ -27,7 +27,7 @@ export type TestLiveTypeId = typeof TestLiveTypeId
  */
 export interface TestLive {
   readonly [TestLiveTypeId]: TestLiveTypeId
-  readonly provide: <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  provide<R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A>
 }
 
 /**

package/src/TestSized.ts

@@ -23,7 +23,7 @@ export interface TestSized {
   readonly [TestSizedTypeId]: TestSizedTypeId
   readonly fiberRef: FiberRef.FiberRef<number>
   readonly size: Effect.Effect<never, never, number>
-  readonly withSize: (size: number) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  withSize(size: number): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
 }
 
 /**

package/src/Tracer.ts

@@ -24,14 +24,14 @@ export type TracerTypeId = typeof TracerTypeId
  */
 export interface Tracer {
   readonly [TracerTypeId]: TracerTypeId
-  readonly span: (
+  span(
     name: string,
     parent: Option.Option<ParentSpan>,
     context: Context.Context<never>,
     links: ReadonlyArray<SpanLink>,
     startTime: bigint
-  ) => Span
-  readonly context: <X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>) => X
+  ): Span
+  context<X>(f: () => X, fiber: Fiber.RuntimeFiber<any, any>): X
 }
 
 /**
@@ -87,9 +87,9 @@ export interface Span {
   readonly attributes: ReadonlyMap<string, unknown>
   readonly links: ReadonlyArray<SpanLink>
   readonly sampled: boolean
-  readonly end: (endTime: bigint, exit: Exit.Exit<unknown, unknown>) => void
-  readonly attribute: (key: string, value: unknown) => void
-  readonly event: (name: string, startTime: bigint, attributes?: Record<string, unknown>) => void
+  end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void
+  attribute(key: string, value: unknown): void
+  event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void
 }
 
 /**

package/src/Types.ts

@@ -142,3 +142,35 @@ export type Concurrency = number | "unbounded" | "inherit"
 export type Mutable<T> = {
   -readonly [P in keyof T]: T[P]
 }
+
+/**
+ * Avoid inference on a specific parameter
+ *
+ * @since 2.0.0
+ * @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
@@ -29,9 +30,9 @@ export declare namespace UpstreamPullRequest {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<out A> {
     readonly [UpstreamPullRequestTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 }
@@ -40,7 +41,7 @@ export declare namespace UpstreamPullRequest {
  * @since 2.0.0
  * @category models
  */
-export interface Pulled<A> extends UpstreamPullRequest.Variance<A> {
+export interface Pulled<out A> extends UpstreamPullRequest.Variance<A> {
   readonly _tag: "Pulled"
   readonly value: A
 }
@@ -101,10 +102,16 @@ export const isNoUpstream: <A>(self: UpstreamPullRequest<A>) => self is NoUpstre
  */
 export const match: {
   <A, Z>(
-    options: { readonly onPulled: (value: A) => Z; readonly onNoUpstream: (activeDownstreamCount: number) => Z }
+    options: {
+      readonly onPulled: (value: A) => Z
+      readonly onNoUpstream: (activeDownstreamCount: number) => Z
+    }
   ): (self: UpstreamPullRequest<A>) => Z
   <A, Z>(
     self: UpstreamPullRequest<A>,
-    options: { readonly onPulled: (value: A) => Z; readonly onNoUpstream: (activeDownstreamCount: number) => Z }
+    options: {
+      readonly onPulled: (value: A) => Z
+      readonly onNoUpstream: (activeDownstreamCount: number) => Z
+    }
   ): Z
 } = internal.match

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
@@ -30,9 +31,9 @@ export declare namespace UpstreamPullStrategy {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<out A> {
     readonly [UpstreamPullStrategyTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Covariant<A>
     }
   }
 }
@@ -41,7 +42,7 @@ export declare namespace UpstreamPullStrategy {
  * @since 2.0.0
  * @category models
  */
-export interface PullAfterNext<A> extends UpstreamPullStrategy.Variance<A> {
+export interface PullAfterNext<out A> extends UpstreamPullStrategy.Variance<A> {
   readonly _tag: "PullAfterNext"
   readonly emitSeparator: Option.Option<A>
 }
@@ -50,7 +51,7 @@ export interface PullAfterNext<A> extends UpstreamPullStrategy.Variance<A> {
  * @since 2.0.0
  * @category models
  */
-export interface PullAfterAllEnqueued<A> extends UpstreamPullStrategy.Variance<A> {
+export interface PullAfterAllEnqueued<out A> extends UpstreamPullStrategy.Variance<A> {
   readonly _tag: "PullAfterAllEnqueued"
   readonly emitSeparator: Option.Option<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.
@@ -38,7 +39,7 @@ export type GenKindTypeId = typeof GenKindTypeId
 export interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R, O, E> {
   readonly value: Kind<F, R, O, E, A>
 
-  readonly [Symbol.iterator]: () => Generator<GenKind<F, R, O, E, A>, A>
+  [Symbol.iterator](): Generator<GenKind<F, R, O, E, A>, A>
 }
 
 /**
@@ -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/index.ts

@@ -514,6 +514,11 @@ export * as Pool from "./Pool.js"
  */
 export * as Predicate from "./Predicate.js"
 
+/**
+ * @since 2.0.0
+ */
+export * as PrimaryKey from "./PrimaryKey.js"
+
 /**
  * @since 2.0.0
  */