Master paste0() in R: The Ultimate Guide You’ll Ever Need

The R programming language, a foundational tool for data science, empowers users to manipulate and analyze information effectively; string manipulation, a key aspect of data processing, is greatly facilitated by functions like paste0(); the tidyverse package, a collection of R packages designed for data science, complements base R functionalities, sometimes offering alternative approaches to string concatenation; RStudio, an integrated development environment (IDE) for R, enhances the coding experience with features such as code completion and debugging tools. This guide dives deep into mastering paste0() in R, ensuring you unlock its full potential for streamlined and efficient data manipulation. So, whether you’re a beginner or an experienced coder, you are about to elevate your understanding of paste0 in r.

The R programming language has become a cornerstone in the field of data science, celebrated for its robust statistical capabilities and extensive ecosystem of packages. Within this environment, the ability to manipulate strings effectively is paramount.

From cleaning messy datasets to generating insightful reports, string manipulation is an indispensable skill for any data professional.

The Indispensable Role of String Concatenation

String concatenation, the process of combining multiple text strings into one, stands out as a fundamental operation.

It allows data scientists to create new variables, standardize data formats, and produce human-readable outputs.

Consider scenarios like creating unique identifiers, formatting dates, or generating file names dynamically.

Each of these relies heavily on the ability to seamlessly join strings together. Without efficient string concatenation, many data manipulation tasks would become significantly more complex and time-consuming.

paste0(): A Core Tool in Base R

Among the various tools available in R for string manipulation, the paste0() function holds a special place. As a part of Base R, it’s readily accessible without the need for external packages, making it an essential tool for every R user.

paste0() is specifically designed for string concatenation, providing a straightforward and efficient way to combine character vectors. Its simplicity and reliability have made it a go-to function for both beginners and experienced R programmers.

Purpose of This Guide

This article aims to serve as a comprehensive guide to the paste0() function in R.

We will delve into its syntax, explore its various applications, and uncover advanced techniques for leveraging its power.

Whether you’re a novice seeking to understand the basics or a seasoned R user looking to refine your skills, this guide will provide you with the knowledge and practical examples to master paste0() and elevate your string manipulation capabilities in R.

The purpose of this guide is to equip you with the knowledge and skills necessary to harness the full potential of paste0(). Before we delve into the intricacies of its syntax and advanced applications, let’s take a step back and clarify what paste0() actually is and why it’s such a vital function for anyone working with strings in R.

Demystifying paste0(): What It Is and Why It Matters

At its core, paste0() is a function in R specifically designed for string concatenation.

String concatenation is the process of joining two or more character strings end-to-end to create a single, combined string.

Defining paste0()

paste0() takes any number of R objects as input, converts them to character strings (if they aren’t already), and then concatenates them.

The key feature of paste0() is that it performs this concatenation without adding any spaces between the strings.

This behavior makes it particularly useful when you need precise control over the final output, such as when creating IDs, file paths, or formatted labels.

The Role of paste0() in String Concatenation

In the realm of data manipulation, paste0() plays a crucial role.

It provides a simple and efficient way to combine disparate pieces of textual information into meaningful strings.

For instance, you might use paste0() to:

• Construct file names from a base name and a file extension.
• Create unique identifiers by combining a prefix and a numerical sequence.
• Generate labels for plots and tables by merging variable names with descriptive text.

paste0() vs. paste(): Understanding the Key Difference

R offers another function for string concatenation called paste(). While both functions serve the same general purpose, there’s a critical distinction between them: the separator.

The paste() function, by default, inserts a space (" ") between the concatenated strings.

In contrast, paste0() provides no separator by default.

This difference can significantly impact the final output. Consider these examples:

paste("Hello", "World") # Output: "Hello World"
paste0("Hello", "World") # Output: "HelloWorld"

While paste() does offer a sep argument to modify the separator, paste0()‘s default behavior often makes it more convenient when you need to combine strings without any intervening characters.

Basic Syntax and Usage

The basic syntax of paste0() is straightforward:

paste0(..., collapse = NULL)

Here, ... represents one or more R objects that you want to concatenate, and collapse is an optional argument that we’ll discuss in detail later.

Let’s illustrate with some simple examples:

# Concatenating two strings
paste0("R", "Programming") # Output: "RProgramming"

# Concatenating a string and a number
paste0("Value: ", 123) # Output: "Value: 123"

# Concatenating multiple strings
paste0("A", "B", "C", "D") # Output: "ABCD"

These examples demonstrate the fundamental usage of paste0(): taking inputs and seamlessly merging them into a single string.

As you can see, paste0() offers a clean and intuitive way to perform basic string concatenation tasks in R. In the following sections, we’ll delve deeper into its arguments, explore its behavior with vectors, and uncover advanced techniques for leveraging its full potential.

Demystifying paste0() has hopefully illuminated its fundamental purpose and its importance in R. Now, to truly master this function, we need to delve into the specifics of its syntax. Understanding the arguments it accepts is crucial for leveraging its full potential and crafting sophisticated string manipulations.

Dissecting the Syntax: Understanding paste0()’s Arguments

The paste0() function, at first glance, might seem deceptively simple. However, its power lies in its flexibility and the arguments it accepts. Understanding these arguments is key to unlocking its full potential.

Breaking Down the Syntax

The general syntax of paste0() is as follows:

paste0(..., collapse = NULL)

Let’s break down each component:

• paste0(): This is the name of the function itself.

• ...: This is a special argument in R that allows you to pass in any number of arguments to the function. In the context of paste0(), these arguments are the R objects that you want to concatenate. These can be character vectors, numbers, logical values, or even more complex objects. paste0() will attempt to convert them into character strings before concatenating them.

• collapse = NULL: This is an optional argument that controls how the elements of a character vector are joined together into a single string. By default, collapse is set to NULL, which means that paste0() will concatenate the corresponding elements of the input vectors element-wise. If you provide a character string to the collapse argument, paste0() will concatenate all the elements of the input vectors into a single string, separated by the specified string.

The Power of ...: Concatenating Multiple Objects

The ellipsis (...) argument is arguably the most important part of paste0(). It grants the function its remarkable versatility. This argument enables paste0() to accept an arbitrary number of inputs, each of which will be converted to a character string (if it isn’t one already) and then concatenated.

Consider these examples:

paste0("Hello", "World") # Output: "HelloWorld"
paste0("The value of pi is ", pi) # Output: "The value of pi is 3.14159265358979"
paste0("File", 1:3, ".txt") # Output: "File1.txt" "File2.txt" "File3.txt"

In the first example, we concatenate two simple strings.

In the second, we combine a string with the numerical value of pi. Notice how paste0() automatically converts pi to its character representation.

The third example showcases paste0()‘s ability to handle vectors. It concatenates the string "File" with each number in the sequence 1 to 3, and then adds the extension ".txt" to each. The result is a character vector of length 3.

collapse: Creating Single Strings from Vectors

The collapse argument offers a way to condense a vector of strings into a single, unified string.

When collapse is left as NULL (the default), paste0() operates element-wise. But when you assign a character string to collapse, paste0() concatenates all the elements into one string, using your specified string as a separator.

Let’s illustrate:

my_vector <- c("apple", "banana", "cherry")

paste0(my_vector) # Output: "apple" "banana" "cherry"
paste0(myvector, collapse = ", ") # Output: "apple, banana, cherry"
paste0(myvector, collapse = " and ") # Output: "apple and banana and cherry"

The first paste0() call, without collapse, simply returns the original vector. The second call uses ", " as the collapse argument, creating a comma-separated string. The third call uses " and " as the collapse argument, creating a string separated by " and ".

This feature is incredibly useful for generating reports, creating labels, or formatting data for output. Consider creating a sentence from a vector of words or constructing a file path from a vector of directory names. The collapse argument provides an elegant and efficient solution.

Demystifying paste0() has hopefully illuminated its fundamental purpose and its importance in R. Now, to truly master this function, we need to delve into the specifics of its syntax. Understanding the arguments it accepts is crucial for leveraging its full potential and crafting sophisticated string manipulations.

Concatenating Like a Pro: Working with Character Vectors in paste0()

paste0() truly shines when working with character vectors.

A character vector, in its simplest form, is an ordered collection of strings.

Understanding how paste0() handles these vectors is essential for performing complex string operations.

This understanding allows you to efficiently manipulate and combine textual data.

paste0() and Character Vectors: A Fundamental Overview

At its core, paste0() is designed to concatenate strings.

When you provide it with single strings, the operation is straightforward.

However, the true power of paste0() becomes apparent when you feed it character vectors.

paste0() then intelligently combines corresponding elements from each vector.

This element-wise concatenation opens doors to a wide range of possibilities.

For example, you can create dynamic labels or generate file names based on variable data.

Concatenating Multiple Vectors: Unleashing the Power

One of the most common use cases for paste0() is concatenating multiple vectors.

This allows you to combine data from different sources into a single, coherent string.

Imagine you have one vector containing first names and another containing last names.

paste0() can effortlessly create a vector of full names by combining these two.

The result is a new character vector where each element is the concatenation of the corresponding elements from the input vectors.

This is an essential technique for data cleaning, transformation, and report generation.

Recycling: Handling Vectors of Different Lengths

R has a clever feature called "recycling."

Recycling automatically adjusts vector lengths during operations.

When paste0() encounters vectors of different lengths, the shorter vector is "recycled."

Recycling repeats its elements until it matches the length of the longest vector.

Consider concatenating a vector of names with a single greeting string.

The greeting will be recycled and applied to each name in the vector.

This can be incredibly useful for adding prefixes or suffixes to a list of items.

Understanding Recycling Results

It’s important to understand how recycling affects the results of paste0().

If the length of the longer vector isn’t a multiple of the shorter vector, R will issue a warning.

This is R’s way of alerting you to potential data mismatches.

While the concatenation will still occur, the warning indicates a possible logical error.

For example, maybe you’re missing data in one of the vectors.

Therefore, it’s crucial to carefully examine the input vectors and ensure that recycling produces the intended outcome.

Use Case Scenarios: Practical Applications

The flexibility of paste0() and its handling of character vectors makes it indispensable in various scenarios.

Here are a few examples:

• Creating Unique Identifiers: Combine user IDs with timestamps to generate unique identifiers for database entries.

• Generating File Paths: Construct file paths dynamically by concatenating directory names, file names, and extensions.

• Building SQL Queries: Assemble SQL queries programmatically by combining table names, column names, and conditions.

• Creating Labels for Plots: Generate informative labels for plots and charts by combining variable names and calculated statistics.

By mastering these techniques, you can significantly enhance your data manipulation capabilities in R.

The ability to seamlessly combine strings is invaluable. But the real magic happens when you begin to integrate paste0() into more complex operations. Leveraging it alongside other functions and control flow structures can unlock powerful data manipulation techniques.

Beyond the Basics: Advanced Uses of paste0() in R

paste0() is more than just a simple concatenation tool; it’s a building block for sophisticated string manipulation within R. We can amplify its utility by combining it with other Base R functions and employing it within loops and conditional statements. Crucially, we’ll also explore how to effectively manage NA values during concatenation.

Harnessing paste0() with Other Base R Functions

The true potential of paste0() emerges when used in conjunction with other Base R functions. This allows for efficient and elegant solutions to complex string-related tasks.

For instance, consider generating a sequence of file names. You might want to create files named "data1.csv", "data2.csv", and so on.

This can be easily accomplished by combining paste0() with the seq() function.

filenames <- paste0("data", seq(1, 10), ".csv")
print(file

_names)

Here, seq(1, 10) generates a sequence of numbers from 1 to 10.

paste0() then combines each number with the prefix "data_" and the suffix ".csv", creating the desired file names.

Another useful combination is with the substr() function.

Imagine you want to extract a portion of a string and then combine it with other text.

text <- "ThisIsAString"
prefix <- "Extracted: "
extractedpart <- substr(text, 5, 9) # Extracts "IsASt"
finalstring <- paste0(prefix, extractedpart)
print(finalstring) # Output: "Extracted: IsASt"

substr() extracts a substring from text, and paste0() then neatly combines it with a descriptive prefix.

These are just a few examples. The possibilities are endless.

The key is to think creatively about how paste0() can be integrated with other functions to achieve your desired outcome.

paste0() in Loops and Conditional Statements

Integrating paste0() into loops and conditional statements empowers you to perform dynamic string manipulation based on specific conditions or iterations.

This is particularly useful when dealing with large datasets or when you need to generate strings based on varying criteria.

Using paste0() Within Loops

Loops allow you to repeat a specific action multiple times.

When combined with paste0(), this enables the creation of strings that change with each iteration.

Consider creating a series of labels for different groups in a dataset.

for (i in 1:5) {
label <- paste0("Group ", i)
print(label)
}

In this example, the loop iterates five times.

In each iteration, paste0() creates a new label by combining the string "Group " with the current value of i.

This is especially useful for generating reports or analyses where labels need to be dynamically created.

paste0() and Conditional Logic

Conditional statements (using if, else if, and else) allow you to execute different code blocks based on whether a certain condition is true or false.

By incorporating paste0() within these statements, you can create strings that vary depending on the data being processed.

value <- 75
status <- if (value > 50) {
paste0("Value is greater than 50 (", value, ")")
} else {
paste0("Value is less than or equal to 50 (", value, ")")
}
print(status)

Here, the if statement checks if the value is greater than 50.

Based on the result, paste0() creates a different status message.

This allows for personalized and informative outputs based on the specific data being analyzed.

Taming NA Values: Handling Missing Data

A common challenge in data manipulation is dealing with missing values, represented as NA in R.

When using paste0(), NA values can lead to unexpected results.

By default, paste0() converts NA values to the character string "NA".

This might not be the desired outcome. It’s essential to understand how paste0() handles NA and implement strategies to manage them effectively.

Understanding NA Conversion

Let’s illustrate the default behavior.

name <- c("Alice", "Bob", NA, "David")
greeting <- paste0("Hello, ", name, "!")
print(greeting)

You’ll notice that the third element in greeting becomes "Hello, NA!".

This is because paste0() converted the NA to the string "NA".

Strategies for Handling NA Values

Several techniques can be used to handle NA values more gracefully during concatenation.

One approach is to use the ifelse() function to replace NA values with a more appropriate string, such as an empty string or a custom message.

name <- c("Alice", "Bob", NA, "David")
greeting <- paste0("Hello, ", ifelse(is.na(name), "Guest", name), "!")
print(greeting)

In this case, is.na(name) checks for NA values in the name vector.

Where an NA is found, ifelse() substitutes "Guest"; otherwise, it uses the original name.

Another option is to filter out NA values before concatenation.

This is useful when you want to exclude elements with missing data from the final result.

name <- c("Alice", "Bob", NA, "David")
validnames <- name[!is.na(name)] # Keep only non-NA values
greeting <- paste0("Hello, ", validnames, "!")
print(greeting)

Here, !is.na(name) creates a logical vector indicating which elements of name are not NA.

This logical vector is then used to subset name, creating a new vector valid_names that contains only the non-missing names.

By understanding these techniques, you can ensure that NA values are handled appropriately, resulting in cleaner and more meaningful string manipulations.

Exploring Alternatives: Other String Concatenation Options in R

While paste0() provides a solid foundation for string manipulation in R, it’s not the only tool in the shed. R boasts a rich ecosystem of functions and packages designed to handle string concatenation and formatting, each with its own strengths and use cases. Understanding these alternatives allows you to choose the most efficient and readable approach for a given task. Let’s explore some prominent options.

sprintf(): Precise Formatting Control

The sprintf() function, inherited from C, offers powerful formatting capabilities. Unlike paste0(), which primarily concatenates strings, sprintf() allows you to embed variables within a template string, specifying the precise format of each variable.

This is particularly useful when you need to control the number of decimal places, add leading zeros, or align text in a specific way. The syntax involves a format string with placeholders (e.g., %s for strings, %d for integers, %f for floating-point numbers) and a list of variables to be inserted.

For example, to create a string with a formatted floating-point number:

name <- "Value"
number <- 3.14159
formattedstring <- sprintf("%s: %.2f", name, number)
print(formattedstring) # Output: "Value: 3.14"

sprintf() shines when precision in formatting is paramount, offering a level of control that paste0() can’t match directly.

The glue Package: Expressive String Interpolation

The glue package provides an elegant and intuitive way to perform string interpolation in R. It allows you to embed R expressions directly within strings using curly braces {}.

This approach is often more readable and less error-prone than paste0() or sprintf(), especially when dealing with complex expressions.

To use glue, you first need to install and load the package:

install.packages("glue")
library(glue)

Then, you can create strings like this:

name <- "Alice"
age <- 30
greeting <- glue("Hello, my name is {name} and I am {age} years old.")
print(greeting) # Output: "Hello, my name is Alice and I am 30 years old."

glue excels in situations where readability and conciseness are key, making string interpolation a breeze.

The stringr Package: A Comprehensive String Toolkit

The stringr package, part of the tidyverse, offers a consistent and user-friendly interface for a wide range of string manipulation tasks, including concatenation. While it doesn’t have a direct equivalent to paste0(), it provides functions like str

_c() that offer similar functionality with added benefits.

str_c(), for instance, provides more explicit control over the separator and handles NA values more gracefully than paste0() by default. Furthermore, stringr provides a wealth of other string-related utilities, such as pattern matching, replacement, and extraction.

The stringr package is a go-to choice for comprehensive string manipulation, providing a cohesive set of tools for various tasks.

The purrr Package: Functional String Manipulation

The purrr package, another member of the tidyverse, brings functional programming principles to R. While not specifically designed for string concatenation, purrr can be effectively used in conjunction with other string functions to perform complex and iterative string operations.

For example, you can use purrr::map() to apply a string concatenation function to each element of a list or vector. This is particularly useful when you need to generate strings based on data stored in complex data structures.

purrr empowers you with powerful and flexible string manipulation techniques, especially when dealing with lists, vectors, and functional programming paradigms.

sprintf() shines when precision in formatting is paramount, offering a level of control that paste0() can’t match directly. While these alternatives offer unique capabilities, mastering paste0() remains essential for any R programmer. Let’s delve into some best practices and essential tips to elevate your paste0() game.

Mastering paste0(): Best Practices and Essential Tips

Efficient, readable, and maintainable code is the hallmark of a skilled programmer. When wielding paste0(), adopting certain practices can significantly improve your code’s quality and prevent common pitfalls.

Prioritizing Efficient Coding Style

Efficiency in coding isn’t just about speed; it’s about resource utilization and minimizing computational overhead. While paste0() is generally efficient, certain approaches can optimize its performance further.

Pre-allocate when possible: If you’re concatenating a large number of strings within a loop, consider pre-allocating a character vector to store the results. This avoids the overhead of repeatedly resizing the vector.

For example, instead of growing a vector with each iteration:

results <- character(length = 100) # Pre-allocate
for (i in 1:100) {
results[i] <- paste0("String ", i)
}

Avoid unnecessary operations: Streamline your code by removing redundant steps. If you’re only concatenating two strings, paste0(string1, string2) is often more efficient than creating a vector c(string1, string2) and then using paste0(collapse = "").

Leverage vectorization: paste0() is vectorized, meaning it operates element-wise on vectors. Exploit this feature to perform concatenations on entire vectors at once, rather than looping through elements individually. This will improve speed and enhance readability.

Readability and Maintainability: Crafting Clear Code

Code is read far more often than it is written. Therefore, prioritize readability and maintainability to make your code easier to understand, debug, and modify in the future.

Use meaningful variable names: Opt for descriptive variable names that clearly indicate the purpose of the strings being concatenated. Avoid generic names like x, y, or string1, which offer little insight.

Employ consistent formatting: Maintain a consistent coding style throughout your project, including indentation, spacing, and naming conventions. This enhances readability and reduces the cognitive load on anyone reading your code.

Add comments judiciously: Explain complex logic or non-obvious code sections with concise comments. However, avoid over-commenting, as excessive comments can clutter the code and make it harder to read. Aim for a balance between clarity and conciseness.

Break down complex concatenations: If you’re dealing with intricate concatenations involving multiple variables and conditions, consider breaking them down into smaller, more manageable steps. This improves readability and simplifies debugging.

Avoiding Common Errors: A Proactive Approach

While paste0() is relatively straightforward, certain common errors can trip up even experienced programmers. Being aware of these pitfalls can help you avoid them in the first place.

Be mindful of NA values: As previously mentioned, paste0() converts NA values to the string "NA". If you need to handle NA values differently (e.g., replace them with an empty string or remove them entirely), use conditional statements or functions like ifelse() or is.na() to preprocess the data before concatenation.

Check data types: Ensure that you’re concatenating character strings. If you’re working with numeric or other data types, you may need to convert them to strings using as.character() before using paste0().

Pay attention to recycling: Understand how paste0() handles vectors of different lengths through recycling. Ensure that recycling is occurring as intended and not producing unexpected results. If necessary, explicitly control the length of vectors using functions like rep() to avoid ambiguity.

Test thoroughly: Always test your code with a variety of inputs, including edge cases and boundary conditions, to ensure that it produces the expected results. Use unit tests to automate the testing process and catch errors early.

By adhering to these best practices and keeping these essential tips in mind, you can master paste0() and wield its power with confidence, writing efficient, readable, and maintainable R code.

Efficient coding style, readability, and maintainability are essential. But even with the best intentions, errors can creep in. Understanding common pitfalls and how to debug them is crucial for mastering paste0().

Troubleshooting paste0(): Debugging Common Errors

Like any programming function, paste0() can sometimes throw unexpected results or errors. Knowing how to diagnose and fix these issues is vital for smooth and efficient coding. This section addresses frequent problems encountered while using paste0(), providing practical troubleshooting tips and guiding you to helpful resources.

Common Errors and Their Causes

Several common errors can arise when using paste0(). Recognizing these errors and understanding their root causes is the first step toward effective debugging.

Unexpected NA Handling

One frequent point of confusion is how paste0() handles NA values. By default, paste0() converts NA values to the character string "NA" during concatenation.

This can lead to undesirable results if you’re expecting NA values to be treated differently (e.g., removed or replaced).

For instance:

x <- c("a", "b", NA, "d")
paste0("Prefix", x) # Output: "Prefixa" "Prefixb" "PrefixNA" "Prefix_d"

Incorrect Use of the collapse Argument

The collapse argument is powerful, but it can be misused. A common mistake is forgetting that collapse joins the elements of a single character vector after concatenation.

It doesn’t directly concatenate multiple vectors together in the way some might expect.

For example, if you intend to collapse after concatenating multiple vectors, ensure the concatenation is performed first:

vec1 <- c("a", "b")
vec2 <- c("c", "d")
paste0(vec1, vec2, collapse = ", ") # Correct: Collapses the result of vec1 & vec2

Mismatched Vector Lengths

paste0() utilizes R’s recycling feature, which can sometimes lead to unexpected outcomes. When concatenating vectors of unequal lengths, the shorter vector is recycled to match the length of the longest vector.

While this can be convenient, it can also introduce errors if not carefully managed. Always ensure that recycling aligns with your intended logic.

Type Mismatches

While paste0() is designed to handle various data types, unexpected type mismatches can still cause issues. Ensure the objects you are trying to concatenate are either character vectors or can be coerced into character vectors.

Explicitly converting values to character type using as.character() can resolve many type-related errors.

Troubleshooting Tips and Strategies

When you encounter an error or unexpected output with paste0(), these troubleshooting steps can help you pinpoint and resolve the problem.

Isolate the Issue

Simplify your code to isolate the exact line causing the problem. Comment out sections of your code or create smaller, reproducible examples to focus on the problematic paste0() call.

Inspect Your Data

Use functions like str(), typeof(), or print() to inspect the structure and content of the vectors you’re concatenating. Pay close attention to:

• Data types
• Vector lengths
• Presence of NA values or special characters

Use Conditional Checks

Implement conditional checks using if statements or ifelse() to handle specific cases or potential errors. For example, you can check for NA values and replace them with an empty string or a placeholder:

x <- c("a", "b", NA, "d")
result <- ifelse(is.na(x), "Missing", x)
paste0("Prefix_", result)

Test with Minimal Examples

Create minimal, self-contained examples that replicate the error. This helps in isolating the issue and makes it easier to seek help from others if needed.

Leveraging R Documentation and Online Resources

R provides extensive documentation and a vibrant online community to help you troubleshoot issues with paste0() and other functions.

R Documentation

The official R documentation is an invaluable resource. Use the ?paste0 command in your R console to access the documentation for paste0().

This documentation provides detailed information about the function’s arguments, behavior, and potential pitfalls.

Online Forums and Communities

• Stack Overflow: A popular question-and-answer website where you can find solutions to common R problems and ask for help with specific issues.
• R-help mailing list: A mailing list dedicated to R-related questions and discussions.
• RStudio Community: A forum for RStudio users to discuss R-related topics and seek help.

When seeking help online, be sure to provide a clear and reproducible example of your code, along with a description of the error you’re encountering. This makes it easier for others to understand your problem and provide effective assistance.

Alright, hopefully this guide helped you master paste0() in R! Go forth and concatenate – and remember, when in doubt, just paste0 in r!