R Anonymous Functions: The \\(x) Syntax That Replaces function(x)

R's \\(x) is a compact shorthand for function(x), introduced in R 4.1. It lets you write one-line inline functions inside sapply, purrr::map, and pipes without the usual boilerplate, and saves a named function object only for logic that really earns a name.

What does \\(x) do in R?

Most R users write function(x) x * 2 on autopilot and never notice that the keyword function is eight characters longer than it needs to be. R 4.1 added a backslash form, \(x) x * 2, that saves the noise in exactly the places it hurts most: inline helpers inside sapply, map, and pipes. The two forms produce the same function object, and we can prove it in one block.

Below, we build the same doubling function twice, once with function(x) and once with \(x), call both on the same input, and compare their bodies.

Both calls return 10, and identical(body(long), body(short)) is TRUE. The parser turns \(x) x * 2 into exactly the same R function object as function(x) x * 2. There is no runtime cost, no special class, no subtle difference in scoping, just fewer characters to type and read.

When should you use \\(x) instead of function(x)?

The whole point of \(x) is inline use, when the function is born, used once, and thrown away in the same expression. If you are going to bind the function to a name (as we just did with minus3), stick with function(x), it reads more like prose. Save \(x) for the spot where writing function(x) would push a one-liner onto two lines.

The classic example is sapply. Here we square each integer from 1 to 5 without ever naming the squaring function.

sapply walks 1:5 and hands each element to our \(x) x^2. The result is a numeric vector, stored in squares. Writing this as sapply(1:5, function(x) x^2) would work identically but makes the eye trip over the word function every time, noise you don't need.

The same pattern shines inside a pipe. Here we add 10 to each element as the last step of a pipeline.

Read it left-to-right: take 1:5, pipe it into sapply, and for each element apply \(x) x + 10. The pipe's readability depends on keeping each step short, and \(x) is what keeps the inline step short.

How does \\(x) compare to purrr's formula (~) syntax?

If you have read any tidyverse code from before 2022, you have seen a third way to write an anonymous function: the tilde form, ~ .x + 1. The purrr package invented this in the days when base R had no shorthand and typing function(x) felt painful. Now that \(x) exists in every R 4.1+ installation, purrr accepts all three forms, and the native \(x) form is the one to reach for in new code.

Figure 1: Three syntaxes for anonymous functions, all produce the same function object.

The block below shows all three styles producing the identical result with purrr::map_dbl.

All three vectors are equal because all three anonymous functions do the same thing. The difference is cosmetic: function(x) is the verbose baseline, \(x) is the shortest form that still names its argument, and ~ .x hides the argument behind a magic .x that only purrr (and rlang::as_function) understands.

What are the gotchas of \\(x) in R?

The \(x) form is small, but three rough edges catch new users: multi-argument forms, braced bodies, and calling an anonymous function immediately. Each one comes from how the parser reads \(...), and each has a one-line fix.

First, multiple arguments. The form takes any number of arguments separated by commas, just like function(...). Here we combine two vectors element-wise with Map.

Map walks the two input vectors in parallel and hands each pair of elements to \(x, y) x + y. Note that x and y are ordinary names, there is nothing magic about .x and .y. Those belong to purrr's tilde form, not to base R.

Second, braced vs unbraced bodies. A one-expression body needs no braces; multi-statement bodies do.

a uses a one-expression body, so no braces are needed. b uses a two-statement body, so the braces are required, the same rule you already know from function(x) { ... }. Notice the outer parentheses: we wrap the whole \(x) ... in ( ... ) so that R reads it as an expression that can be called with (5) immediately afterwards.

When should you NOT use an anonymous function?

Anonymous functions are a convenience, not a goal. Every time you write one, you pay three small costs: the function has no name in error messages, it cannot be unit tested on its own, and it cannot be reused from anywhere else. When any of those costs starts to matter, extract the body into a named function.

Figure 2: Decide inline \(x) vs a named function before you write it.

Compare the two blocks below. The first crams a multi-step scoring rule inline; the second pulls it out into score_row, which is now testable and reusable.

Both produce the same result, but the second version tells you what the inner logic means the moment you read its name. If score_row ever breaks, the stack trace will say score_row instead of FUN, which matters a lot the first time you are debugging at 11pm. And next quarter, when someone else needs the same rule, they can call score_row directly instead of copy-pasting a lambda.

Practice Exercises

These capstones combine the ideas from above. Each is solvable with the functions shown in this tutorial, try them before peeking at the solutions.

Exercise 1: Column means with map_dbl and \\(x)

Use purrr::map_dbl with an anonymous function to compute the mean of every column in mtcars. Store the result in my_means.

Exercise 2: Refactor a nested lambda into a named helper

The starting code below computes the mean of each numeric column for each species of iris, using two nested anonymous functions. Refactor it so the inner logic lives in a named helper col_means, and the outer sapply uses \(g) only as glue.

Complete Example

Let's put everything together. We'll compute per-species z-scores for each numeric column of iris, a small but realistic "apply per group" task. Z-scoring each column means subtracting its mean and dividing by its standard deviation, so every column ends up with mean 0 and standard deviation 1 within its group.

The outer lapply(split(iris[, 1:4], iris$Species), \(df) ...) walks the three species groups. Inside it, sapply(df, \(col) (col - mean(col)) / sd(col)) z-scores each numeric column using a second anonymous function. Both anonymous functions are one-liners used exactly once, the textbook sweet spot for \(x). The sanity checks at the end confirm the transformation worked: column means round to 0 and column standard deviations round to 1.

Summary

Key takeaways:

1. \(x) is pure sugar for function(x), same function object, no runtime cost.
2. Use it inline inside sapply, Map, Filter, Reduce, and every purrr::map* variant.
3. Multi-argument forms work: \(x, y) x + y.
4. Wrap the function in parentheses to call it immediately: (\(x) x + 1)(4).
5. If you would ever grep for, test, or reuse the logic, give it a real name.

References

1. R Core Team, NEWS for R 4.1.0: introduction of \(x) backslash syntax. Link
2. Wickham, H., Advanced R, 2nd Edition. Chapter 6: Functions. Link
3. Wickham, H., Advanced R, 2nd Edition. Chapter 9: Functionals. Link
4. purrr documentation, map() reference and argument-function forms. Link
5. rlang documentation, as_function() and how formulas become functions. Link
6. Jumping Rivers, New features in R 4.1.0: pipe and anonymous functions. Link
7. tidyverse blog, Differences between the base R and magrittr pipes. Link

Continue Learning

• Writing R Functions, Learn how named functions work in R, including defaults, ..., and return semantics.
• purrr map() Variants, The full map, map_dbl, map_df, map2, and pmap family, all of which accept \(x) forms.
• Reduce, Filter, Map in R, Base R's higher-order toolkit, and when each is sharper than a for loop.