Функции высшего порядка

[1, 2, 3].map((x) => x * 2);
[1, 2, 3].filter((x) => x > 1);
[1, 2, 3].reduce((acc, x) => acc + x, 0);

setTimeout(() => console.log('позже'), 1000);
element.addEventListener('click', handler);

function multiplier(factor) {
    return (n) => n * factor;
}

const double = multiplier(2);
double(5); // 10

function compose(...fns) {
    return (x) => fns.reduceRight((acc, fn) => fn(acc), x);
}

[1, 2, 3].forEach((item, index, array) => {
    console.log(item, index);
});

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

const evens = [1, 2, 3, 4].filter((x) => x % 2 === 0); // [2, 4]

const sum = [1, 2, 3].reduce((acc, x) => acc + x, 0); // 6

const counted = ['a', 'b', 'a'].reduce((acc, x) => {
    acc[x] = (acc[x] ?? 0) + 1;
    return acc;
}, {});

[1, 2, 3].some((x) => x > 2);   // true
[1, 2, 3].every((x) => x > 0);  // true

[1, 2, 3].find((x) => x > 1);       // 2
[1, 2, 3].findIndex((x) => x > 1);  // 1

[1, 2].flatMap((x) => [x, x * 2]); // [1, 2, 2, 4]

[3, 1, 2].sort((a, b) => a - b); // [1, 2, 3]

const pipe = (...fns) => (x) => fns.reduce((acc, fn) => fn(acc), x);

const process = pipe(
    (x) => x * 2,
    (x) => x + 1,
    (x) => x.toString(),
);

process(5); // '11'

const compose = (...fns) => (x) => fns.reduceRight((acc, fn) => fn(acc), x);

function debounce(fn, delay) {
    let timer;

    return (...args) => {
        clearTimeout(timer);
        timer = setTimeout(() => fn(...args), delay);
    };
}

const search = debounce((query) => console.log(query), 500);

function throttle(fn, delay) {
    let last = 0;

    return (...args) => {
        const now = Date.now();
        if (now - last >= delay) {
            last = now;
            fn(...args);
        }
    };
}

function once(fn) {
    let called = false;
    let result;

    return (...args) => {
        if (!called) {
            called = true;
            result = fn(...args);
        }
        return result;
    };
}

async function retry(fn, attempts = 3, delay = 1000) {
    for (let i = 0; i < attempts; i++) {
        try {
            return await fn();
        } catch (e) {
            if (i === attempts - 1) throw e;
            await new Promise((r) => setTimeout(r, delay));
        }
    }
}

function indexBy(items, key) {
    return items.reduce((acc, item) => {
        acc[item[key]] = item;
        return acc;
    }, {});
}