<E>(onNone: () => E): <A>(self: Option<A>) => Result<A, E>
<A, E>(self: Option<A>, onNone: () => E): Result<A, E>Converts an Option<A> into a Result<A, E>.
When to use
Use when an existing Option should become a Result, preserving Some as
success and turning None into a caller-provided failure.
Details
Some<A>becomesSuccess<A>NonebecomesFailure<E>using the provided function- Supports both data-first and data-last (piped) usage
Example (Converting an Option to a Result)
import { Option, Result } from "effect"
const some = Result.fromOption(Option.some(1), () => "missing")
console.log(some)
// Output: { _tag: "Success", success: 1, ... }
const none = Result.fromOption(Option.none(), () => "missing")
console.log(none)
// Output: { _tag: "Failure", failure: "missing", ... }export const const fromOption: {
<E>(onNone: () => E): <A>(
self: Option<A>
) => Result<A, E>
<A, E>(
self: Option<A>,
onNone: () => E
): Result<A, E>
}
Converts an Option<A> into a Result<A, E>.
When to use
Use when an existing Option should become a Result, preserving Some as
success and turning None into a caller-provided failure.
Details
Some<A> becomes Success<A>None becomes Failure<E> using the provided function- Supports both data-first and data-last (piped) usage
Example (Converting an Option to a Result)
import { Option, Result } from "effect"
const some = Result.fromOption(Option.some(1), () => "missing")
console.log(some)
// Output: { _tag: "Success", success: 1, ... }
const none = Result.fromOption(Option.none(), () => "missing")
console.log(none)
// Output: { _tag: "Failure", failure: "missing", ... }
fromOption: {
<function (type parameter) E in <E>(onNone: () => E): <A>(self: Option<A>) => Result<A, E>E>(onNone: () => EonNone: () => function (type parameter) E in <E>(onNone: () => E): <A>(self: Option<A>) => Result<A, E>E): <function (type parameter) A in <A>(self: Option<A>): Result<A, E>A>(self: Option<A>self: import OptionOption<function (type parameter) A in <A>(self: Option<A>): Result<A, E>A>) => 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>(self: Option<A>): Result<A, E>A, function (type parameter) E in <E>(onNone: () => E): <A>(self: Option<A>) => Result<A, E>E>
<function (type parameter) A in <A, E>(self: Option<A>, onNone: () => E): Result<A, E>A, function (type parameter) E in <A, E>(self: Option<A>, onNone: () => E): Result<A, E>E>(self: Option<A>self: import OptionOption<function (type parameter) A in <A, E>(self: Option<A>, onNone: () => E): Result<A, E>A>, onNone: () => EonNone: () => function (type parameter) E in <A, E>(self: Option<A>, onNone: () => E): Result<A, E>E): 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: Option<A>, onNone: () => E): Result<A, E>A, function (type parameter) E in <A, E>(self: Option<A>, onNone: () => E): Result<A, E>E>
} = import resultresult.const fromOption: {
<E>(onNone: () => E): <A>(
self: Option<A>
) => Result.Result<A, E>
<A, E>(
self: Option<A>,
onNone: () => E
): Result.Result<A, E>
}