Part of the appeal of a for() loop is the development workflow. Sketch:

Pick i. Develop code that works. Drop into a loop over i. Done. What is so nice about this? It's clear how to experiment with your logic via top-level code.

With very little modification, something similar works with the functional approaches to iteration.

Pick i. Set .x <- thingy[[i]] (for a map workflow) or .x <- thingy[i, , drop = FALSE] for a pmap workflow) or what have you. Now develop your logic as in a for loop situation.

I touch on this in ex06_runif-via-pmap.R and in my purrr tutorial workflow advice.

Related to #3 How debug map() calls.

Sometimes we are the ones who miss opportunities to vectorize our own functions. Or sometimes we de-vectorize things that started out as vectorized. Red flags:

@colearendt:

Thinking too much in control structures like if () {} else {} often lands me in a non-vectorized state.

@hadley:

use of unlist() is a good warning sign that you're de-vectorising a function

Capturing the first match of the pattern "a" by row, looking into selected columns(1 to 3). The result should be a vector with a length equals to the number of rows of the data frame: Unfortunately the function is slow when applied to a large data frame.
This is the data frame:

df <- data.frame(
  x = c("ab", "ay", "cd", "ae", "ef"),
  y = c("bx", "ax", NA, "cx","ax"),
  z = c("cy", "dy", "ey", "ay", "by")
)

This is function

first_valid_code <- function(data, colvec, pattern){
  colvec <- enquo(colvec)
  f0 <- function(x) grepl(pattern = pattern, x, ignore.case = T, perl = T)
  f1 <- function(x) detect(x, f0)
  data %>%
    select(!!colvec) %>%
    map_dfr(as.character) %>%
    transpose() %>%
    map(f1) %>%
    map_if(is.null, ~NA_character_) %>%
    unlist()
}

This is the result when running the function on df:

first_valid_code(df,colvec = c(1:3), pattern = "a")

[1] "ab" "ay" NA "ae" "ax"

With apologies, @jennybc , I think that there is an error in the flevels function definition.

Should it not read as follows, please;-

'''
flevels <- function(df) {
mutate(df, method = fct_reorder(method, .x = desc(time)))
}
...
There appears to be a "." missing before the "x=..."

Productive recent conversation with @mpettis

https://gist.github.com/mpettis/1afd9a7f42fff34ba9a2d5c240356acc

Interesting to really think through pros and cons of "split then recombine" vs "nest and extract/unnest".

There's also a connection to the need for "map within map". Or, rather, avoiding this need. Which seems good because that's awfully hard to reason about.

Also connected to the conversation re: a tidy-er split() function: tidyverse/tidyr#434

This is related to ex09_row-summaries.

Data from a repeated measures design is usually recorded like this:

library(tidyverse)

df <- tribble(
  ~ name, ~ t1, ~t2, ~t3, ~x,
  "Abby",    1,   2,   3, "a",
  "Bess",    4,   5,   6, "a",
  "Carl",    7,   8,   9, "b"
)

Note that I have an additional variable, x, that I'd like to not lose while calculating the average of t* variables for each row.

The end goal is a data frame with (at a minimum) the variables name, x, and t_avg (this is the average of the t* variables). And this data frame should not be grouped.

(1) My original approach was the following:

df %>%
  rowwise() %>%
  mutate(t_avg = mean(c(t1, t2, t3))) %>%
  ungroup()
#> # A tibble: 3 x 6
#>   name     t1    t2    t3 x     t_avg
#>   <chr> <dbl> <dbl> <dbl> <chr> <dbl>
#> 1 Abby      1     2     3 a         2
#> 2 Bess      4     5     6 a         5
#> 3 Carl      7     8     9 b         8

But, it uses rowwise(), so 🙅.

(2) Summarising in a separate data frame is suggested at ex09_row-summaries, but this requires introducing a new data frame.

(3) An alternative is gathering the data first, so something like:

df %>%
  gather(t, value, -c(name, x)) %>%
  group_by(name) %>%
  mutate(t_avg = mean(value)) %>%
  select(-c(t, value)) %>%
  distinct() %>%
  ungroup()
#> # A tibble: 3 x 3
#>   name  x     t_avg
#>   <chr> <chr> <dbl>
#> 1 Abby  a         2
#> 2 Bess  a         5
#> 3 Carl  b         8

It's a lot more lines of code and some new functions, but the upside is explicitly addressing the problem that df is not a tidy data frame to begin with.

Among other reasons for not using (1), I like the group_by() -> ungroup() workflow better than rowwise() -> ungroup().

From a teaching (to an intro audience) perspective I'm leaning towards (3) since it seems to me like the most explicit approach, but I'd love to hear thoughts on this.

Inspired by a post from @vllorens in R-Ladies slack.

There are different patients and, for each patient, several samples. However, only one sample per patient was analyzed. This is indicated in column “sampleUsed”. How to turn the input tibble into the output here? You could work this row-wise: for each patient, identify the sample used, then determine which column to consult, to get the correct sample size. But it's actually easier to reshape the data and solve an easier problem, column-wise.

library(tidyverse)

df <- tibble::tribble(
  ~patient, ~sampleUsed, ~sample1_size, ~sample2_size, ~sample3_size, ~sample4_size,
  1L, "sample1", 12L, 13L, 17L,  9L,
  2L, "sample4", 15L, 13L, 21L, 11L,
  3L, "sample2", 14L, 15L, 13L, 15L,
  4L, "sample1", 20L, 14L, 15L, 13L
)

df %>% 
  gather(key = "key", value = "sample_size", ends_with("size")) %>% 
  filter(str_detect(key, sampleUsed)) %>% 
  select(-key)
#> # A tibble: 4 x 3
#>   patient sampleUsed sample_size
#>     <int> <chr>            <int>
#> 1       1 sample1             12
#> 2       4 sample1             20
#> 3       3 sample2             15
#> 4       2 sample4             11

Question raised in connection to this example:

What if data frame includes variables that should not be passed to .f()?

df_oops <- tibble(
  n = 1:3,
  min = c(0, 10, 100),
  max = c(1, 100, 1000),
  oops = c("please", "ignore", "me")
)
df_oops
#> # A tibble: 3 x 4
#>       n   min   max oops  
#>   <int> <dbl> <dbl> <chr> 
#> 1     1    0.    1. please
#> 2     2   10.  100. ignore
#> 3     3  100. 1000. me

This will not work!

set.seed(123)
pmap(df_oops, runif)
#> Error in .f(n = .l[[c(1L, i)]], min = .l[[c(2L, i)]], max = .l[[c(3L, : unused argument (oops = .l[[c(4, i)]])

Use that to motivate some development and debugging strategies.

This term can sound much more intimidating than it is, especially if you are new to R. @edgararuiz likened it to "quantum entanglement".

How to demystify it quickly when introduced?

@garrett suggestions: "a function that works with vectors", a diagram, clear code demo

@jimhester points to this quote from @andrie's book:

Vectorized functions are a very useful feature of R, but programmers who are used to other languages often have trouble with this concept at first. A vectorized function works not just on a single value, but on a whole vector of values at the same time.

This is a great read. I offer this up for consideration on adding clarity to one section.

Here you are using a list to wrap the dots argument that has the single-row values of each column of the data frame and feeding it to runif. When I read it, I had to stop and think for a bit, and recall that pmap splices the list values in as function arguments, and so what is fed to my_runif are actual keyword arguments (like what do.call does), and not a list of length 1 lists. And that is why you have to wrap the dots argument in a list.

It didn't take me long to think through, but perhaps a sentence that addresses what cleared it up for me, per above, would help others.

Thanks again for this stuff, it is very valuable.

From @krlmlr

library(tidyverse)

df <- tribble(
  ~name, ~t1, ~t2, ~t3,
  "Abby", 1, 2, 3,
  "Bess", 4, 5, 6,
  "Carl", 7, 8, 9
)

df %>%
  gather("key", "value", -name) %>%
  nest(-name) %>%
  mutate(
    sum = map(data, "value") %>% map_dbl(sum),
    mean = map(data, "value") %>% map_dbl(mean)
  )
#> # A tibble: 3 x 4
#>   name  data               sum  mean
#>   <chr> <list>           <dbl> <dbl>
#> 1 Abby  <tibble [3 × 2]>     6     2
#> 2 Bess  <tibble [3 × 2]>    15     5
#> 3 Carl  <tibble [3 × 2]>    24     8