
Мыслим в парадигме функционального программирования с Ramda
Статья будет полезна тем, кто хочет приоткрыть для себя дверь в мир функционального программирования. В начале рассмотрим отличия ООП и ФП, затем как сочетать функции друг с другом и в конце применим знаменитые фишки функционального подхода.
Давайте для начала разберемся с основными особенностями парадигмы функционального программирования, для простоты восприятия оттолкнемся от объектно-ориентированного подхода.
Отличия объектно-ориентированного и функционального подходов
Что такое ООП?
- Работаем с объектами, то есть классами и экземплярами этих классов;
- Пишем в императивном стиле;
- Классы тесно связаны между собой;
- Данные и методы по работе с классом лежат в самом классе. Эти данные должны быть инкапсулированы и доступ к ним должен осуществляться через геттеры/сеттеры и методы этого класса;
- Данные являются изменяемыми. Мы можем их изменить в любой момент работы нашего кода.
Что такое ФП?
- Работаем с функциями;
- Пишем в декларативном стиле;
- Каждая функция - самостоятельная единица;
- Используем чистые функции. Они не производят побочных эффектов, то есть не изменяют входные параметры, ничего не выводят, ничего не присваивают внешним переменным, не вызывают нечистые функции, не обращаются к внешним API, работают детерминировано;
- Данные являются иммутабельными.
Основное отличие в том, что в ФП важно не то, как мы хотим что-то получить, а что мы хотим получить.
С чего начать, чтобы мыслить в парадигме функционального программирования?
Сперва попробуем вместо циклов использовать итерационные функции. Применим те, которые дает нам Ramda :
// Замените это:
for (const value of someArray) {
console.log(value)
}
// на это:
R.forEach(value => console.log(value), someArray)Для операций с массивами, в Ramda имеются и другие:
// map:
R.map(x => x * 2, [1, 2, 3]) // --> [2, 4, 6]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]const summ = (accum, value) => accum + value
// reduce:
R.reduce(summ, 5, [1, 2, 3, 4]) // --> 15const isOdd = x => x % 2 !== 0
// find:
R.find(isOdd, [1, 2, 3, 4]) // --> 1Начинаем соединять функции
В предыдущих примерах мы применяли find для нахождения первого нечетного числа в массиве. Если бы у нас была задача найти первое четное число, мы создали бы isEven и использовали ее. Но мы знаем, что любое четное число не является нечетным. Здесь мы переиспользуем isOdd. В Ramda есть метод complement, который является функцией высшего порядка. Он принимает в себя isOdd. На выходе получится новая функция, возвращающая true, когда наша оригинальная isOdd возвращает false, и наоборот:
const isOdd = x => x % 2 !== 0
R.find(R.complement(isOdd), [1, 2, 3, 4]) // --> 2Она делает то же самое, что оператор !. Давайте запишем эту функции в переменную с соответствующим именем, чтобы мы могли переиспользовать её:
const isOdd = x => x % 2 !== 0
const isEven = R.complement(isOdd)
R.find(isEven, [1, 2, 3, 4]) // --> 2Существуют аналоги операторов && и || — функции both / either соответственно:
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 :
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) // --> trueconst 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Допустим, нужно обработать данные друг за другом, конвейером. Например, перемножить два числа, к произведению прибавить единицу, а результат возвести в квадрат:
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, где принимает список из нескольких функций, затем возвращает новую, которая ожидает на вход такое же количество параметров, что и первая в списке. После передает результат работы первой во вторую, и так далее. Результат работы заключительной функции в списке будет являться результатом прохождения всего конвейера. Есть ограничение, каждая функция после первой должна ожидать только один аргумент.
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 автоматически каррированы. Это означает, что вы можете вызывать функцию с меньшим количеством параметров, чем она требует, и она вернет «частично примененную». Функции будут продолжать возвращать новые пока все параметры не будут переданы. И когда будет передан последний параметр произойдет вызов последней функции, который вернет финальный результат.
R.add(1, 2) // --> 3
R.add(1)(2) // --> 3
const increment = R.add(1) // --> function
increment(2) // --> 3В Ramda так же есть функция curry, которая позволяет каррировать любую другую.
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Каррированые функции позволяют нам делать две важные вещи в функциональном программировании — специализацию и композицию.
Специализация происходит от возможности каррированых функций быть «частично примененными». Мы можем сохранить эти частично примененные методы в переменные и использовать позже.
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.
const increment = (x) => x + 1
const double = (x) => x * 2
const doublePlusOne = (x) => increment(double(x))
doublePlusOne(10) // --> 21Мы сделали композицию. Выглядит неплохо, но что будет если мы захотим сделать композицию из более чем двух?
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 и с ее помощью можем записать в более человеко-читаемой манере.
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, хотя это будет справедливо для любой из каррированых.
const mathPipe = R.pipe(
R.multiply(4),
R.add(2),
)
mathPipe(10) // --> 42В данном примере multiply и add принимают 2 параметра, но мы передали только один. Каждая из них вернула новую, которая ждет последнего параметра. Таким образом, когда мы вызываем mathPipe со значением 10, первая, частично примененная, возвращает нам 40 и затем это значение передается во вторую, частично примененную и в итоге мы получим 42.
На простых примерах мы рассмотрели, как функциональное программирование помогает писать более чистый код, который можно переиспользовать.

