Forem: ysael pepin

Functional programming basics part 3: Currying

ysael pepin — Sat, 02 Mar 2019 13:47:45 +0000

So what is this thing people are calling currying?

Currying is simply the action of converting a function that take multiple arguments into one that can support the ability to return a new function if the argument it got is not the last one.

If it is the last argument, it will execute.

Let's say I have a simple function:

const add = (x, y) => x + y;

If I try to call it with only one argument, it fails...

const add = (x, y) => x + y;

add(1) // undefined 
// (x is now 1 but y is undefined, so 1 + undefined = undefined)

Fortunately, modern JavaScript give us the ability to curry very easily via arrow functions.

Here is the same function curried:

const add = x => y => x + y;

add(1) // function add() 
/* (this newly returned function as encapsulated 
the value of 1 and will look like this --> y => 1 + y ) */

The nice thing about this is that now, we can call it with only one argument witch will return a new function that will expect one last argument y.

We could alternatively put that new returned function in a variable and start using it:

const add = x => y => x + y;

const add1 = add(1);


console.log(add1(1)) // 2

Hope that helps you understand what currying is :)

Functional programming basics part 2: Higher order function

ysael pepin — Mon, 17 Sep 2018 14:17:02 +0000

So what make a function of the highest order?

In order to be called a Higher order function, one must either take an other function as a parameter or return a function.

Take function as a parameter??? what? no way!!

Let's start by writing a simple function that is not from the highest order:

const addYtoX = (x, y) => x + y

Now lets try to pass this function to an other function:

const ofTheHighestOrder = (f, x, y) =>  f(x, y)

console.log (ofTheHighestOrder(addYtoX, 1, 2)) // 3

Woah that worked!! As you can see we can pass functions to other functions and use them like any other property!

Let's rename our highness to make it more declarative:

    const performOperation = (operation, x, y) =>  operation(x, y)

    console.log (performOperation(addYtoX, 1, 2)) // 3

That make senses right? I hope you can see at this point the value and the potential of a higher order function?

Let's see an other example:

    const addYtoX = (x, y) => x + y
    const multiplyYbyX = (x, y) => x * y
    const performOperation = (operation, x, y) =>  operation(x, y)

    console.log (performOperation(addYtoX, 1, 2)) // 3
    console.log (performOperation(multiplyYbyX, 1, 2)) // 2

Voilà!! There is so much more we can do with this but we will stop here for now and look at the second variation of a higher order function; a function that returns a function... humm that sound weird lets just write one and see if this works!

    const ofTheHighestOrder = () => {
        return poke = () => '... your highness?? '
    }

    console.log(ofTheHighestOrder()) // function poke()

Cool! As you can see we are able to return a function from a function!!! Let's fiddle a bit more with this guy:

    const ofTheHighestOrder = () => {
        return poke = () => '... your highness?? '
    }

    const willPoke = ofTheHighestOrder()

    console.log(willPoke()) // ... your highness??

Awesome! we can create other functions using a function that returns a function which make them of the highest order as well.

For now that might seem quite useless but that opens the door to a lot more possibilities that we will explore in further episodes.

Until then, stay high!

Functional programming basics part 1: Pure function

ysael pepin — Thu, 13 Sep 2018 01:23:49 +0000

What is purity?

Purity for a function is defined as one that will always return the same output for the same input and perform no side effects.

So what do we mean by same output for the same input?

well... lets see some examples...

lets say we have this code:

let y = 2
const addYtoX = (x) => x + y

This function is not considered pure as the output could be modified by the value of y witch mean we cannot guaranty it will return the same output for the same input.

let y = 2;
const addYtoX = (x) => x + y

console.log(addYtoX(3)) // 5

y = 1 
console.log(addYtoX(3)) // 4

As you can see the value of y will affect the output of the function even if we call it using the same input... this is definitely impure.

Lets look at the pure version of the same function:


const addYtoX = (x, y) => x + y

There you go!!!

I can call this guy as many times as I want and I can be sure to get the same output for the same input.

That's cool man, but what about that side effect thing?

well... lets see the same function but with added side effects!


const addYtoX = (x, y) => {
    makeSomeNoodles()
    return x + y
};

I hope you can guess the side effect is caused by the makeSomeNoodles function call right?

Why is that bad? Well... the function is suppose to add x to y and now it is making noodles before computing my values? And I have no idea what is happening during that function.... maybe it is actually crashing my simple function before it can execute or worst!!!

Anyway, I hope you get the basic idea. :)

Until next time... stay pure!