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

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, Covariant, 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,10 +137,10 @@ 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 E, out A> extends Effect<never, E, A> {
   readonly _op: "Blocked"
-  readonly i0: RequestBlock<R>
-  readonly i1: Effect<R, E, A>
+  readonly i0: RequestBlock
+  readonly i1: Effect<never, E, A>
 }
 
 /**
@@ -200,18 +200,18 @@ 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
-    readonly _A: (_: never) => A
+    readonly _R: Covariant<R>
+    readonly _E: Covariant<E>
+    readonly _A: Covariant<A>
   }
   /**
    * @since 2.0.0
@@ -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
@@ -1504,7 +1512,7 @@ export const catchAll: {
 /**
  * Recovers from both recoverable and unrecoverable errors.
  *
- * See `absorb`, `sandbox`, `mapErrorCause` for other functions that can
+ * See `sandbox`, `mapErrorCause` for other functions that can
  * recover from defects.
  *
  * @since 2.0.0
@@ -1648,10 +1656,9 @@ export const catchTag: {
 export const catchTags: {
   <
     E,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
   >(
     cases: Cases
   ): <R, A>(
@@ -1674,10 +1681,9 @@ export const catchTags: {
     R,
     E,
     A,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & { [K in Extract<E, { _tag: string }>["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect<any, any, any>) }
+      & (unknown extends E ? {} : { [K in Exclude<keyof Cases, Extract<E, { _tag: string }>["_tag"]>]: never })
   >(
     self: Effect<R, E, A>,
     cases: Cases
@@ -1844,7 +1850,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 +1920,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
 
 /**
@@ -2196,7 +2199,7 @@ export const mapError: {
  * function. This can be used to transform errors while preserving the
  * original structure of `Cause`.
  *
- * See `absorb`, `sandbox`, `catchAllCause` for other functions for dealing
+ * See `sandbox`, `catchAllCause` for other functions for dealing
  * with defects.
  *
  * @since 2.0.0
@@ -3537,6 +3540,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 +3676,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 +4640,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>
 }
 
 /**
@@ -4820,29 +4880,20 @@ export const ap: {
  * @category requests & batching
  * @since 2.0.0
  */
-export const blocked: <R, E, A>(blockedRequests: RequestBlock<R>, _continue: Effect<R, E, A>) => Blocked<R, E, A> =
+export const blocked: <E, A>(blockedRequests: RequestBlock, _continue: Effect<never, E, A>) => Blocked<E, A> =
   core.blocked
 
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export const runRequestBlock: <R>(blockedRequests: RequestBlock<R>) => Blocked<R, never, void> = core.runRequestBlock
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-export const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<R, E, A>> = core.step
+export const runRequestBlock: <R>(blockedRequests: RequestBlock) => Effect<R, never, void> = core.runRequestBlock
 
 /**
  * @category requests & batching
  * @since 2.0.0
  */
-export const flatMapStep: <R, E, A, R1, E1, B>(
-  self: Effect<R, E, A>,
-  f: (step: Exit.Exit<E, A> | Blocked<R, E, A>) => Effect<R1, E1, B>
-) => Effect<R | R1, E1, B> = core.flatMapStep
+export const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<E, A>> = core.step
 
 /**
  * @since 2.0.0

package/src/Either.ts

@@ -11,7 +11,9 @@ import type { Inspectable } from "./Inspectable.js"
 import * as either from "./internal/either.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
+import type { Predicate, Refinement } from "./Predicate.js"
 import { isFunction } from "./Predicate.js"
+import type * as Types from "./Types.js"
 import type * as Unify from "./Unify.js"
 import * as Gen from "./Utils.js"
 
@@ -37,13 +39,13 @@ 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
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
-    readonly _E: (_: never) => E
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: EitherUnify<this>
@@ -54,13 +56,13 @@ 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
   readonly [TypeId]: {
-    readonly _A: (_: never) => A
-    readonly _E: (_: never) => E
+    readonly _A: Types.Covariant<A>
+    readonly _E: Types.Covariant<E>
   }
   [Unify.typeSymbol]?: unknown
   [Unify.unifySymbol]?: EitherUnify<this>
@@ -147,11 +149,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 {
@@ -368,6 +376,59 @@ export const match: {
   }): B | C => isLeft(self) ? onLeft(self.left) : onRight(self.right)
 )
 
+/**
+ * Filter the right value with the provided function.
+ * If the predicate fails, set the left value with the result of the provided function.
+ *
+ * @example
+ * import * as E from 'effect/Either'
+ * import { pipe } from 'effect/Function'
+ *
+ * const isPositive = (n: number): boolean => n > 0
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     E.right(1),
+ *     E.filterOrLeft(isPositive, n => `${n} is not positive`)
+ *   ),
+ *   E.right(1)
+ * )
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     E.right(0),
+ *     E.filterOrLeft(isPositive, n => `${n} is not positive`)
+ *   ),
+ *   E.left("0 is not positive")
+ * )
+ *
+ * @since 2.0.0
+ * @category filtering & conditionals
+ */
+export const filterOrLeft: {
+  <A, B extends A, X extends A, E2>(
+    filter: Refinement<A, B>,
+    orLeftWith: (a: X) => E2
+  ): <E>(self: Either<E, A>) => Either<E2 | E, B>
+  <A, X extends A, Y extends A, E2>(
+    filter: Predicate<X>,
+    orLeftWith: (a: Y) => E2
+  ): <E>(self: Either<E, A>) => Either<E2 | E, A>
+  <E, A, B extends A, X extends A, E2>(
+    self: Either<E, A>,
+    filter: Refinement<A, B>,
+    orLeftWith: (a: X) => E2
+  ): Either<E | E2, B>
+  <E, A, X extends A, Y extends A, E2>(
+    self: Either<E, A>,
+    filter: Predicate<X>,
+    orLeftWith: (a: Y) => E2
+  ): Either<E | E2, A>
+} = dual(3, <E, A, E2>(
+  self: Either<E, A>,
+  filter: Predicate<A>,
+  orLeftWith: (a: A) => E2
+): Either<E | E2, A> => flatMap(self, (a) => filter(a) ? right(a) : left(orLeftWith(a))))
+
 /**
  * @category getters
  * @since 2.0.0
@@ -491,7 +552,7 @@ export const orElse: {
 )
 
 /**
- * @category combining
+ * @category sequencing
  * @since 2.0.0
  */
 export const flatMap: {
@@ -504,8 +565,25 @@ export const flatMap: {
 )
 
 /**
+ * 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)
+)
+
+/**
+ * @category zipping
  * @since 2.0.0
- * @category combining
  */
 export const zipWith: {
   <E2, A2, A, B>(
@@ -537,13 +615,13 @@ export const ap: {
 )
 
 /**
- * Takes a structure of `Option`s and returns an `Option` of values with the same structure.
+ * Takes a structure of `Either`s and returns an `Either` of values with the same structure.
  *
- * - If a tuple is supplied, then the returned `Option` will contain a tuple with the same length.
- * - If a struct is supplied, then the returned `Option` will contain a struct with the same keys.
- * - If an iterable is supplied, then the returned `Option` will contain an array.
+ * - If a tuple is supplied, then the returned `Either` will contain a tuple with the same length.
+ * - If a struct is supplied, then the returned `Either` will contain a struct with the same keys.
+ * - If an iterable is supplied, then the returned `Either` will contain an array.
  *
- * @param fields - the struct of `Option`s to be sequenced.
+ * @param fields - the struct of `Either`s to be sequenced.
  *
  * @example
  * import * as Either from "effect/Either"

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
 }
 
@@ -110,7 +110,7 @@ export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence
   combineMany(isAlwaysEquivalent, collection)
 
 /**
- * @category combinators
+ * @category mapping
  * @since 2.0.0
  */
 export const mapInput: {

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