effect 2.0.0-next.55 → 2.0.0-next.56

package/src/RedBlackTree.ts

@@ -30,8 +30,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: (_: Key) => Key
+    readonly _Value: (_: never) => Value
+  }
 }
 
 /**

package/src/Ref.ts

@@ -22,8 +22,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,7 +34,7 @@ export declare namespace Ref {
   /**
    * @since 2.0.0
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [RefTypeId]: {
       readonly _A: (_: A) => A
     }

package/src/Reloadable.ts

@@ -27,7 +27,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 +46,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: (_: A) => A
     }
   }
 }

package/src/Request.ts

@@ -14,6 +14,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 +35,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,7 +45,7 @@ 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
@@ -120,6 +121,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.
  *
@@ -189,10 +234,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 +288,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,7 +310,7 @@ 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
     }

package/src/RequestBlock.ts

@@ -30,14 +30,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: (
+  export interface Reducer<in R, in out Z> {
+    emptyCase(): Z
+    parCase(left: Z, right: Z): Z
+    singleCase(
       dataSource: RequestResolver.RequestResolver<unknown, R>,
       blockedRequest: Request.Entry<unknown>
-    ) => Z
-    readonly seqCase: (left: Z, right: Z) => Z
+    ): Z
+    seqCase(left: Z, right: Z): Z
   }
 }
 
@@ -53,7 +53,7 @@ export interface Empty {
  * @since 2.0.0
  * @category models
  */
-export interface Par<R> {
+export interface Par<out R> {
   readonly _tag: "Par"
   readonly left: RequestBlock<R>
   readonly right: RequestBlock<R>
@@ -63,7 +63,7 @@ export interface Par<R> {
  * @since 2.0.0
  * @category models
  */
-export interface Seq<R> {
+export interface Seq<out R> {
   readonly _tag: "Seq"
   readonly left: RequestBlock<R>
   readonly right: RequestBlock<R>
@@ -73,7 +73,7 @@ export interface Seq<R> {
  * @since 2.0.0
  * @category models
  */
-export interface Single<R> {
+export interface Single<out R> {
   readonly _tag: "Single"
   readonly dataSource: RequestResolver.RequestResolver<unknown, R>
   readonly blockedRequest: Request.Entry<unknown>

package/src/RequestResolver.ts

@@ -48,18 +48,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 +70,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 _A: (_: A) => void
       readonly _R: (_: never) => R
-      readonly _A: (_: never) => A
     }
   }
 }

package/src/Resource.ts

@@ -27,7 +27,7 @@ export type ResourceTypeId = typeof ResourceTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Resource<E, A> extends Resource.Variance<E, A> {
+export interface Resource<in out E, in out A> extends Resource.Variance<E, A> {
   /** @internal */
   readonly scopedRef: ScopedRef.ScopedRef<Exit.Exit<E, A>>
   /** @internal */
@@ -42,10 +42,10 @@ export declare namespace Resource {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<in out E, in out A> {
     readonly [ResourceTypeId]: {
-      _E: (_: never) => E
-      _A: (_: never) => A
+      _E: (_: E) => E
+      _A: (_: A) => A
     }
   }
 }

package/src/Runtime.ts

@@ -18,7 +18,7 @@ import type { Scheduler } from "./Scheduler.js"
  * @since 2.0.0
  * @category models
  */
-export interface AsyncFiberException<E, A> {
+export interface AsyncFiberException<out E, out A> {
   readonly _tag: "AsyncFiberException"
   readonly fiber: Fiber.RuntimeFiber<E, A>
 }
@@ -27,7 +27,7 @@ export interface AsyncFiberException<E, A> {
  * @since 2.0.0
  * @category models
  */
-export interface Cancel<E, A> {
+export interface Cancel<out E, out A> {
   (fiberId?: FiberId.FiberId, onExit?: (exit: Exit.Exit<E, A>) => void): void
 }
 
@@ -35,7 +35,7 @@ export interface Cancel<E, A> {
  * @since 2.0.0
  * @category models
  */
-export interface Runtime<R> extends Pipeable {
+export interface Runtime<in R> extends Pipeable {
   /**
    * The context used as initial for forks
    */

package/src/STM.ts

@@ -65,7 +65,7 @@ export type STMTypeId = typeof STMTypeId
  * @since 2.0.0
  * @category models
  */
-export interface STM<R, E, A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
+export interface STM<out R, out E, out A> extends Effect.Effect<R, E, A>, STM.Variance<R, E, A>, Pipeable {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: STMUnify<this>
   [Unify.ignoreSymbol]?: STMUnifyIgnore
@@ -137,7 +137,7 @@ export declare namespace STM {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, A> {
+  export interface Variance<out R, out E, out A> {
     readonly [STMTypeId]: {
       readonly _R: (_: never) => R
       readonly _E: (_: never) => E
@@ -150,12 +150,12 @@ export declare namespace STM {
  * @category models
  * @since 2.0.0
  */
-export interface STMGen<R, E, A> {
+export interface STMGen<out R, out E, out A> {
   readonly _R: () => R
   readonly _E: () => E
   readonly _A: () => A
   readonly value: STM<R, E, A>
-  readonly [Symbol.iterator]: () => Generator<STMGen<R, E, A>, A>
+  [Symbol.iterator](): Generator<STMGen<R, E, A>, A>
 }
 
 /**
@@ -1208,7 +1208,7 @@ export const isSuccess: <R, E, A>(self: STM<R, E, A>) => STM<R, never, boolean>
 export const iterate: <R, E, Z>(
   initial: Z,
   options: {
-    readonly while: (z: Z) => boolean
+    readonly while: Predicate<Z>
     readonly body: (z: Z) => STM<R, E, Z>
   }
 ) => STM<R, E, Z> = stm.iterate
@@ -1236,7 +1236,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => STM<R, E, A>
       readonly discard?: false | undefined
@@ -1245,7 +1245,7 @@ export const loop: {
   <Z, R, E, A>(
     initial: Z,
     options: {
-      readonly while: (z: Z) => boolean
+      readonly while: Predicate<Z>
       readonly step: (z: Z) => Z
       readonly body: (z: Z) => STM<R, E, A>
       readonly discard: true
@@ -1465,8 +1465,13 @@ export const orTry: {
  * @category traversing
  */
 export const partition: {
-  <R, E, A, A2>(f: (a: A) => STM<R, E, A2>): (elements: Iterable<A>) => STM<R, never, [Array<E>, Array<A2>]>
-  <R, E, A, A2>(elements: Iterable<A>, f: (a: A) => STM<R, E, A2>): STM<R, never, [Array<E>, Array<A2>]>
+  <R, E, A, A2>(
+    f: (a: A) => STM<R, E, A2>
+  ): (elements: Iterable<A>) => STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
+  <R, E, A, A2>(
+    elements: Iterable<A>,
+    f: (a: A) => STM<R, E, A2>
+  ): STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
 } = stm.partition
 
 /**
@@ -1823,11 +1828,17 @@ export const tap: {
  */
 export const tapBoth: {
   <E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
-    options: { readonly onFailure: (error: XE) => STM<R2, E2, A2>; readonly onSuccess: (value: XA) => STM<R3, E3, A3> }
+    options: {
+      readonly onFailure: (error: XE) => STM<R2, E2, A2>
+      readonly onSuccess: (value: XA) => STM<R3, E3, A3>
+    }
   ): <R>(self: STM<R, E, A>) => STM<R2 | R3 | R, E | E2 | E3, A>
   <R, E, XE extends E, R2, E2, A2, A, XA extends A, R3, E3, A3>(
     self: STM<R, E, A>,
-    options: { readonly onFailure: (error: XE) => STM<R2, E2, A2>; readonly onSuccess: (value: XA) => STM<R3, E3, A3> }
+    options: {
+      readonly onFailure: (error: XE) => STM<R2, E2, A2>
+      readonly onSuccess: (value: XA) => STM<R3, E3, A3>
+    }
   ): STM<R | R2 | R3, E | E2 | E3, A>
 } = stm.tapBoth
 
@@ -2026,7 +2037,7 @@ export const firstSuccessOf = <R, E, A>(effects: Iterable<STM<R, E, A>>): STM<R,
   suspend<R, E, A>(() => {
     const list = Chunk.fromIterable(effects)
     if (!Chunk.isNonEmpty(list)) {
-      return dieSync(() => Cause.IllegalArgumentException(`Received an empty collection of effects`))
+      return dieSync(() => new Cause.IllegalArgumentException(`Received an empty collection of effects`))
     }
     return Chunk.reduce(
       Chunk.tailNonEmpty(list),

package/src/Schedule.ts

@@ -67,7 +67,7 @@ export type ScheduleDriverTypeId = typeof ScheduleDriverTypeId
  * @category model
  * @since 2.0.0
  */
-export interface Schedule<Env, In, Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
+export interface Schedule<out Env, in In, out Out> extends Schedule.Variance<Env, In, Out>, Pipeable {
   /**
    * Initial State
    */
@@ -75,11 +75,11 @@ export interface Schedule<Env, In, Out> extends Schedule.Variance<Env, In, Out>,
   /**
    * Schedule Step
    */
-  readonly step: (
+  step(
     now: number,
     input: In,
     state: any
-  ) => Effect.Effect<Env, never, readonly [any, Out, ScheduleDecision.ScheduleDecision]>
+  ): Effect.Effect<Env, never, readonly [any, Out, ScheduleDecision.ScheduleDecision]>
 }
 
 /**
@@ -90,7 +90,7 @@ export declare namespace Schedule {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Env, In, Out> {
+  export interface Variance<out Env, in In, out Out> {
     readonly [ScheduleTypeId]: {
       readonly _Env: (_: never) => Env
       readonly _In: (_: In) => void
@@ -101,7 +101,7 @@ export declare namespace Schedule {
   /**
    * @since 2.0.0
    */
-  export interface DriverVariance<Env, In, Out> {
+  export interface DriverVariance<out Env, in In, out Out> {
     readonly [ScheduleDriverTypeId]: {
       readonly _Env: (_: never) => Env
       readonly _In: (_: In) => void
@@ -114,11 +114,11 @@ export declare namespace Schedule {
  * @since 2.0.0
  * @category models
  */
-export interface ScheduleDriver<Env, In, Out> extends Schedule.DriverVariance<Env, In, Out> {
+export interface ScheduleDriver<out Env, in In, out Out> extends Schedule.DriverVariance<Env, In, Out> {
   readonly state: Effect.Effect<never, never, unknown>
   readonly last: Effect.Effect<never, Cause.NoSuchElementException, Out>
   readonly reset: Effect.Effect<never, never, void>
-  readonly next: (input: In) => Effect.Effect<Env, Option.Option<never>, Out>
+  next(input: In): Effect.Effect<Env, Option.Option<never>, Out>
 }
 
 /**

package/src/Scheduler.ts

@@ -21,15 +21,15 @@ export type Task = () => void
  * @category models
  */
 export interface Scheduler {
-  readonly shouldYield: (fiber: RuntimeFiber<unknown, unknown>) => number | false
-  readonly scheduleTask: (task: Task, priority: number) => void
+  shouldYield(fiber: RuntimeFiber<unknown, unknown>): number | false
+  scheduleTask(task: Task, priority: number): void
 }
 
 /**
  * @since 2.0.0
  * @category utils
  */
-export class PriorityBuckets<T = Task> {
+export class PriorityBuckets<in out T = Task> {
   /**
    * @since 2.0.0
    */

package/src/Scope.ts

@@ -44,11 +44,11 @@ export interface Scope extends Pipeable {
   /**
    * @internal
    */
-  readonly fork: (strategy: ExecutionStrategy.ExecutionStrategy) => Effect.Effect<never, never, Scope.Closeable>
+  fork(strategy: ExecutionStrategy.ExecutionStrategy): Effect.Effect<never, never, Scope.Closeable>
   /**
    * @internal
    */
-  readonly addFinalizer: (finalizer: Scope.Finalizer) => Effect.Effect<never, never, void>
+  addFinalizer(finalizer: Scope.Finalizer): Effect.Effect<never, never, void>
 }
 
 /**
@@ -61,7 +61,7 @@ export interface CloseableScope extends Scope, Pipeable {
   /**
    * @internal
    */
-  readonly close: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<never, never, void>
+  close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<never, never, void>
 }
 
 /**

package/src/ScopedCache.ts

@@ -26,18 +26,18 @@ export type ScopedCacheTypeId = typeof ScopedCacheTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
+export interface ScopedCache<in Key, out Error, out Value> extends ScopedCache.Variance<Key, Error, Value>, Pipeable {
   /**
    * Retrieves the value associated with the specified key if it exists.
    * Otherwise returns `Option.none`.
    */
-  readonly getOption: (key: Key) => Effect.Effect<Scope.Scope, Error, Option.Option<Value>>
+  getOption(key: Key): Effect.Effect<Scope.Scope, Error, Option.Option<Value>>
 
   /**
    * Retrieves the value associated with the specified key if it exists and the
    * lookup function has completed. Otherwise returns `Option.none`.
    */
-  readonly getOptionComplete: (key: Key) => Effect.Effect<Scope.Scope, never, Option.Option<Value>>
+  getOptionComplete(key: Key): Effect.Effect<Scope.Scope, never, Option.Option<Value>>
 
   /**
    * Returns statistics for this cache.
@@ -49,24 +49,24 @@ export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key
    * cache. Sometime `contains` can return true if the resource is currently
    * being created but not yet totally created.
    */
-  readonly contains: (key: Key) => Effect.Effect<never, never, boolean>
+  contains(key: Key): Effect.Effect<never, never, boolean>
 
   /**
    * Return statistics for the specified entry.
    */
-  readonly entryStats: (key: Key) => Effect.Effect<never, never, Option.Option<Cache.EntryStats>>
+  entryStats(key: Key): Effect.Effect<never, never, Option.Option<Cache.EntryStats>>
 
   /**
    * Gets the value from the cache if it exists or otherwise computes it, the
    * release action signals to the cache that the value is no longer being used
    * and can potentially be finalized subject to the policies of the cache.
    */
-  readonly get: (key: Key) => Effect.Effect<Scope.Scope, Error, Value>
+  get(key: Key): Effect.Effect<Scope.Scope, Error, Value>
 
   /**
    * Invalidates the resource associated with the specified key.
    */
-  readonly invalidate: (key: Key) => Effect.Effect<never, never, void>
+  invalidate(key: Key): Effect.Effect<never, never, void>
 
   /**
    * Invalidates all values in the cache.
@@ -81,7 +81,7 @@ export interface ScopedCache<Key, Error, Value> extends ScopedCache.Variance<Key
    * computed, concurrent call the .get will use the old resource if this one is
    * not expired.
    */
-  readonly refresh: (key: Key) => Effect.Effect<never, Error, void>
+  refresh(key: Key): Effect.Effect<never, Error, void>
 
   /**
    * Returns the approximate number of values in the cache.
@@ -97,7 +97,7 @@ export declare namespace ScopedCache {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<Key, Error, Value> {
+  export interface Variance<in Key, out Error, out Value> {
     readonly [ScopedCacheTypeId]: {
       _Key: (_: Key) => void
       _Error: (_: never) => Error

package/src/ScopedRef.ts

@@ -30,7 +30,7 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface ScopedRef<A> extends ScopedRef.Variance<A>, Pipeable {
+export interface ScopedRef<in out A> extends ScopedRef.Variance<A>, Pipeable {
   /** @internal */
   readonly ref: Synchronized.SynchronizedRef<readonly [Scope.Scope.Closeable, A]>
 }
@@ -43,9 +43,9 @@ export declare namespace ScopedRef {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [ScopedRefTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
     }
   }
 }

package/src/SingleProducerAsyncInput.ts

@@ -26,7 +26,7 @@ import * as internal from "./internal/channel/singleProducerAsyncInput.js"
  * @since 2.0.0
  * @category models
  */
-export interface SingleProducerAsyncInput<Err, Elem, Done>
+export interface SingleProducerAsyncInput<in out Err, in out Elem, in out Done>
   extends AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done>
 {
   readonly close: Effect.Effect<never, never, unknown>
@@ -39,11 +39,11 @@ export interface SingleProducerAsyncInput<Err, Elem, Done>
  * @since 2.0.0
  * @category models
  */
-export interface AsyncInputProducer<Err, Elem, Done> {
-  readonly awaitRead: () => Effect.Effect<never, never, unknown>
-  readonly done: (value: Done) => Effect.Effect<never, never, unknown>
-  readonly emit: (element: Elem) => Effect.Effect<never, never, unknown>
-  readonly error: (cause: Cause.Cause<Err>) => Effect.Effect<never, never, unknown>
+export interface AsyncInputProducer<in Err, in Elem, in Done> {
+  awaitRead(): Effect.Effect<never, never, unknown>
+  done(value: Done): Effect.Effect<never, never, unknown>
+  emit(element: Elem): Effect.Effect<never, never, unknown>
+  error(cause: Cause.Cause<Err>): Effect.Effect<never, never, unknown>
 }
 
 /**
@@ -52,7 +52,7 @@ export interface AsyncInputProducer<Err, Elem, Done> {
  * @since 2.0.0
  * @category models
  */
-export interface AsyncInputConsumer<Err, Elem, Done> {
+export interface AsyncInputConsumer<out Err, out Elem, out Done> {
   takeWith<A>(
     onError: (cause: Cause.Cause<Err>) => A,
     onElement: (element: Elem) => A,