Introduction

In R, both = and <- can assign values, but they do not play exactly the same role in the language. The practical distinction is mostly about parser behavior and readability: <- is the conventional assignment operator, while = also serves as the syntax for naming function arguments.

Both Can Assign at Top Level

At the console or in ordinary statements, both forms work:

1x <- 5
2y = 10
3
4print(x)
5print(y)

So for simple top-level assignment, the language accepts both.

Why R Users Prefer <-

The main reason is clarity. In R, = has a second major role inside function calls:

mean(x = c(1, 2, 3))

Here, x = is not assigning to a variable in your workspace. It is naming the argument x for the mean function.

Because = is used so heavily in function calls, many R users prefer:

• '<- for assignment'
• '= for function arguments'

That convention makes code easier to scan quickly.

Example of the Difference in Practice

Assignment:

numbers <- c(1, 2, 3)

Function argument naming:

mean(x = numbers, trim = 0)

If you use = for both kinds of operations everywhere, the syntax still works in many places, but it becomes easier to misread what the code is doing.

Contexts Where = Is More Limited

= does not behave as flexibly as <- in every expression context. For example, R is much happier with <- in constructs where the parser expects assignment-like behavior.

This works:

if ((x <- 5) > 3) {
  print(x)
}

Using = in similar expression-heavy situations is more awkward or may fail to parse the way you expect.

That is one reason <- is considered the more general assignment form in normal R code.

There Are Other Assignment Operators Too

R also has:

• '<<- for superassignment to a parent environment'
• '-> and ->> for rightward assignment'

Example:

value <- 10
10 -> other_value

Those exist, but ordinary scripts should usually stick with <- unless there is a good reason not to.

Readability and Style

Consider these two versions:

df = data.frame(a = 1:3, b = 4:6)
result = subset(df, a > 1)

df <- data.frame(a = 1:3, b = 4:6)
result <- subset(df, a > 1)

The second version makes it visually obvious which = signs belong to function arguments and which operations are assignments. That is the main style argument for <-.

What About the Tidyverse Style

Modern R code in the tidyverse still overwhelmingly uses <- for assignment, even though pipes and other syntax choices have evolved. This reflects a broad ecosystem norm rather than an obscure historical relic.

If you are reading tutorials, packages, or production R code, <- will almost always be the default assignment operator you see.

Common Pitfalls

The biggest mistake is assuming = and <- are completely identical everywhere. They overlap heavily, but parser context and readability considerations still make <- the safer default for assignment.

Another issue is mixing = assignment with heavy function-call syntax in the same block. Because = also names arguments, the code becomes harder to scan, especially for people used to standard R style.

Finally, do not confuse assignment with comparison. In R, equality testing uses ==, not =. That distinction matters no matter which assignment operator style you choose.

Summary

• Both = and <- can assign values in many ordinary R statements.
• '<- is the conventional and clearer assignment operator in R code.'
• '= is also used for naming function arguments, which is why many R users avoid it for general assignment.'
• '<- works more naturally in expression contexts where assignment is intended.'
• Use == for comparison; neither = nor <- is an equality test.