<A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (
...a: A
) => Option<NonNullable<B>>Lifts a function that may return null or undefined into one that returns
an Option.
When to use
Use to wrap existing nullable-returning functions for use in Option pipelines
Details
- Calls the original function with the given arguments
- Wraps the result via fromNullishOr
Example (Lifting a parser)
import { Option } from "effect"
const parse = (s: string): number | undefined => {
const n = parseFloat(s)
return isNaN(n) ? undefined : n
}
const parseOption = Option.liftNullishOr(parse)
console.log(parseOption("1"))
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
console.log(parseOption("not a number"))
// Output: { _id: 'Option', _tag: 'None' }export const const liftNullishOr: <
A extends ReadonlyArray<unknown>,
B
>(
f: (...a: A) => B
) => (...a: A) => Option<NonNullable<B>>
Lifts a function that may return null or undefined into one that returns
an Option.
When to use
Use to wrap existing nullable-returning functions for use in Option pipelines
Details
- Calls the original function with the given arguments
- Wraps the result via
fromNullishOr
Example (Lifting a parser)
import { Option } from "effect"
const parse = (s: string): number | undefined => {
const n = parseFloat(s)
return isNaN(n) ? undefined : n
}
const parseOption = Option.liftNullishOr(parse)
console.log(parseOption("1"))
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
console.log(parseOption("not a number"))
// Output: { _id: 'Option', _tag: 'None' }
liftNullishOr = <function (type parameter) A in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>A extends interface ReadonlyArray<T>ReadonlyArray<unknown>, function (type parameter) B in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>B>(
f: (...a: A) => Bf: (...a: A extends ReadonlyArray<unknown>a: function (type parameter) A in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>A) => function (type parameter) B in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>B
): (...a: A extends ReadonlyArray<unknown>a: function (type parameter) A in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>A) => 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<type NonNullable<T> = T & {}Exclude null and undefined from T
NonNullable<function (type parameter) B in <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B): (...a: A) => Option<NonNullable<B>>B>> =>
(...a: A extends ReadonlyArray<unknown>a) => const fromNullishOr: <A>(
a: A
) => Option<NonNullable<A>>
Converts a nullable value (null or undefined) into an Option.
When to use
Use when you need JavaScript nullish values to become absence at an API
boundary while all other values, including falsy ones, remain present.
Details
null or undefined → None
- Any other value →
Some (typed as NonNullable<A>)
Example (Converting nullable values to an Option)
import { Option } from "effect"
console.log(Option.fromNullishOr(undefined))
// Output: { _id: 'Option', _tag: 'None' }
console.log(Option.fromNullishOr(null))
// Output: { _id: 'Option', _tag: 'None' }
console.log(Option.fromNullishOr(1))
// Output: { _id: 'Option', _tag: 'Some', value: 1 }
fromNullishOr(f: (...a: A) => Bf(...a: A extends ReadonlyArray<unknown>a))