Discover functional programming patterns with RamdaJS. Learn about pure functions, currying, and point-free style while deepening your knowledge of map, filter, and reduce methods.

We know the functional programming (FP) hype train's been riding strong the past few years, especially in the JavaScript community. We extol FP in countless books, videos, and blog posts, with no sign of slowing down.

As a result this course isn't to convince you, today's JS developer, of how awesome FP is. I'm simply sharing some popular patterns using Ramda, an FP library that I've blogged on many times.

Before going through them, though, we will lay the groundwork with concepts like pure functions, currying, and point-free style.

You're already doing FP through map, filter, reduce, and Lodash, so why not dive a bit deeper and see if you like it down here?

Functional Programming Patterns With RamdaJS!

Time for some exercises! While doing them take a look at [Ramda's docs](https://ramdajs.com/docs/#) to see what functions can help you.

Remember point-free means your data's not visible.

// sum is NOT point-free...
// nums parameter is showing
const sum = (nums) => nums.reduce((x, y) => x + y, 0);

// sum is point-free
import { add, reduce } from 'ramda';
const sum = reduce(add, 0);

// This is okay too,
// but inner function (x, y) => {} isn't point-free
import { reduce } from 'ramda';
const sum = reduce((x, y) => x + y, 0);


#### Exercise 1
This code tells you if a given sentence contains "Bobo", regardless of case. Refactor it to be point-free.

https://ramdajs.com/docs/#test

// Uncommenting this import may help :D
// import R from 'ramda';

const countBobos = (sentence) => /bobo/ig.test(sentence);


// You can import all of Ramda
import R from 'ramda';

// Or just the function you need (recommended)
import { test } from 'ramda';

// But either one is correct
const countBobos1 = R.test(/bobo/ig);
const countBobos2 = test(/bobo/ig);




#### Exercise 2
This code tells you if someone should consider a tech career. Refactor it to be point-free.

https://ramdajs.com/docs/#ifElse 
https://ramdajs.com/docs/#where

// import R from 'ramda';

const shouldCode = (person) => (
  person.lovesTech && person.worksHard ?
    `${person.name} may enjoy a tech career!` :
    `${person.name} wouldn't enjoy a tech career.`
);


import { equals, ifElse, where } from 'ramda';

// Even though the two inner functions show a person
// parameter, shouldCode() itself is still point-free.
// Each function's independently judged from the others.
const shouldCode = ifElse(
  where({
	  lovesTech: equals(true),
  	worksHard: equals(true),
  }),
  (person) => `${person.name} may enjoy a tech career!`,
  (person) => `${person.name} wouldn't enjoy a tech career.`
);


#### Exercise 3
This code returns everyone's `age`. Refactor it to be point-free.

https://ramdajs.com/docs/#map 
https://ramdajs.com/docs/#prop 
https://ramdajs.com/docs/#pluck

// import R from 'ramda';

const getAges = (people) => people.map((person) => person.age);


import { map, pluck, prop } from 'ramda';

// You may have done this
const getAges1 = map(prop('age'));
// And you'd be correct :D

// But this works too
const getAges2 = pluck('age');

#### Exercise 4
This code rejects everyone under 18, and over 25. Refactor it to be point-free.

https://ramdajs.com/docs/#filter 
https://ramdajs.com/docs/#propSatisfies

// import R from 'ramda';

const keepYoungAdults = (people) => people.filter((p) => (
 p.age >= 18 && p.age <= 25
));

import { both, filter, gte, lte, propSatisfies } from 'ramda';

const youngAdultAge = both(gte(18), lte(25));
const isYoungAdult = propSatisfies(youngAdultAge, 'age');
const keepYoungAdults1 = filter(isYoungAdult);

// You can also apply the opposite logic with reject()
import { either, gt, lt, propSatisfies, reject } from 'ramda';

const notYoungAdultAge = either(gt(18), lt(25));
const isNotYoungAdult = propSatisfies(notYoungAdultAge, 'age');
const keepYoungAdults2 = reject(isNotYoungAdult);


#### Exercise 5
Create a function called `defaultTo`. It takes two parameters:

* `defaultVal`: A default value
* `val`: The value to return

If `val` is `null` or `undefined`, return `defaultVal`.
 
Else, return `val`.

Curry it to allow preloading arguments.

```javascript
const defaultToBobo = defaultTo('Bobo');

defaultToBobo(null); // 'Bobo'
defaultToBobo('Patrick'); // 'Patrick'
```

import { curry } from 'ramda';

const defaultTo = curry((defaultVal, val) => val == null ? defaultVal : val);





# Exercise 1
This code tells you if a given sentence contains "Bobo", regardless of case. Refactor it to be point-free.

https://ramdajs.com/docs/#test

# Exercise 2
This code tells you if someone should consider a tech career. Refactor it to be point-free.

https://ramdajs.com/docs/#ifElse 
https://ramdajs.com/docs/#where

# Exercise 3
This code returns everyone's `age`. Refactor it to be point-free.

https://ramdajs.com/docs/#map 
https://ramdajs.com/docs/#prop 
https://ramdajs.com/docs/#pluck

# Exercise 4
This code rejects everyone under 18, and over 25. Refactor it to be point-free.

https://ramdajs.com/docs/#filter 
https://ramdajs.com/docs/#propSatisfies

# Exercise 5
Create a function called `defaultTo`. It takes two parameters:

* `defaultVal`: A default value
* `val`: The value to return

If `val` is `null` or `undefined`, return `defaultVal`.
 
Else, return `val`.

Curry it to allow preloading arguments.

```javascript
const defaultToBobo = defaultTo('Bobo');

defaultToBobo(null); // 'Bobo'
defaultToBobo('Patrick'); // 'Patrick'
```

Exercises with problem, solution, and explanation.

Introduction

Pure Functions

Higher-Order Functions

Function Composition

Currying

Pipe and Compose

Sorting

Conditional Logic

Using What We've Learned

Functors

Lenses

Lenses Exercises

Building a Wikipedia Search

Closing Comments

Spicy Exercises

Exercise 1

Exercise 2

Exercise 3

Exercise 4

Exercise 5