<const E>(element: E): <const T extends ReadonlyArray<unknown>>(
self: T
) => [...T, E]
<const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [
...T,
E
]Appends a single element to the end of a tuple.
When to use
Use when you need the appended value to remain part of the tuple's type-level shape and preserve literal element positions.
Details
The result type is [...T, E], preserving all existing element types.
Example (Appending an element)
import { pipe, Tuple } from "effect"
const result = pipe(Tuple.make(1, 2), Tuple.appendElement("end"))
console.log(result) // [1, 2, "end"]export const const appendElement: {
<const E>(element: E): <
const T extends ReadonlyArray<unknown>
>(
self: T
) => [...T, E]
<
const T extends ReadonlyArray<unknown>,
const E
>(
self: T,
element: E
): [...T, E]
}
Appends a single element to the end of a tuple.
When to use
Use when you need the appended value to remain part of the tuple's type-level
shape and preserve literal element positions.
Details
The result type is [...T, E], preserving all existing element types.
Example (Appending an element)
import { pipe, Tuple } from "effect"
const result = pipe(Tuple.make(1, 2), Tuple.appendElement("end"))
console.log(result) // [1, 2, "end"]
appendElement: {
<const function (type parameter) E in <const E>(element: E): <const T extends ReadonlyArray<unknown>>(self: T) => [...T, E]E>(element: const Eelement: function (type parameter) E in <const E>(element: E): <const T extends ReadonlyArray<unknown>>(self: T) => [...T, E]E): <const function (type parameter) T in <const T extends ReadonlyArray<unknown>>(self: T): [...T, E]T extends interface ReadonlyArray<T>ReadonlyArray<unknown>>(self: const T extends ReadonlyArray<unknown>self: function (type parameter) T in <const T extends ReadonlyArray<unknown>>(self: T): [...T, E]T) => [...function (type parameter) T in <const T extends ReadonlyArray<unknown>>(self: T): [...T, E]T, function (type parameter) E in <const E>(element: E): <const T extends ReadonlyArray<unknown>>(self: T) => [...T, E]E]
<const function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]T extends interface ReadonlyArray<T>ReadonlyArray<unknown>, const function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]E>(self: const T extends ReadonlyArray<unknown>self: function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]T, element: const Eelement: function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]E): [...function (type parameter) T in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]T, function (type parameter) E in <const T extends ReadonlyArray<unknown>, const E>(self: T, element: E): [...T, E]E]
} = dual<(...args: Array<any>) => any, <T extends ReadonlyArray<unknown>, E>(self: T, element: E) => [...T, E]>(arity: 2, body: <T extends ReadonlyArray<unknown>, E>(self: T, element: E) => [...T, E]): ((...args: Array<any>) => any) & (<T extends ReadonlyArray<unknown>, E>(self: T, element: E) => [...T, 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) T in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]T extends interface ReadonlyArray<T>ReadonlyArray<unknown>, function (type parameter) E in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]E>(self: T extends ReadonlyArray<unknown>self: function (type parameter) T in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]T, element: Eelement: function (type parameter) E in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]E): [...function (type parameter) T in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]T, function (type parameter) E in <T extends ReadonlyArray<unknown>, E>(self: T, element: E): [...T, E]E] => [...self: T extends ReadonlyArray<unknown>self, element: Eelement])