<S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>
<S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>Transforms values of a struct selectively using per-key functions. Keys without a corresponding function are copied unchanged.
When to use
Use when you want to update specific fields while keeping the rest intact.
Details
Each transform function receives the current value and returns the new value; the return type can differ from the input type.
Example (Transforming selected values)
import { pipe, Struct } from "effect"
const result = pipe(
{ name: "alice", age: 30, active: true },
Struct.evolve({
name: (s) => s.toUpperCase(),
age: (n) => n + 1
})
)
console.log(result) // { name: "ALICE", age: 31, active: true }export const const evolve: {
<S extends object, E extends Evolver<S>>(
e: E
): (self: S) => Evolved<S, E>
<S extends object, E extends Evolver<S>>(
self: S,
e: E
): Evolved<S, E>
}
Transforms values of a struct selectively using per-key functions. Keys
without a corresponding function are copied unchanged.
When to use
Use when you want to update specific fields while keeping the rest intact.
Details
Each transform function receives the current value and returns the new value;
the return type can differ from the input type.
Example (Transforming selected values)
import { pipe, Struct } from "effect"
const result = pipe(
{ name: "alice", age: 30, active: true },
Struct.evolve({
name: (s) => s.toUpperCase(),
age: (n) => n + 1
})
)
console.log(result) // { name: "ALICE", age: 31, active: true }
evolve: {
<function (type parameter) S in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>S extends object, function (type parameter) E in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>E extends type Evolver<S> = {
readonly [K in keyof S]?:
| ((a: S[K]) => unknown)
| undefined
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>S>>(e: E extends Evolver<S>e: function (type parameter) E in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>E): (self: S extends objectself: function (type parameter) S in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>S) => type Evolved<S, E> = {
[K in keyof {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}]: {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}[K]
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>S, function (type parameter) E in <S extends object, E extends Evolver<S>>(e: E): (self: S) => Evolved<S, E>E>
<function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S extends object, function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E extends type Evolver<S> = {
readonly [K in keyof S]?:
| ((a: S[K]) => unknown)
| undefined
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S>>(self: S extends objectself: function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S, e: E extends Evolver<S>e: function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E): type Evolved<S, E> = {
[K in keyof {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}]: {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}[K]
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S, function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E>
} = dual<(...args: Array<any>) => any, <S extends object, E extends Evolver<S>>(self: S, e: E) => Evolved<S, E>>(arity: 2, body: <S extends object, E extends Evolver<S>>(self: S, e: E) => Evolved<S, E>): ((...args: Array<any>) => any) & (<S extends object, E extends Evolver<S>>(self: S, e: E) => Evolved<S, E>) (+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) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S extends object, function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E extends type Evolver<S> = {
readonly [K in keyof S]?:
| ((a: S[K]) => unknown)
| undefined
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S>>(self: S extends objectself: function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S, e: E extends Evolver<S>e: function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E): type Evolved<S, E> = {
[K in keyof {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}]: {
[K in keyof S]: K extends keyof E
? E[K] extends (...a: any) => infer R
? R
: S[K]
: S[K]
}[K]
}
function (type parameter) S in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>S, function (type parameter) E in <S extends object, E extends Evolver<S>>(self: S, e: E): Evolved<S, E>E> => {
return function buildStruct<S, (k: keyof S, v: S[keyof S]) => [keyof S, any]>(source: S, f: (k: keyof S, v: S[keyof S]) => [keyof S, any]): anyWalk source; for each key decide what to emit via the small callback.
The callback returns either
• undefined → nothing is copied, or
• [newKey, newVal]
so every public API just supplies a different callback.
buildStruct(self: S extends objectself, (k: keyof Sk, v: S[keyof S]v) => [k: keyof Sk, var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.hasOwn(o: object, v: PropertyKey): booleanDetermines whether an object has a property with the specified name.
hasOwn(e: E extends Evolver<S>e, k: string | number | symbolk) ? (e: E extends Evolver<S>e as any)[k: keyof Sk](v: S[keyof S]v) : v: S[keyof S]v])
}
)