To purrr or not to purrr
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.
Nicolas Attalides, Data Scientist
library(purrr) library(magrittr)
I first started using R long before the RStudio and tidyverse days… I remember writing chunks of code in a text editor and copy/pasting it into the R console! Yes I know, shocking. Nonetheless, most of us will have written code over the years that works just fine in base R, however in my case, the ever-growing adoption of the tidyverse packages (and my personal aspiration to improve my coding skills) has created a sense of necessity to re-write parts of it to fit within the tidyverse setting.
In this blog post I explore the purrr
package (part of tidyverse collection) and its use within a data
scientist’s toolset. I aim to present the case for using the purrr
functions and through the use of examples compare them with base R functionality. To do this, we will concentrate on two typical coding scenarios in base R: 1) loops and 2) the suite of apply functions and then compare them with their relevant counterpart map functions in the purrr
package.
However, before I start, I wanted to make it clear that I do sympathise with those of you whose first reaction to purrr
is “but I can do all this stuff in base R”. Putting that aside, the obvious first obstacle for us to overcome is to lose the notion of “if it’s not broken why change it” and open our ‘coding’ minds to change. At least, I hope you agree with me that the silver lining of this kind of exercise is to satisfy ones curiosity about the purrr
package and maybe learn something new!
Let us first briefly describe the concept of functional programming (FP) in case you are not familiar with it.
Functional programming (FP)
R is a functional programming language which means that a user of R has the necessary tools to create and manipulate functions. There is no need to go into too much depth here but it suffices to know that FP is the process of writing code in a structured way and through functions remove code duplications and redundancies. In effect, computations or evaluations are treated as mathematical functions and the output of a function only depends on the values of its inputs – known as arguments. FP ensures that any side-effects such as changes in state do not affect the expected output such that if you call the same function twice with the same arguments the function returns the same output.
For those that are interested to find out more, I suggest reading Hadley Wickham’s Functional Programming chapter in the “Advanced R” book. The companion website for this can be found here.
The purrr
package, which forms part of the tidyverse ecosystem of packages, further enhances the functional programming aspect of R. It allows the user to write functional code with less friction in a complete and consistent manner. The purrr
functions can be used, among other things, to replace loops and the suite of apply functions.
Let’s talk about loops
The motivation behind the examples we are going to look at involve iterating in R for various scenarios. For example, iterate over elements of a vector or list, iterate over rows or columns of a matrix … the list (pun intended) can go on and on!
One of the first things that one gets very excited to ‘play’ when learning to use R – at least that was the case for me – is loops! Lot’s of loops, elaborate, complex… dare I say never ending infinite loops (queue hysteric laughter emoji). Joking aside, it is usually the default answer to a problem that involves iteration of some sort as I demonstrate below.
# Create a vector of the mean values of all the columns of the mtcars dataset # The long repetitive way mean_vec <- c(mean(mtcars$mpg), mean(mtcars$cyl), mean(mtcars$disp), mean(mtcars$hp), mean(mtcars$drat), mean(mtcars$wt), mean(mtcars$qsec), mean(mtcars$vs), mean(mtcars$am), mean(mtcars$gear), mean(mtcars$carb)) mean_vec # The loop way mean_vec_loop <- vector("double", ncol(mtcars)) for (i in seq_along(mtcars)) { mean_vec_loop[[i]] <- mean(mtcars[[i]]) } mean_vec_loop
The resulting vectors are the same and the difference in speed (milliseconds) is negligible. I hope that we can all agree that the long way is definitely not advised and actually is bad coding practice, let alone the frustration (and error-prone task) of copy/pasting. Having said that, I am sure there are other ways to do this - I demonstrate this later using lapply
- but my aim was to show the benefit of using a for loop in base R for an iteration problem.
Now imagine if in the above example I wanted to calculate the variance of each column as well...
# Create two vectors of the mean and variance of all the columns of the mtcars dataset # For mean mean_vec_loop <- vector("double", ncol(mtcars)) for (i in seq_along(mtcars)) { mean_vec_loop[[i]] <- mean(mtcars[[i]]) } mean_vec_loop #For variance var_vec_loop <- vector("double", ncol(mtcars)) for (i in seq_along(mtcars)) { var_vec_loop[[i]] <- var(mtcars[[i]]) } var_vec_loop # Or combine both calculations in one loop for (i in seq_along(mtcars)) { mean_vec_loop[[i]] <- mean(mtcars[[i]]) var_vec_loop[[i]] <- var(mtcars[[i]]) } mean_vec_loop var_vec_loop
Now let us assume that we know that we want to create these vectors not just for the mtcars dataset but for other datasets as well. We could in theory copy/paste the for
loops and just change the dataset we supply in the loop but one should agree that this action is repetitive and could result to mistakes. Instead we can generalise this into functions. This is where FP comes into play.
# Create two functions that returns the mean and variance of the columns of a dataset # For mean col_mean <- function(df) { output <- vector("double", length(df)) for (i in seq_along(df)) { output[[i]] <- mean(df[[i]]) } output } col_mean(mtcars) #For variance col_variance <- function(df) { output <- vector("double", length(df)) for (i in seq_along(df)) { output[[i]] <- var(df[[i]]) } output } col_variance(mtcars)
Why not take this one step further and take full advantage of R's functional programming tools by creating a function that takes as an argument a function! Yes, you read it correctly... a function within a function!
Why do we want to do that? Well, the code for the two functions above, as clean as it might look, is still repetitive and the only real difference between col_mean
and col_var
is the mathematical function that we are calling. So why not generalise this further?
# Create a function that returns a computational value (such as mean or variance) # for a given dataset col_calculation <- function(df, fun) { output <- vector("double", length(df)) for (i in seq_along(df)) { output[[i]] <- fun(df[[i]]) } output } col_calculation(mtcars, mean) col_calculation(mtcars, var)
Did someone say apply?
I mentioned earlier that an alternative way to solve the problem is to use the apply
function (or suite of apply
functions such as lapply
, sapply
, vapply
, etc). In fact, these functions are what we call Higher Order Functions. Similar to what we did earlier, these are functions that can take other functions as an argument.
The benefit of using higher order functions instead of a for
loop is that they allow us to think about what code we are executing at a higher level. Think of it as: "apply this to that" rather than "take the first item, do this, take the next item, do this..."
I must admit that at first it might take a little while to get used to but there is definitely a sense of pride when you can improve your code by eliminating for
loops and replace them with apply-type functions.
# Create a list/vector of the mean values of all the columns of the mtcars dataset lapply(mtcars, mean) %>% head # Returns a list sapply(mtcars, mean) %>% head # Returns a vector
Once again, speed of execution is not the issue and neither is the common misconception about loops being slow compared to apply
functions. As a matter of fact the main argument in favour of using lapply
or any of the purrr
functions as we will see later is the pure simplicity and readability of the code. Full stop.
Enter the purrr
The best place to start when exploring the purrr
package is the map
function. The reader will notice that these functions are utilised in a very similar way to the apply
family of functions. The subtle difference is that the purrr
functions are consistent and the user can be assured of the output - as opposed to some cases when using for example sapply
as I demonstrate later on.
# Create a list/vector of the mean values of all the columns of the mtcars dataset map(mtcars, mean) %>% head # Returns a list map_dbl(mtcars, mean) %>% head # Returns a vector - of class double
Let us introduce the iris dataset with a slight modification in order to demonstrate the inconsistency that sometimes can occur when using the sapply
function. This can often cause issues with the code and introduce mystery bugs that are hard to spot.
# Modify iris dataset iris_mod <- iris iris_mod$Species <- ordered(iris_mod$Species) # Ordered factor levels class(iris_mod$Species) # Note: The ordered function changes the class # Extract class of every column in iris_mod sapply(iris_mod, class) %>% str # Returns a list of the results sapply(iris_mod[1:3], class) %>% str # Returns a character vector!?!? - Note: inconsistent object type
Since by default map
returns a list one can ensure that an object of the same class is returned without any unexpected (and unwanted) surprises. This is inline with FP consistency.
# Extract class of every column in iris_mod map(iris_mod, class) %>% str # Returns a list of the results map(iris_mod[1:3], class) %>% str # Returns a list of the results
To further demonstrate the consistency of the purrr
package in this type of setting, the map_*()
functions (see below) can be used to return a vector of the expected type, otherwise you get an informative error.
map_lgl()
makes a logical vector.map_int()
makes an integer vector.map_dbl()
makes a double vector.map_chr()
makes a character vector.
# Extract class of every column in iris_mod map_chr(iris_mod[1:4], class) %>% str # Returns a character vector map_chr(iris_mod, class) %>% str # Returns a meaningful error # As opposed to the equivalent base R function vapply vapply(iris_mod[1:4], class, character(1)) %>% str # Returns a character vector vapply(iris_mod, class, character(1)) %>% str # Returns a possibly harder to understand error
It is worth noting that if the user does not wish to rely on tidyverse dependencies they can always use base R functions but need to be extra careful of the potential inconsistencies that might arise.
Multiple arguments and neat tricks
In case we wanted to apply a function to multiple vector arguments we have the option of mapply
from base R or the map2
from purrr
.
# Create random normal values from a list of means and a list of standard deviations mu <- list(10, 100, -100) sigma <- list(0.01, 1, 10) mapply(rnorm, n = 5, mu, sigma, SIMPLIFY = FALSE) # I need SIMPLIFY = FALSE because otherwise I get a matrix map2(mu, sigma, rnorm, n = 5)
The map2
function can easily extend to further arguments - not just two as in the example above - and that is where the pmap
function comes in.
I also thought of sharing a couple of neat tricks that one can use with the map
function.
1) Say you want to fit a linear model for every cylinder type in the mtcars dataset. You can avoid code duplication and do it as follows:
# Split mtcars dataset by cylinder values and then fit a simple lm models <- mtcars %>% split(.$cyl) %>% # Split by cylinder into 3 lists map(function(df) lm(mpg ~ wt, data = df)) # Fit linear model for each list
2) Say we are using a function, such as sqrt
(calculate square root), on a list that contains a non-numeric element. The base R function lapply
throws an error and execution stops without knowing what caused the error. The safely
function of purrr
completes execution and the user can identify what caused the error.
x <- list(1, 2, 3, "e", 5) # Base R lapply(x, sqrt) # purrr package safe_sqrt <- safely(sqrt) safe_result_list <- map(x, safe_sqrt) %>% transpose safe_result_list$result
Conclusion
Overall, I think it is fair to say that using higher order functions in R is a great way to improve ones code. With that in mind, my closing remark for this blog post is to simply re-iterate the benefits of using the purrr
package. That is:
- The output is consistent.
- The code is easier to read and write.
If you enjoyed learning about purrr
, then you can join us at our purrr
workshop at this years EARL London - early bird tickets are available now!
R-bloggers.com offers daily e-mail updates about R news and tutorials about learning R and many other topics. Click here if you're looking to post or find an R/data-science job.
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.