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

package/src/ReadonlyRecord.ts

@@ -16,7 +16,7 @@ import * as Option from "./Option.js"
  * @category models
  * @since 2.0.0
  */
-export interface ReadonlyRecord<A> {
+export interface ReadonlyRecord<out A> {
   readonly [x: string]: A
 }
 
@@ -370,6 +370,7 @@ export const pop: {
  *
  * assert.deepStrictEqual(map({ a: 3, b: 5 }, g), { a: "A-3", b: "B-5" })
  *
+ * @category mapping
  * @since 2.0.0
  */
 export const map: {
@@ -436,27 +437,19 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const filter: {
-  <K extends string, C extends A, B extends A, A = C>(
-    refinement: (a: A, key: K) => a is B
-  ): (self: Record<K, C>) => Record<string, B>
+  <K extends string, A, B extends A>(refinement: (a: A, key: K) => a is B): (self: Record<K, A>) => Record<string, B>
   <K extends string, B extends A, A = B>(
-    predicate: (a: A, key: K) => boolean
+    predicate: (A: A, key: K) => boolean
   ): (self: Record<K, B>) => Record<string, B>
-  <K extends string, C extends A, B extends A, A = C>(
-    self: Record<K, C>,
-    refinement: (a: A, key: K) => a is B
-  ): Record<string, B>
-  <K extends string, B extends A, A = B>(
-    self: Record<K, B>,
-    predicate: (a: A, key: K) => boolean
-  ): Record<string, B>
+  <K extends string, A, B extends A>(self: Record<K, A>, refinement: (a: A, key: K) => a is B): Record<string, B>
+  <K extends string, A>(self: Record<K, A>, predicate: (a: A, key: K) => boolean): Record<string, A>
 } = dual(
   2,
-  <B extends A, A = B>(
-    self: Record<string, B>,
+  <A>(
+    self: Record<string, A>,
     predicate: (a: A, key: string) => boolean
-  ): Record<string, B> => {
-    const out: Record<string, B> = {}
+  ): Record<string, A> => {
+    const out: Record<string, A> = {}
     for (const key of Object.keys(self)) {
       if (predicate(self[key], key)) {
         out[key] = self[key]
@@ -467,26 +460,80 @@ export const filter: {
 )
 
 /**
- * Given a record with `Option` values, returns a record with only the `Some` values, with the same keys.
+ * Given a record with `Option` values, returns a new record containing only the `Some` values, preserving the original keys.
  *
  * @param self - A record with `Option` values.
  *
  * @example
- * import { compact } from "effect/ReadonlyRecord"
- * import { some, none } from 'effect/Option'
+ * import { getSomes } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
- *   compact({ a: some(1), b: none(), c: some(2) }),
+ *   getSomes({ a: some(1), b: none(), c: some(2) }),
  *   { a: 1, c: 2 }
  * )
  *
  * @category filtering
  * @since 2.0.0
  */
-export const compact: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
+export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
   identity
 )
 
+/**
+ * Given a record with `Either` values, returns a new record containing only the `Left` values, preserving the original keys.
+ *
+ * @example
+ * import { getLefts } from "effect/ReadonlyRecord"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getLefts({ a: right(1), b: left("err"), c: right(2) }),
+ *   { b: "err" }
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getLefts = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, E> => {
+  const out: Record<string, E> = {}
+  for (const key of Object.keys(self)) {
+    const value = self[key]
+    if (E.isLeft(value)) {
+      out[key] = value.left
+    }
+  }
+
+  return out
+}
+
+/**
+ * Given a record with `Either` values, returns a new record containing only the `Right` values, preserving the original keys.
+ *
+ * @example
+ * import { getRights } from "effect/ReadonlyRecord"
+ * import { right, left } from "effect/Either"
+ *
+ * assert.deepStrictEqual(
+ *   getRights({ a: right(1), b: left("err"), c: right(2) }),
+ *   { a: 1, c: 2 }
+ * )
+ *
+ * @category filtering
+ * @since 2.0.0
+ */
+export const getRights = <E, A>(self: ReadonlyRecord<Either<E, A>>): Record<string, A> => {
+  const out: Record<string, A> = {}
+  for (const key of Object.keys(self)) {
+    const value = self[key]
+    if (E.isRight(value)) {
+      out[key] = value.right
+    }
+  }
+
+  return out
+}
+
 /**
  * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
  *
@@ -507,17 +554,17 @@ export const compact: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<stri
 export const partitionMap: {
   <K extends string, A, B, C>(
     f: (a: A, key: K) => Either<B, C>
-  ): (self: Record<K, A>) => [Record<string, B>, Record<string, C>]
+  ): (self: Record<K, A>) => [left: Record<string, B>, right: Record<string, C>]
   <K extends string, A, B, C>(
     self: Record<K, A>,
     f: (a: A, key: K) => Either<B, C>
-  ): [Record<string, B>, Record<string, C>]
+  ): [left: Record<string, B>, right: Record<string, C>]
 } = dual(
   2,
   <A, B, C>(
     self: Record<string, A>,
     f: (a: A, key: string) => Either<B, C>
-  ): [Record<string, B>, Record<string, C>] => {
+  ): [left: Record<string, B>, right: Record<string, C>] => {
     const left: Record<string, B> = {}
     const right: Record<string, C> = {}
     for (const key of Object.keys(self)) {
@@ -574,26 +621,26 @@ export const separate: <A, B>(
 export const partition: {
   <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): (
     self: Record<K, C>
-  ) => [Record<string, C>, Record<string, B>]
+  ) => [excluded: Record<string, Exclude<C, B>>, satisfying: Record<string, B>]
   <K extends string, B extends A, A = B>(
     predicate: (a: A, key: K) => boolean
-  ): (self: Record<K, B>) => [Record<string, B>, Record<string, B>]
-  <K extends string, C extends A, B extends A, A = C>(
-    self: Record<K, C>,
+  ): (self: Record<K, B>) => [excluded: Record<string, B>, satisfying: Record<string, B>]
+  <K extends string, A, B extends A>(
+    self: Record<K, A>,
     refinement: (a: A, key: K) => a is B
-  ): [Record<string, C>, Record<string, B>]
-  <K extends string, B extends A, A = B>(
-    self: Record<K, B>,
+  ): [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+  <K extends string, A>(
+    self: Record<K, A>,
     predicate: (a: A, key: K) => boolean
-  ): [Record<string, B>, Record<string, B>]
+  ): [excluded: Record<string, A>, satisfying: Record<string, A>]
 } = dual(
   2,
-  <B extends A, A = B>(
-    self: Record<string, B>,
+  <A>(
+    self: Record<string, A>,
     predicate: (a: A, key: string) => boolean
-  ): [Record<string, B>, Record<string, B>] => {
-    const left: Record<string, B> = {}
-    const right: Record<string, B> = {}
+  ): [excluded: Record<string, A>, satisfying: Record<string, A>] => {
+    const left: Record<string, A> = {}
+    const right: Record<string, A> = {}
     for (const key of Object.keys(self)) {
       if (predicate(self[key], key)) {
         right[key] = self[key]
@@ -740,11 +787,21 @@ export const reduce: {
  * @since 2.0.0
  */
 export const every: {
+  <A, K extends string, B extends A>(
+    refinement: (value: A, key: K) => value is B
+  ): (self: Record<K, A>) => self is Readonly<Record<K, B>>
   <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
+  <A, K extends string, B extends A>(
+    self: Record<K, A>,
+    refinement: (value: A, key: K) => value is B
+  ): self is Readonly<Record<K, B>>
   <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
+} = dual(2, <A, K extends string, B extends A>(
+  self: Record<K, A>,
+  refinement: (value: A, key: K) => value is B
+): self is Readonly<Record<K, A>> => {
   for (const key in self) {
-    if (!predicate(self[key], key)) {
+    if (!refinement(self[key], key)) {
       return false
     }
   }

package/src/RedBlackTree.ts

@@ -9,6 +9,7 @@ import * as RBTI from "./internal/redBlackTree/iterator.js"
 import type { Option } from "./Option.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
 
 const TypeId: unique symbol = RBT.RedBlackTreeTypeId as TypeId
 
@@ -30,8 +31,11 @@ export const Direction = RBTI.Direction
  * @since 2.0.0
  * @category models
  */
-export interface RedBlackTree<Key, Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
+export interface RedBlackTree<in out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _Key: Types.Invariant<Key>
+    readonly _Value: Types.Covariant<Value>
+  }
 }
 
 /**

package/src/Ref.ts

@@ -5,6 +5,7 @@ import type * as Effect from "./Effect.js"
 import * as internal from "./internal/ref.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
@@ -22,8 +23,8 @@ export type RefTypeId = typeof RefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Ref<A> extends Ref.Variance<A>, Pipeable {
-  readonly modify: <B>(f: (a: A) => readonly [B, A]) => Effect.Effect<never, never, B>
+export interface Ref<in out A> extends Ref.Variance<A>, Pipeable {
+  modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B>
 }
 
 /**
@@ -34,9 +35,9 @@ export declare namespace Ref {
   /**
    * @since 2.0.0
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [RefTypeId]: {
-      readonly _A: (_: A) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Reloadable.ts

@@ -7,6 +7,7 @@ import * as internal from "./internal/reloadable.js"
 import type * as Layer from "./Layer.js"
 import type * as Schedule from "./Schedule.js"
 import type * as ScopedRef from "./ScopedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -27,7 +28,7 @@ export type ReloadableTypeId = typeof ReloadableTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Reloadable<A> extends Reloadable.Variance<A> {
+export interface Reloadable<in out A> extends Reloadable.Variance<A> {
   /**
    * @internal
    */
@@ -46,9 +47,9 @@ export declare namespace Reloadable {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [ReloadableTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }

package/src/Request.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import type * as _Cache from "./Cache.js"
+import type { Cause } from "./Cause.js"
 import type * as Data from "./Data.js"
 import type { Deferred } from "./Deferred.js"
 import type { DurationInput } from "./Duration.js"
@@ -14,6 +15,7 @@ import * as core from "./internal/core.js"
 import * as fiberRuntime from "./internal/fiberRuntime.js"
 import * as internal from "./internal/request.js"
 import type * as Option from "./Option.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -34,7 +36,7 @@ export type RequestTypeId = typeof RequestTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Request<E, A> extends Request.Variance<E, A>, Data.Case {}
+export interface Request<out E, out A> extends Request.Variance<E, A>, Data.Case {}
 
 /**
  * @since 2.0.0
@@ -44,10 +46,10 @@ export declare namespace Request {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<out E, out A> {
     readonly [RequestTypeId]: {
-      readonly _E: (_: never) => E
-      readonly _A: (_: never) => A
+      readonly _E: Types.Covariant<E>
+      readonly _A: Types.Covariant<A>
     }
   }
 
@@ -120,6 +122,50 @@ export const tagged: <R extends Request<any, any> & { _tag: string }>(
   tag: R["_tag"]
 ) => Request.Constructor<R, "_tag"> = internal.tagged
 
+/**
+ * Provides a constructor for a Request Class.
+ *
+ * @example
+ * import * as Request from "effect/Request"
+ *
+ * type Error = never
+ * type Success = string
+ *
+ * class MyRequest extends Request.Class<Error, Success, {
+ *   readonly id: string
+ * }> {}
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const Class: new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Request<unknown, unknown> ? never : P]: A[P] }
+) => Request<Error, Success> & Readonly<A> = internal.Class as any
+
+/**
+ * Provides a Tagged constructor for a Request Class.
+ *
+ * @example
+ * import * as Request from "effect/Request"
+ *
+ * type Error = never
+ * type Success = string
+ *
+ * class MyRequest extends Request.TaggedClass("MyRequest")<Error, Success, {
+ *   readonly name: string
+ * }> {}
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const TaggedClass: <Tag extends string>(
+  tag: Tag
+) => new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends "_tag" | keyof Request<unknown, unknown> ? never : P]: A[P] }
+) => Request<Error, Success> & Readonly<A> & { readonly _tag: Tag } = internal.TaggedClass as any
+
 /**
  * Complete a `Request` with the specified result.
  *
@@ -171,6 +217,17 @@ export const fail: {
   <A extends Request<any, any>>(self: A, error: Request.Error<A>): Effect.Effect<never, never, void>
 } = internal.fail
 
+/**
+ * Complete a `Request` with the specified cause.
+ *
+ * @since 2.0.0
+ * @category request completion
+ */
+export const failCause: {
+  <A extends Request<any, any>>(cause: Cause<Request.Error<A>>): (self: A) => Effect.Effect<never, never, void>
+  <A extends Request<any, any>>(self: A, cause: Cause<Request.Error<A>>): Effect.Effect<never, never, void>
+} = internal.failCause
+
 /**
  * Complete a `Request` with the specified value.
  *
@@ -189,10 +246,10 @@ export const succeed: {
 export interface Listeners {
   readonly count: number
   readonly observers: Set<(count: number) => void>
-  readonly addObserver: (f: (count: number) => void) => void
-  readonly removeObserver: (f: (count: number) => void) => void
-  readonly increment: () => void
-  readonly decrement: () => void
+  addObserver(f: (count: number) => void): void
+  removeObserver(f: (count: number) => void): void
+  increment(): void
+  decrement(): void
 }
 
 /**
@@ -243,7 +300,7 @@ export type EntryTypeId = typeof EntryTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Entry<R> extends Entry.Variance<R> {
+export interface Entry<out R> extends Entry.Variance<R> {
   readonly request: R
   readonly result: Deferred<
     [R] extends [Request<infer _E, infer _A>] ? _E : never,
@@ -265,9 +322,9 @@ export declare namespace Entry {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R> {
+  export interface Variance<out R> {
     readonly [EntryTypeId]: {
-      readonly _R: (_: never) => R
+      readonly _R: Types.Covariant<R>
     }
   }
 }

package/src/RequestBlock.ts

@@ -1,11 +1,7 @@
 /**
  * @since 2.0.0
  */
-import type * as Context from "./Context.js"
-import type { FiberRef } from "./FiberRef.js"
 import * as _RequestBlock from "./internal/blockedRequests.js"
-import * as core from "./internal/core.js"
-import * as _dataSource from "./internal/dataSource.js"
 import type * as Request from "./Request.js"
 import type * as RequestResolver from "./RequestResolver.js"
 
@@ -19,7 +15,7 @@ import type * as RequestResolver from "./RequestResolver.js"
  * @since 2.0.0
  * @category models
  */
-export type RequestBlock<R> = Empty | Par<R> | Seq<R> | Single<R>
+export type RequestBlock = Empty | Par | Seq | Single
 
 /**
  * @since 2.0.0
@@ -30,14 +26,14 @@ export declare namespace RequestBlock {
    * @since 2.0.0
    * @category models
    */
-  export interface Reducer<R, Z> {
-    readonly emptyCase: () => Z
-    readonly parCase: (left: Z, right: Z) => Z
-    readonly singleCase: (
-      dataSource: RequestResolver.RequestResolver<unknown, R>,
+  export interface Reducer<in out Z> {
+    emptyCase(): Z
+    parCase(left: Z, right: Z): Z
+    singleCase(
+      dataSource: RequestResolver.RequestResolver<unknown, never>,
       blockedRequest: Request.Entry<unknown>
-    ) => Z
-    readonly seqCase: (left: Z, right: Z) => Z
+    ): Z
+    seqCase(left: Z, right: Z): Z
   }
 }
 
@@ -53,29 +49,29 @@ export interface Empty {
  * @since 2.0.0
  * @category models
  */
-export interface Par<R> {
+export interface Par {
   readonly _tag: "Par"
-  readonly left: RequestBlock<R>
-  readonly right: RequestBlock<R>
+  readonly left: RequestBlock
+  readonly right: RequestBlock
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Seq<R> {
+export interface Seq {
   readonly _tag: "Seq"
-  readonly left: RequestBlock<R>
-  readonly right: RequestBlock<R>
+  readonly left: RequestBlock
+  readonly right: RequestBlock
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Single<R> {
+export interface Single {
   readonly _tag: "Single"
-  readonly dataSource: RequestResolver.RequestResolver<unknown, R>
+  readonly dataSource: RequestResolver.RequestResolver<unknown, never>
   readonly blockedRequest: Request.Entry<unknown>
 }
 
@@ -83,75 +79,40 @@ export interface Single<R> {
  * @since 2.0.0
  * @category constructors
  */
-export const single: <R, A>(
-  dataSource: RequestResolver.RequestResolver<A, R>,
+export const single: <A>(
+  dataSource: RequestResolver.RequestResolver<A, never>,
   blockedRequest: Request.Entry<A>
-) => RequestBlock<R> = _RequestBlock.single
+) => RequestBlock = _RequestBlock.single
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const empty: RequestBlock<never> = _RequestBlock.empty
+export const empty: RequestBlock = _RequestBlock.empty
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const mapRequestResolvers: <R, A, R2>(
-  self: RequestBlock<R>,
-  f: (dataSource: RequestResolver.RequestResolver<A, R>) => RequestResolver.RequestResolver<A, R2>
-) => RequestBlock<R | R2> = _RequestBlock.mapRequestResolvers
+export const mapRequestResolvers: <A>(
+  self: RequestBlock,
+  f: (dataSource: RequestResolver.RequestResolver<A>) => RequestResolver.RequestResolver<A>
+) => RequestBlock = _RequestBlock.mapRequestResolvers
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const parallel: <R, R2>(self: RequestBlock<R>, that: RequestBlock<R2>) => RequestBlock<R | R2> =
-  _RequestBlock.par
+export const parallel: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.par
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const reduce: <R, Z>(self: RequestBlock<R>, reducer: RequestBlock.Reducer<R, Z>) => Z = _RequestBlock.reduce
+export const reduce: <Z>(self: RequestBlock, reducer: RequestBlock.Reducer<Z>) => Z = _RequestBlock.reduce
 
 /**
  * @since 2.0.0
  * @category constructors
  */
-export const sequential: <R, R2>(self: RequestBlock<R>, that: RequestBlock<R2>) => RequestBlock<R | R2> =
-  _RequestBlock.seq
-
-/**
- * Provides each data source with part of its required environment.
- *
- * @since 2.0.0
- * @category utils
- */
-export const mapInputContext = <R0, R>(
-  self: RequestBlock<R>,
-  f: (context: Context.Context<R0>) => Context.Context<R>
-): RequestBlock<R0> => reduce(self, MapInputContextReducer(f))
-
-const MapInputContextReducer = <R0, R>(
-  f: (context: Context.Context<R0>) => Context.Context<R>
-): RequestBlock.Reducer<R, RequestBlock<R0>> => ({
-  emptyCase: () => empty,
-  parCase: (left, right) => parallel(left, right),
-  seqCase: (left, right) => sequential(left, right),
-  singleCase: (dataSource, blockedRequest) =>
-    single(
-      _dataSource.mapInputContext(dataSource, f),
-      blockedRequest as any
-    )
-})
-
-/**
- * Provides each data source with a fiber ref value.
- *
- * @since 2.0.0
- * @category utils
- */
-export const locally: <R, A>(self: RequestBlock<R>, ref: FiberRef<A>, value: A) => RequestBlock<R> =
-  core.requestBlockLocally
+export const sequential: (self: RequestBlock, that: RequestBlock) => RequestBlock = _RequestBlock.seq

package/src/RequestResolver.ts

@@ -11,6 +11,7 @@ import * as core from "./internal/core.js"
 import * as internal from "./internal/dataSource.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as Request from "./Request.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -48,18 +49,18 @@ export type RequestResolverTypeId = typeof RequestResolverTypeId
  * @since 2.0.0
  * @category models
  */
-export interface RequestResolver<A, R = never> extends Equal.Equal, Pipeable {
+export interface RequestResolver<in A, out R = never> extends RequestResolver.Variance<A, R>, Equal.Equal, Pipeable {
   /**
    * Execute a collection of requests. The outer `Chunk` represents batches
    * of requests that must be performed sequentially. The inner `Chunk`
    * represents a batch of requests that can be performed in parallel.
    */
-  readonly runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<R, never, void>
+  runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<R, never, void>
 
   /**
    * Identify the data source using the specific identifier
    */
-  readonly identified: (...identifiers: Array<unknown>) => RequestResolver<A, R>
+  identified(...identifiers: Array<unknown>): RequestResolver<A, R>
 }
 
 /**
@@ -70,10 +71,10 @@ export declare namespace RequestResolver {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, A> {
+  export interface Variance<in A, out R> {
     readonly [RequestResolverTypeId]: {
-      readonly _R: (_: never) => R
-      readonly _A: (_: never) => A
+      readonly _A: Types.Contravariant<A>
+      readonly _R: Types.Covariant<R>
     }
   }
 }