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

package/src/SortedSet.ts

@@ -6,13 +6,14 @@ import * as Dual from "./Function.js"
 import { pipe } from "./Function.js"
 import * as Hash from "./Hash.js"
 import type { Inspectable } from "./Inspectable.js"
-import { NodeInspectSymbol, toJSON, toString } from "./Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } 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"
+import type * as Types from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
 
@@ -26,9 +27,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: Types.Invariant<A>
   }
   /** @internal */
   readonly keyTree: RBT.RedBlackTree<A, boolean>
@@ -36,7 +37,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)))
@@ -48,7 +49,7 @@ const SortedSetProto: Omit<SortedSet<unknown>, "keyTree"> = {
     return RBT.keys(this.keyTree)
   },
   toString<A>(this: SortedSet<A>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   },
   toJSON() {
     return {
@@ -145,13 +146,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 +162,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 +277,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

@@ -29,6 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -63,7 +64,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,11 +113,11 @@ 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
-      _A: (_: never) => A
+      _R: Types.Covariant<R>
+      _E: Types.Covariant<E>
+      _A: Types.Covariant<A>
     }
   }
 
@@ -320,7 +321,7 @@ export const asyncOption: <R, E, A>(
  * @category constructors
  */
 export const asyncScoped: <R, E, A>(
-  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R, E, unknown>,
+  register: (emit: Emit.Emit<R, E, A, void>) => Effect.Effect<R | Scope.Scope, E, unknown>,
   outputBuffer?: number
 ) => Stream<Exclude<R, Scope.Scope>, E, A> = internal.asyncScoped
 
@@ -994,8 +995,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 +1024,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 +1176,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 +1271,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 +1985,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 +2479,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 +2526,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 +2882,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 +2917,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 +3420,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 +3527,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 +3605,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 +3634,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 +4061,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/Streamable.ts

@@ -6,8 +6,11 @@ import { pipeArguments } from "./Pipeable.js"
 import * as Stream from "./Stream.js"
 
 const streamVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 

package/src/SubscriptionRef.ts

@@ -9,6 +9,7 @@ import type * as PubSub from "./PubSub.js"
 import * as Ref from "./Ref.js"
 import type * as Stream from "./Stream.js"
 import * as Synchronized from "./SynchronizedRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -29,7 +30,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 +54,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: Types.Invariant<A>
     }
   }
 }

package/src/Supervisor.ts

@@ -15,6 +15,7 @@ import type * as Layer from "./Layer.js"
 import type * as MutableRef from "./MutableRef.js"
 import type * as Option from "./Option.js"
 import type * as SortedSet from "./SortedSet.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -32,7 +33,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 +44,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,9 +93,9 @@ 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
+      readonly _T: Types.Covariant<T>
     }
   }
 }

package/src/SynchronizedRef.ts

@@ -7,6 +7,7 @@ import * as ref from "./internal/ref.js"
 import * as internal from "./internal/synchronizedRef.js"
 import type * as Option from "./Option.js"
 import type * as Ref from "./Ref.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -24,8 +25,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 +37,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: Types.Invariant<A>
     }
   }
 }

package/src/TArray.ts

@@ -7,6 +7,7 @@ import type * as Order from "./Order.js"
 import type { Predicate } from "./Predicate.js"
 import type * as STM from "./STM.js"
 import type * as TRef from "./TRef.js"
+import type * as Types from "./Types.js"
 
 /**
  * @since 2.0.0
@@ -24,12 +25,12 @@ export type TArrayTypeId = typeof TArrayTypeId
  * @since 2.0.0
  * @category models
  */
-export interface TArray<A> extends TArray.Variance<A> {}
+export interface TArray<in out A> extends TArray.Variance<A> {}
 /**
  * @internal
  * @since 2.0.0
  */
-export interface TArray<A> {
+export interface TArray<in out A> {
   /** @internal */
   readonly chunk: Array<TRef.TRef<A>>
 }
@@ -42,9 +43,9 @@ export declare namespace TArray {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<A> {
+  export interface Variance<in out A> {
     readonly [TArrayTypeId]: {
-      readonly _A: (_: never) => A
+      readonly _A: Types.Invariant<A>
     }
   }
 }