Functional programming with Ramda.js

2015-09-05 · [neiro]

JavaScript is one of the most dynamic, flexible programming languages. It supports multiple programming paradigms - imperative, object (prototype) oriented, scripting, and functional.
Let’ see what JavaScript has common with functional programming languages:

First-class functions - functions are objects themselves
Anonymous functions - functions can be unnamed and nested
Closures - functions that refer to independent variables, that were created in other scope
Recursion - function can call itself

By the way, there are some significant differences:

Immutability - objects, functions in JavaScript can be modified after creation
Pure functions - JavaScript functions often depends on outside scope, and it’s hard to create function that always returns the same result with given same parameters
Strong (and static) typing - JavaScript allows use a value of one type as if it were a value of another type, and has not static typing system

JavaScript ecosystem has great tools for advanced use of functional programming features, such as Underscore and Lodash - most popular toolkit libraries. But if you want use library, that was specifically designed for functional programming, you may have to look at Ramda.js .

Ramda.js has some distinguishing features:

It’s designed in pure functional style, with immutability and side-effects free functions, that helps you to write simple and effective code.
Parameters in functions have the same order, with key params at first and data at last
Ramda.js functions are automatically curried, that allows you to easily build new functions from old ones

To show examples of Ramda.js using, i will use io.js 3.2 and Babel, so let’s create new .js file:

1#!/usr/bin/env babel-node
2
3import R from 'ramda';

Ramda.js API has some general use functions:

 1
 2// Typing let str = 'test';
 3R.is(String, str); //=> true // The same with currying
 4R.is(String)(str); //=> true
 5let isString = R.is(String); isString('string'); //=> true
 6R.type(isString); //=> String
 7
 8// Math
 9R.add(100, 500); //=> 600
10R.add(100)(500); //=> 600
11R.mean([2,3,7]); //=> 4 R.sum(R.range(1, 5)); //=> 10
12
13// Logic
14R.and(true, false); //=> false
15R.and([])(0); //=> 0
16R.not(1);//=> false
17R.both(isString, R.is(String))(str); // => true

Like the Underscore and Lodash, Ramda has collection helper functions:

 1
 2// Lists
 3let animals = [ { name: 'goose',
 4type: 'bird', color: 'white' }, { name: 'parrot', type: 'bird', color:
 5'yellow' }, { name: 'cat', type: 'mammal', color: 'grey' }];
 6
 7R.map(animal => animal.color + ' ' + animal.name, animals); //=> [
 8'white goose', 'yellow parrot', 'grey cat' ] R.head(animals).name; //=>
 9goose R.last(animals).name; //=> cat
10R.uniq(R.pluck('type', animals)); //=> [ 'bird', 'mammal' ]
11R.length(R.filter(animal => animal.type === 'bird', animals)); //=> 2

And object helpers too:

 1
 2// Objects let cat = { type: 'animal',
 3subclass: 'mammal', binomialName: 'Felis catus' };
 4R.assoc('status', 'domesticated', cat).status; //=> domesticated
 5R.dissoc('binomialName', cat).binomialName; //=> undefined
 6R.keys(cat); //=> [ 'type', 'subclass', 'binomialName' ]
 7R.has('type', cat); //=> true
 8R.prop('type', cat); //=> animal
 9R.values(cat); //=> [ 'animal', 'mammal', 'felis catus' ]
10
11// Object transformation
12let transformations = { type: R.toUpper, binomialName: R.toLower }
13R.evolve(transformations, cat).type; // => ANIMAL

But key point of Ramda.js is functions. Ramda allows you to easily compose multiple functions in different orders:

1// Compose and pipe R.join(' and ',
2R.uniq(R.map(R.toUpper)(R.pluck('type', animals)))); //=> BIRD and MAMMAL
3// Performs right-to-left function composition
4R.compose(R.join(' and '), R.uniq, R.map(R.toUpper), R.pluck('type') )(animals);
5//=> BIRD and MAMMAL
6
7// Performs left-to-right function composition
8R.pipe(R.pluck('type') R.map(R.toUpper), R.uniq, R.join(' and ')
9)(animals); //=> BIRD and MAMMAL

Another power of Ramda is currying. Currying is the process of translating evaluation of function that takes multiple parameters in evaluating a sequence of functions, each with one argument.

1let tripleMultiply = (a, b, c) => a * b * c;
2tripleMultiply(3, 9, 2); //=> 54
3tripleMultiply(3, 9)(2); //=> TypeError: tripleMultiply(..) is not a function
4let curriedMultiply = R.curry(tripleMultiply);
5curriedMultiply(3, 9)(2); //=> 54
6curriedMultiply(3)(9)(2); //=> 54

Pattern matching is also available through R.cond. That allows you to check sequence of conditions to match different patterns:

1let checkNumber = R.cond([ [R.is(Number),
2R.identity], [R.is(String), parseInt], [R.is(Boolean), Number],
3[R.isEmpty, R.always(0)], [R.T, R.always(NaN)]]); checkNumber(100500); //=> 100500
4checkNumber('146%'); //=> 146
5checkNumber('Hodor'); //=> NaN
6checkNumber(true); //=> 1
7checkNumber(false); //=> 0
8checkNumber([]); //=> 0
9checkNumber(['test']); //=> NaN

Ramda.js is one of the best functional programming libraries that exists in JavaScript ecosystem. It can completely replace Underscore, Lodash in your project with own object, lists and others helpers. Immutability, currying and composing allows you to write both efficient and simple code in pure functional style.

#javascript #ramda #functional