(onUndefined: () => unknown): <A>(self: A | undefined) => A
<A>(self: A | undefined, onUndefined: () => unknown): AReturns the defined value, or throws the value produced by onUndefined
when the input is undefined.
When to use
Use when you need fail-fast unwrapping of an A | undefined value and want
to provide the thrown error for the undefined case.
Details
Defined values are returned unchanged. When the input is undefined,
onUndefined is called and its result is thrown.
export const const getOrThrowWith: {
(onUndefined: () => unknown): <A>(
self: A | undefined
) => A
<A>(
self: A | undefined,
onUndefined: () => unknown
): A
}
Returns the defined value, or throws the value produced by onUndefined
when the input is undefined.
When to use
Use when you need fail-fast unwrapping of an A | undefined value and want
to provide the thrown error for the undefined case.
Details
Defined values are returned unchanged. When the input is undefined,
onUndefined is called and its result is thrown.
getOrThrowWith: {
(onUndefined: () => unknownonUndefined: () => unknown): <function (type parameter) A in <A>(self: A | undefined): AA>(self: A | undefinedself: function (type parameter) A in <A>(self: A | undefined): AA | undefined) => function (type parameter) A in <A>(self: A | undefined): AA
<function (type parameter) A in <A>(self: A | undefined, onUndefined: () => unknown): AA>(self: A | undefinedself: function (type parameter) A in <A>(self: A | undefined, onUndefined: () => unknown): AA | undefined, onUndefined: () => unknownonUndefined: () => unknown): function (type parameter) A in <A>(self: A | undefined, onUndefined: () => unknown): AA
} = dual<(...args: Array<any>) => any, <A>(self: A | undefined, onUndefined: () => unknown) => A>(arity: 2, body: <A>(self: A | undefined, onUndefined: () => unknown) => A): ((...args: Array<any>) => any) & (<A>(self: A | undefined, onUndefined: () => unknown) => A) (+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>(self: A | undefined, onUndefined: () => unknown): AA>(self: A | undefinedself: function (type parameter) A in <A>(self: A | undefined, onUndefined: () => unknown): AA | undefined, onUndefined: () => unknownonUndefined: () => unknown): function (type parameter) A in <A>(self: A | undefined, onUndefined: () => unknown): AA => {
if (self: A | undefinedself !== var undefinedundefined) {
return self: A & ({} | null)self
}
throw onUndefined: () => unknownonUndefined()
})