Cause: Flattened Structure

In v3, Cause<E> was a recursive tree with six variants:

Empty | Fail<E> | Die | Interrupt | Sequential<E> | Parallel<E>

The Sequential and Parallel variants composed causes into a tree to represent errors from finalizers or concurrent operations.

In v4, Cause<E> has been flattened to a simple wrapper around an array of Reason values:

interface Cause<E> {
  readonly reasons: ReadonlyArray<Reason<E>>
}

type Reason<E> = Fail<E> | Die | Interrupt

There are only three reason variants — Fail, Die, and Interrupt. The Empty, Sequential, and Parallel variants have been removed. An empty cause is represented by an empty reasons array. Multiple failures (from concurrent or sequential composition) are collected into a flat array.

Accessing Reasons

v3 — pattern match on the recursive tree structure:

import { Cause } from "effect"

const handle = (cause: Cause.Cause<string>) => {
  switch (cause._tag) {
    case "Fail":
      return cause.error
    case "Die":
      return cause.defect
    case "Empty":
      return undefined
    case "Sequential":
      return handle(cause.left)
    case "Parallel":
      return handle(cause.left)
    case "Interrupt":
      return cause.fiberId
  }
}

v4 — iterate over the flat reasons array:

import { Cause } from "effect"

const handle = (cause: Cause.Cause<string>) => {
  for (const reason of cause.reasons) {
    switch (reason._tag) {
      case "Fail":
        return reason.error
      case "Die":
        return reason.defect
      case "Interrupt":
        return reason.fiberId
    }
  }
}

Reason Guards

The v3 type-level guards (isFailType, isDieType, isInterruptType, etc.) have been replaced by reason-level guards:

v3	v4
`Cause.isEmptyType(cause)`	`cause.reasons.length === 0`
`Cause.isFailType(cause)`	`Cause.isFailReason(reason)`
`Cause.isDieType(cause)`	`Cause.isDieReason(reason)`
`Cause.isInterruptType(cause)`	`Cause.isInterruptReason(reason)`
`Cause.isSequentialType(cause)`	Removed
`Cause.isParallelType(cause)`	Removed

Cause-Level Predicates

v3	v4
`Cause.isFailure(cause)`	`Cause.hasFails(cause)`
`Cause.isDie(cause)`	`Cause.hasDies(cause)`
`Cause.isInterrupted(cause)`	`Cause.hasInterrupts(cause)`
`Cause.isInterruptedOnly(cause)`	`Cause.hasInterruptsOnly(cause)`

Constructors

v3	v4
`Cause.empty`	`Cause.empty`
`Cause.fail(error)`	`Cause.fail(error)`
`Cause.die(defect)`	`Cause.die(defect)`
`Cause.interrupt(fiberId)`	`Cause.interrupt(fiberId)`
`Cause.sequential(left, right)`	`Cause.combine(left, right)`
`Cause.parallel(left, right)`	`Cause.combine(left, right)`

In v4, Cause.combine concatenates the reasons arrays of two causes. The distinction between sequential and parallel composition is no longer represented in the data structure.

Extractors

v3	v4
`Cause.failureOption(cause)`	`Cause.findErrorOption(cause)`
`Cause.failureOrCause(cause)`	`Cause.findError(cause)`
`Cause.dieOption(cause)`	`Cause.findDefect(cause)`
`Cause.interruptOption(cause)`	`Cause.findInterrupt(cause)`
`Cause.failures(cause)`	`cause.reasons.filter(Cause.isFailReason)`
`Cause.defects(cause)`	`cause.reasons.filter(Cause.isDieReason)`
`Cause.interruptors(cause)`	`Cause.interruptors(cause)`

Note: findError and findDefect return Result.Result instead of Option. Use findErrorOption for the Option-based variant.

Error Classes

All *Exception classes have been renamed to *Error:

v3	v4
`Cause.NoSuchElementException`	`Cause.NoSuchElementError`
`Cause.TimeoutException`	`Cause.TimeoutError`
`Cause.IllegalArgumentException`	`Cause.IllegalArgumentError`
`Cause.ExceededCapacityException`	`Cause.ExceededCapacityError`
`Cause.UnknownException`	`Cause.UnknownError`
`Cause.RuntimeException`	Removed
`Cause.InterruptedException`	Removed
`Cause.InvalidPubSubCapacityException`	Removed

The corresponding guards follow the same pattern:

v3	v4
`Cause.isNoSuchElementException(u)`	`Cause.isNoSuchElementError(u)`
`Cause.isTimeoutException(u)`	`Cause.isTimeoutError(u)`
`Cause.isIllegalArgumentException(u)`	`Cause.isIllegalArgumentError(u)`
`Cause.isExceededCapacityException(u)`	`Cause.isExceededCapacityError(u)`
`Cause.isUnknownException(u)`	`Cause.isUnknownError(u)`

New in v4

Cause.fromReasons(reasons) — construct a Cause from an array of Reason values.
Cause.makeFailReason(error), Cause.makeDieReason(defect), Cause.makeInterruptReason(fiberId) — construct individual Reason values.
Cause.annotate(cause, annotations) — attach annotations to a Cause.
Cause.findFail(cause), Cause.findDie(cause), Cause.findInterrupt(cause) — extract specific reason types using the Result module.
Cause.filterInterruptors(cause) — extract interrupting fiber IDs as a Result.
Cause.Done — a graceful completion signal for queues and streams.