Matching

Matching consumes both channels of an Effect and produces one result. Use the ordinary variants for typed failures and the Cause variants when defects and interruptions must also be considered.

match

Effect.match handles a typed failure or success with pure functions. Defects and interruptions are not handled.

Example (Matching Both Channels)

1
import { Effect } from "effect"
2

3
const task: Effect.Effect<number, string> = Effect.fail("unavailable")
4

5
const program = Effect.match(task, {
6
  onFailure: (error) => `failure: ${error}`,
7
  onSuccess: (value) => `success: ${value}`,
8
})
9

10
Effect.runSync(program) // => "failure: unavailable"

matchEffect

Effect.matchEffect is the effectful version: both handlers return Effects and may introduce new errors or requirements.

Example (Running an Effectful Handler)

1
import { Effect } from "effect"
2

3
const task: Effect.Effect<number, string> = Effect.succeed(42)
4

5
const program = Effect.matchEffect(task, {
6
  onFailure: (error) => Effect.succeed(`failure: ${error}`),
7
  onSuccess: (value) => Effect.succeed(`success: ${value}`),
8
})
9

10
Effect.runSync(program) // => "success: 42"

matchCause and matchCauseEffect

Effect.matchCause passes the complete Cause to onFailure, so it also handles defects and interruptions. Effect.matchCauseEffect is its effectful counterpart.

Example (Matching a Defect)

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

3
const program = Effect.die("boom").pipe(
4
  Effect.matchCause({
5
    onFailure: (cause) =>
6
      Cause.hasDies(cause) ? "terminated by a defect" : "failed",
7
    onSuccess: () => "succeeded",
8
  }),
9
)
10

11
Effect.runSync(program) // => "terminated by a defect"

ignore and ignoreCause

Effect.ignore discards the success value and recovers from typed errors, producing Effect<void, never, R>. Defects and interruptions are preserved.

Effect.ignoreCause also discards every failure cause. Use it sparingly because it can hide defects.

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

3
Effect.runSync(Effect.ignore(Effect.fail("error"))) // => undefined
4

5
const defect = Effect.ignore(Effect.die("boom"))
6
Effect.runSyncExit(defect) // => Exit.die("boom")
7

8
Effect.runSync(Effect.ignoreCause(Effect.die("boom"))) // => undefined