Application of pipe (%>%) functions

Useful tricks and features in OMICs mining

Before we start to work with the content of tibbles, namely sort, arrange, slice, select, filter, mutate, etc., we need to start using 'pipes'. Pipes are handy functions that allow for organizing data preparation and analysis, including manipulating the content of data frames, data transformation and normalization, computation, and plotting. Different computational operations on data can be chained using pipes, creating a pipeline. Pipelines allow for an output from a function to be immediately passed to another function for further actions. This develops a chain of actions, processing an R object into desired outputs through an elegant, simple-to-read, well-organized code block. Again, we will highlight that pipes are functions and are used to process one primary R object at a time. Pipes are supplied from the magrittr package (https://magrittr.tidyverse.org/), which is installed together with dplyr package from the tidyverse collection. Therefore, to use pipes, we will call the tidyverse collection. In the code, pipes from the magrittr are denoted as %>%.

More information about pipes you can find here:

An Introduction to the Pipe in RTowards Data Science

Beginner’s Guide to Piping Data in RThe CodeHub

11 Using Pipes | R for Epidemiology

Pipe — %>%

According to the tidyverse style guide (https://style.tidyverse.org/pipes.html), in the code, before a pipe symbol, one should leave a space. Every new step in the pipeline should be started from a new line to increase readability, except for very short pipelines. After the first step in the pipeline, the next step in the new line should be indented by two spaces. This way, it is easier to add additional lines of code and less likely to overlook a step of a process.

If a function used in the pipeline has long arguments, it is good to split them and put each argument on its own line.

If we want to keep the output from the pipeline as an R object, we can assign it at the beginning, in one line of code with a pipeline, or in two separate lines; the tidyverse style guide allows assigning objects at the end of a pipeline, too.

However, in this Gitbook, we will mostly rely on the first option. Below, you will find examples of pipelines adhering to these rules:

# Using pipes for the first time
# Step 1: call library
library(tidyverse)

# First exemplary pipe (short pipe - command in one line)
# Arranging CE 16:1 concentrations in descending order (from high to low)
data %>% arrange(desc(`CE 16:1`))

# Explanation of the pipe:
# 1) Take object 'data' from the global environment, 
# 2) Push it through the pipe (from the left to the right), 
# 3) Pull the column `CE 16:1`, 
# 4) Arrange concentrations from high to low (descending order).


# Alternatively, you could use:
data %>%
  arrange(desc(`CE 16:1`))

# or without pipe (pipe is not necessary for short operations)
arrange(data, desc(`CE 16:1`))

Output of the first pipeline.

Now, take a look at the following block of code presenting long pipelines:

# Long pipeline - style guide for pipes (PIPELINE 1) 
data %>% 
  select(`Label`, `SM 39:1;O2`) %>%
  filter(Label == 'N' | Label == 'T') %>%
  group_by(Label) %>%
  summarize_if(is.numeric, mean)
  
# Explanation:
# 1) Take 'data' tibble from the global environment,
# 2) Push through the pipe,
# 3) Select columns: `Label` & `SM 39:1;O2` from 'data',
# 4) Push through the pipe,
# 5) Filter entries using `Label` column: keep entries containing `Label` 'N' OR 'T',
# 6) Push through the pipe,
# 7) Group by `Label`,
# 8) Push through the pipe,
# 9) Use 'summarize' if a column is numeric - calculate the mean for it. 
  
# Pipeline with functions containing long arguments: select, pivot_longer, summarise; 
# (PIPELINE 2)
data %>% 
  select(`Sample Name`,
         `Label`, 
         `LPC 16:0`,
         `LPC 18:0`,
         `LPC 18:1`,
         `LPC 18:2`,
         `SM 32:1;O2`,
         `SM 39:1;O2`,
         `SM 41:1;O2`) %>%
  pivot_longer(cols = `LPC 16:0`:`SM 41:1;O2`, 
               names_to = 'Lipids', 
               values_to = 'Concentration') %>%
filter(Label == 'N' | Label == 'T') %>%
  group_by(Label, Lipids) %>%
  summarise(
    `Mean concentration` = mean(Concentration),
    `SD concentration` = sd(Concentration))

# Explanation:
# 1) Take 'data' tibble from the global environment,
# 2) Push through the pipe,
# 3) Select columns,
# 4) Change the wide data frame into a long data frame,
# 5) Filter entries using `Label` column: keep 'N' OR 'T' entries,
# 6) Push through the pipe,
# 7) Group entries by `Label` and then `Lipids` (long table!),
# 8) Summarize the long table grouping data by `Label` & `Lipids`: calculate mean & sd

The output of both pipelines looks like this:

Console after executing lines of code for PIPELINE 1 and 2: A/ Executed code and output of PIPELINE 1 - means calculated for N and T for concentrations of SM 39:1;O2. B/ Executed code and output of PIPELINE 2 - means and standard deviations calculated for N and T for concentrations of selected lipids.

Finally, we will show you how you can store the outputs of pipelines. Please see the code block below:

# Three ways of storing the output of pipelines (assignment):
# 1) At the beginning of the code, in one line with the pipeline, 
# as 'mean.value' object, with <-:

mean.value <- data %>% 
  select(`Label`, `SM 39:1;O2`) %>%
  filter(Label == 'N' | Label == 'T') %>%
  group_by(Label) %>%
  summarize_if(is.numeric, mean)
  
# 2) At the beginning of the code, in two separate lines, 
# as 'mean.value' object, with <-:

mean.value <- 
  data %>% 
  select(`Label`, `SM 39:1;O2`) %>%
  filter(Label == 'N' | Label == 'T') %>%
  group_by(Label) %>%
  summarize_if(is.numeric, mean)
  
# 3) At the end of the code, as 'mean.value' object, with ->:

data %>% 
  select(`Label`, `SM 39:1;O2`) %>%
  filter(Label == 'N' | Label == 'T') %>%
  group_by(Label) %>%
  summarize_if(is.numeric, mean) ->
  mean.value

You can find the script containing all of the code blocks here:

3KB

Pipes in R via magrittr (dplyr - tidyverse).R

All blocks of code from this subchapter gathered in one R script.

Now that you know how the pipe function works, let's actively use it for OMICs analysis in the following chapters!