11 Other purrr functions

In this reading, you’ll learn about two more map variants, map_dfr() and map_dfc(). Then, you’ll learn about walk(), as well as some useful purrr functions that work with functions that return either TRUE or FALSE.

The purrr package contains more functions than we can cover. The purrr cheatsheet is a great way to find helpful functions when you encounter a new type of iteration problem.

11.1 map functions that output tibbles

Instead of creating an atomic vector or list, the map variants map_dfr() and map_dfc() create a tibble.

With these map functions, the assembly line worker creates a tibble for each input element, and the output conveyor belt ends up with a collection of tibbles.

The worker then combines all the small tibbles into a single, larger tibble. There are multiple ways to combine smaller tibbles into a larger tibble. map_dfr() (r for rows) stacks the smaller tibbles on top of each other.

map_dfc() (c for columns) stacks them side-by-side.

There are _dfr and _dfc variants of pmap() and map2() as well. In the following sections, we’ll cover map_dfr() and map_dfc() in more detail.

11.1.1 _dfr

map_dfr() is useful when reading in data from multiple files. The following code reads in several very simple csv files, each of which contains the name of a different dinosaur genus.

read_csv() produces a tibble, and so we can use map_dfr() to map over all three file names and bind the resulting individual tibbles into a single tibble.

The result is a tibble with three rows and two columns, because map_dfr() aligns the columns of the individual tibbles by name.

The individual tibbles can have different numbers of rows or columns. map_dfr() just creates a column for each unique column name. If some of the individual tibbles lack a column that others have, map_dfr() fills in with NA values.

11.1.2 _dfc

map_dfc() is typically less useful than map_dfr() because it relies on row position to stack the tibbles side-by-side. Row position is prone to error, and it will often be difficult to check if the data in each row is aligned correctly. However, if you have data with variables in different places and are positive the rows are aligned, map_dfc() may be appropriate.

Unfortunately, even if the individual tibbles contain a unique identifier for each row, map_dfc() doesn’t use the identifiers to verify that the rows are aligned correctly, nor does it combine identically named columns.

Instead, you end up with a duplicated column (id and id1).

If you have a unique identifier for each row, it is much better to join on that identifier.

Also, because map_dfc() combines tibbles by row position, the tibbles can have different numbers of columns, but must have the same number of rows.

The following files have different numbers of rows, and so map_dfc() produces an error.

11.2 Walk

The walk functions work similarly to the map functions, but you use them when you’re interested in applying a function that performs an action instead of producing data (e.g., print()).

The walk functions are useful for performing actions like writing files and printing plots. For example, say we used purrr to generate a list of plots.

We can now use walk() to print them out.

The walk functions look like they don’t return anything, but they actually return their input invisibly. When functions return something invisibly, it just means they don’t print their return value out when you call them. This functionality makes the walk functions useful in pipes. You can call a walk function to perform an action, get your input back, and continue operating on that input.

11.3 Predicate functions

In Chapter 6, we introduced predicate functions, which are functions that return a single TRUE or FALSE. purrr includes several useful functions that work with predicate functions.

keep() and discard() iterate over a vector and keep or discard only those elements for which the predicate function returns TRUE.

With tibbles, you can use keep() and discard() to select columns that meet a certain condition.

some() looks at the entire input vector and returns TRUE if the predicate is true for any element of the vector and FAlSE otherwise.

For every() to return TRUE, every element of the vector must meet the predicate.

Other useful purrr functions that use predicate functions include head_while(), compact(), has_element(), and detect(). Take a look at the purrr cheatsheet for details.