Functional programming in R (with purrr)

Purrr is a set of tools allowing consistent functional programming in R in a tidyverse style (using magrittr pipes and following the same naming conventions found in other tidyverse packages).

As Hadley Wickham says, in many ways, purrr is the equivalent of the dplyr, but while dplyr focuses on data frames, purrr works on vectors: it works on the elements of atomic vectors, lists, and data frames. Since R's most basic data structure is the vector, this makes purrr extremely powerful and flexible.

Install it with:

install.packages("tidyverse")
## or
install.packages("purrr")

Load it with:

library(tidyverse)
## or
library(purrr)

As always, once the package is loaded, you can get information on the package with:

?purrr

and on any of its functions with:

?function
## e.g. for the map function
?map

map(.x, .f, ...)

.x     a list or atomic vector
.f     a function, formula, or atomic vector
...     additional arguments passed to .f

For every element of .x, apply .f.

What we have, in the simplest case, is:

map(list, function)

length(banding)

So, back to our example, we do have a list: a list of vectors. That's what our banding data frame is! So no problem about applying map() to it.

map(banding[4:6], mean)

banding[4:6] %>% map(mean)

However, the output of map() is always a list. And a list as output is not really convenient here. There are other map functions which have vector or data frame outputs. To get a numeric vector as the output, we use map_dbl():

map_dbl(banding[4:6], mean)

banding[4:6] %>% map_dbl(mean)

Similarly, you can calculate the variance, the sum, look for the largest value, or apply any other function to our data.

map_dbl(banding[4:6], var)
map_dbl(banding[4:6], sum)
map_dbl(banding[4:6], max)

Now, imagine that you would like to plot the relationship between tarsus and mass for each population.

for (i in unique(banding$population)) {
  print(ggplot(banding %>% filter(population == i),
               aes(tarsus, mass)) + geom_point())
}

banding %>%
  split(.$population) %>%
  map(~ ggplot(., aes(tarsus, mass)) + geom_point())

graphs <-
  banding %>%
  split(.$population) %>%
  map(~ ggplot(., aes(tarsus, mass)) + geom_point())

modify(.x, .f, ...)
modify_if(.x, .p, .f, ...)
modify_at(.x, .at, .f, ...)

.x     a list or atomic vector
.f     a function, formula, or atomic vector
...    additional arguments passed to .f
.p     a predicate function.
       Only the elements for which .p evaluates to TRUE will be modified
.at    a character vector of names or a numeric vector of positions.
       Only the elements corresponding to .at will be modified

For every element of .x, apply .f, and return a modified version of .x.

So basically, in its simplest form, we have:

modify(list, function)

walk(.x, .f, ...)

.x     a list or atomic vector
.f     a function, formula, or atomic vector
...     additional arguments passed to .f

We already have a list of graphs: graphs. Now, we can create a list of paths where we want to save them:

paths <- paste0("population_", names(graphs), ".png")

So we want to save each element of graphs into an element of paths. The function we will use is ggsave. To apply it to all of our elements, instead of using map, we will use walk because we are not trying to create a new object.

The problem is that we have 2 lists to deal with. Map and walk only allow to deal with one list. But map2 and walk2 allow to deal with 2 lists (pmap and pwalk allow to deal with any number of lists).

Here is how walk2 works (it is the same for map2):

walk2(.x, .y, .f, ...)

.x, .y   vectors of the same length.
         A vector of length 1 will be recycled.
.f       a function, formula, or atomic vector
...       additional arguments passed to .f

walk2(paths, graphs, ggsave)