<A, E>(self: Result<A, E>): A | undefinedExtracts the success value, or returns undefined on failure.
When to use
Use when you need to pass failed Result values to APIs that represent
absence as undefined.
Details
Success<A>returnsAFailure<E>returnsundefined
Example (Unwrapping to optional)
import { Result } from "effect"
console.log(Result.getOrUndefined(Result.succeed(1)))
// Output: 1
console.log(Result.getOrUndefined(Result.fail("err")))
// Output: undefinedexport const const getOrUndefined: <A, E>(
self: Result<A, E>
) => A | undefined
Extracts the success value, or returns undefined on failure.
When to use
Use when you need to pass failed Result values to APIs that represent
absence as undefined.
Details
Success<A> returns AFailure<E> returns undefined
Example (Unwrapping to optional)
import { Result } from "effect"
console.log(Result.getOrUndefined(Result.succeed(1)))
// Output: 1
console.log(Result.getOrUndefined(Result.fail("err")))
// Output: undefined
getOrUndefined: <function (type parameter) A in <A, E>(self: Result<A, E>): A | undefinedA, function (type parameter) E in <A, E>(self: Result<A, E>): A | undefinedE>(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>): A | undefinedA, function (type parameter) E in <A, E>(self: Result<A, E>): A | undefinedE>) => function (type parameter) A in <A, E>(self: Result<A, E>): A | undefinedA | undefined = const getOrElse: {
<E, A2>(onFailure: (err: E) => A2): <A>(
self: Result<A, E>
) => A2 | A
<A, E, A2>(
self: Result<A, E>,
onFailure: (err: E) => A2
): A | A2
}
import constUndefinedconstUndefined)