<S extends ReadonlyArray<any>, B>(
f: (a: ReadonlyArray.Infer<S>, i: number) => B
): (self: S) => ReadonlyArray.With<S, B>
<S extends ReadonlyArray<any>, B>(
self: S,
f: (a: ReadonlyArray.Infer<S>, i: number) => B
): ReadonlyArray.With<S, B>Transforms each element using a function, returning a new array.
When to use
Use to transform each element independently while preserving the array shape.
Details
The function receives (element, index). The return type preserves
NonEmptyArray.
Example (Doubling values)
import { Array } from "effect"
console.log(Array.map([1, 2, 3], (x) => x * 2)) // [2, 4, 6]mappingflatMap
Source effect/Array.ts:34936 lines
export const const map: {
<S extends ReadonlyArray<any>, B>(
f: (a: ReadonlyArray.Infer<S>, i: number) => B
): (self: S) => ReadonlyArray.With<S, B>
<S extends ReadonlyArray<any>, B>(
self: S,
f: (a: ReadonlyArray.Infer<S>, i: number) => B
): ReadonlyArray.With<S, B>
}
Transforms each element using a function, returning a new array.
When to use
Use to transform each element independently while preserving the array shape.
Details
The function receives (element, index). The return type preserves
NonEmptyArray.
Example (Doubling values)
import { Array } from "effect"
console.log(Array.map([1, 2, 3], (x) => x * 2)) // [2, 4, 6]
map: {
<function (type parameter) S in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>S extends interface ReadonlyArray<T>ReadonlyArray<any>, function (type parameter) B in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>B>(
f: (
a: ReadonlyArray.Infer<S>,
i: number
) => B
a: ReadonlyArray.Infer<S>a: ReadonlyArray.type ReadonlyArray.Infer<S extends Iterable<any>> = S extends readonly (infer A)[] ? A : S extends Iterable<infer A> ? A : neverInfers the element type of an iterable.
Example (Inferring an element type)
import type { Array } from "effect"
type StringArrayType = Array.ReadonlyArray.Infer<ReadonlyArray<string>>
// StringArrayType is string
Infer<function (type parameter) S in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>S>, i: numberi: number) => function (type parameter) B in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>B
): (self: S extends ReadonlyArray<any>self: function (type parameter) S in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>S) => ReadonlyArray.type ReadonlyArray.With<S extends Iterable<any>, A> = S extends readonly [any, ...any[]] ? [A, ...A[]] : A[]Constructs an array type preserving non-emptiness.
Example (Preserving non-emptiness)
import type { Array } from "effect"
type Result = Array.ReadonlyArray.With<readonly [number], string>
// Result is NonEmptyArray<string>
With<function (type parameter) S in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>S, function (type parameter) B in <S extends ReadonlyArray<any>, B>(f: (a: ReadonlyArray.Infer<S>, i: number) => B): (self: S) => ReadonlyArray.With<S, B>B>
<function (type parameter) S in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>S extends interface ReadonlyArray<T>ReadonlyArray<any>, function (type parameter) B in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>B>(self: S extends ReadonlyArray<any>self: function (type parameter) S in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>S, f: (
a: ReadonlyArray.Infer<S>,
i: number
) => B
a: ReadonlyArray.Infer<S>a: ReadonlyArray.type ReadonlyArray.Infer<S extends Iterable<any>> = S extends readonly (infer A)[] ? A : S extends Iterable<infer A> ? A : neverInfers the element type of an iterable.
Example (Inferring an element type)
import type { Array } from "effect"
type StringArrayType = Array.ReadonlyArray.Infer<ReadonlyArray<string>>
// StringArrayType is string
Infer<function (type parameter) S in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>S>, i: numberi: number) => function (type parameter) B in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>B): ReadonlyArray.type ReadonlyArray.With<S extends Iterable<any>, A> = S extends readonly [any, ...any[]] ? [A, ...A[]] : A[]Constructs an array type preserving non-emptiness.
Example (Preserving non-emptiness)
import type { Array } from "effect"
type Result = Array.ReadonlyArray.With<readonly [number], string>
// Result is NonEmptyArray<string>
With<function (type parameter) S in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>S, function (type parameter) B in <S extends ReadonlyArray<any>, B>(self: S, f: (a: ReadonlyArray.Infer<S>, i: number) => B): ReadonlyArray.With<S, B>B>
} = dual<(...args: Array<any>) => any, <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B) => Array<B>>(arity: 2, body: <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B) => Array<B>): ((...args: Array<any>) => any) & (<A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B) => Array<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, i: number) => B): Array<B>A, function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>B>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>A>, f: (a: A, i: number) => Bf: (a: Aa: function (type parameter) A in <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>A, i: numberi: number) => function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>B): interface Array<T>Array<function (type parameter) B in <A, B>(self: ReadonlyArray<A>, f: (a: A, i: number) => B): Array<B>B> => self: readonly A[]self.globalThis.ReadonlyArray<A>.map<B>(callbackfn: (value: A, index: number, array: readonly A[]) => B, thisArg?: any): B[]Calls a defined callback function on each element of an array, and returns an array that contains the results.
map(f: (a: A, i: number) => Bf))Referenced by 13 symbols