<const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(
evolver: E
): (self: T) => Evolved<T, E>
<const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(
self: T,
evolver: E
): Evolved<T, E>Transforms elements of a tuple by providing an array of transform functions. Each function applies to the element at the same position. Positions beyond the array's length are copied unchanged.
When to use
Use when you want to update the first N elements while keeping the rest.
Details
Each transform function receives the current value and can return a different type.
Example (Transforming selected elements)
import { pipe, Tuple } from "effect"
const result = pipe(
Tuple.make("hello", 42, true),
Tuple.evolve([
(s) => s.toUpperCase(),
(n) => n * 2
])
)
console.log(result) // ["HELLO", 84, true]Source effect/Tuple.ts:2919 lines
export const const evolve: {
<
const T extends ReadonlyArray<unknown>,
const E extends Evolver<T>
>(
evolver: E
): (self: T) => Evolved<T, E>
<
const T extends ReadonlyArray<unknown>,
const E extends Evolver<T>
>(
self: T,
evolver: E
): Evolved<T, E>
}
Transforms elements of a tuple by providing an array of transform functions.
Each function applies to the element at the same position. Positions beyond
the array's length are copied unchanged.
When to use
Use when you want to update the first N elements while keeping the rest.
Details
Each transform function receives the current value and can return a different
type.
Example (Transforming selected elements)
import { pipe, Tuple } from "effect"
const result = pipe(
Tuple.make("hello", 42, true),
Tuple.evolve([
(s) => s.toUpperCase(),
(n) => n * 2
])
)
console.log(result) // ["HELLO", 84, true]
evolve: {
<const function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>T extends interface ReadonlyArray<T>ReadonlyArray<unknown>, const function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>E extends type Evolver<T> = {
readonly [I in keyof T]?:
| ((a: T[I]) => unknown)
| undefined
}
function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>T>>(evolver: const E extends Evolver<T>evolver: function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>E): (self: const T extends ReadonlyArray<unknown>self: function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>T) => type Evolved<T, E> = {
[I in keyof T]: I extends keyof E
? E[I] extends (...a: any) => infer R
? R
: T[I]
: T[I]
}
function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>T, function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(evolver: E): (self: T) => Evolved<T, E>E>
<const function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>T extends interface ReadonlyArray<T>ReadonlyArray<unknown>, const function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>E extends type Evolver<T> = {
readonly [I in keyof T]?:
| ((a: T[I]) => unknown)
| undefined
}
function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>T>>(self: const T extends ReadonlyArray<unknown>self: function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>T, evolver: const E extends Evolver<T>evolver: function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>E): type Evolved<T, E> = {
[I in keyof T]: I extends keyof E
? E[I] extends (...a: any) => infer R
? R
: T[I]
: T[I]
}
function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>T, function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): Evolved<T, E>E>
} = dual<(...args: Array<any>) => any, <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E) => unknown[]>(arity: 2, body: <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E) => unknown[]): ((...args: Array<any>) => any) & (<const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E) => unknown[]) (+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,
<const function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): unknown[]T extends interface ReadonlyArray<T>ReadonlyArray<unknown>, const function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): unknown[]E extends type Evolver<T> = {
readonly [I in keyof T]?:
| ((a: T[I]) => unknown)
| undefined
}
function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): unknown[]T>>(self: const T extends ReadonlyArray<unknown>self: function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): unknown[]T, evolver: const E extends Evolver<T>evolver: function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E extends Evolver<T>>(self: T, evolver: E): unknown[]E) => {
return self: const T extends ReadonlyArray<unknown>self.ReadonlyArray<unknown>.map<unknown>(callbackfn: (value: unknown, index: number, array: readonly unknown[]) => unknown, thisArg?: any): unknown[]Calls a defined callback function on each element of an array, and returns an array that contains the results.
map((e: unknowne, i: numberi) => (evolver: const E extends Evolver<T>evolver[i: numberi] !== var undefinedundefined ? evolver: const E extends Evolver<T>evolver[i: numberi](e: unknowne) : e: unknowne))
}
)