Exit

An Exit<A, E> describes the result of running an Effect workflow.

There are two possible states for an Exit<A, E>:

• Exit.Success: Contains a success value of type A.
• Exit.Failure: Contains a failure Cause of type E.

Creating Exits

The Exit module provides two primary functions for constructing exit values: Exit.succeed and Exit.failCause. These functions represent the outcomes of an effectful computation in terms of success or failure.

succeed

Exit.succeed creates an Exit value that represents a successful outcome. You use this function when you want to indicate that a computation completed successfully and to provide the resulting value.

Example (Creating a Successful Exit)

1
import { Exit } from "effect"
2

3
// Create an Exit representing a successful outcome with the value 42
4
//
5
//      ┌─── Exit<number, never>
6
//      ▼
7
const successExit = Exit.succeed(42)
8

9
console.log(successExit)
10
// Output: { _id: 'Exit', _tag: 'Success', value: 42 }

failCause

Exit.failCause creates an Exit value that represents a failure. The failure is described using a Cause object, which can encapsulate expected errors, defects, interruptions, or even composite errors.

Example (Creating a Failed Exit)

1
import { Exit, Cause } from "effect"
2

3
// Create an Exit representing a failure with an error message
4
//
5
//      ┌─── Exit<never, string>
6
//      ▼
7
const failureExit = Exit.failCause(Cause.fail("Something went wrong"))
8

9
console.log(failureExit)
10
/*
11
Output:
12
{
13
  _id: 'Exit',
14
  _tag: 'Failure',
15
  cause: { _id: 'Cause', _tag: 'Fail', failure: 'Something went wrong' }
16
}
17
*/

Pattern Matching

You can handle different outcomes of an Exit using the Exit.match function. This function lets you provide two separate callbacks to handle both success and failure cases of an Effect execution.

Example (Matching Success and Failure States)

1
import { Effect, Exit, Cause } from "effect"
2

3
//      ┌─── Exit<number, never>
4
//      ▼
5
const simulatedSuccess = Effect.runSyncExit(Effect.succeed(1))
6

7
console.log(
8
  Exit.match(simulatedSuccess, {
9
    onFailure: (cause) => `Exited with failure state: ${Cause.pretty(cause)}`,
10
    onSuccess: (value) => `Exited with success value: ${value}`,
11
  }),
12
)
13
// Output: "Exited with success value: 1"
14

15
//      ┌─── Exit<never, string>
16
//      ▼
17
const simulatedFailure = Effect.runSyncExit(Effect.failCause(Cause.fail("error")))
18

19
console.log(
20
  Exit.match(simulatedFailure, {
21
    onFailure: (cause) => `Exited with failure state: ${Cause.pretty(cause)}`,
22
    onSuccess: (value) => `Exited with success value: ${value}`,
23
  }),
24
)
25
// Output: "Exited with failure state: Error: error"

Exit vs Either

Conceptually, Exit<A, E> can be thought of as Either<A, Cause<E>>. However, the Cause type represents more than just expected errors of type E. It includes:

• Interruption causes
• Defects (unexpected errors)
• The combination of multiple causes

This allows Cause to capture richer and more complex error states compared to a simple Either.

Exit vs Effect

Exit is actually a subtype of Effect. This means that Exit values can also be considered as Effect values.

• An Exit, in essence, is a “constant computation”.
• Effect.succeed is essentially the same as Exit.succeed.
• Effect.failCause is the same as Exit.failCause.