<A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>
<A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>Maps each element with a nullable-returning function, keeping only non-null / non-undefined results.
When to use
Use when you need to map and filter in one step, where the mapper can return
null or undefined to skip elements.
Example (Flat mapping with nullable values)
import { Array } from "effect"
console.log(Array.flatMapNullishOr([1, 2, 3], (n) => (n % 2 === 0 ? null : n)))
// [1, 3]export const const flatMapNullishOr: {
<A, B>(f: (a: A) => B): (
self: ReadonlyArray<A>
) => Array<NonNullable<B>>
<A, B>(
self: ReadonlyArray<A>,
f: (a: A) => B
): Array<NonNullable<B>>
}
Maps each element with a nullable-returning function, keeping only non-null /
non-undefined results.
When to use
Use when you need to map and filter in one step, where the mapper can return
null or undefined to skip elements.
Example (Flat mapping with nullable values)
import { Array } from "effect"
console.log(Array.flatMapNullishOr([1, 2, 3], (n) => (n % 2 === 0 ? null : n)))
// [1, 3]
flatMapNullishOr: {
<function (type parameter) A in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>A, function (type parameter) B in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>B>(f: (a: A) => Bf: (a: Aa: function (type parameter) A in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>A) => function (type parameter) B in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>B): (self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>A>) => interface Array<T>Array<type NonNullable<T> = T & {}Exclude null and undefined from T
NonNullable<function (type parameter) B in <A, B>(f: (a: A) => B): (self: ReadonlyArray<A>) => Array<NonNullable<B>>B>>
<function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A, function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A>, f: (a: A) => Bf: (a: Aa: function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A) => function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B): interface Array<T>Array<type NonNullable<T> = T & {}Exclude null and undefined from T
NonNullable<function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B>>
} = dual<(...args: Array<any>) => any, <A, B>(self: ReadonlyArray<A>, f: (a: A) => B) => Array<NonNullable<B>>>(arity: 2, body: <A, B>(self: ReadonlyArray<A>, f: (a: A) => B) => Array<NonNullable<B>>): ((...args: Array<any>) => any) & (<A, B>(self: ReadonlyArray<A>, f: (a: A) => B) => Array<NonNullable<B>>) (+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>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A, function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A>, f: (a: A) => Bf: (a: Aa: function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>A) => function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B): interface Array<T>Array<type NonNullable<T> = T & {}Exclude null and undefined from T
NonNullable<function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A) => B): Array<NonNullable<B>>B>> => const flatMap: {
<
S extends ReadonlyArray<any>,
T extends ReadonlyArray<any>
>(
f: (a: ReadonlyArray.Infer<S>, i: number) => T
): (
self: S
) => ReadonlyArray.AndNonEmpty<
S,
T,
ReadonlyArray.Infer<T>
>
<A, B>(
self: NonEmptyReadonlyArray<A>,
f: (
a: A,
i: number
) => NonEmptyReadonlyArray<B>
): NonEmptyArray<B>
<A, B>(
self: ReadonlyArray<A>,
f: (a: A, i: number) => ReadonlyArray<B>
): Array<B>
}
self: readonly A[]self, (a: Aa) => const fromNullishOr: <B>(
a: B
) => NonNullable<B>[]
Converts a nullable value to an array: null/undefined becomes [],
anything else becomes [value].
When to use
Use to treat a nullable single value as zero or one array element.
Example (Converting nullable values to an array)
import { Array } from "effect"
console.log(Array.fromNullishOr(1)) // [1]
console.log(Array.fromNullishOr(null)) // []
console.log(Array.fromNullishOr(undefined)) // []
fromNullishOr(f: (a: A) => Bf(a: Aa)))
)