<E>(self: Cause<E>): Result.Result<Set<number>, Cause<E>>Returns a Result whose success value is the set of defined fiber IDs from
the cause's Interrupt reasons. If the cause has no Interrupt
reason, the failure value is the original cause.
When to use
Use when you need absence of interrupt reasons to fail with the original cause.
Gotchas
Interrupt reasons without a fiberId still count as interrupts, so the
function succeeds with an empty Set when every interrupt reason has an
undefined fiber ID.
Example (Extracting interruptors with Result)
import { Cause, Result } from "effect"
const result = Cause.filterInterruptors(Cause.interrupt(1))
if (!Result.isFailure(result)) {
console.log(result.success) // Set(1) { 1 }
}export const const filterInterruptors: <E>(
self: Cause<E>
) => Result.Result<Set<number>, Cause<E>>
Returns a Result whose success value is the set of defined fiber IDs from
the cause's Interrupt reasons. If the cause has no Interrupt
reason, the failure value is the original cause.
When to use
Use when you need absence of interrupt reasons to fail with the original
cause.
Gotchas
Interrupt reasons without a fiberId still count as interrupts, so the
function succeeds with an empty Set when every interrupt reason has an
undefined fiber ID.
Example (Extracting interruptors with Result)
import { Cause, Result } from "effect"
const result = Cause.filterInterruptors(Cause.interrupt(1))
if (!Result.isFailure(result)) {
console.log(result.success) // Set(1) { 1 }
}
filterInterruptors: <function (type parameter) E in <E>(self: Cause<E>): Result.Result<Set<number>, Cause<E>>E>(self: Cause<E>(parameter) self: {
reasons: ReadonlyArray<Reason<E>>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
interface Cause<out E>A structured representation of how an Effect failed.
When to use
Use to preserve the full structured failure information for an effect instead
of collapsing it to a single error value.
Details
Access the individual failure entries through the reasons array, then
narrow each entry with
isFailReason
,
isDieReason
, or
- Use
hasFails
/
hasDies
/
hasInterrupts
to test
for the presence of specific reason kinds without iterating.
- Use
findError
/
findDefect
to extract the first value
of a given kind.
- Use
combine
to merge two causes.
Cause implements Equal — two causes with the same reasons (by value)
compare as equal.
Example (Creating and inspecting a cause)
import { Cause } from "effect"
const cause = Cause.fail("Something went wrong")
console.log(cause.reasons.length) // 1
console.log(Cause.isFailReason(cause.reasons[0])) // true
Companion namespace for the Cause interface.
Cause<function (type parameter) E in <E>(self: Cause<E>): Result.Result<Set<number>, Cause<E>>E>) => import ResultResult.type Result<A, E = never> = Result.Success<A, E> | Result.Failure<A, E>A value that is either Success<A, E> or Failure<A, E>.
When to use
Use when both success and failure should remain available as data and
Option would lose failure information.
Details
- Use
succeed
/
fail
to construct
- Use
match
to fold both branches
- Use
isSuccess
/
isFailure
to narrow the type
E defaults to never, so Result<number> means a result that cannot fail.
Example (Creating and matching a Result)
import { Result } from "effect"
const success = Result.succeed(42)
const failure = Result.fail("something went wrong")
const message = Result.match(success, {
onSuccess: (value) => `Success: ${value}`,
onFailure: (error) => `Error: ${error}`
})
console.log(message)
// Output: "Success: 42"
Namespace containing type-level utilities for extracting the inner types
of a Result.
Example (Extracting inner types)
import type { Result } from "effect"
type R = Result.Result<number, string>
// number
type A = Result.Result.Success<R>
// string
type E = Result.Result.Failure<R>
Result<interface Set<T>Set<number>, interface Cause<out E>A structured representation of how an Effect failed.
When to use
Use to preserve the full structured failure information for an effect instead
of collapsing it to a single error value.
Details
Access the individual failure entries through the reasons array, then
narrow each entry with
isFailReason
,
isDieReason
, or
- Use
hasFails
/
hasDies
/
hasInterrupts
to test
for the presence of specific reason kinds without iterating.
- Use
findError
/
findDefect
to extract the first value
of a given kind.
- Use
combine
to merge two causes.
Cause implements Equal — two causes with the same reasons (by value)
compare as equal.
Example (Creating and inspecting a cause)
import { Cause } from "effect"
const cause = Cause.fail("Something went wrong")
console.log(cause.reasons.length) // 1
console.log(Cause.isFailReason(cause.reasons[0])) // true
Companion namespace for the Cause interface.
Cause<function (type parameter) E in <E>(self: Cause<E>): Result.Result<Set<number>, Cause<E>>E>> =
import effecteffect.const causeFilterInterruptors: <E>(
self: Cause.Cause<E>
) => Result.Result<Set<number>, Cause.Cause<E>>