<N extends string>(tag: N): <A>(
self: ReadonlyArray<A>
) => Array<{ [K in N]: A }>
<A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{
[K in N]: A
}>Wraps each array element in an object with the given key, starting a do-notation scope.
When to use
Use when you already have an array and want to start a do-notation pipeline by naming each element.
Details
Equivalent to Array.map(self, (a) => ({ [tag]: a })). This is an
alternative to starting with Do plus bind when you already have an array.
Example (Naming an existing array)
import { Array, pipe } from "effect"
const result = pipe(
[1, 2, 3],
Array.bindTo("x")
)
console.log(result) // [{ x: 1 }, { x: 2 }, { x: 3 }]export const const bindTo: {
<N extends string>(tag: N): <A>(
self: ReadonlyArray<A>
) => Array<{ [K in N]: A }>
<A, N extends string>(
self: ReadonlyArray<A>,
tag: N
): Array<{ [K in N]: A }>
}
Wraps each array element in an object with the given key, starting a do-notation scope.
When to use
Use when you already have an array and want to start a do-notation pipeline
by naming each element.
Details
Equivalent to Array.map(self, (a) => ({ [tag]: a })). This is an
alternative to starting with Do plus bind when you already have an array.
Example (Naming an existing array)
import { Array, pipe } from "effect"
const result = pipe(
[1, 2, 3],
Array.bindTo("x")
)
console.log(result) // [{ x: 1 }, { x: 2 }, { x: 3 }]
bindTo: {
<function (type parameter) N in <N extends string>(tag: N): <A>(self: ReadonlyArray<A>) => Array<{ [K in N]: A; }>N extends string>(tag: N extends stringtag: function (type parameter) N in <N extends string>(tag: N): <A>(self: ReadonlyArray<A>) => Array<{ [K in N]: A; }>N): <function (type parameter) A in <A>(self: ReadonlyArray<A>): Array<{ [K in N]: A; }>A>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A>(self: ReadonlyArray<A>): Array<{ [K in N]: A; }>A>) => interface Array<T>Array<{ [function (type parameter) KK in function (type parameter) N in <N extends string>(tag: N): <A>(self: ReadonlyArray<A>) => Array<{ [K in N]: A; }>N]: function (type parameter) A in <A>(self: ReadonlyArray<A>): Array<{ [K in N]: A; }>A }>
<function (type parameter) A in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>A, function (type parameter) N in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>N extends string>(self: readonly A[]self: interface ReadonlyArray<T>ReadonlyArray<function (type parameter) A in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>A>, tag: N extends stringtag: function (type parameter) N in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>N): interface Array<T>Array<{ [function (type parameter) KK in function (type parameter) N in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>N]: function (type parameter) A in <A, N extends string>(self: ReadonlyArray<A>, tag: N): Array<{ [K in N]: A; }>A }>
} = import internalDoNotationinternalDoNotation.const bindTo: <F extends TypeLambda>(
map: Map<F>
) => {
<N extends string>(name: N): <R, O, E, A>(
self: Kind<F, R, O, E, A>
) => Kind<F, R, O, E, Record<N, A>>
<R, O, E, A, N extends string>(
self: Kind<F, R, O, E, A>,
name: N
): Kind<F, R, O, E, Record<N, A>>
}
bindTo<ReadonlyArrayTypeLambda>(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) as any