map

From purrr v0.2.2.2 by Lionel Henry

Apply a function to each element of a vector

map() returns the transformed input; walk() calls .f for its side-effect and returns the original input. map() returns a list or a data frame; map_lgl(), map_int(), map_dbl() and map_chr() return vectors of the corresponding type (or die trying); map_df() returns a data frame by row-binding the individual elements.

Usage

map(.x, .f, ...)
map_lgl(.x, .f, ...)
map_chr(.x, .f, ...)
map_int(.x, .f, ...)
map_dbl(.x, .f, ...)
map_df(.x, .f, ..., .id = NULL)
walk(.x, .f, ...)

Arguments

.x

A list or atomic vector.

.f

A function, formula, or atomic vector.

If a function, it is used as is.

If a formula, e.g. ~ .x + 2, it is converted to a function with two arguments, .x or . and .y. This allows you to create very compact anonymous functions with up to two inputs.

If character or integer vector, e.g. "y", it is converted to an extractor function, function(x) x[["y"]]. To index deeply into a nested list, use multiple values; c("x", "y") is equivalent to z[["x"]][["y"]]. You can also set .null to set a default to use instead of NULL for absent components.

...

Additional arguments passed on to .f.

.id

If not NULL a variable with this name will be created giving either the name or the index of the data frame.

Details

Note that map() understands data frames, including grouped data frames. It can be much faster than mutate_each() when your data frame has many columns. However, map() will be slower for the more common case of many groups with functions that dplyr knows how to translate to C++.

Value

map() always returns a list.

map_lgl() returns a logical vector, map_int() an integer vector, map_dbl(), a double vector, map_chr(), a character vector. The output of .f will be automatically typed upwards, e.g. logical -> integer -> double -> character.

walk() (invisibly) the input .x. It's called primarily for its side effects, but this makes it easier to combine in a pipe.

Examples

# NOT RUN {
1:10 %>%
  map(rnorm, n = 10) %>%
  map_dbl(mean)

# Or use an anonymous function
1:10 %>%
  map(function(x) rnorm(10, x))

# Or a formula
1:10 %>%
  map(~ rnorm(10, .x))

# A more realistic example: split a data frame into pieces, fit a
# model to each piece, summarise and extract R^2
mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .x)) %>%
  map(summary) %>%
  map_dbl("r.squared")

# Use map_lgl(), map_dbl(), etc to reduce to a vector.
# * list
mtcars %>% map(sum)
# * vector
mtcars %>% map_dbl(sum)

# If each element of the output is a data frame, use
# map_df to row-bind them together:
mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .x)) %>%
  map_df(~ as.data.frame(t(as.matrix(coef(.)))))
# (if you also want to preserve the variable names see
# the broom package)
# }

Documentation reproduced from package purrr, version 0.2.2.2, License: GPL-3 | file LICENSE

Community examples

mftuchman@gmail.com at May 22, 2019 purrr v0.2.5

Expanding on the first example. Is it specified what the `.x` argument to `map` refers to when `.f` takes multiple arguments? ```{r} map(1:10,rnorm,mean=5) # length of vector is what ranges from 1 to 10, mean is 5 ``` ```{r} map(1:10,rnorm,n=20,mean=5) # sd is what ranges from 1 to 10 ```

map