Exit

When to use

Use when you need to discard a successful Exit value while preserving whether the Exit succeeded or failed.

Details

Failures pass through unchanged.

Allocates a new Exit if successful.

See

• void for a pre-allocated void success
• asVoidAll to combine multiple exits into a single void Exit

declare const asVoid: <A, E>(self: Exit<A, E>) => Exit<void, E>

import { Exit } from "effect"

Exit.asVoid(Exit.succeed(42)) // => Exit.succeed(undefined)

When to use

Use to validate that all exits in a collection succeeded

Details

If all exits are successful, this returns a void success. If any exit is a failure, this returns a single failure with all error causes combined.

Iterates over the entire collection. Collects all failure causes, not just the first.

See

• asVoid to discard the value of a single Exit

declare const asVoidAll: <I extends Iterable<Exit<any, any>>>(exits: I) => Exit<void, I extends Iterable<Exit<infer _A, infer _E>> ? _E : never>

import { Exit } from "effect"

Exit.asVoidAll([Exit.succeed(1), Exit.succeed(2), Exit.succeed(3)]) // => Exit.succeed(undefined)
Exit.asVoidAll([Exit.succeed(1), Exit.fail("err"), Exit.succeed(3)]) // => Exit.fail("err")

When to use

Use to apply a transformation to the value inside a successful Exit

Details

Failures pass through unchanged.

Allocates a new Exit if successful.

See

• mapError to transform the error
• mapBoth to transform both success and error

declare const map: {
  <A, B>(f: (a: A) => B): <E>(self: Exit<A, E>) => Exit<B, E>;
  <A, E, B>(self: Exit<A, E>, f: (a: A) => B): Exit<B, E>;
}

import { Exit } from "effect"

Exit.map(Exit.succeed(21), (x) => x * 2) // => Exit.succeed(42)

When to use

Use when you need to remap both channels in one step.

Details

onSuccess transforms the value if the Exit is a Success. onFailure transforms the typed error if the Exit is a Failure with a Fail reason. Allocates a new Exit.

Gotchas

If the Cause contains only defects or interruptions, the failure passes through unchanged.

See

• map to transform only the success value
• mapError to transform only the error

declare const mapBoth: {
  <E, E2, A, A2>(options: {
    readonly onFailure: (e: E) => E2;
    readonly onSuccess: (a: A) => A2;
  }): (self: Exit<A, E>) => Exit<A2, E2>;
  <A, E, E2, A2>(self: Exit<A, E>, options: {
    readonly onFailure: (e: E) => E2;
    readonly onSuccess: (a: A) => A2;
  }): Exit<A2, E2>;
}

import { Exit } from "effect"

Exit.mapBoth(Exit.succeed(42), {
  onSuccess: (x) => String(x),
  onFailure: (error: string) => error.toUpperCase()
}) // => Exit.succeed("42")

When to use

Use to remap typed errors while preserving the Exit structure

Details

Successes pass through unchanged.

Allocates a new Exit if the error is transformed.

Gotchas

Only transforms typed errors (Fail reasons). If the Cause contains only defects or interruptions, the failure passes through unchanged.

See

• map to transform the success value
• mapBoth to transform both success and error

declare const mapError: {
  <E, E2>(f: (a: NoInfer<E>) => E2): <A>(self: Exit<A, E>) => Exit<A, E2>;
  <A, E, E2>(self: Exit<A, E>, f: (a: NoInfer<E>) => E2): Exit<A, E2>;
}

import { Exit } from "effect"

Exit.mapError(Exit.fail("bad input"), (error) => error.toUpperCase()) // => Exit.fail("BAD INPUT")

When to use

Use when you need unexpected, unrecoverable errors that should not appear in the typed error channel.

Details

The defect is wrapped in a Cause.Die internally.

Returns a Failure<never> with E = never, since defects do not appear in the typed error channel.

See

• fail to create a Failure from a typed error
• hasDies to check whether an Exit contains defects

declare const die: (defect: unknown) => Exit<never>

import { Exit } from "effect"

Exit.die("Unexpected error") // => Exit.die("Unexpected error")

When to use

Use when you need to represent an expected typed failure as an Exit.

Details

The error is wrapped in a Cause.Fail internally.

Returns a Failure<never, E>.

See

• succeed to create a successful Exit
• die to create a Failure from an unexpected defect
• failCause to create a Failure from a full Cause

declare const fail: <E>(e: E) => Exit<never, E>

import { Exit } from "effect"

Exit.fail("Something went wrong") // => Exit.fail("Something went wrong")

When to use

Use when you already have a Cause<E> and want to wrap it in an Exit for advanced error handling where you need full control over the Cause structure.

Details

Returns a Failure<never, E>. If you only have an error value, use fail instead.

See

• fail to create a Failure from a plain error value
• die to create a Failure from a defect

declare const failCause: <E>(cause: Cause.Cause<E>) => Exit<never, E>

import { Cause, Exit } from "effect"

Exit.failCause(Cause.fail("Something went wrong")) // => Exit.fail("Something went wrong")

When to use

Use to signal that a fiber was interrupted.

Details

Optionally pass a fiber ID to identify which fiber was interrupted. Returns a Failure<never> with an Interrupt cause.

See

• hasInterrupts to check whether an Exit contains interruptions

declare const interrupt: (fiberId?: number) => Exit<never>

import { Exit } from "effect"

Exit.interrupt(123) // => Exit.interrupt(123)

When to use

Use when you need an Exit that contains a known success value.

Details

Returns a Success<A> with the provided value. Does not perform any computation.

See

• fail to create a failed Exit
• void for a pre-allocated success with no value

declare const succeed: <A>(a: A) => Exit<A>

import { Exit } from "effect"

Exit.succeed(42) // => Exit.succeed(42)

When to use

Use when composing Exit checks with Filter or other Result-based filtering APIs and you want the raw Cause rather than the Failure wrapper.

Details

Returns Result.succeed(cause) when the Exit is a Failure, or Result.fail(success) with the original Success otherwise.

Gotchas

This is not an Option accessor or an Effect failure. A failed extraction is represented as data in the Result failure channel.

See

• filterFailure to get the full Failure object
• getCause to get the Cause as an Option instead

declare const filterCause: <A, E>(self: Exit<A, E>) => Result.Result<Cause.Cause<E>, Success<A>>

import { Cause, Exit, Result } from "effect"

Exit.filterCause(Exit.fail("err")) // => Result.succeed(Cause.fail("err"))

When to use

Use when composing Exit checks with Filter or other Result-based filtering APIs and you want the full Failure wrapper.

Details

Returns Result.succeed(failure) when the Exit is a Failure, or Result.fail(success) with the original Success otherwise.

Gotchas

This is not an Option accessor or an Effect failure. A failed extraction is represented as data in the Result failure channel.

See

• filterSuccess for the inverse
• filterCause to extract the Cause directly

declare const filterFailure: <A, E>(self: Exit<A, E>) => Result.Result<Failure<never, E>, Success<A>>

import { Exit, Result } from "effect"

Exit.filterFailure(Exit.fail("err")) // => Result.succeed(Exit.fail("err"))

When to use

Use when composing Exit checks with Filter or other Result-based filtering APIs and you want the full Success wrapper.

Details

Returns Result.succeed(success) when the Exit is a Success, or Result.fail(failure) with the original Failure otherwise.

Gotchas

This is not an Option accessor or an Effect failure. A failed extraction is represented as data in the Result failure channel.

See

• filterFailure for the inverse
• filterValue to extract the raw value instead of the Success object

declare const filterSuccess: <A, E>(self: Exit<A, E>) => Result.Result<Success<A>, Failure<never, E>>

import { Exit, Result } from "effect"

Exit.filterSuccess(Exit.succeed(42)) // => Result.succeed(Exit.succeed(42))

When to use

Use when composing Exit checks with Filter or other Result-based filtering APIs and you want the raw success value rather than the Success wrapper.

Details

Returns Result.succeed(value) when the Exit is a Success, or Result.fail(failure) with the original Failure otherwise.

Gotchas

This is not an Option accessor or an Effect failure. A failed extraction is represented as data in the Result failure channel.

See

• filterSuccess to get the full Success object
• getSuccess to get the value as an Option instead

declare const filterValue: <A, E>(self: Exit<A, E>) => Result.Result<A, Failure<never, E>>

import { Exit, Result } from "effect"

Exit.filterValue(Exit.succeed(42)) // => Result.succeed(42)

When to use

Use when you need the first defect from an Exit as a Result for Filter or other Result-based filtering APIs.

Details

Returns Result.succeed(defect) when the Cause contains a Die reason, or Result.fail(exit) with the original Exit otherwise.

Gotchas

Only finds the first Die reason. If the Cause has multiple defects, the rest are ignored.

See

• findError to find typed errors instead
• hasDies to check for defects without extracting them

declare const findDefect: <A, E>(input: Exit<A, E>) => Result.Result<unknown, Exit<A, E>>

import { Exit, Result } from "effect"

Exit.findDefect(Exit.die("boom")) // => Result.succeed("boom")
Exit.findDefect(Exit.fail("err")) // => Result.fail(Exit.fail("err"))

When to use

Use when you need the first typed error from an Exit as a Result for Filter or other Result-based filtering APIs.

Details

Returns Result.succeed(error) when the Cause contains a Fail reason, or Result.fail(exit) with the original Exit otherwise.

Gotchas

Only finds the first Fail reason. If the Cause has multiple errors, the rest are ignored.

See

• findErrorOption to get the error as an Option instead
• findDefect to find defects instead

declare const findError: <A, E>(input: Exit<A, E>) => Result.Result<E, Exit<A, E>>

import { Exit, Result } from "effect"

Exit.findError(Exit.fail("not found")) // => Result.succeed("not found")
Exit.findError(Exit.die("bug")) // => Result.fail(Exit.die("bug"))

When to use

Use when you need the first typed error from an Exit as an Option, ignoring successes and non-typed failures.

Details

Returns Option.some(error) if the Cause contains a Fail reason. Successes, defect-only failures, and interrupt-only failures return Option.none().

Gotchas

Only finds the first Fail reason. If the Cause has multiple typed errors, the rest are ignored.

See

• findError for filter-pipeline usage
• getCause to get the full Cause as an Option

declare const findErrorOption: <A, E>(self: Exit<A, E>) => Option<E>

import { Exit, Option } from "effect"

Exit.findErrorOption(Exit.fail("err")) // => Option.some("err")
Exit.findErrorOption(Exit.die("bug")) // => Option.none()
Exit.findErrorOption(Exit.succeed(42)) // => Option.none()

When to use

Use when you need the failure Cause from an Exit as an Option instead of pattern matching.

Details

Returns Option.some(cause) for a Failure and Option.none() for a Success.

See

• getSuccess to extract the success value
• filterCause for filter-pipeline usage

declare const getCause: <A, E>(self: Exit<A, E>) => Option<Cause.Cause<E>>

import { Cause, Exit, Option } from "effect"

Exit.getCause(Exit.fail("err")) // => Option.some(Cause.fail("err"))
Exit.getCause(Exit.succeed(42)) // => Option.none()

When to use

Use when you need the success value from an Exit as an Option instead of pattern matching.

Details

Returns Option.some(value) for a Success and Option.none() for a Failure.

See

• getCause to extract the Cause of a failure
• filterValue for filter-pipeline usage

declare const getSuccess: <A, E>(self: Exit<A, E>) => Option<A>

import { Exit, Option } from "effect"

Exit.getSuccess(Exit.succeed(42)) // => Option.some(42)
Exit.getSuccess(Exit.fail("err")) // => Option.none()

When to use

Use to check whether an Exit failure cause contains unexpected errors.

Details

Returns false for successful exits. Only checks for Die reasons in the Cause. A Cause with only Fail or Interrupt reasons returns false.

See

• hasFails to check for typed errors
• hasInterrupts to check for interruptions

declare const hasDies: <A, E>(self: Exit<A, E>) => self is Failure<A, E>

import { Exit } from "effect"

Exit.hasDies(Exit.die("bug")) // => true
Exit.hasDies(Exit.fail("err")) // => false
Exit.hasDies(Exit.succeed(42)) // => false

When to use

Use to distinguish typed failures from defects or interruptions.

Details

Returns false for successful exits. Only checks for Fail reasons in the Cause. A Cause with only Die or Interrupt reasons returns false.

See

• hasDies to check for defects
• hasInterrupts to check for interruptions

declare const hasFails: <A, E>(self: Exit<A, E>) => self is Failure<A, E>

import { Exit } from "effect"

Exit.hasFails(Exit.fail("err")) // => true
Exit.hasFails(Exit.die("bug")) // => false
Exit.hasFails(Exit.succeed(42)) // => false

When to use

Use to check whether an Exit contains fiber interruption.

Details

Returns false for successful exits. Only checks for Interrupt reasons in the Cause. A Cause with only Fail or Die reasons returns false.

See

• hasFails to check for typed errors
• hasDies to check for defects

declare const hasInterrupts: <A, E>(self: Exit<A, E>) => self is Failure<A, E>

import { Exit } from "effect"

Exit.hasInterrupts(Exit.interrupt(1)) // => true
Exit.hasInterrupts(Exit.fail("err")) // => false
Exit.hasInterrupts(Exit.succeed(42)) // => false

When to use

Use to validate unknown values at system boundaries and narrow them to Exit<unknown, unknown>.

Details

Does not inspect the contents of the Exit. Returns true for both Success and Failure exits.

See

• isSuccess to check for a successful Exit
• isFailure to check for a failed Exit

declare const isExit: (u: unknown) => u is Exit<unknown, unknown>

import { Exit } from "effect"

Exit.isExit(Exit.succeed(42)) // => true
Exit.isExit(Exit.fail("err")) // => true
Exit.isExit("not an exit") // => false

When to use

Use as a type guard to narrow Exit<A, E> to Failure<A, E> and access the cause property.

See

• isSuccess for the opposite check
• match for exhaustive pattern matching

declare const isFailure: <A, E>(self: Exit<A, E>) => self is Failure<A, E>

import { Cause, Exit } from "effect"

const exit = Exit.fail("error")

if (Exit.isFailure(exit)) {
  exit.cause // => Cause.fail("error")
}

When to use

Use as a type guard to narrow Exit<A, E> to Success<A, E> and access the value property.

See

• isFailure for the opposite check
• match for exhaustive pattern matching

declare const isSuccess: <A, E>(self: Exit<A, E>) => self is Success<A, E>

import { Exit } from "effect"

const exit = Exit.succeed(42)

if (Exit.isSuccess(exit)) {
  exit.value // => 42
}

When to use

Use when you need to synchronously inspect whether an Effect computation succeeded or failed.

Details

An Exit<A, E> is either Success<A, E> containing a value of type A, or Failure<A, E> containing a Cause<E> describing why the computation failed.

Since Exit is also an Effect, you can yield it inside Effect.gen.

See

• Success for the success case
• Failure for the failure case
• match for pattern matching

type Exit<A, E = never> = Success<A, E> | Failure<A, E>

import { Exit } from "effect"

const success: Exit.Exit<number> = Exit.succeed(42)
const failure: Exit.Exit<number, string> = Exit.fail("error")

Exit.match(success, {
  onSuccess: (value) => `Got value: ${value}`,
  onFailure: (cause) => `Got error: ${cause}`
}) // => "Got value: 42"

When to use

Use when working with the failed branch of an Exit after narrowing with isFailure. Access the cause via the cause property after narrowing.

Details

The Cause<E> may contain typed errors, defects, or interruptions.

See

• isFailure to narrow an Exit to Failure
• Success for the success counterpart

interface Failure<out A, out E> extends Proto<A, E> {
  readonly _tag: "Failure";
  readonly cause: Cause<E>;
}

import { Cause, Exit } from "effect"

const failure = Exit.fail("something went wrong")

if (Exit.isFailure(failure)) {
  failure.cause // => Cause.fail("something went wrong")
}

When to use

Use when working with the successful branch of an Exit after narrowing with isSuccess. Access the value via the value property after narrowing.

See

• isSuccess to narrow an Exit to Success
• Failure for the failure counterpart

interface Success<out A, out E = never> extends Proto<A, E> {
  readonly _tag: "Success";
  readonly value: A;
}

import { Exit } from "effect"

const success = Exit.succeed(42)

if (Exit.isSuccess(success)) {
  success.value // => 42
}

When to use

Use to reference helper types that describe the shared structure of Exit values.

When to use

Use when you need exhaustive handling of both Exit success and failure outcomes.

Details

Calls onSuccess with the value if the Exit is a Success, and calls onFailure with the Cause if the Exit is a Failure.

See

• isSuccess and isFailure for simple boolean checks

declare const match: {
  <A, E, X1, X2>(options: {
    readonly onFailure: (cause: Cause.Cause<NoInfer<E>>) => X2;
    readonly onSuccess: (a: NoInfer<A>) => X1;
  }): (self: Exit<A, E>) => X1 | X2;
  <A, E, X1, X2>(self: Exit<A, E>, options: {
    readonly onFailure: (cause: Cause.Cause<E>) => X2;
    readonly onSuccess: (a: A) => X1;
  }): X1 | X2;
}

import { Exit } from "effect"

Exit.match(Exit.succeed(42), {
  onSuccess: (value) => `Got: ${value}`,
  onFailure: () => "Failed"
}) // => "Got: 42"