<A, E>(self: Result<A, E>): Option<E>Converts a Result into an Option, keeping only the failure value.
When to use
Use when you need to discard a Result success and keep only the failure
value as an Option.
Details
FailurebecomesSomewith the failure valueSuccessbecomesNoneand the success value is discarded
Example (Extracting the failure side)
import { Option, Result } from "effect"
console.log(Option.getFailure(Result.succeed("ok")))
// Output: { _id: 'Option', _tag: 'None' }
console.log(Option.getFailure(Result.fail("err")))
// Output: { _id: 'Option', _tag: 'Some', value: 'err' }export const const getFailure: <A, E>(
self: Result<A, E>
) => Option<E>
Converts a Result into an Option, keeping only the failure value.
When to use
Use when you need to discard a Result success and keep only the failure
value as an Option.
Details
Failure becomes Some with the failure valueSuccess becomes None and the success value is discarded
Example (Extracting the failure side)
import { Option, Result } from "effect"
console.log(Option.getFailure(Result.succeed("ok")))
// Output: { _id: 'Option', _tag: 'None' }
console.log(Option.getFailure(Result.fail("err")))
// Output: { _id: 'Option', _tag: 'Some', value: 'err' }
getFailure: <function (type parameter) A in <A, E>(self: Result<A, E>): Option<E>A, function (type parameter) E in <A, E>(self: Result<A, E>): Option<E>E>(self: Result<A, E>self: type Result<A, E = never> = Success<A, E> | 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<function (type parameter) A in <A, E>(self: Result<A, E>): Option<E>A, function (type parameter) E in <A, E>(self: Result<A, E>): Option<E>E>) => type Option<A> = None<A> | Some<A>The Option data type represents optional values. An Option<A> is either
Some<A>, containing a value of type A, or None, representing absence.
When to use
Use to represent initial values that may not yet exist
- Returning from partial functions (not defined for all inputs)
- Managing optional fields in data structures
Namespace containing utility types for Option.
When to use
Use to access type-level helpers associated with Option.
Option<function (type parameter) E in <A, E>(self: Result<A, E>): Option<E>E> = import resultresult.const getFailure: <A, E>(
self: Result.Result<A, E>
) => Option<E>