<B, A, C = B>(options: {
readonly onNone: LazyArg<B>
readonly onSome: (a: A) => C
}): (self: Option<A>) => B | C
<A, B, C = B>(
self: Option<A>,
options: { readonly onNone: LazyArg<B>; readonly onSome: (a: A) => C }
): B | CPattern-matches on an Option, handling both None and Some cases.
When to use
Use when you need to handle both Some and None in one expression and
transform an Option into a plain value.
Details
- If
None, callsonNoneand returns its result - If
Some, callsonSomewith the value and returns its result - Supports the
dualAPI (data-last and data-first)
Example (Matching on an Option)
import { Option } from "effect"
const message = Option.match(Option.some(1), {
onNone: () => "Option is empty",
onSome: (value) => `Option has a value: ${value}`
})
console.log(message)
// Output: "Option has a value: 1"export const const match: {
<B, A, C = B>(options: {
readonly onNone: LazyArg<B>
readonly onSome: (a: A) => C
}): (self: Option<A>) => B | C
<A, B, C = B>(
self: Option<A>,
options: {
readonly onNone: LazyArg<B>
readonly onSome: (a: A) => C
}
): B | C
}
Pattern-matches on an Option, handling both None and Some cases.
When to use
Use when you need to handle both Some and None in one expression and
transform an Option into a plain value.
Details
- If
None, calls onNone and returns its result
- If
Some, calls onSome with the value and returns its result
- Supports the
dual API (data-last and data-first)
Example (Matching on an Option)
import { Option } from "effect"
const message = Option.match(Option.some(1), {
onNone: () => "Option is empty",
onSome: (value) => `Option has a value: ${value}`
})
console.log(message)
// Output: "Option has a value: 1"
match: {
<function (type parameter) B in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) A in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) C in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) B in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
options: {
readonly onNone: LazyArg<B>
readonly onSome: (a: A) => C
}
onNone: LazyArg<B>onNone: type LazyArg<A> = () => AA zero-argument function that produces a value when invoked.
When to use
Use to type a lazy value provider that should not run until called.
Example (Creating a lazy argument)
import { Function } from "effect"
const constNull: Function.LazyArg<null> = Function.constant(null)
LazyArg<function (type parameter) B in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
onSome: (a: A) => ConSome: (a: Aa: function (type parameter) A in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) C in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
self: Option<A>self: 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) A in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) B in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) C in <B, A, C = B>(options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): (self: Option<A>) => B | C
function (type parameter) A in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
self: Option<A>self: 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) A in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
options: {
readonly onNone: LazyArg<B>
readonly onSome: (a: A) => C
}
onNone: LazyArg<B>onNone: type LazyArg<A> = () => AA zero-argument function that produces a value when invoked.
When to use
Use to type a lazy value provider that should not run until called.
Example (Creating a lazy argument)
import { Function } from "effect"
const constNull: Function.LazyArg<null> = Function.constant(null)
LazyArg<function (type parameter) B in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
onSome: (a: A) => ConSome: (a: Aa: function (type parameter) A in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, options: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
dual<(...args: Array<any>) => any, <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}) => B | C>(arity: 2, body: <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}) => B | C): ((...args: Array<any>) => any) & (<A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}) => B | C) (+1 overload)
Creates a function that can be called in data-first style or data-last
(pipe-friendly) style.
When to use
Use to expose one implementation through both direct and pipe-friendly
call styles.
Details
Pass either the arity of the uncurried function or a predicate that decides
whether the current call is data-first. Arity is the common case. Use a
predicate when optional arguments make arity ambiguous.
Example (Selecting data-first or data-last style by arity)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(2, (self, that) => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Defining overloads with call signatures)
import { Function, pipe } from "effect"
const sum: {
(that: number): (self: number) => number
(self: number, that: number): number
} = Function.dual(2, (self: number, that: number): number => self + that)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
Example (Selecting data-first or data-last style with a predicate)
import { Function, pipe } from "effect"
const sum = Function.dual<
(that: number) => (self: number) => number,
(self: number, that: number) => number
>(
(args) => args.length === 2,
(self, that) => self + that
)
console.log(sum(2, 3)) // 5
console.log(pipe(2, sum(3))) // 5
dual(
2,
<function (type parameter) A in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
self: Option<A>self: 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) A in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
onNone: LazyArg<B>onNone, onSome: (a: A) => ConSome }: {
readonly onNone: LazyArg<B>onNone: type LazyArg<A> = () => AA zero-argument function that produces a value when invoked.
When to use
Use to type a lazy value provider that should not run until called.
Example (Creating a lazy argument)
import { Function } from "effect"
const constNull: Function.LazyArg<null> = Function.constant(null)
LazyArg<function (type parameter) B in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
onSome: (a: A) => ConSome: (a: Aa: function (type parameter) A in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) B in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
function (type parameter) C in <A, B, C = B>(self: Option<A>, { onNone, onSome }: {
readonly onNone: LazyArg<B>;
readonly onSome: (a: A) => C;
}): B | C
const isNone: <A>(
self: Option<A>
) => self is None<A>
Checks whether an Option is None (absent).
When to use
Use when you need to branch on an absent Option before accessing .value.
Details
- Acts as a type guard, narrowing to
None<A>
Example (Checking for None)
import { Option } from "effect"
console.log(Option.isNone(Option.some(1)))
// Output: false
console.log(Option.isNone(Option.none()))
// Output: true
isNone(self: Option<A>self) ? onNone: LazyArg<B>onNone() : onSome: (a: A) => ConSome(self: Option<A>(parameter) self: {
_tag: "Some";
_op: "Some";
value: A;
valueOrUndefined: A;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
toString: () => string;
toJSON: () => unknown;
}
Some<A>.value: Avalue)
)