Use the purrr::reduce() and purrr::accumulate() family of functionals.
Use purrr::safely() and purrr::possibly() to deal with failure.
9.1. Introduction
9.2. map()
9.3. purrr style
9.4. map_ variants
9.5. reduce() and accumulate family of functions
Some functions that weren’t covered
What are functionals
Introduction
Functionals are functions that take function as input and return a vector as output. Functionals that you probably have used before are: apply(), lapply() or tapply().
alternatives to loops
a functional is better than a for loop is better than while is better than repeat
Benefits
encourages function logic to be separated from iteration logic
can collapse into vectors/data frames easily
Map
map() has two arguments, a vector and a function. It performs the function on each element of the vector and returns a list. We can also pass in some additional argument into the function.
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 25 3 27 22 22 29 30 2 2 3 6
map_dbl(mtcars, ~length(unique(.x)))
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 25 3 27 22 22 29 30 2 2 3 6
map_dbl(mtcars, ~length(unique(..1)))
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 25 3 27 22 22 29 30 2 2 3 6
map_dbl(mtcars, ~length(unique(.)))
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 25 3 27 22 22 29 30 2 2 3 6
# not the taskmap_dbl(mtcars, length)
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 32 32 32 32 32 32 32 32 32 32 32
map_dbl(mtcars, length(unique))
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 21.00 6.00 160.00 110.00 3.90 2.62 16.46 0.00 1.00 4.00 4.00
map_dbl(mtcars, 1)
#> mpg cyl disp hp drat wt qsec vs am gear carb
#> 21.00 6.00 160.00 110.00 3.90 2.62 16.46 0.00 1.00 4.00 4.00
#errormap_dbl(mtcars, length(unique()))
#> Error in unique.default(): argument "x" is missing, with no default
map_dbl(mtcars, ~length(unique(x)))
#> Error in `map_dbl()`:
#> ℹ In index: 1.
#> ℹ With name: mpg.
#> Caused by error in `.f()`:
#> ! object 'x' not found
Modify
Sometimes we might want the output to be the same as the input, then in that case we can use the modify function rather than map
df <-data.frame(x=1:3,y=6:4)map(df, .f=~.x*3)
#> $x
#> [1] 3 6 9
#>
#> $y
#> [1] 18 15 12
modify(.x=df,.f=~.x*3)
#> x y
#> 1 3 18
#> 2 6 15
#> 3 9 12
Note that modify() always returns the same type of output (which is not necessarily true with map()). Additionally, modify() does not actually change the value of df.
df
#> x y
#> 1 1 6
#> 2 2 5
#> 3 3 4
purrr style
mtcars |>map(head, 20) |># pull first 20 of each columnmap_dbl(mean) |># mean of each vectorhead()
tt <- tidytuesdayR::tt_load("2020-06-30")# filter data & exclude columns with lost of nullslist_df <-map(.x = tt[1:3], .f =~ .x |>filter(issue <=152| issue >200) |>mutate(timeframe =ifelse(issue <=152, "first 5 years", "last 5 years")) |>select_if(~mean(is.na(.x)) <0.2) )# write to global environmentiwalk(.x = list_df,.f =~assign(x = .y, value = .x, envir =globalenv()))
map_*() variants
There are many variants
map2_*()
raise each value .x by 2
map_dbl(.x =1:5, .f =function(x) x ^2)
#> [1] 1 4 9 16 25
raise each value .x by another value .y
map2_dbl(.x =1:5, .y =2:6, .f =~ (.x ^ .y))
#> [1] 1 8 81 1024 15625
The benefit of using the map over apply family of function
It is written in C
It preserves names
We always know the return value type
We can apply the function for multiple input values
We can pass additional arguments into the function
walk()
We use walk() when we want to call a function for it side effect(s) rather than its return value, like generating plots, write.csv(), or ggsave(). If you don’t want a return value, map() will print more info than you may want.
cat() does have a result, it’s just usually returned invisibly.
cat("hello")
#> hello
(cat("hello"))
#> hello
#> NULL
We can use pwalk() to save a list of plot to disk. Note that the “p” in pwalk() means that we have more than 1 (or 2) variables to pipe into the function. Also note that the name of the first argument in all of the “p” functions is now .l (instead of .x).
walk, walk2 and pwalk all invisibly return .x the first argument. This makes them suitable for use in the middle of pipelines.
note: I don’t think that it is “.x” (or “.l”) that they are returning invisibly. But I’m not sure what it is. Hadley says:
purrr provides the walk family of functions that ignore the return values of the .f and instead return .x invisibly.
But not in the first cat() example, it is the NULL values that get returned invisibly (those aren’t the same as .x).
imap()
imap() is like map2()except that .y is derived from names(.x) if named or seq_along(.x) if not.
These two produce the same result
imap_chr(.x = mtcars, .f =~paste(.y, "has a mean of", round(mean(.x), 1))) |>head()
#> mpg cyl
#> "mpg has a mean of 20.1" "cyl has a mean of 6.2"
#> disp hp
#> "disp has a mean of 230.7" "hp has a mean of 146.7"
#> drat wt
#> "drat has a mean of 3.6" "wt has a mean of 3.2"
map2_chr(.x = mtcars, .y =names(mtcars),.f =~paste(.y, "has a mean of", round(mean(.x), 1))) |>head()
#> mpg cyl
#> "mpg has a mean of 20.1" "cyl has a mean of 6.2"
#> disp hp
#> "disp has a mean of 230.7" "hp has a mean of 146.7"
#> drat wt
#> "drat has a mean of 3.6" "wt has a mean of 3.2"
pmap()
you can pass a named list or dataframe as arguments to a function
for example runif() has the parameters n, min and max
The reduce() function is a powerful functional that allows you to abstract away from a sequence of functions that are applied in a fixed direction.
reduce() takes a vector as its first argument, a function as its second argument, and an optional .init argument last. It will then apply the function repeatedly to the vector until there is only a single element left.
(Hint: start at the top of the image and read down.)
Let me really quickly demonstrate reduce() in action.
Say you wanted to add up the numbers 1 through 5 using only the plus operator +. You could do something like:
1+2+3+4+5
#> [1] 15
Which is the same as:
reduce(1:5, `+`)
#> [1] 15
And if you want the start value to be something that is not the first argument of the vector, pass that value to the .init argument:
#> $age
#> # A tibble: 1 × 2
#> name age
#> <chr> <dbl>
#> 1 john 30
#>
#> $sex
#> # A tibble: 2 × 3
#> name sex trt$name $treatment
#> <chr> <chr> <chr> <chr>
#> 1 john M Mary A
#> 2 mary F Mary A
df |>reduce(.f = full_join)
#> Joining with `by = join_by(name)`
#> # A tibble: 2 × 4
#> name age sex trt$name $treatment
#> <chr> <dbl> <chr> <chr> <chr>
#> 1 john 30 M Mary A
#> 2 mary NA F Mary A
reduce(.x = df,.f = full_join)
#> Joining with `by = join_by(name)`
#> # A tibble: 2 × 4
#> name age sex trt$name $treatment
#> <chr> <dbl> <chr> <chr> <chr>
#> 1 john 30 M Mary A
#> 2 mary NA F Mary A
The map() functions also have shortcuts for extracting elements from vectors (powered by purrr::pluck()). Note that map(my_list, 3) is a shortcut for map(my_list, pluck, 3).
# Select by namemap_dbl(my_list, "x")
#> [1] 1 4 8
# Or by positionmap_dbl(my_list, 1)
#> [1] -1 -2 -3
# Or by bothmap_dbl(my_list, list("y", 1))
#> [1] 2 5 9
# You'll get an error if you try to retrieve an inside item that doesn't have # a consistent format and you want a numeric outputmap_dbl(my_list, list("y"))
#> Error in `map_dbl()`:
#> ℹ In index: 2.
#> Caused by error:
#> ! Result must be length 1, not 2.
# You'll get an error if a component doesn't exist:map_chr(my_list, "z")
#> Error in `map_chr()`:
#> ℹ In index: 3.
#> Caused by error:
#> ! Result must be length 1, not 0.
#> Error: Result 3 must be a single string, not NULL of length 0# Unless you supply a .default valuemap_chr(my_list, "z", .default =NA)
#> [1] "a" "b" NA
#> [1] "a" "b" NA
Not covered: flatten()
flatten() will turn a list of lists into a simpler vector.
safely() is an adverb. It takes a function (a verb) and returns a modified version. In this case, the modified function will never throw an error. Instead it always returns a list with two elements.
result is the original result. If there is an error this will be NULL
error is an error object. If the operation was successful the “error” will be NULL.
