<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>
} = import dualdual(
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))
}
)