Intermediate steps

One option is to save each step as a new object:

diamonds_1 <- filter(diamonds, color == "I")
diamonds_2 <- group_by(diamonds_1, cut)
(diamonds_3 <- summarize(diamonds_2, price = mean(price)))

## # A tibble: 5 x 2
##         cut    price
##       <ord>    <dbl>
## 1      Fair 4685.446
## 2      Good 5078.533
## 3 Very Good 5255.880
## 4   Premium 5946.181
## 5     Ideal 4451.970

Why do we not like doing this? We have to name each intermediate object. Here I just append a number to the end, but this is not good self-documentation. What should we expect to find in diamond_2? It would be nicer to have an informative name, but there isn’t a natural one. Then we have to remember how the data exists in each intermediate step and remember to reference the correct one. What happens if we misidentify the data frame?

diamonds_1 <- filter(diamonds, color == "I")
diamonds_2 <- group_by(diamonds_1, cut)
(diamonds_3 <- summarize(diamonds_1, price = mean(price)))

## # A tibble: 1 x 1
##      price
##      <dbl>
## 1 5091.875

We don’t get the correct answer. Worse, we don’t get an explicit error message because the code, as written, works. R can execute this command for us and doesn’t know to warn us that we used diamonds_1 instead of diamonds_2.

Overwrite the original

Instead of creating intermediate objects, let’s just replace the original data frame with the modified form.

# copy diamonds to diamonds_t just for demonstration purposes
diamonds_t <- diamonds

diamonds_t <- filter(diamonds_t, color == "I")
diamonds_t <- group_by(diamonds_t, cut)
(diamonds_t <- summarize(diamonds_t, price = mean(price)))

## # A tibble: 5 x 2
##         cut    price
##       <ord>    <dbl>
## 1      Fair 4685.446
## 2      Good 5078.533
## 3 Very Good 5255.880
## 4   Premium 5946.181
## 5     Ideal 4451.970

This works, but still has a couple of problems. What happens if I make an error in the middle of the operation? I need to rerun the entire operation from the beginning. With your own data sources, this means having to read in the .csv file all over again to restore a fresh copy.

Function composition

We could string all the function calls together into a single object and forget assigning it anywhere.

summarize(
  group_by(
    filter(diamonds, color == "I"),
    cut
  ),
  price = mean(price)
)

## # A tibble: 5 x 2
##         cut    price
##       <ord>    <dbl>
## 1      Fair 4685.446
## 2      Good 5078.533
## 3 Very Good 5255.880
## 4   Premium 5946.181
## 5     Ideal 4451.970

But now we have to read the function from the inside out. This is not intuitive for humans. Again, the computer will handle it just fine, but if you make a mistake debugging it will be a pain.

Back to the pipe

diamonds %>%
  filter(color == "I") %>%
  group_by(cut) %>%
  summarize(price = mean(price))

## # A tibble: 5 x 2
##         cut    price
##       <ord>    <dbl>
## 1      Fair 4685.446
## 2      Good 5078.533
## 3 Very Good 5255.880
## 4   Premium 5946.181
## 5     Ideal 4451.970

Piping is the clearest syntax to implement, as it focuses on actions, not objects. Or as Hadley would say:

[I]t focuses on verbs, not nouns.

magrittr automatically passes the output from the first line into the next line as the input. This is why tidyverse functions always accept a data frame as the first argument.