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

package/src/Sink.ts

@@ -44,7 +44,7 @@ export type SinkTypeId = typeof SinkTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Sink<R, E, In, L, Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {}
+export interface Sink<out R, out E, in In, out L, out Z> extends Sink.Variance<R, E, In, L, Z>, Pipeable {}
 
 /**
  * @since 2.0.0
@@ -90,14 +90,14 @@ export declare namespace Sink {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, In, L, Z> {
+  export interface Variance<out R, out E, in In, out L, out Z> {
     readonly [SinkTypeId]: VarianceStruct<R, E, In, L, Z>
   }
   /**
    * @since 2.0.0
    * @category models
    */
-  export interface VarianceStruct<R, E, In, L, Z> {
+  export interface VarianceStruct<out R, out E, in In, out L, out Z> {
     _R: (_: never) => R
     _E: (_: never) => E
     _In: (_: In) => void
@@ -215,8 +215,10 @@ export const collectAllUntilEffect: <In, R, E>(
  * @since 2.0.0
  * @category constructors
  */
-export const collectAllWhile: <In>(predicate: Predicate<In>) => Sink<never, never, In, In, Chunk.Chunk<In>> =
-  internal.collectAllWhile
+export const collectAllWhile: {
+  <In, Out extends In>(refinement: Refinement<In, Out>): Sink<never, never, In, In, Chunk.Chunk<Out>>
+  <In>(predicate: Predicate<In>): Sink<never, never, In, In, Chunk.Chunk<In>>
+} = internal.collectAllWhile
 
 /**
  * Accumulates incoming elements into a chunk as long as they verify effectful
@@ -356,11 +358,17 @@ export const dieSync: (evaluate: LazyArg<unknown>) => Sink<never, never, unknown
  */
 export const dimap: {
   <In0, In, Z, Z2>(
-    options: { readonly onInput: (input: In0) => In; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (input: In0) => In
+      readonly onDone: (z: Z) => Z2
+    }
   ): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>
   <R, E, L, In0, In, Z, Z2>(
     self: Sink<R, E, In, L, Z>,
-    options: { readonly onInput: (input: In0) => In; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (input: In0) => In
+      readonly onDone: (z: Z) => Z2
+    }
   ): Sink<R, E, In0, L, Z2>
 } = internal.dimap
 
@@ -396,11 +404,17 @@ export const dimapEffect: {
  */
 export const dimapChunks: {
   <In0, In, Z, Z2>(
-    options: { readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
+      readonly onDone: (z: Z) => Z2
+    }
   ): <R, E, L>(self: Sink<R, E, In, L, Z>) => Sink<R, E, In0, L, Z2>
   <R, E, L, In0, In, Z, Z2>(
     self: Sink<R, E, In, L, Z>,
-    options: { readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>; readonly onDone: (z: Z) => Z2 }
+    options: {
+      readonly onInput: (chunk: Chunk.Chunk<In0>) => Chunk.Chunk<In>
+      readonly onDone: (z: Z) => Z2
+    }
   ): Sink<R, E, In0, L, Z2>
 } = internal.dimapChunks
 

package/src/SortedMap.ts

@@ -25,14 +25,20 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface SortedMap<K, V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
-  readonly [TypeId]: TypeId
+export interface SortedMap<in out K, out V> extends Iterable<[K, V]>, Equal.Equal, Pipeable, Inspectable {
+  readonly [TypeId]: {
+    readonly _K: (_: K) => K
+    readonly _V: (_: never) => V
+  }
   /** @internal */
   readonly tree: RBT.RedBlackTree<K, V>
 }
 
 const SortedMapProto: Omit<SortedMap<unknown, unknown>, "tree"> = {
-  [TypeId]: TypeId,
+  [TypeId]: {
+    _K: (_: any) => _,
+    _V: (_: never) => _
+  },
   [Hash.symbol]<K, V>(this: SortedMap<K, V>): number {
     return pipe(Hash.hash(this.tree), Hash.combine(Hash.hash("effect/SortedMap")))
   },

package/src/SortedSet.ts

@@ -10,7 +10,7 @@ import { NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
 import type { Order } from "./Order.js"
 import type { Pipeable } from "./Pipeable.js"
 import { pipeArguments } from "./Pipeable.js"
-import type { Predicate, Refinement } from "./Predicate.js"
+import type { Predicate } from "./Predicate.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
 
@@ -26,9 +26,9 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface SortedSet<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
+export interface SortedSet<in out A> extends Iterable<A>, Equal.Equal, Pipeable, Inspectable {
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: (_: A) => A
   }
   /** @internal */
   readonly keyTree: RBT.RedBlackTree<A, boolean>
@@ -36,7 +36,7 @@ export interface SortedSet<A> extends Iterable<A>, Equal.Equal, Pipeable, Inspec
 
 const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
   [TypeId]: {
-    _A: (_: never) => _
+    _A: (_: any) => _
   },
   [Hash.symbol]<A>(this: SortedSet<A>): number {
     return pipe(Hash.hash(this.keyTree), Hash.combine(Hash.hash(TypeId)))
@@ -145,13 +145,11 @@ export const difference: {
  * @category elements
  */
 export const every: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => self is SortedSet<B>
   <A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
-  <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): self is SortedSet<B>
   <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
-} = Dual.dual(2, <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): self is SortedSet<B> => {
+} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>): boolean => {
   for (const value of self) {
-    if (!refinement(value)) {
+    if (!predicate(value)) {
       return false
     }
   }
@@ -163,20 +161,9 @@ export const every: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
-  <A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
-  <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
+  <A, B extends A>(predicate: Predicate<B>): (self: SortedSet<A>) => SortedSet<A>
   <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
-} = Dual.dual<
-  {
-    <A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
-    <A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
-  },
-  {
-    <A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
-    <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
-  }
->(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {
+} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A> => {
   const ord = RBT.getOrder(self.keyTree)
   let out = empty<A>(ord)
   for (const value of self) {
@@ -289,28 +276,26 @@ export const map: {
  * @category filtering
  */
 export const partition: {
-  <C extends A, B extends A, A = C>(
-    refinement: Refinement<A, B>
-  ): (self: SortedSet<C>) => [SortedSet<Exclude<C, B>>, SortedSet<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: SortedSet<B>) => [SortedSet<B>, SortedSet<B>]
-  <C extends A, B extends A, A = C>(
-    self: SortedSet<C>,
-    refinement: Refinement<A, B>
-  ): [SortedSet<Exclude<C, B>>, SortedSet<B>]
-  <B extends A, A = B>(self: SortedSet<B>, predicate: (a: A) => boolean): [SortedSet<B>, SortedSet<B>]
-} = Dual.dual(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {
-  const ord = RBT.getOrder(self.keyTree)
-  let right = empty(ord)
-  let left = empty(ord)
-  for (const value of self) {
-    if (predicate(value)) {
-      right = add(right, value)
-    } else {
-      left = add(left, value)
+  <B extends A, A = B>(
+    predicate: (a: A) => boolean
+  ): (self: SortedSet<B>) => [excluded: SortedSet<B>, satisfying: SortedSet<B>]
+  <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<A>]
+} = Dual.dual(
+  2,
+  <A>(self: SortedSet<A>, predicate: (a: A) => boolean): [excluded: SortedSet<A>, satisfying: SortedSet<A>] => {
+    const ord = RBT.getOrder(self.keyTree)
+    let right = empty(ord)
+    let left = empty(ord)
+    for (const value of self) {
+      if (predicate(value)) {
+        right = add(right, value)
+      } else {
+        left = add(left, value)
+      }
     }
+    return [left, right]
   }
-  return [left, right] as const
-})
+)
 
 /**
  * @since 2.0.0

package/src/Stream.ts

@@ -63,7 +63,7 @@ export type StreamTypeId = typeof StreamTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Stream<R, E, A> extends Stream.Variance<R, E, A>, Pipeable {
+export interface Stream<out R, out E, out A> extends Stream.Variance<R, E, A>, Pipeable {
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: StreamUnify<this>
   [Unify.ignoreSymbol]?: StreamUnifyIgnore
@@ -112,7 +112,7 @@ export declare namespace Stream {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, A> {
+  export interface Variance<out R, out E, out A> {
     readonly [StreamTypeId]: {
       _R: (_: never) => R
       _E: (_: never) => E
@@ -994,8 +994,8 @@ export const dropRight: {
  * @category utils
  */
 export const dropUntil: {
-  <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropUntil
 
 /**
@@ -1023,8 +1023,8 @@ export const dropUntilEffect: {
  * @category utils
  */
 export const dropWhile: {
-  <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.dropWhile
 
 /**
@@ -1175,9 +1175,9 @@ export const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Stream<nev
  */
 export const filter: {
   <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
-  <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>
+  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.filter
 
 /**
@@ -1270,9 +1270,9 @@ export const finalizer: <R, _>(finalizer: Effect.Effect<R, never, _>) => Stream<
  */
 export const find: {
   <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
-  <A, X extends A>(predicate: Predicate<X>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
   <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
-  <R, E, A, X extends A>(self: Stream<R, E, A>, predicate: Predicate<X>): Stream<R, E, A>
+  <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.find
 
 /**
@@ -1984,11 +1984,17 @@ export const mapAccumEffect: {
  */
 export const mapBoth: {
   <E, E2, A, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): <R>(self: Stream<R, E, A>) => Stream<R, E2, A2>
   <R, E, E2, A, A2>(
     self: Stream<R, E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): Stream<R, E2, A2>
 } = internal.mapBoth
 
@@ -2472,21 +2478,36 @@ export const paginateEffect: <S, R, E, A>(
  * @category utils
  */
 export const partition: {
+  <C extends A, B extends A, A = C>(
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): <R, E>(
+    self: Stream<R, E, C>
+  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<C, B>>, satisfying: Stream<never, E, B>]>
   <A>(
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ): <R, E>(
-    self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R, E, [Stream<never, E, A>, Stream<never, E, A>]>
+  ): <R, E, B extends A>(
+    self: Stream<R, E, B>
+  ) => Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, B>, satisfying: Stream<never, E, B>]>
+  <R, E, A, B extends A>(
+    self: Stream<R, E, A>,
+    refinement: Refinement<A, B>,
+    options?: {
+      bufferSize?: number | undefined
+    }
+  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, Exclude<A, B>>, satisfying: Stream<never, E, B>]>
   <R, E, A>(
     self: Stream<R, E, A>,
     predicate: Predicate<A>,
     options?: {
       bufferSize?: number | undefined
     }
-  ): Effect.Effect<Scope.Scope | R, E, [Stream<never, E, A>, Stream<never, E, A>]>
+  ): Effect.Effect<Scope.Scope | R, E, [excluded: Stream<never, E, A>, satisfying: Stream<never, E, A>]>
 } = internal.partition
 
 /**
@@ -2504,14 +2525,14 @@ export const partitionEither: {
     }
   ): <R, E>(
     self: Stream<R, E, A>
-  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [Stream<never, E2 | E, A2>, Stream<never, E2 | E, A3>]>
+  ) => Effect.Effect<Scope.Scope | R2 | R, E2 | E, [left: Stream<never, E2 | E, A2>, right: Stream<never, E2 | E, A3>]>
   <R, E, A, R2, E2, A2, A3>(
     self: Stream<R, E, A>,
     predicate: (a: A) => Effect.Effect<R2, E2, Either.Either<A2, A3>>,
     options?: {
       readonly bufferSize?: number | undefined
     }
-  ): Effect.Effect<Scope.Scope | R | R2, E | E2, [Stream<never, E | E2, A2>, Stream<never, E | E2, A3>]>
+  ): Effect.Effect<Scope.Scope | R | R2, E | E2, [left: Stream<never, E | E2, A2>, right: Stream<never, E | E2, A3>]>
 } = internal.partitionEither
 
 /**
@@ -2860,12 +2881,18 @@ export const repeatElements: {
 export const repeatElementsWith: {
   <R2, B, A, C>(
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
   <R, E, R2, B, A, C>(
     self: Stream<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): Stream<R | R2, E, C>
 } = internal.repeatElementsWith
 
@@ -2889,12 +2916,18 @@ export const repeatValue: <A>(value: A) => Stream<never, never, A> = internal.re
 export const repeatWith: {
   <R2, B, A, C>(
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
   <R, E, R2, B, A, C>(
     self: Stream<R, E, A>,
     schedule: Schedule.Schedule<R2, unknown, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): Stream<R | R2, E, C>
 } = internal.repeatWith
 
@@ -3386,12 +3419,18 @@ export const schedule: {
 export const scheduleWith: {
   <R2, A, A0 extends A, B, C>(
     schedule: Schedule.Schedule<R2, A0, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): <R, E>(self: Stream<R, E, A>) => Stream<R2 | R, E, C>
   <R, E, R2, A, A0 extends A, B, C>(
     self: Stream<R, E, A>,
     schedule: Schedule.Schedule<R2, A0, B>,
-    options: { readonly onElement: (a: A) => C; readonly onSchedule: (b: B) => C }
+    options: {
+      readonly onElement: (a: A) => C
+      readonly onSchedule: (b: B) => C
+    }
   ): Stream<R | R2, E, C>
 } = internal.scheduleWith
 
@@ -3487,7 +3526,7 @@ export const someOrFail: {
  * @category utils
  */
 export const split: {
-  <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, Chunk.Chunk<A>>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, Chunk.Chunk<B>>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, Chunk.Chunk<A>>
 } = internal.split
 
@@ -3565,7 +3604,7 @@ export const takeRight: {
  * @category utils
  */
 export const takeUntil: {
-  <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeUntil
 
@@ -3594,7 +3633,9 @@ export const takeUntilEffect: {
  * @category utils
  */
 export const takeWhile: {
-  <A>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, A>
+  <A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Stream<R, E, A>) => Stream<R, E, B>
+  <B extends A, A = B>(predicate: Predicate<A>): <R, E>(self: Stream<R, E, B>) => Stream<R, E, B>
+  <R, E, A, B extends A>(self: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>
   <R, E, A>(self: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>
 } = internal.takeWhile
 
@@ -4019,8 +4060,8 @@ export const updateService = internal.updateService
  * @category utils
  */
 export const when: {
-  (predicate: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
-  <R, E, A>(self: Stream<R, E, A>, predicate: LazyArg<boolean>): Stream<R, E, A>
+  (test: LazyArg<boolean>): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, A>
+  <R, E, A>(self: Stream<R, E, A>, test: LazyArg<boolean>): Stream<R, E, A>
 } = internal.when
 
 /**

package/src/StreamEmit.ts

@@ -18,7 +18,7 @@ import type * as Option from "./Option.js"
  * @since 2.0.0
  * @category models
  */
-export interface Emit<R, E, A, B> extends EmitOps<R, E, A, B> {
+export interface Emit<in R, in E, in A, out B> extends EmitOps<R, E, A, B> {
   (f: Effect.Effect<R, Option.Option<E>, Chunk.Chunk<A>>): Promise<B>
 }
 
@@ -26,58 +26,58 @@ export interface Emit<R, E, A, B> extends EmitOps<R, E, A, B> {
  * @since 2.0.0
  * @category models
  */
-export interface EmitOps<R, E, A, B> {
+export interface EmitOps<in R, in E, in A, out B> {
   /**
    * Emits a chunk containing the specified values.
    */
-  readonly chunk: (chunk: Chunk.Chunk<A>) => Promise<B>
+  chunk(chunk: Chunk.Chunk<A>): Promise<B>
 
   /**
    * Terminates with a cause that dies with the specified defect.
    */
-  readonly die: <Err>(defect: Err) => Promise<B>
+  die<Err>(defect: Err): Promise<B>
 
   /**
    * Terminates with a cause that dies with a `Throwable` with the specified
    * message.
    */
-  readonly dieMessage: (message: string) => Promise<B>
+  dieMessage(message: string): Promise<B>
 
   /**
    * Either emits the specified value if this `Exit` is a `Success` or else
    * terminates with the specified cause if this `Exit` is a `Failure`.
    */
-  readonly done: (exit: Exit.Exit<E, A>) => Promise<B>
+  done(exit: Exit.Exit<E, A>): Promise<B>
 
   /**
    * Terminates with an end of stream signal.
    */
-  readonly end: () => Promise<B>
+  end(): Promise<B>
 
   /**
    * Terminates with the specified error.
    */
-  readonly fail: (error: E) => Promise<B>
+  fail(error: E): Promise<B>
 
   /**
    * Either emits the success value of this effect or terminates the stream
    * with the failure value of this effect.
    */
-  readonly fromEffect: (effect: Effect.Effect<R, E, A>) => Promise<B>
+  fromEffect(effect: Effect.Effect<R, E, A>): Promise<B>
 
   /**
    * Either emits the success value of this effect or terminates the stream
    * with the failure value of this effect.
    */
-  readonly fromEffectChunk: (effect: Effect.Effect<R, E, Chunk.Chunk<A>>) => Promise<B>
+  fromEffectChunk(effect: Effect.Effect<R, E, Chunk.Chunk<A>>): Promise<B>
 
   /**
    * Terminates the stream with the specified cause.
    */
-  readonly halt: (cause: Cause.Cause<E>) => Promise<B>
+  halt(cause: Cause.Cause<E>): Promise<B>
 
   /**
    * Emits a chunk containing the specified value.
    */
-  readonly single: (value: A) => Promise<B>
+  single(value: A): Promise<B>
 }

package/src/SubscriptionRef.ts

@@ -29,7 +29,9 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface SubscriptionRef<A> extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable {
+export interface SubscriptionRef<in out A>
+  extends SubscriptionRef.Variance<A>, Synchronized.SynchronizedRef<A>, Pipeable
+{
   /** @internal */
   readonly ref: Ref.Ref<A>
   /** @internal */
@@ -51,9 +53,9 @@ export declare namespace SubscriptionRef {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [SubscriptionRefTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
     }
   }
 }

package/src/Supervisor.ts

@@ -32,7 +32,7 @@ export type SupervisorTypeId = typeof SupervisorTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Supervisor<T> extends Supervisor.Variance<T> {
+export interface Supervisor<out T> extends Supervisor.Variance<T> {
   /**
    * Returns an `Effect` that succeeds with the value produced by this
    * supervisor. This value may change over time, reflecting what the supervisor
@@ -43,45 +43,45 @@ export interface Supervisor<T> extends Supervisor.Variance<T> {
   /**
    * Supervises the start of a `Fiber`.
    */
-  readonly onStart: <R, E, A>(
+  onStart<R, E, A>(
     context: Context.Context<R>,
     effect: Effect.Effect<R, E, A>,
     parent: Option.Option<Fiber.RuntimeFiber<any, any>>,
     fiber: Fiber.RuntimeFiber<E, A>
-  ) => void
+  ): void
 
   /**
    * Supervises the end of a `Fiber`.
    */
-  readonly onEnd: <E, A>(value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>) => void
+  onEnd<E, A>(value: Exit.Exit<E, A>, fiber: Fiber.RuntimeFiber<E, A>): void
 
   /**
    * Supervises the execution of an `Effect` by a `Fiber`.
    */
-  readonly onEffect: <E, A>(fiber: Fiber.RuntimeFiber<E, A>, effect: Effect.Effect<any, any, any>) => void
+  onEffect<E, A>(fiber: Fiber.RuntimeFiber<E, A>, effect: Effect.Effect<any, any, any>): void
 
   /**
    * Supervises the suspension of a computation running within a `Fiber`.
    */
-  readonly onSuspend: <E, A>(fiber: Fiber.RuntimeFiber<E, A>) => void
+  onSuspend<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void
 
   /**
    * Supervises the resumption of a computation running within a `Fiber`.
    */
-  readonly onResume: <E, A>(fiber: Fiber.RuntimeFiber<E, A>) => void
+  onResume<E, A>(fiber: Fiber.RuntimeFiber<E, A>): void
 
   /**
    * Maps this supervisor to another one, which has the same effect, but whose
    * value has been transformed by the specified function.
    */
-  readonly map: <B>(f: (a: T) => B) => Supervisor<B>
+  map<B>(f: (a: T) => B): Supervisor<B>
 
   /**
    * Returns a new supervisor that performs the function of this supervisor, and
    * the function of the specified supervisor, producing a tuple of the outputs
    * produced by both supervisors.
    */
-  readonly zip: <A>(right: Supervisor<A>) => Supervisor<[T, A]>
+  zip<A>(right: Supervisor<A>): Supervisor<[T, A]>
 }
 
 /**
@@ -92,7 +92,7 @@ export declare namespace Supervisor {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<T> {
+  export interface Variance<out T> {
     readonly [SupervisorTypeId]: {
       readonly _T: (_: never) => T
     }

package/src/SynchronizedRef.ts

@@ -24,8 +24,8 @@ export type SynchronizedRefTypeId = typeof SynchronizedRefTypeId
  * @since 2.0.0
  * @category models
  */
-export interface SynchronizedRef<A> extends SynchronizedRef.Variance<A>, Ref.Ref<A> {
-  readonly modifyEffect: <R, E, B>(f: (a: A) => Effect.Effect<R, E, readonly [B, A]>) => Effect.Effect<R, E, B>
+export interface SynchronizedRef<in out A> extends SynchronizedRef.Variance<A>, Ref.Ref<A> {
+  modifyEffect<R, E, B>(f: (a: A) => Effect.Effect<R, E, readonly [B, A]>): Effect.Effect<R, E, B>
 }
 
 /**
@@ -36,9 +36,9 @@ export declare namespace SynchronizedRef {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [SynchronizedRefTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: (_: A) => A
     }
   }
 }