<A, E>(self: Result<A, E>): A | nullExtracts the success value, or returns null on failure.
When to use
Use when you need to pass failed Result values to APIs that represent
absence as null.
Details
Success<A>returnsAFailure<E>returnsnull
Example (Unwrapping to nullable)
import { Result } from "effect"
console.log(Result.getOrNull(Result.succeed(1)))
// Output: 1
console.log(Result.getOrNull(Result.fail("err")))
// Output: nullexport const const getOrNull: <A, E>(
self: Result<A, E>
) => A | null
Extracts the success value, or returns null on failure.
When to use
Use when you need to pass failed Result values to APIs that represent
absence as null.
Details
Success<A> returns AFailure<E> returns null
Example (Unwrapping to nullable)
import { Result } from "effect"
console.log(Result.getOrNull(Result.succeed(1)))
// Output: 1
console.log(Result.getOrNull(Result.fail("err")))
// Output: null
getOrNull: <function (type parameter) A in <A, E>(self: Result<A, E>): A | nullA, function (type parameter) E in <A, E>(self: Result<A, E>): A | nullE>(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 | nullA, function (type parameter) E in <A, E>(self: Result<A, E>): A | nullE>) => function (type parameter) A in <A, E>(self: Result<A, E>): A | nullA | null = 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 constNullconstNull)