Карування (Currying) · fullstack.org.ua

Просунутий19 хв· Fullstack Team

Карування (Currying)

Познайомтеся з каруванням — перетворенням функції з кількома параметрами на послідовність функцій, кожна з яких приймає один аргумент. Розберіть практичне застосування цього підходу у функціональному програмуванні.

Що таке карування

Карування (англ. currying) — це перетворення функції, яка приймає кілька аргументів одночасно, на послідовність функцій, кожна з яких приймає один аргумент.

Наприклад, функцію:

javascript

const add = (a, b, c) => a + b + c;

javascript

const formatPrice = (currency) => (locale) => (amount) => {
  return new Intl.NumberFormat(locale, {
    style: "currency",
    currency,
  }).format(amount);
};

const formatInUah = formatPrice("UAH");
const formatInUahForUkraine = formatInUah("uk-UA");

console.log(formatInUahForUkraine(1250.5));
// 1 250,50 грн

javascript

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }

    return (...nextArgs) => curried(...args, ...nextArgs);
  };
}

function calculateTotal(taxRate, discount, price) {
  const priceWithTax = price * (1 + taxRate);
  return priceWithTax * (1 - discount);
}

const curriedCalculateTotal = curry(calculateTotal);

console.log(curriedCalculateTotal(0.2)(0.1)(100)); // 108
console.log(curriedCalculateTotal(0.2, 0.1)(100)); // 108
console.log(curriedCalculateTotal(0.2)(0.1, 100)); // 108

javascript

function curryN(arity, fn) {
  return function curried(...args) {
    if (args.length >= arity) {
      return fn(...args);
    }

    return (...nextArgs) => curried(...args, ...nextArgs);
  };
}

const sumThree = curryN(
  3,
  (a, b, c) => a + b + c,
);

console.log(sumThree(1)(2)(3)); // 6

javascript

const map = curry((callback, items) => items.map(callback));

const filter = curry((predicate, items) => items.filter(predicate));

const greaterThan = curry((minimum, value) => value > minimum);

const multiplyBy = curry((factor, value) => factor * value);

const numbers = [1, 2, 3, 4, 5, 6];

const greaterThanThree = filter(greaterThan(3));
const doubled = map(multiplyBy(2));

const result = doubled(greaterThanThree(numbers));

console.log(result); // [8, 10, 12]

javascript

function pipe(...functions) {
  return (initialValue) => {
    return functions.reduce(
      (value, fn) => fn(value),
      initialValue,
    );
  };
}

const map = curry((callback, items) => items.map(callback));
const filter = curry((predicate, items) => items.filter(predicate));
const greaterThan = curry((minimum, value) => value > minimum);
const multiplyBy = curry((factor, value) => factor * value);

const processNumbers = pipe(
  filter(greaterThan(2)),
  map(multiplyBy(10)),
);

console.log(processNumbers([1, 2, 3, 4])); // [30, 40]

javascript

const calculator = {
  base: 10,

  add(value, multiplier) {
    return (this.base + value) * multiplier;
  },
};

const curriedAdd = curry(calculator.add);

// Значення this втрачається під час передавання методу окремо.
console.log(curriedAdd(5)(2)); // NaN

javascript

const createUrl = (protocol, host, path) => {
  return `${protocol}://${host}/${path}`;
};

const curriedCreateUrl = curry(createUrl);

// Тут "example.com" стане protocol, а не host.

javascript

const __ = Symbol("placeholder");

function curryWithPlaceholder(fn, arity = fn.length) {
  function curried(...receivedArgs) {
    const hasEnoughArguments =
      receivedArgs.length >= arity &&
      receivedArgs.slice(0, arity).every((argument) => argument !== __);

    if (hasEnoughArguments) {
      return fn(...receivedArgs);
    }

    return (...nextArgs) => {
      const mergedArgs = [...receivedArgs];
      let nextIndex = 0;

      for (let index = 0; index < mergedArgs.length; index += 1) {
        if (mergedArgs[index] === __ && nextIndex < nextArgs.length) {
          mergedArgs[index] = nextArgs[nextIndex];
          nextIndex += 1;
        }
      }

      while (nextIndex < nextArgs.length) {
        mergedArgs.push(nextArgs[nextIndex]);
        nextIndex += 1;
      }

      return curried(...mergedArgs);
    };
  }

  return curried;
}

const createUrl = (protocol, host, path) => {
  return `${protocol}://${host}/${path}`;
};

const curriedCreateUrl = curryWithPlaceholder(createUrl);

const createExampleUrl = curriedCreateUrl("https", __, "docs");
console.log(createExampleUrl("example.com"));
// https://example.com/docs

javascript

const createLogger = curry((prefix, message) => {
  console.log(`[${prefix}] ${message}`);
});

const logError = createLogger("ERROR");

logError("Не вдалося завантажити дані");
logError("Недійсний формат відповіді");

javascript

const curry = (fn) => {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }

    return (...nextArgs) => curried(...args, ...nextArgs);
  };
};

const fetchJson = curry(async (baseUrl, endpoint, options) => {
  const response = await fetch(`${baseUrl}${endpoint}`, options);

  if (!response.ok) {
    throw new Error(`HTTP-помилка: ${response.status}`);
  }

  return response.json();
});

const fetchFromApi = fetchJson("https://api.example.com");

async function loadUser() {
  try {
    const user = await fetchFromApi("/users/42", {
      method: "GET",
    });

    console.log(user);
  } catch (error) {
    console.error(error.message);
  }
}

loadUser();

javascript

class User {
  constructor(role, name) {
    this.role = role;
    this.name = name;
  }
}

const createUser = curry((role, name) => {
  return new User(role, name);
});

const createAdmin = createUser("admin");

console.log(createAdmin("Olena"));
// User { role: 'admin', name: 'Olena' }

javascript

const curry = (fn) => {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }

    return (...nextArgs) => curried(...args, ...nextArgs);
  };
};

const minLength = curry((length, value) => {
  return value.length >= length;
});

const hasAtLeastEightCharacters = minLength(8);

console.log(hasAtLeastEightCharacters("JavaScript")); // true
console.log(hasAtLeastEightCharacters("JS")); // false

Карування (Currying)

Що таке карування

Карування та часткове застосування