DEV Community: Paul Bricout

Programming concepts in JS: Currying 🍛

Paul Bricout — Sun, 04 Apr 2021 18:28:42 +0000

What does Currying mean?

According to Wikipedia:

"In mathematics and computer science, currying is the technique of converting a function that takes multiple arguments into a sequence of functions that each take a single argument."

Okay, but what does it mean?

Imagine that you have a function that takes a value in meters and a unit of distance as inputs and convert the value to the given unit, here is a basic implementation of such a function:

const convertMetersTo = (toUnit, value) => {
    switch (toUnit) {
        case 'mm':
            return value * 1000
        case 'cm':
            return value * 100
        case 'dm':
            return value * 10
        case 'm':
            return value * 1
        case 'dam':
            return value * 0.1
        case 'hm':
            return value * 0.01
        case 'km':
            return value * 0.001
    }
}

convertMetersTo('km', 3)  // returns 0.003

Now, currying this function means that we want to make it return another function in order to be sequential, taking our example we would change it to look like this:

const convertMetersTo = (toUnit) => (value) => {
    switch (toUnit) {
        case 'mm':
            return value * 1000
        case 'cm':
            return value * 100
        case 'dm':
            return value * 10
        case 'm':
            return value * 1
        case 'dam':
            return value * 0.1
        case 'hm':
            return value * 0.01
        case 'km':
            return value * 0.001
    }
}

convertMetersTo('km')(3) // returns 0.003

Okay, but why would I do that?

So, obviously both method works, but here is why I believe you should try to identify opportunities to curry functions. Let's say that you will use this function multiple times in a row (for one reason or another), in the first case you will write it as:

const convertedValue1 = convertMetersTo('km', value1)
const convertedValue2 = convertMetersTo('km', value2)
const convertedValue3 = convertMetersTo('km', value3)
const convertedValue4 = convertMetersTo('km', value4)

It is straightforward enough, but this is a simple example and remember that as a dev your job is too be as lazy as possible and avoid repeating yourself. With Currying, you would just need to declare the unit once, and then it gives a function that you can reuse as you like.

const convertMetersToKm = convertMetersTo('km')

const convertedValue1 = convertMetersToKm(value1)
const convertedValue2 = convertMetersToKm(value2)
const convertedValue3 = convertMetersToKm(value3)
const convertedValue4 = convertMetersToKm(value4)

Or, we could reverse the order of the arguments for, let's say, displaying one value in different units:

const convertMetersTo = (value) => (toUnit) => {
    switch (toUnit) {
        case 'mm':
            return value * 1000
        case 'cm':
            return value * 100
        case 'dm':
            return value * 10
        case 'm':
            return value * 1
        case 'dam':
            return value * 0.1
        case 'hm':
            return value * 0.01
        case 'km':
            return value * 0.001
    }
}

const value = 1000
const convertValueTo = convertMetersTo(value)

const convertedValue1 = convertValueTo('mm') // 1000000
const convertedValue2 = convertValueTo('cm') // 100000
const convertedValue3 = convertValueTo('dm') // 10000
const convertedValue4 = convertValueTo('km') // 1

Now imagine this with more complex functions: you get to avoid repetition and make your code simpler and more efficient.

In some other examples, you could have some computation made in the first function, and that way you avoid having your code making the same computation multiple time!

A couple of examples that React/Redux devs uses all the time

Redux's connect function

Redux's connect function is a good example of a use for currying, since it is a function that returns another function passing down mapped props from the redux store to our component.

It wouldn't be impossible nor unthinkable to use the same base connect function to pass down the same props to different component like so:

const RedPriceBase = ({ price }) => {
    return <p style={{ color: 'red' }}>{ price } in red!</p>
}

const BluePriceBase = ({ price }) => {
    return <p style={{ color: 'blue' }}>{ price } in blue!</p>
}

const mapStateToProps = (state) => {
    return {
        price: state.price
    }
}

// one redux connect function
const connector = connect(mapStateToProps)

// reused for two components
export const RedPrice = connector(RedPriceBase)
export const BluePriceBase = connector(BluePriceBase)

Redux Thunk

Here is what a typical Thunk Action used in redux looks like:
```
const fetchData = (params) => {
    return async (dispatch) => {
        dispatch(fetchDataRequest())
        try {
           const response = Api.fetchData(params)
           dispatch(fetchDataSuccess(response))
        } catch (e) {
            dispatch(fetchDataFailure(e))
        }
    }
}
```
The pattern looks familiar? Yup it's another example of currying! Here behind the scenes, when the action gets dispatched to the redux store, the redux-thunk middleware sees if the returned value of the action is a function (instead othe the typical action object with keys type and payload), and in that case it calls it with dispatch and getState!

Conclusion

This short article was made to explore what is currying in a programming context, how and why we could use it, and give some example for JS devs to give a better understanding. Currying is such a simple concept that I would love to see implemented in more and more codebases!

I don't write a lot of articles, this is the second write I wrote in a year, but I would love to get on writing more often about programming and such so if you have feedback to give me, as well as ideas and suggestions on how I could make this article better and easier to read, please leave a comment saying so!

Automating stuff on your computer with cron jobs (with any language)

Paul Bricout — Sun, 15 Dec 2019 12:15:45 +0000

This post was made on mac, works also on Linux, for windows you might want to use scheduled tasks instead.

Hey, in this tutorial I will explain how to automate stuff by running a script at a specific time on your computer using the magic of cron jobs. I'll take the example of cleaning your download folder, but you can be creative and go crazy with this!

Also, note that I'm using python as an example because I think that it fits this purpose well, but you could use any language!

1) What are Cron Jobs?

A Cron Job is a command specific to Unix-like systems (e.g. Linux or macOS) that allows to schedule future tasks to be repeated at a certain interval. Very useful for automating things on your server (such as a CI pipeline for example), it can also be used to automate boring things too.

These intervals are coded following this scheme:

Examples:

* * * * 1 \<command\> : Executes the command every minutes on Mondays
*/5 * * * * \<command\> : Executes the command every 5 minutes
0 */6 * * * \<command\> : Executes the command every 6 hours at 00 minutes.

These commands can be very customizable, go to Crontab Guru to play around and find you perfect interval.

2) How to set up a cron job?

So as an example I made a python script that looks for file that haven't been modified since three weeks and deletes them, it also shows a desktop notification when running.

If you want to do the same copy this file and put it in your download folder. It works on mac, but could easily be modified for linux (or windows).

Please also note that Python isn't my main language, I just use it for small scripts. 😅

Once you have downloaded this, go to your command line and type:

env EDITOR=nano crontab -e

This will open a text file in the nano editor. Then write:

0 */4 * * * (cd ~/Downloads/ && python cleanup.py)

This will automate the script and run it every 4 hours at 00 minutes. If you want to add more scripts to run, just add line and writ another command! Once you're done hit control+O and enter to save and control+X to exit.

And here you go, the scripts is running without you needing to do anything:

3) Further commands with crontab:

To list all current cronjobs: crontab -l
To add a line or edit or delete a particular line use the previous env EDITOR=nano crontab -e command and edit the line, save and you're good to go.
To erase everything use: crontab -r

And here we are, you know everything you need to start automating the boring tasks on your computer! Here my example was pretty simple, but using more complex scripts and a bit of networking you could do crazy things, like automating your whole file system, organizing your mails (using GMail's API), and many other things!

This is my first tutorial ever, so please feel free to leave a constructive comment on what I could have done better for the next ones.