pmap  R Documentation 
These functions are variants of map()
that iterate over multiple arguments
simultaneously. They are parallel in the sense that each input is processed
in parallel with the others, not in the sense of multicore computing, i.e.
they share the same notion of "parallel" as base::pmax()
and base::pmin()
.
pmap(.l, .f, ..., .progress = FALSE)
pmap_lgl(.l, .f, ..., .progress = FALSE)
pmap_int(.l, .f, ..., .progress = FALSE)
pmap_dbl(.l, .f, ..., .progress = FALSE)
pmap_chr(.l, .f, ..., .progress = FALSE)
pmap_vec(.l, .f, ..., .ptype = NULL, .progress = FALSE)
pwalk(.l, .f, ..., .progress = FALSE)
.l 
A list of vectors. The length of Vectors of length 1 will be recycled to any length; all other elements must be have the same length. A data frame is an important special case of 
.f 
A function, specified in one of the following ways:

... 
Additional arguments passed on to the mapped function. We now generally recommend against using # Instead of x > map(f, 1, 2, collapse = ",") # do: x > map(\(x) f(x, 1, 2, collapse = ",")) This makes it easier to understand which arguments belong to which function and will tend to yield better error messages. 
.progress 
Whether to show a progress bar. Use 
.ptype 
If 
The output length is determined by the length of the input. The output names are determined by the input names. The output type is determined by the suffix:
No suffix: a list; .f()
can return anything.
_lgl()
, _int()
, _dbl()
, _chr()
return a logical, integer, double,
or character vector respectively; .f()
must return a compatible atomic
vector of length 1.
_vec()
return an atomic or S3 vector, the same type that .f
returns.
.f
can return pretty much any type of vector, as long as its length 1.
walk()
returns the input .x
(invisibly). This makes it easy to
use in a pipe. The return value of .f()
is ignored.
Any errors thrown by .f
will be wrapped in an error with class
purrr_error_indexed.
Other map variants:
imap()
,
lmap()
,
map2()
,
map_depth()
,
map_if()
,
map()
,
modify()
x < list(1, 1, 1)
y < list(10, 20, 30)
z < list(100, 200, 300)
pmap(list(x, y, z), sum)
# Matching arguments by position
pmap(list(x, y, z), function(first, second, third) (first + third) * second)
# Matching arguments by name
l < list(a = x, b = y, c = z)
pmap(l, function(c, b, a) (a + c) * b)
# Vectorizing a function over multiple arguments
df < data.frame(
x = c("apple", "banana", "cherry"),
pattern = c("p", "n", "h"),
replacement = c("P", "N", "H"),
stringsAsFactors = FALSE
)
pmap(df, gsub)
pmap_chr(df, gsub)
# Use `...` to absorb unused components of input list .l
df < data.frame(
x = 1:3,
y = 10:12,
z = letters[1:3]
)
plus < function(x, y) x + y
## Not run:
# this won't work
pmap(df, plus)
## End(Not run)
# but this will
plus2 < function(x, y, ...) x + y
pmap_dbl(df, plus2)
# The "p" for "parallel" in pmap() is the same as in base::pmin()
# and base::pmax()
df < data.frame(
x = c(1, 2, 5),
y = c(5, 4, 8)
)
# all produce the same result
pmin(df$x, df$y)
map2_dbl(df$x, df$y, min)
pmap_dbl(df, min)
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.