Логотип
Разработчикам

Мыслим в парадигме функционального программирования с Ramda

Евгений Жиленко

Фронтенд-разработчик

Статья будет полезна тем, кто хочет приоткрыть для себя дверь в мир функционального программирования. В начале рассмотрим отличия ООП и ФП, затем как сочетать функции друг с другом и в конце применим знаменитые фишки функционального подхода.

Давайте для начала разберемся с основными особенностями парадигмы функционального программирования, для простоты восприятия оттолкнемся от объектно-ориентированного подхода.

Отличия объектно-ориентированного и функционального подходов

Что такое ООП?

  1. Работаем с объектами, то есть классами и экземплярами этих классов;
  2. Пишем в императивном стиле;
  3. Классы тесно связаны между собой;
  4. Данные и методы по работе с классом лежат в самом классе. Эти данные должны быть инкапсулированы и доступ к ним должен осуществляться через геттеры/сеттеры и методы этого класса;
  5. Данные являются изменяемыми. Мы можем их изменить в любой момент работы нашего кода.

Что такое ФП?

  1. Работаем с функциями;
  2. Пишем в декларативном стиле;
  3. Каждая функция - самостоятельная единица;
  4. Используем чистые функции. Они не производят побочных эффектов, то есть не изменяют входные параметры, ничего не выводят, ничего не присваивают внешним переменным, не вызывают нечистые функции, не обращаются к внешним API, работают детерминировано;
  5. Данные являются иммутабельными.

Основное отличие в том, что в ФП важно не то, как мы хотим что-то получить, а что мы хотим получить.

С чего начать, чтобы мыслить в парадигме функционального программирования?

Сперва попробуем вместо циклов использовать итерационные функции. Применим те, которые дает нам Ramda :

JavaScript
// Замените это:
for (const value of someArray) {
  console.log(value)
}

// на это:
R.forEach(value => console.log(value), someArray)

Для операций с массивами, в Ramda имеются и другие:

JavaScript
// map:
R.map(x => x * 2, [1, 2, 3])  // --> [2, 4, 6]
JavaScript
const isOdd = x => x % 2 !== 0

// filter:
R.filter(isOdd, [1, 2, 3, 4])  // --> [1, 3]

// reject:
R.reject(isOdd, [1, 2, 3, 4])  // --> [2, 4]
JavaScript
const summ = (accum, value) => accum + value

// reduce:
R.reduce(summ, 5, [1, 2, 3, 4]) // --> 15
JavaScript
const isOdd = x => x % 2 !== 0

// find:
R.find(isOdd, [1, 2, 3, 4]) // --> 1

Начинаем соединять функции

В предыдущих примерах мы применяли find для нахождения первого нечетного числа в массиве. Если бы у нас была задача найти первое четное число, мы создали бы isEven и использовали ее. Но мы знаем, что любое четное число не является нечетным. Здесь мы переиспользуем isOdd. В Ramda есть метод complement, который является функцией высшего порядка. Он принимает в себя isOdd. На выходе получится новая функция, возвращающая true, когда наша оригинальная isOdd возвращает false, и наоборот:

JavaScript
const isOdd = x => x % 2 !== 0

R.find(R.complement(isOdd), [1, 2, 3, 4]) // --> 2

Она делает то же самое, что оператор !. Давайте запишем эту функции в переменную с соответствующим именем, чтобы мы могли переиспользовать её:

JavaScript
const isOdd = x => x % 2 !== 0
const isEven = R.complement(isOdd)

R.find(isEven, [1, 2, 3, 4]) // --> 2

Существуют аналоги операторов && и || — функции both / either соответственно:

JavaScript
const isInRange = R.both(x => x > 0, x => x < 10);

isInRange(11) // --> false
isInRange(5) // --> true

const isOutOfRange = R.either((x) => x < 0, (x) => x > 10);

isOutOfRange(-1) // --> true
isOutOfRange(5) // --> false
isOutOfRange(11) // --> true

В Ramda также присутствуют allPass и anyPass :

JavaScript
const isEnouthScore = player => player.score > 1000
const isEnouthKeys = player => player.keys > 2
const isEnouthTasks = player => player.tasksComplited > 4

const canPassToNextLevel = R.anyPass([isEnouthScore, isEnouthKeys, isEnouthTasks]);

const player1 = {
  score: 900,
  keys: 1,
  tasksComplited: 3,
}

const player2 = {
  score: 800,
  keys: 1,
  tasksComplited: 5,
}

canPassToNextLevel(player1) // --> false
canPassToNextLevel(player2) // --> true
JavaScript
const isEnouthScore = player => player.score > 1000
const isEnouthKeys = player => player.keys > 2
const isEnouthTasks = player => player.tasksComplited > 4

const canPassToNextLevel = R.allPass([isEnouthScore, isEnouthKeys, isEnouthTasks]);

const player1 = {
  score: 1200,
  keys: 3,
  tasksComplited: 6,
}

const player2 = {
  score: 1100,
  keys: 1,
  tasksComplited: 5,
}

canPassToNextLevel(player1) // --> true
canPassToNextLevel(player2) // --> false

Допустим, нужно обработать данные друг за другом, конвейером. Например, перемножить два числа, к произведению прибавить единицу, а результат возвести в квадрат:

JavaScript
const multiply = (a, b) => a * b
const addOne = x => x + 1
const square = x => x * x

const operate = (x, y) => {
  const product = multiply(x, y)
  const incremented = addOne(product)
  const squared = square(incremented)

  return squared
}

operate(3, 4) // => ((3 * 4) + 1)^2 => (12 + 1)^2 => 13^2 => 169

Заметьте, что каждая последующая функция применяется к результату предыдущей в конвейере. Ramda предоставляет инструмент pipe, где принимает список из нескольких функций, затем возвращает новую, которая ожидает на вход такое же количество параметров, что и первая в списке. После передает результат работы первой во вторую, и так далее. Результат работы заключительной функции в списке будет являться результатом прохождения всего конвейера. Есть ограничение, каждая функция после первой должна ожидать только один аргумент.

JavaScript
const multiply = (a, b) => a * b
const addOne = x => x + 1
const square = x => x * x

const operate = R.pipe(
  multiply,
  addOne,
  square
)

operate(3, 4) // --> 169

Все функции в Ramda автоматически каррированы. Это означает, что вы можете вызывать функцию с меньшим количеством параметров, чем она требует, и она вернет «частично примененную». Функции будут продолжать возвращать новые пока все параметры не будут переданы. И когда будет передан последний параметр произойдет вызов последней функции, который вернет финальный результат.

JavaScript
R.add(1, 2) // --> 3

R.add(1)(2) // --> 3

const increment = R.add(1) // --> function

increment(2) // --> 3

В Ramda так же есть функция curry, которая позволяет каррировать любую другую.

JavaScript
const add = (a, b) => a + b

add(1, 2) // --> 3
add(1)(2) // --> Uncaught TypeError: add(...) is not a function

const curriedAdd = R.curry(add)

curriedAdd(1, 2) // --> 3
curriedAdd(1)(2) // --> 3

Каррированые функции позволяют нам делать две важные вещи в функциональном программировании — специализацию и композицию.

Специализация происходит от возможности каррированых функций быть «частично примененными». Мы можем сохранить эти частично примененные методы в переменные и использовать позже.

JavaScript
const sweets = [
  {
    name: 'cookie',
    price : 1,
  },
  {
    name: 'candy',
    price : 2,
  },
  {
    name: 'cake',
    price : 3,
  },
]
//Создаем функцию, которая применяет скидку к сладости
const applyDiscount = (discount, sweet) => (
  {...sweet, price: sweet.price - sweet.price*(discount / 100)}
)

//Каррируем эту функцию
const curredApplyDiscount = R.curry(applyDiscount);

//Частично применяем каррированую функцию
const applyTenPersentDiscount = curredApplyDiscount(10);
const applyFiftheenPersentDiscount = curredApplyDiscount(15);

R.map(applyTenPersentDiscount, sweets)
//[{"name": "cookie", "price": 0.9}, {"name": "candy", "price": 1.8}, {"name": "cake", "price": 2.7}]

R.map(applyFiftheenPersentDiscount, sweets)
//[{"name": "cookie", "price": 0.85}, {"name": "candy", "price": 1.7}, {"name": "cake", "price": 2.55}]

Другая важная концепция — это композиция функций. Мы можем комбинировать так, чтобы получить новую функцию. Тут мы создали новую, которая возвращает результат работы обеих double и increment.

JavaScript
const increment = (x) => x + 1
const double = (x) => x * 2

const doublePlusOne = (x) => increment(double(x))

doublePlusOne(10) // --> 21

Мы сделали композицию. Выглядит неплохо, но что будет если мы захотим сделать композицию из более чем двух?

JavaScript
const increment = (x) => x + 1
const double = (x) => x * 2
const square = (x) => x * x
const halve = (x) => x / 2

const calculateThings = (x) => halve(square(increment(double(x))))

calculateThings(10) // --> 220.5

Теперь это выглядит плохо. Но мы уже знаем pipe и с ее помощью можем записать в более человеко-читаемой манере.

JavaScript
const increment = (x) => x + 1
const double = (x) => x * 2
const square = (x) => x * x
const halve = (x) => x / 2

const calculateThings = R.pipe(double, increment , square, halve)

calculateThings(10) // --> 220.5

Это же можно применить и к каррированым. Возьмем для примера встроенные функции Ramda, хотя это будет справедливо для любой из каррированых.

JavaScript
const mathPipe = R.pipe(
  R.multiply(4),
  R.add(2),
)
mathPipe(10) // --> 42

В данном примере multiply и add принимают 2 параметра, но мы передали только один. Каждая из них вернула новую, которая ждет последнего параметра. Таким образом, когда мы вызываем mathPipe со значением 10, первая, частично примененная, возвращает нам 40 и затем это значение передается во вторую, частично примененную и в итоге мы получим 42.

На простых примерах мы рассмотрели, как функциональное программирование помогает писать более чистый код, который можно переиспользовать.

Оцените статью:
4,92,7к151