dplyr

https://dplyr.tidyverse.org
Admin
dplyr is a grammar of data manipulation providing a consistent set of verbs that help solve the most...
Tokens:280,383
Snippets:2,027
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Initialize example vector

Source: https://dplyr.tidyverse.org/reference/recode.html

Setup code to create a sample vector for recoding examples.

```R
set.seed(1234)

x <- sample(c("a", "b", "c"), 10, replace = TRUE)
```

--------------------------------

### Setup for mutate examples

Source: https://dplyr.tidyverse.org/articles/dplyr.html

Creates a smaller tibble for demonstrating mutate semantics.

```R
df <- starwars |> select(name, height, mass)
```

--------------------------------

### Initialize example data for reframe

Source: https://dplyr.tidyverse.org/reference/reframe.html

Setup code creating a tibble with grouping variable 'g' and character variable 'x' to demonstrate reframe operations.

```R
table <- c("a", "b", "d", "f")

df <- tibble(
  g = c(1, 1, 1, 2, 2, 2, 2),
  x = c("e", "a", "b", "c", "f", "d", "a")
)
```

--------------------------------

### Example input vectors for when_any and when_all

Source: https://dplyr.tidyverse.org/reference/when-any-all.html

Example logical vectors used to demonstrate elementwise operations.

```R
x <- c(TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, NA, NA, NA)
y <- c(TRUE, FALSE, NA, TRUE, FALSE, NA, TRUE, FALSE, NA)
```

--------------------------------

### Relocating columns with examples

Source: https://dplyr.tidyverse.org/reference/relocate.html

Examples demonstrating how to move columns using relocate() with various arguments like .before, .after, last_col(), and selection helpers like where().

```R
df <- tibble(a = 1, b = 1, c = 1, d = "a", e = "a", f = "a")
df |> relocate(f)
#> # A tibble: 1 × 6
#>   f         a     b     c d     e    
#>   <chr> <dbl> <dbl> <dbl> <chr> <chr>
#> 1 a         1     1     1 a     a    
df |> relocate(a, .after = c)
#> # A tibble: 1 × 6
#>       b     c     a d     e     f    
#>   <dbl> <dbl> <dbl> <chr> <chr> <chr>
#> 1     1     1     1 a     a     a    
df |> relocate(f, .before = b)
#> # A tibble: 1 × 6
#>       a f         b     c d     e    
#>   <dbl> <chr> <dbl> <dbl> <chr> <chr>
#> 1     1 a         1     1 a     a    
df |> relocate(a, .after = last_col())
#> # A tibble: 1 × 6
#>       b     c d     e     f         a
#>   <dbl> <dbl> <chr> <chr> <chr> <dbl>
#> 1     1     1 a     a     a         1

# relocated columns can change name
df |> relocate(ff = f)
#> # A tibble: 1 × 6
#>   ff        a     b     c d     e    
#>   <chr> <dbl> <dbl> <dbl> <chr> <chr>
#> 1 a         1     1     1 a     a    

# Can also select variables based on their type
df |> relocate(where(is.character))
#> # A tibble: 1 × 6
#>   d     e     f         a     b     c
#>   <chr> <chr> <chr> <dbl> <dbl> <dbl>
#> 1 a     a     a         1     1     1
df |> relocate(where(is.numeric), .after = last_col())
#> # A tibble: 1 × 6
#>   d     e     f         a     b     c
#>   <chr> <chr> <chr> <dbl> <dbl> <dbl>
#> 1 a     a     a         1     1     1
# Or with any other select helper
df |> relocate(any_of(c("a", "e", "i", "o", "u")))
#> # A tibble: 1 × 6
#>       a e         b     c d     f    
#>   <dbl> <chr> <dbl> <dbl> <chr> <chr>
#> 1     1 a         1     1 a     a    

# When .before or .after refers to multiple variables they will be
# moved to be immediately before/after the selected variables.
df2 <- tibble(a = 1, b = "a", c = 1, d = "a")
df2 |> relocate(where(is.numeric), .after = where(is.character))
#> # A tibble: 1 × 4
#>   b     d         a     c
#>   <chr> <chr> <dbl> <dbl>
#> 1 a     a         1     1
df2 |> relocate(where(is.numeric), .before = where(is.character))
#> # A tibble: 1 × 4
#>       a     c b     d    
#>   <dbl> <dbl> <chr> <chr>
#> 1     1     1 a     a    
```

--------------------------------

### copy_to example

Source: https://dplyr.tidyverse.org/reference/copy_to.html

An example showing how to copy the iris dataset to an in-memory database using copy_to.

```R
if (FALSE) { # \dontrun{
iris2 <- dbplyr::src_memdb() |> copy_to(iris, overwrite = TRUE)
iris2
} # }
```

--------------------------------

### Arrange columns using across() and starts_with()

Source: https://dplyr.tidyverse.org/reference/arrange.html

This example shows how to arrange the iris dataset by all columns starting with 'Sepal' in descending order.

```r
iris |> arrange(across(starts_with("Sepal"), desc))
```

--------------------------------

### Set operations examples

Source: https://dplyr.tidyverse.org/reference/setops.html

Examples demonstrating how to use set operations on tibbles, including handling of duplicates and equality checks.

```R
df1 <- tibble(x = 1:3)
df2 <- tibble(x = 3:5)

intersect(df1, df2)
#> # A tibble: 1 × 1
#>       x
#>   <int>
#> 1     3
union(df1, df2)
#> # A tibble: 5 × 1
#>       x
#>   <int>
#> 1     1
#> 2     2
#> 3     3
#> 4     4
#> 5     5
union_all(df1, df2)
#> # A tibble: 6 × 1
#>       x
#>   <int>
#> 1     1
#> 2     2
#> 3     3
#> 4     3
#> 5     4
#> 6     5
setdiff(df1, df2)
#> # A tibble: 2 × 1
#>       x
#>   <int>
#> 1     1
#> 2     2
setdiff(df2, df1)
#> # A tibble: 2 × 1
#>       x
#>   <int>
#> 1     4
#> 2     5
symdiff(df1, df2)
#> # A tibble: 4 × 1
#>       x
#>   <int>
#> 1     1
#> 2     2
#> 3     4
#> 4     5

setequal(df1, df2)
#> [1] FALSE
setequal(df1, df1[3:1, ])
#> [1] TRUE

# Note that the following functions remove pre-existing duplicates:
df1 <- tibble(x = c(1:3, 3, 3))
df2 <- tibble(x = c(3:5, 5))

intersect(df1, df2)
#> # A tibble: 1 × 1
#>       x
#>   <dbl>
#> 1     3
union(df1, df2)
#> # A tibble: 5 × 1
#>       x
#>   <dbl>
#> 1     1
#> 2     2
#> 3     3
#> 4     4
#> 5     5
setdiff(df1, df2)
#> # A tibble: 2 × 1
#>       x
#>   <dbl>
#> 1     1
#> 2     2
symdiff(df1, df2)
#> # A tibble: 4 × 1
#>       x
#>   <dbl>
#> 1     1
#> 2     2
#> 3     4
#> 4     5
```

--------------------------------

### Install dplyr

Source: https://dplyr.tidyverse.org/index.html

Instructions for installing the dplyr package, either as part of the tidyverse or as a standalone package.

```R
# The easiest way to get dplyr is to install the whole tidyverse:
install.packages("tidyverse")

# Alternatively, install just dplyr:
install.packages("dplyr")
```

--------------------------------

### if_else() examples

Source: https://dplyr.tidyverse.org/reference/if_else.html

Examples demonstrating basic usage, handling NA values with the missing argument, type preservation compared to base R, and usage within mutate().

```R
x <- c(-5:5, NA)
if_else(x < 0, NA, x)
#>  [1] NA NA NA NA NA  0  1  2  3  4  5 NA

# Explicitly handle `NA` values in the `condition` with `missing`
if_else(x < 0, "negative", "positive", missing = "missing")
#>  [1] "negative" "negative" "negative" "negative" "negative" "positive"
#>  [7] "positive" "positive" "positive" "positive" "positive" "missing" 

# Unlike `ifelse()`, `if_else()` preserves types
x <- factor(sample(letters[1:5], 10, replace = TRUE))
ifelse(x %in% c("a", "b", "c"), x, NA)
#>  [1]  2 NA NA  2 NA  1  2 NA  2 NA
if_else(x %in% c("a", "b", "c"), x, NA)
#>  [1] c    <NA> <NA> c    <NA> b    c    <NA> c    <NA>
#> Levels: b c d

# `if_else()` is often useful for creating new columns inside of `mutate()`
starwars |>
  mutate(category = if_else(height < 100, "short", "tall"), .keep = "used")
#> # A tibble: 87 × 2
#>    height category
#>     <int> <chr>   
#>  1    172 tall    
#>  2    167 tall    
#>  3     96 short   
#>  4    202 tall    
#>  5    150 tall    
#>  6    178 tall    
#>  7    165 tall    
#>  8     97 short   
#>  9    183 tall    
#> 10    182 tall    
#> # ℹ 77 more rows
```

--------------------------------

### Examples of compute, collect, and collapse

Source: https://dplyr.tidyverse.org/reference/compute.html

Demonstrates how to use compute, collect, and collapse on a remote database table.

```R
mtcars2 <- dbplyr::src_memdb() |>
  copy_to(mtcars, name = "mtcars2-cc", overwrite = TRUE)

remote <- mtcars2 |>
  filter(cyl == 8) |>
  select(mpg:drat)

# Compute query and save in remote table
compute(remote)
#> # Source:   table<`dbplyr_me1YyZvyFT`> [?? x 5]
#> # Database: sqlite 3.51.2 [:memory:]
#>      mpg   cyl  disp    hp  drat
#>    <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1  18.7     8  360    175  3.15
#>  2  14.3     8  360    245  3.21
#>  3  16.4     8  276.   180  3.07
#>  4  17.3     8  276.   180  3.07
#>  5  15.2     8  276.   180  3.07
#>  6  10.4     8  472    205  2.93
#>  7  10.4     8  460    215  3   
#>  8  14.7     8  440    230  3.23
#>  9  15.5     8  318    150  2.76
#> 10  15.2     8  304    150  3.15
#> 11  13.3     8  350    245  3.73
#> 12  19.2     8  400    175  3.08
#> 13  15.8     8  351    264  4.22
#> 14  15       8  301    335  3.54

# Compute query bring back to this session
collect(remote)
#> # A tibble: 14 × 5
#>      mpg   cyl  disp    hp  drat
#>    <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1  18.7     8  360    175  3.15
#>  2  14.3     8  360    245  3.21
#>  3  16.4     8  276.   180  3.07
#>  4  17.3     8  276.   180  3.07
#>  5  15.2     8  276.   180  3.07
#>  6  10.4     8  472    205  2.93
#>  7  10.4     8  460    215  3   
#>  8  14.7     8  440    230  3.23
#>  9  15.5     8  318    150  2.76
#> 10  15.2     8  304    150  3.15
#> 11  13.3     8  350    245  3.73
#> 12  19.2     8  400    175  3.08
#> 13  15.8     8  351    264  4.22
#> 14  15       8  301    335  3.54

# Creates a fresh query based on the generated SQL
collapse(remote)
#> # Source:   SQL [?? x 5]
#> # Database: sqlite 3.51.2 [:memory:]
#>      mpg   cyl  disp    hp  drat
#>    <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1  18.7     8  360    175  3.15
#>  2  14.3     8  360    245  3.21
#>  3  16.4     8  276.   180  3.07
#>  4  17.3     8  276.   180  3.07
#>  5  15.2     8  276.   180  3.07
#>  6  10.4     8  472    205  2.93
#>  7  10.4     8  460    215  3   
#>  8  14.7     8  440    230  3.23
#>  9  15.5     8  318    150  2.76
#> 10  15.2     8  304    150  3.15
#> 11  13.3     8  350    245  3.73
#> 12  19.2     8  400    175  3.08
#> 13  15.8     8  351    264  4.22
#> 14  15       8  301    335  3.54
```

--------------------------------

### Examples of distinct()

Source: https://dplyr.tidyverse.org/reference/distinct.html

Examples demonstrating how to use distinct() to filter rows, keep all variables, use computed variables, and select columns with pick().

```R
df <- tibble(
  x = sample(10, 100, rep = TRUE),
  y = sample(10, 100, rep = TRUE)
)
nrow(df)
#> [1] 100
nrow(distinct(df))
#> [1] 63
nrow(distinct(df, x, y))
#> [1] 63

distinct(df, x)
#> # A tibble: 10 × 1
#>        x
#>    <int>
#>  1    10
#>  2     5
#>  3     8
#>  4     3
#>  5     2
#>  6     6
#>  7     4
#>  8     1
#>  9     7
#> 10     9
distinct(df, y)
#> # A tibble: 10 × 1
#>        y
#>    <int>
#>  1     7
#>  2    10
#>  3     4
#>  4     8
#>  5     9
#>  6     5
#>  7     6
#>  8     1
#>  9     2
#> 10     3

# You can choose to keep all other variables as well
distinct(df, x, .keep_all = TRUE)
#> # A tibble: 10 × 2
#>        x     y
#>    <int> <int>
#>  1    10     7
#>  2     5    10
#>  3     8     8
#>  4     3     9
#>  5     2     9
#>  6     6     1
#>  7     4    10
#>  8     1    10
#>  9     7     5
#> 10     9     4
distinct(df, y, .keep_all = TRUE)
#> # A tibble: 10 × 2
#>        x     y
#>    <int> <int>
#>  1    10     7
#>  2     5    10
#>  3     5     4
#>  4     8     8
#>  5     3     9
#>  6    10     5
#>  7    10     6
#>  8     6     1
#>  9     7     2
#> 10     5     3

# You can also use distinct on computed variables
distinct(df, diff = abs(x - y))
#> # A tibble: 10 × 1
#>     diff
#>    <int>
#>  1     3
#>  2     5
#>  3     1
#>  4     0
#>  5     6
#>  6     7
#>  7     4
#>  8     9
#>  9     2
#> 10     8

# Use `pick()` to select columns with tidy-select
distinct(starwars, pick(contains("color")))
#> # A tibble: 67 × 3
#>    hair_color    skin_color  eye_color
#>    <chr>         <chr>       <chr>    
#>  1 blond         fair        blue     
#>  2 NA            gold        yellow   
#>  3 NA            white, blue red      
#>  4 none          white       yellow   
#>  5 brown         light       brown    
#>  6 brown, grey   light       blue     
#>  7 brown         light       blue     
#>  8 NA            white, red  red      
#>  9 black         light       brown    
#> 10 auburn, white fair        blue-gray
#> # ℹ 57 more rows
```

--------------------------------

### coalesce() examples

Source: https://dplyr.tidyverse.org/reference/coalesce.html

Examples demonstrating replacing missing values with a single value, using multiple vectors, and handling lists.

```R
# Replace missing values with a single value
x <- sample(c(1:5, NA, NA, NA))
coalesce(x, 0L)
#> [1] 0 5 2 1 0 3 4 0

# Or replace missing values with the corresponding non-missing value in
# another vector
x <- c(1, 2, NA, NA, 5, NA)
y <- c(NA, NA, 3, 4, 5, NA)
coalesce(x, y)
#> [1]  1  2  3  4  5 NA

# For cases like these where your replacement is a single value or a single
# vector, `replace_values()` works just as well
replace_values(x, NA ~ 0)
#> [1] 1 2 0 0 5 0
coalesce(x, 0)
#> [1] 1 2 0 0 5 0

replace_values(x, NA ~ y)
#> [1]  1  2  3  4  5 NA
coalesce(x, y)
#> [1]  1  2  3  4  5 NA

# `coalesce()` really shines when you have >2 vectors to coalesce with
z <- c(NA, 2, 3, 4, 5, 6)
coalesce(x, y, z)
#> [1] 1 2 3 4 5 6

# If you're looking to replace values with `NA`, rather than replacing `NA`
# with a value, then use `replace_values()`
x <- c(0, -1, 5, -99, 8)
replace_values(x, c(-1, -99) ~ NA)
#> [1]  0 NA  5 NA  8

# The equivalent to a missing value in a list is `NULL`
coalesce(list(1, 2, NULL, NA), list(0))
#> [[1]]
#> [1] 1
#> 
#> [[2]]
#> [1] 2
#> 
#> [[3]]
#> [1] 0
#> 
#> [[4]]
#> [1] NA
#> 

# Supply lists of vectors by splicing them into dots
vecs <- list(
  c(1, 2, NA, NA, 5),
  c(NA, NA, 3, 4, 5)
)
coalesce(!!!vecs)
#> [1] 1 2 3 4 5
```

--------------------------------

### Ranking function examples

Source: https://dplyr.tidyverse.org/reference/row_number.html

Examples demonstrating how row_number(), min_rank(), and dense_rank() handle ties, and how they can be used within filter() and mutate() for grouped data.

```R
x <- c(5, 1, 3, 2, 2, NA)
row_number(x)
#> [1]  5  1  4  2  3 NA
min_rank(x)
#> [1]  5  1  4  2  2 NA
dense_rank(x)
#> [1]  4  1  3  2  2 NA

# Ranking functions can be used in `filter()` to select top/bottom rows
df <- data.frame(
  grp = c(1, 1, 1, 2, 2, 2, 3, 3, 3),
  x = c(3, 2, 1, 1, 2, 2, 1, 1, 1),
  y = c(1, 3, 2, 3, 2, 2, 4, 1, 2),
  id = 1:9
)
# Always gives exactly 1 row per group
df |> group_by(grp) |> filter(row_number(x) == 1)
#> # A tibble: 3 × 4
#> # Groups:   grp [3]
#>     grp     x     y    id
#>   <dbl> <dbl> <dbl> <int>
#> 1     1     1     2     3
#> 2     2     1     3     4
#> 3     3     1     4     7
# May give more than 1 row if ties
df |> group_by(grp) |> filter(min_rank(x) == 1)
#> # A tibble: 5 × 4
#> # Groups:   grp [3]
#>     grp     x     y    id
#>   <dbl> <dbl> <dbl> <int>
#> 1     1     1     2     3
#> 2     2     1     3     4
#> 3     3     1     4     7
#> 4     3     1     1     8
#> 5     3     1     2     9
# Rank by multiple columns (to break ties) by selecting them with `pick()`
df |> group_by(grp) |> filter(min_rank(pick(x, y)) == 1)
#> # A tibble: 3 × 4
#> # Groups:   grp [3]
#>     grp     x     y    id
#>   <dbl> <dbl> <dbl> <int>
#> 1     1     1     2     3
#> 2     2     1     3     4
#> 3     3     1     1     8
# See slice_min() and slice_max() for another way to tackle the same problem

# You can use row_number() without an argument to refer to the "current"
# row number.
df |> group_by(grp) |> filter(row_number() == 1)
#> # A tibble: 3 × 4
#> # Groups:   grp [3]
#>     grp     x     y    id
#>   <dbl> <dbl> <dbl> <int>
#> 1     1     3     1     1
#> 2     2     1     3     4
#> 3     3     1     4     7

# It's easiest to see what this does with mutate():
df |> group_by(grp) |> mutate(grp_id = row_number())
#> # A tibble: 9 × 5
#> # Groups:   grp [3]
#>     grp     x     y    id grp_id
#>   <dbl> <dbl> <dbl> <int>  <int>
#> 1     1     3     1     1      1
#> 2     1     2     3     2      2
#> 3     1     1     2     3      3
#> 4     2     1     3     4      1
#> 5     2     2     2     5      2
#> 6     2     2     2     6      3
#> 7     3     1     4     7      1
#> 8     3     1     1     8      2
#> 9     3     1     2     9      3
```

--------------------------------

### Filtering joins examples

Source: https://dplyr.tidyverse.org/reference/filter-joins.html

Examples demonstrating how to use semi_join and anti_join to filter data, including how to suppress join messages by explicitly providing the 'by' argument.

```R
# "Filtering" joins keep cases from the LHS
band_members |> semi_join(band_instruments)
#> Joining with `by = join_by(name)`
#> # A tibble: 2 × 2
#>   name  band   
#>   <chr> <chr>  
#> 1 John  Beatles
#> 2 Paul  Beatles
band_members |> anti_join(band_instruments)
#> Joining with `by = join_by(name)`
#> # A tibble: 1 × 2
#>   name  band  
#>   <chr> <chr> 
#> 1 Mick  Stones

# To suppress the message about joining variables, supply `by`
band_members |> semi_join(band_instruments, by = join_by(name))
#> # A tibble: 2 × 2
#>   name  band   
#>   <chr> <chr>  
#> 1 John  Beatles
#> 2 Paul  Beatles
# This is good practice in production code
```

--------------------------------

### Examples of proportional ranking

Source: https://dplyr.tidyverse.org/reference/percent_rank.html

Demonstrates the output of cume_dist and percent_rank compared to manual calculations.

```R
x <- c(5, 1, 3, 2, 2)

cume_dist(x)
#> [1] 1.0 0.2 0.8 0.6 0.6
percent_rank(x)
#> [1] 1.00 0.00 0.75 0.25 0.25

# You can understand what's going on by computing it by hand
sapply(x, function(xi) sum(x <= xi) / length(x))
#> [1] 1.0 0.2 0.8 0.6 0.6
sapply(x, function(xi) sum(x < xi)  / (length(x) - 1))
#> [1] 1.00 0.00 0.75 0.25 0.25
# The real computations are a little more complex in order to
# correctly deal with missing values
```

--------------------------------

### Define sample data for join examples

Source: https://dplyr.tidyverse.org/articles/two-table.html

Creates two simple tibbles to demonstrate different join behaviors.

```r
df1 <- tibble(x = c(1, 2), y = 2:1)
df2 <- tibble(x = c(3, 1), a = 10, b = "a")
```

--------------------------------

### Arrange using pick and starts_with

Source: https://dplyr.tidyverse.org/reference/arrange.html

Uses the pick() function to select columns starting with 'Sepal' for the arrange operation.

```r
iris |> arrange(pick(starts_with("Sepal")))
```

```text
#>     Sepal.Length Sepal.Width Petal.Length Petal.Width    Species
#> 1            4.3         3.0          1.1         0.1     setosa
#> 2            4.4         2.9          1.4         0.2     setosa
#> 3            4.4         3.0          1.3         0.2     setosa
#> 4            4.4         3.2          1.3         0.2     setosa
#> 5            4.5         2.3          1.3         0.3     setosa
#> 6            4.6         3.1          1.5         0.2     setosa
#> 7            4.6         3.2          1.4         0.2     setosa
#> 8            4.6         3.4          1.4         0.3     setosa
#> 9            4.6         3.6          1.0         0.2     setosa
#> 10           4.7         3.2          1.3         0.2     setosa
#> 11           4.7         3.2          1.6         0.2     setosa
#> 12           4.8         3.0          1.4         0.1     setosa
#> 13           4.8         3.0          1.4         0.3     setosa
#> 14           4.8         3.1          1.6         0.2     setosa
#> 15           4.8         3.4          1.6         0.2     setosa
#> 16           4.8         3.4          1.9         0.2     setosa
#> 17           4.9         2.4          3.3         1.0 versicolor
#> 18           4.9         2.5          4.5         1.7  virginica
#> 19           4.9         3.0          1.4         0.2     setosa
#> 20           4.9         3.1          1.5         0.1     setosa
#> 21           4.9         3.1          1.5         0.2     setosa
#> 22           4.9         3.6          1.4         0.1     setosa
#> 23           5.0         2.0          3.5         1.0 versicolor
#> 24           5.0         2.3          3.3         1.0 versicolor
#> 25           5.0         3.0          1.6         0.2     setosa
#> 26           5.0         3.2          1.2         0.2     setosa
#> 27           5.0         3.3          1.4         0.2     setosa
#> 28           5.0         3.4          1.5         0.2     setosa
#> 29           5.0         3.4          1.6         0.4     setosa
#> 30           5.0         3.5          1.3         0.3     setosa
#> 31           5.0         3.5          1.6         0.6     setosa
#> 32           5.0         3.6          1.4         0.2     setosa
#> 33           5.1         2.5          3.0         1.1 versicolor
#> 34           5.1         3.3          1.7         0.5     setosa
#> 35           5.1         3.4          1.5         0.2     setosa
#> 36           5.1         3.5          1.4         0.2     setosa
#> 37           5.1         3.5          1.4         0.3     setosa
#> 38           5.1         3.7          1.5         0.4     setosa
#> 39           5.1         3.8          1.5         0.3     setosa
#> 40           5.1         3.8          1.9         0.4     setosa
#> 41           5.1         3.8          1.6         0.2     setosa
#> 42           5.2         2.7          3.9         1.4 versicolor
#> 43           5.2         3.4          1.4         0.2     setosa
#> 44           5.2         3.5          1.5         0.2     setosa
#> 45           5.2         4.1          1.5         0.1     setosa
#> 46           5.3         3.7          1.5         0.2     setosa
#> 47           5.4         3.0          4.5         1.5 versicolor
#> 48           5.4         3.4          1.7         0.2     setosa
#> 49           5.4         3.4          1.5         0.4     setosa
#> 50           5.4         3.7          1.5         0.2     setosa
#> 51           5.4         3.9          1.7         0.4     setosa
#> 52           5.4         3.9          1.3         0.4     setosa
#> 53           5.5         2.3          4.0         1.3 versicolor
#> 54           5.5         2.4          3.8         1.1 versicolor
#> 55           5.5         2.4          3.7         1.0 versicolor
#> 56           5.5         2.5          4.0         1.3 versicolor
#> 57           5.5         2.6          4.4         1.2 versicolor
#> 58           5.5         3.5          1.3         0.2     setosa
#> 59           5.5         4.2          1.4         0.2     setosa
#> 60           5.6         2.5          3.9         1.1 versicolor
#> 61           5.6         2.7          4.2         1.3 versicolor
#> 62           5.6         2.8          4.9         2.0  virginica
#> 63           5.6         2.9          3.6         1.3 versicolor
#> 64           5.6         3.0          4.5         1.5 versicolor
#> 65           5.6         3.0          4.1         1.3 versicolor
#> 66           5.7         2.5          5.0         2.0  virginica
#> 67           5.7         2.6          3.5         1.0 versicolor
#> 68           5.7         2.8          4.5         1.3 versicolor
#> 69           5.7         2.8          4.1         1.3 versicolor
#> 70           5.7         2.9          4.2         1.3 versicolor
```

--------------------------------

### Cross join examples

Source: https://dplyr.tidyverse.org/reference/cross_join.html

Demonstrates performing a standard cross join and customizing the suffix for duplicate column names.

```R
# Cross joins match each row in `x` to every row in `y`.
# Data within the columns is not used in the matching process.
cross_join(band_instruments, band_members)
#> # A tibble: 9 × 4
#>   name.x plays  name.y band   
#>   <chr>  <chr>  <chr>  <chr>  
#> 1 John   guitar Mick   Stones 
#> 2 John   guitar John   Beatles
#> 3 John   guitar Paul   Beatles
#> 4 Paul   bass   Mick   Stones 
#> 5 Paul   bass   John   Beatles
#> 6 Paul   bass   Paul   Beatles
#> 7 Keith  guitar Mick   Stones 
#> 8 Keith  guitar John   Beatles
#> 9 Keith  guitar Paul   Beatles

# Control the suffix added to variables duplicated in
# `x` and `y` with `suffix`.
cross_join(band_instruments, band_members, suffix = c("", "_y"))
#> # A tibble: 9 × 4
#>   name  plays  name_y band   
#>   <chr> <chr>  <chr>  <chr>  
#> 1 John  guitar Mick   Stones 
#> 2 John  guitar John   Beatles
#> 3 John  guitar Paul   Beatles
#> 4 Paul  bass   Mick   Stones 
#> 5 Paul  bass   John   Beatles
#> 6 Paul  bass   Paul   Beatles
#> 7 Keith guitar Mick   Stones 
#> 8 Keith guitar John   Beatles
#> 9 Keith guitar Paul   Beatles
```

--------------------------------

### Comparing with_groups and .by

Source: https://dplyr.tidyverse.org/reference/with_groups.html

Examples showing the superseded with_groups approach compared to the modern .by argument approach.

```R
df <- tibble(g = c(1, 1, 2, 2, 3), x = runif(5))

# Old
df |>
  with_groups(g, mutate, x_mean = mean(x))
#> # A tibble: 5 × 3
#>       g     x x_mean
#>   <dbl> <dbl>  <dbl>
#> 1     1 0.185  0.472
#> 2     1 0.758  0.472
#> 3     2 0.567  0.749
#> 4     2 0.932  0.749
#> 5     3 0.639  0.639
# New
df |> mutate(x_mean = mean(x), .by = g)
#> # A tibble: 5 × 3
#>       g     x x_mean
#>   <dbl> <dbl>  <dbl>
#> 1     1 0.185  0.472
#> 2     1 0.758  0.472
#> 3     2 0.567  0.749
#> 4     2 0.932  0.749
#> 5     3 0.639  0.639
```

--------------------------------

### Example of case_when

Source: https://dplyr.tidyverse.org/reference/case-and-replace-when.html

Demonstrates using case_when to create a new character vector based on numeric conditions.

```R
x <- 1:70
case_when(
  x %% 35 == 0 ~ "fizz buzz",
  x %% 5 == 0 ~ "fizz",
  x %% 7 == 0 ~ "buzz",
  .default = as.character(x)
)
```
Tokens:
Raw