dfdlT

• dfdlT(fn, arity?: boolean)
• dfdlT(fn, isDataFirst: (args: IArguments) => boolean)

Same as dfdl but allows explicit type definitions, which is in particularly useful if you want to use generics or additional overloads:

Example (Generics)

import { dfdlT } from "@monstermann/dfdl";

const map = dfdlT<
    <T, U>(fn: (item: T) => U) => (arr: T[]) => U[],
    <T, U>(arr: T[], fn: (item: T) => U) => U[]
>((arr, fn) => arr.map(fn));

Example (Overloads)

import { dfdlT } from "@monstermann/dfdl";

const map: {
    <T, U>(fn: (item: T) => U): (arr: T[]) => U[];
    <T, U>(arr: T[], fn: (item: T) => U): U[];
} = dfdlT(<T, U>(arr: T[], fn: (item: T) => U): U[] => arr.map(fn));

Data-first

map([1, 2, 3], (x) => x * 2); // [2, 4, 6]

Data-last

map((x) => x * 2)([1, 2, 3]); // [2, 4, 6]

pipe(
    [1, 2, 3],
    map((x) => x * 2),
); // [2, 4, 6]

TIP

Typically when defining your functions in this case, you should experience better type inference when using NoInfer:

const map = dfdlT<
    <T, U>(fn: (item: NoInfer<T>) => U) => (arr: T[]) => U[],
    <T, U>(arr: T[], fn: (item: NoInfer<T>) => U) => U[]
>((arr, fn) => arr.map(fn));