rlang: call2 – R documentation

Become an expert in R — Interactive courses, Cheat Sheets, certificates and more!

call2

Create a call

Description

Quoted function calls are one of the two types of symbolic objects in R. They represent the action of calling a function, possibly with arguments. There are two ways of creating a quoted call:

By quoting it. Quoting prevents functions from being called. Instead, you get the description of the function call as an R object. That is, a quoted function call.
By constructing it with base::call(), base::as.call(), or call2(). In this case, you pass the call elements (the function to call and the arguments to call it with) separately.

See section below for the difference between call2() and the base constructors.

Usage

call2(.fn, ..., .ns = NULL)

Arguments

`.fn`	Function to call. Must be a callable object: a string, symbol, call, or a function.
`...`	<dynamic> Arguments for the function call. Empty arguments are preserved.
`.ns`	Namespace with which to prefix `.fn`. Must be a string or symbol.

Difference with base constructors

call2() is more flexible and convenient than base::call():

The function to call can be a string or a callable object: a symbol, another call (e.g. a $ or [[ call), or a function to inline. base::call() only supports strings and you need to use base::as.call() to construct a call with a callable object.
```
call2(list, 1, 2)

as.call(list(list, 1, 2))
```

The .ns argument is convenient for creating namespaced calls.

call2("list", 1, 2, .ns = "base")

ns_call <- as.call(list(as.name("::"), as.name("list"), as.name("base")))
as.call(list(ns_call, 1, 2))

call2() has tidy dots support and you can splice lists of arguments with !!!. With base R, you need to use as.call() instead of call() if the arguments are in a list.
```
args <- list(na.rm = TRUE, trim = 0)

call2("mean", 1:10, !!!args)

as.call(c(list(as.name("mean"), 1:10), args))
```

Caveats of inlining objects in calls

call2() makes it possible to inline objects in calls, both in function and argument positions. Inlining an object or a function has the advantage that the correct object is used in all environments. If all components of the code are inlined, you can even evaluate in the empty environment.

However inlining also has drawbacks. It can cause issues with NSE functions that expect symbolic arguments. The objects may also leak in representations of the call stack, such as traceback().

Examples

# fn can either be a string, a symbol or a call
call2("f", a = 1)
call2(quote(f), a = 1)
call2(quote(f()), a = 1)

#' Can supply arguments individually or in a list
call2(quote(f), a = 1, b = 2)
call2(quote(f), !!!list(a = 1, b = 2))

# Creating namespaced calls is easy:
call2("fun", arg = quote(baz), .ns = "mypkg")

# Empty arguments are preserved:
call2("[", quote(x), , drop = )

rlang

Functions for Base Types and Core R and 'Tidyverse' Features

v0.4.11

MIT + file LICENSE

Authors

Lionel Henry [aut, cre], Hadley Wickham [aut], mikefc [cph] (Hash implementation based on Mike's xxhashlite), Yann Collet [cph] (Author of the embedded xxHash library), RStudio [cph]

Initial release