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

package/src/Duration.ts

@@ -63,6 +63,7 @@ export type DurationInput =
   | Duration
   | number // millis
   | bigint // nanos
+  | [number, number] // [seconds, nanos]
   | `${number} ${Unit}`
 
 const DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos|micros|millis|seconds|minutes|hours|days|weeks)$/
@@ -77,6 +78,10 @@ export const decode = (input: DurationInput): Duration => {
     return millis(input)
   } else if (isBigInt(input)) {
     return nanos(input)
+  } else if (Array.isArray(input)) {
+    if (input.length === 2 && isNumber(input[0]) && isNumber(input[1])) {
+      return nanos(BigInt(input[0]) * bigint1e9 + BigInt(input[1]))
+    }
   } else {
     DURATION_REGEX.lastIndex = 0 // Reset the lastIndex before each use
     const match = DURATION_REGEX.exec(input)

package/src/Effect.ts

@@ -54,7 +54,7 @@ import * as Scheduler from "./Scheduler.js"
 import type * as Scope from "./Scope.js"
 import type * as Supervisor from "./Supervisor.js"
 import type * as Tracer from "./Tracer.js"
-import type { Concurrency } from "./Types.js"
+import type { Concurrency, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 // -------------------------------------------------------------------------------------
@@ -99,7 +99,7 @@ export type EffectTypeId = typeof EffectTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Effect<R, E, A> extends Effect.Variance<R, E, A>, Equal.Equal, Pipeable {
+export interface Effect<out R, out E, out A> extends Effect.Variance<R, E, A>, Equal.Equal, Pipeable {
   readonly [Unify.typeSymbol]?: unknown
   readonly [Unify.unifySymbol]?: EffectUnify<this>
   readonly [Unify.ignoreSymbol]?: EffectUnifyIgnore
@@ -137,7 +137,7 @@ export interface EffectTypeLambda extends TypeLambda {
  * @since 2.0.0
  * @category models
  */
-export interface Blocked<R, E, A> extends Effect<R, E, A> {
+export interface Blocked<out R, out E, out A> extends Effect<R, E, A> {
   readonly _op: "Blocked"
   readonly i0: RequestBlock<R>
   readonly i1: Effect<R, E, A>
@@ -200,14 +200,14 @@ export declare namespace Effect {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, A> {
+  export interface Variance<out R, out E, out A> {
     readonly [EffectTypeId]: VarianceStruct<R, E, A>
   }
   /**
    * @since 2.0.0
    * @category models
    */
-  export interface VarianceStruct<R, E, A> {
+  export interface VarianceStruct<out R, out E, out A> {
     readonly _V: string
     readonly _R: (_: never) => R
     readonly _E: (_: never) => E
@@ -508,7 +508,9 @@ export const allSuccesses: <R, E, A>(
  * @category collecting & elements
  */
 export const dropUntil: {
-  <A, R, E>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>
+  <B extends A, R, E, A = B>(
+    predicate: (a: A, i: number) => Effect<R, E, boolean>
+  ): (elements: Iterable<B>) => Effect<R, E, Array<B>>
   <A, R, E>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>
 } = effect.dropUntil
 
@@ -519,8 +521,10 @@ export const dropUntil: {
  * @category collecting & elements
  */
 export const dropWhile: {
-  <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>
-  <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>
+  <B extends A, R, E, A = B>(
+    predicate: (a: A, i: number) => Effect<R, E, boolean>
+  ): (elements: Iterable<B>) => Effect<R, E, Array<B>>
+  <A, R, E>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>
 } = effect.dropWhile
 
 /**
@@ -709,11 +713,11 @@ export const partition: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
     }
-  ): (elements: Iterable<A>) => Effect<R, never, [Array<E>, Array<B>]>
+  ): (elements: Iterable<A>) => Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>
   <R, E, A, B>(elements: Iterable<A>, f: (a: A) => Effect<R, E, B>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
-  }): Effect<R, never, [Array<E>, Array<B>]>
+  }): Effect<R, never, [excluded: Array<E>, satisfying: Array<B>]>
 } = fiberRuntime.partition
 
 /**
@@ -852,7 +856,9 @@ export const replicateEffect: {
  * @category collecting & elements
  */
 export const takeUntil: {
-  <R, E, A>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>
+  <B extends A, R, E, A = B>(
+    predicate: (a: A, i: number) => Effect<R, E, boolean>
+  ): (elements: Iterable<B>) => Effect<R, E, Array<B>>
   <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>
 } = effect.takeUntil
 
@@ -863,7 +869,9 @@ export const takeUntil: {
  * @category collecting & elements
  */
 export const takeWhile: {
-  <R, E, A>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>
+  <R, E, B extends A, A = B>(
+    predicate: (a: A, i: number) => Effect<R, E, boolean>
+  ): (elements: Iterable<B>) => Effect<R, E, Array<B>>
   <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>
 } = effect.takeWhile
 
@@ -1105,7 +1113,7 @@ export const gen: {
  * @category models
  * @since 2.0.0
  */
-export interface EffectGen<R, E, A> {
+export interface EffectGen<out R, out E, out A> {
   readonly _R: () => R
   readonly _E: () => E
   readonly _A: () => A
@@ -1844,7 +1852,7 @@ export const retryWhileEffect: {
 
 const try_: {
   <A, E>(options: { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }): Effect<never, E, A>
-  <A>(evaluate: LazyArg<A>): Effect<never, unknown, A>
+  <A>(evaluate: LazyArg<A>): Effect<never, Cause.UnknownException, A>
 } = effect.try_
 export {
   /**
@@ -1914,12 +1922,9 @@ export const tryMapPromise: {
  */
 export const tryPromise: {
   <A, E>(
-    options: {
-      readonly try: (signal: AbortSignal) => Promise<A>
-      readonly catch: (error: unknown) => E
-    }
+    options: { readonly try: (signal: AbortSignal) => Promise<A>; readonly catch: (error: unknown) => E }
   ): Effect<never, E, A>
-  <A>(try_: (signal: AbortSignal) => Promise<A>): Effect<never, unknown, A>
+  <A>(try_: (signal: AbortSignal) => Promise<A>): Effect<never, Cause.UnknownException, A>
 } = effect.tryPromise
 
 /**
@@ -3537,6 +3542,41 @@ export const flatMap: {
   <R, E, A, R1, E1, B>(self: Effect<R, E, A>, f: (a: A) => Effect<R1, E1, B>): Effect<R | R1, E | E1, B>
 } = core.flatMap
 
+/**
+ * Executes a sequence of two `Effect`s. The second `Effect` can be dependent on the result of the first `Effect`.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+export const andThen: {
+  <A, X>(
+    f: (a: NoInfer<A>) => X
+  ): <R, E>(
+    self: Effect<R, E, A>
+  ) => [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1>
+    : [X] extends [Promise<infer A1>] ? Effect<R, E | Cause.UnknownException, A1>
+    : Effect<R, E, X>
+  <X>(
+    f: X
+  ): <R, E, A>(
+    self: Effect<R, E, A>
+  ) => [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1>
+    : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1>
+    : Effect<R, E, X>
+  <A, R, E, X>(
+    self: Effect<R, E, A>,
+    f: (a: NoInfer<A>) => X
+  ): [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1>
+    : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1>
+    : Effect<R, E, X>
+  <A, R, E, X>(
+    self: Effect<R, E, A>,
+    f: X
+  ): [X] extends [Effect<infer R1, infer E1, infer A1>] ? Effect<R | R1, E | E1, A1>
+    : [X] extends [Promise<infer A1>] ? Effect<R, Cause.UnknownException | E, A1>
+    : Effect<R, E, X>
+} = core.andThen
+
 /**
  * @since 2.0.0
  * @category sequencing
@@ -3638,10 +3678,32 @@ export const summarized: {
  * @category sequencing
  */
 export const tap: {
-  <A, X extends A, R2, E2, _>(
-    f: (a: X) => Effect<R2, E2, _>
-  ): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>
-  <R, E, A, X extends A, R2, E2, _>(self: Effect<R, E, A>, f: (a: X) => Effect<R2, E2, _>): Effect<R | R2, E | E2, A>
+  <A, X>(
+    f: (a: NoInfer<A>) => X
+  ): <R, E>(
+    self: Effect<R, E, A>
+  ) => [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A>
+    : [X] extends [Promise<infer _A1>] ? Effect<R, E | Cause.UnknownException, A>
+    : Effect<R, E, A>
+  <X>(
+    f: X
+  ): <R, E, A>(
+    self: Effect<R, E, A>
+  ) => [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A>
+    : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A>
+    : Effect<R, E, A>
+  <A, R, E, X>(
+    self: Effect<R, E, A>,
+    f: (a: NoInfer<A>) => X
+  ): [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A>
+    : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A>
+    : Effect<R, E, A>
+  <A, R, E, X>(
+    self: Effect<R, E, A>,
+    f: X
+  ): [X] extends [Effect<infer R1, infer E1, infer _A1>] ? Effect<R | R1, E | E1, A>
+    : [X] extends [Promise<infer _A1>] ? Effect<R, Cause.UnknownException | E, A>
+    : Effect<R, E, A>
 } = core.tap
 
 /**
@@ -4580,9 +4642,9 @@ export interface Permit {
  * @since 2.0.0
  */
 export interface Semaphore {
-  readonly withPermits: (permits: number) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
-  readonly take: (permits: number) => Effect<never, never, number>
-  readonly release: (permits: number) => Effect<never, never, void>
+  withPermits(permits: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>
+  take(permits: number): Effect<never, never, number>
+  release(permits: number): Effect<never, never, void>
 }
 
 /**

package/src/Either.ts

@@ -37,7 +37,7 @@ export type TypeId = typeof TypeId
  * @category models
  * @since 2.0.0
  */
-export interface Left<E, A> extends Data.Case, Pipeable, Inspectable {
+export interface Left<out E, out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "Left"
   readonly _op: "Left"
   readonly left: E
@@ -54,7 +54,7 @@ export interface Left<E, A> extends Data.Case, Pipeable, Inspectable {
  * @category models
  * @since 2.0.0
  */
-export interface Right<E, A> extends Data.Case, Pipeable, Inspectable {
+export interface Right<out E, out A> extends Data.Case, Pipeable, Inspectable {
   readonly _tag: "Right"
   readonly _op: "Right"
   readonly right: A
@@ -147,11 +147,17 @@ export const fromOption: {
 
 const try_: {
   <A, E>(
-    options: { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }
+    options: {
+      readonly try: LazyArg<A>
+      readonly catch: (error: unknown) => E
+    }
   ): Either<E, A>
   <A>(evaluate: LazyArg<A>): Either<unknown, A>
 } = (<A, E>(
-  evaluate: LazyArg<A> | { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }
+  evaluate: LazyArg<A> | {
+    readonly try: LazyArg<A>
+    readonly catch: (error: unknown) => E
+  }
 ) => {
   if (isFunction(evaluate)) {
     try {
@@ -491,7 +497,7 @@ export const orElse: {
 )
 
 /**
- * @category combining
+ * @category sequencing
  * @since 2.0.0
  */
 export const flatMap: {
@@ -503,6 +509,23 @@ export const flatMap: {
     isLeft(self) ? left(self.left) : f(self.right)
 )
 
+/**
+ * Executes a sequence of two `Either`s. The second `Either` can be dependent on the result of the first `Either`.
+ *
+ * @category sequencing
+ * @since 2.0.0
+ */
+export const andThen: {
+  <A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: Either<E1, A>) => Either<E1 | E2, B>
+  <E2, B>(f: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E1 | E2, B>
+  <E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B>): Either<E1 | E2, B>
+  <E1, A, E2, B>(self: Either<E1, A>, f: Either<E2, B>): Either<E1 | E2, B>
+} = dual(
+  2,
+  <E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B> | Either<E2, B>): Either<E1 | E2, B> =>
+    isFunction(f) ? flatMap(self, f) : flatMap(self, () => f)
+)
+
 /**
  * @since 2.0.0
  * @category combining

package/src/Equal.ts

@@ -16,7 +16,7 @@ export const symbol: unique symbol = Symbol.for("effect/Equal")
  * @category models
  */
 export interface Equal extends Hash.Hash {
-  readonly [symbol]: (that: Equal) => boolean
+  [symbol](that: Equal): boolean
 }
 
 /**

package/src/Equivalence.ts

@@ -12,7 +12,7 @@ import type { TypeLambda } from "./HKT.js"
  * @category type class
  * @since 2.0.0
  */
-export interface Equivalence<A> {
+export interface Equivalence<in A> {
   (self: A, that: A): boolean
 }
 

package/src/Exit.ts

@@ -9,7 +9,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as core from "./internal/core.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type { Predicate } from "./Predicate.js"
+import type { Predicate, Refinement } from "./Predicate.js"
 import type * as Unify from "./Unify.js"
 
 /**
@@ -31,7 +31,7 @@ export type Exit<E, A> = Failure<E, A> | Success<E, A>
  * @since 2.0.0
  * @category models
  */
-export interface Failure<E, A> extends Effect.Effect<never, E, A>, Pipeable, Inspectable {
+export interface Failure<out E, out A> extends Effect.Effect<never, E, A>, Pipeable, Inspectable {
   readonly _tag: "Failure"
   readonly _op: "Failure"
   readonly cause: Cause.Cause<E>
@@ -65,7 +65,7 @@ export interface ExitUnifyIgnore extends Effect.EffectUnifyIgnore {
  * @since 2.0.0
  * @category models
  */
-export interface Success<E, A> extends Effect.Effect<never, E, A>, Pipeable, Inspectable {
+export interface Success<out E, out A> extends Effect.Effect<never, E, A>, Pipeable, Inspectable {
   readonly _tag: "Success"
   readonly _op: "Success"
   readonly value: A
@@ -168,7 +168,9 @@ export const die: (defect: unknown) => Exit<never, never> = core.exitDie
  * @category elements
  */
 export const exists: {
+  <A, B extends A>(refinement: Refinement<A, B>): <E>(self: Exit<E, A>) => self is Exit<never, B>
   <A>(predicate: Predicate<A>): <E>(self: Exit<E, A>) => boolean
+  <E, A, B extends A>(self: Exit<E, A>, refinement: Refinement<A, B>): self is Exit<never, B>
   <E, A>(self: Exit<E, A>, predicate: Predicate<A>): boolean
 } = core.exitExists
 
@@ -286,11 +288,17 @@ export const map: {
  */
 export const mapBoth: {
   <E, A, E2, A2>(
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): (self: Exit<E, A>) => Exit<E2, A2>
   <E, A, E2, A2>(
     self: Exit<E, A>,
-    options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
+    options: {
+      readonly onFailure: (e: E) => E2
+      readonly onSuccess: (a: A) => A2
+    }
   ): Exit<E2, A2>
 } = core.exitMapBoth
 
@@ -324,11 +332,17 @@ export const mapErrorCause: {
  */
 export const match: {
   <E, A, Z1, Z2>(
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+    options: {
+      readonly onFailure: (cause: Cause.Cause<E>) => Z1
+      readonly onSuccess: (a: A) => Z2
+    }
   ): (self: Exit<E, A>) => Z1 | Z2
   <E, A, Z1, Z2>(
     self: Exit<E, A>,
-    options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
+    options: {
+      readonly onFailure: (cause: Cause.Cause<E>) => Z1
+      readonly onSuccess: (a: A) => Z2
+    }
   ): Z1 | Z2
 } = core.exitMatch
 

package/src/Fiber.ts

@@ -56,11 +56,11 @@ export type RuntimeFiberTypeId = typeof RuntimeFiberTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
+export interface Fiber<out E, out A> extends Fiber.Variance<E, A>, Pipeable {
   /**
    * The identity of the fiber.
    */
-  readonly id: () => FiberId.FiberId
+  id(): FiberId.FiberId
 
   /**
    * Awaits the fiber, which suspends the awaiting fiber until the result of the
@@ -90,7 +90,7 @@ export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
    * specified fiber. If the fiber has already exited, the returned effect will
    * resume immediately. Otherwise, the effect will resume when the fiber exits.
    */
-  readonly interruptAsFork: (fiberId: FiberId.FiberId) => Effect.Effect<never, never, void>
+  interruptAsFork(fiberId: FiberId.FiberId): Effect.Effect<never, never, void>
 }
 
 /**
@@ -100,7 +100,7 @@ export interface Fiber<E, A> extends Fiber.Variance<E, A>, Pipeable {
  * @since 2.0.0
  * @category models
  */
-export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E, A> {
+export interface RuntimeFiber<out E, out A> extends Fiber<E, A>, Fiber.RuntimeVariance<E, A> {
   /**
    * Reads the current number of ops that have occurred since the last yield
    */
@@ -109,12 +109,12 @@ export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E
   /**
    * Reads the current value of a fiber ref
    */
-  readonly getFiberRef: <X>(fiberRef: FiberRef<X>) => X
+  getFiberRef<X>(fiberRef: FiberRef<X>): X
 
   /**
    * The identity of the fiber.
    */
-  readonly id: () => FiberId.Runtime
+  id(): FiberId.Runtime
 
   /**
    * The status of the fiber.
@@ -129,24 +129,24 @@ export interface RuntimeFiber<E, A> extends Fiber<E, A>, Fiber.RuntimeVariance<E
   /**
    * Adds an observer to the list of observers.
    */
-  readonly addObserver: (observer: (exit: Exit.Exit<E, A>) => void) => void
+  addObserver(observer: (exit: Exit.Exit<E, A>) => void): void
 
   /**
    * Removes the specified observer from the list of observers that will be
    * notified when the fiber exits.
    */
-  readonly removeObserver: (observer: (exit: Exit.Exit<E, A>) => void) => void
+  removeObserver(observer: (exit: Exit.Exit<E, A>) => void): void
 
   /**
    * Retrieves all fiber refs of the fiber.
    */
-  readonly getFiberRefs: () => FiberRefs.FiberRefs
+  getFiberRefs(): FiberRefs.FiberRefs
 
   /**
    * Unsafely observes the fiber, but returns immediately if it is not
    * already done.
    */
-  readonly unsafePoll: () => Exit.Exit<E, A> | null
+  unsafePoll(): Exit.Exit<E, A> | null
 }
 
 /**
@@ -163,7 +163,7 @@ export declare namespace Fiber {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<E, A> {
+  export interface Variance<out E, out A> {
     readonly [FiberTypeId]: {
       readonly _E: (_: never) => E
       readonly _A: (_: never) => A
@@ -173,7 +173,7 @@ export declare namespace Fiber {
   /**
    * @since 2.0.0
    */
-  export interface RuntimeVariance<E, A> {
+  export interface RuntimeVariance<out E, out A> {
     readonly [RuntimeFiberTypeId]: {
       readonly _E: (_: never) => E
       readonly _A: (_: never) => A
@@ -491,11 +491,17 @@ export const mapFiber: {
  */
 export const match: {
   <E, A, Z>(
-    options: { readonly onFiber: (fiber: Fiber<E, A>) => Z; readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z }
+    options: {
+      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+    }
   ): (self: Fiber<E, A>) => Z
   <E, A, Z>(
     self: Fiber<E, A>,
-    options: { readonly onFiber: (fiber: Fiber<E, A>) => Z; readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z }
+    options: {
+      readonly onFiber: (fiber: Fiber<E, A>) => Z
+      readonly onRuntimeFiber: (fiber: RuntimeFiber<E, A>) => Z
+    }
   ): Z
 } = internal.match
 

package/src/FiberRef.ts

@@ -42,28 +42,28 @@ export type FiberRefTypeId = typeof FiberRefTypeId
  * @since 2.0.0
  * @category model
  */
-export interface FiberRef<A> extends Variance<A>, Pipeable {
+export interface FiberRef<in out A> extends Variance<A>, Pipeable {
   /** @internal */
   readonly initial: A
   /** @internal */
-  readonly diff: (oldValue: A, newValue: A) => unknown
+  diff(oldValue: A, newValue: A): unknown
   /** @internal */
-  readonly combine: (first: unknown, second: unknown) => unknown
+  combine(first: unknown, second: unknown): unknown
   /** @internal */
-  readonly patch: (patch: unknown) => (oldValue: A) => A
+  patch(patch: unknown): (oldValue: A) => A
   /** @internal */
   readonly fork: unknown
   /** @internal */
-  readonly join: (oldValue: A, newValue: A) => A
+  join(oldValue: A, newValue: A): A
 }
 
 /**
  * @since 2.0.0
  * @category models
  */
-export interface Variance<A> {
+export interface Variance<in out A> {
   readonly [FiberRefTypeId]: {
-    readonly _A: (_: never) => A
+    readonly _A: (_: A) => A
   }
 }
 

package/src/GroupBy.ts

@@ -28,7 +28,7 @@ export type GroupByTypeId = typeof GroupByTypeId
  * @since 2.0.0
  * @category models
  */
-export interface GroupBy<R, E, K, V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
+export interface GroupBy<out R, out E, out K, out V> extends GroupBy.Variance<R, E, K, V>, Pipeable {
   readonly grouped: Stream.Stream<R, E, readonly [K, Queue.Dequeue<Take.Take<E, V>>]>
 }
 
@@ -40,7 +40,7 @@ export declare namespace GroupBy {
    * @since 2.0.0
    * @category models
    */
-  export interface Variance<R, E, K, V> {
+  export interface Variance<out R, out E, out K, out V> {
     readonly [GroupByTypeId]: {
       readonly _R: (_: never) => R
       readonly _E: (_: never) => E

package/src/Hash.ts

@@ -28,7 +28,7 @@ export const symbol: unique symbol = Symbol.for("effect/Hash")
  * @category models
  */
 export interface Hash {
-  readonly [symbol]: () => number
+  [symbol](): number
 }
 
 /**

package/src/HashMap.ts

@@ -22,7 +22,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface HashMap<Key, Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
+export interface HashMap<out Key, out Value> extends Iterable<[Key, Value]>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
 }
 
@@ -381,7 +381,7 @@ export const reduce: {
  */
 export const filter: {
   <K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
-  <K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
+  <K, B extends A, A = B>(f: (a: A, k: K) => boolean): (self: HashMap<K, B>) => HashMap<K, B>
   <K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
   <K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
 } = HM.filter
@@ -414,6 +414,8 @@ export const filterMap: {
  * @since 2.0.0
  */
 export const findFirst: {
-  <K, A>(predicate: (k: K, a: A) => boolean): (self: HashMap<K, A>) => Option<[K, A]>
-  <K, A>(self: HashMap<K, A>, predicate: (k: K, a: A) => boolean): Option<[K, A]>
+  <K, A, B extends A>(predicate: (a: A, k: K) => a is B): (self: HashMap<K, A>) => Option<[K, B]>
+  <K, B extends A, A = B>(predicate: (a: A, k: K) => boolean): (self: HashMap<K, B>) => Option<[K, B]>
+  <K, A, B extends A>(self: HashMap<K, A>, predicate: (a: A, k: K) => a is B): Option<[K, B]>
+  <K, A>(self: HashMap<K, A>, predicate: (a: A, k: K) => boolean): Option<[K, A]>
 } = HM.findFirst

package/src/HashSet.ts

@@ -20,7 +20,7 @@ export type TypeId = typeof TypeId
  * @since 2.0.0
  * @category models
  */
-export interface HashSet<A> extends Iterable<A>, Equal, Pipeable, Inspectable {
+export interface HashSet<out A> extends Iterable<A>, Equal, Pipeable, Inspectable {
   readonly [TypeId]: TypeId
 }
 
@@ -271,10 +271,10 @@ export const reduce: {
  * @category filtering
  */
 export const filter: {
-  <A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
-  <A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>
-  <A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): HashSet<B>
-  <A>(self: HashSet<A>, f: Predicate<A>): HashSet<A>
+  <A, B extends A>(refinement: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
+  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => HashSet<B>
+  <A, B extends A>(self: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>
+  <A>(self: HashSet<A>, predicate: Predicate<A>): HashSet<A>
 } = HS.filter
 
 /**
@@ -290,11 +290,11 @@ export const filter: {
 export const partition: {
   <C extends A, B extends A, A = C>(
     refinement: Refinement<A, B>
-  ): (self: HashSet<C>) => [HashSet<Exclude<C, B>>, HashSet<B>]
-  <B extends A, A = B>(predicate: (a: A) => boolean): (self: HashSet<B>) => [HashSet<B>, HashSet<B>]
-  <C extends A, B extends A, A = C>(
-    self: HashSet<C>,
+  ): (self: HashSet<C>) => [excluded: HashSet<Exclude<C, B>>, satisfying: HashSet<B>]
+  <B extends A, A = B>(predicate: Predicate<A>): (self: HashSet<B>) => [excluded: HashSet<B>, satisfying: HashSet<B>]
+  <A, B extends A>(
+    self: HashSet<A>,
     refinement: Refinement<A, B>
-  ): [HashSet<Exclude<C, B>>, HashSet<B>]
-  <B extends A, A = B>(self: HashSet<B>, predicate: (a: A) => boolean): [HashSet<B>, HashSet<B>]
+  ): [excluded: HashSet<Exclude<A, B>>, satisfying: HashSet<B>]
+  <A>(self: HashSet<A>, predicate: Predicate<A>): [excluded: HashSet<A>, satisfying: HashSet<A>]
 } = HS.partition