You can access the quosure components (its expression and its environment) with:

  • get_expr() and get_env(). These getters also support other kinds of objects such as formulas.

  • quo_get_expr() and quo_get_env(). These getters only work with quosures and throw an error with other types of input.

Note that a quosure usually does not carry environments for literal objects like strings or numbers. quo() and enquo() only capture an environment for symbolic expressions.

Test if an object is a quosure with is_quosure(). If you know an object is a quosure, use the quo_ prefixed predicates to check its contents, quo_is_missing(), quo_is_symbol(), etc.

is_quosure(x)

quo_is_missing(quo)

quo_is_symbol(quo, name = NULL)

quo_is_call(quo, name = NULL, n = NULL, ns = NULL)

quo_is_symbolic(quo)

quo_is_null(quo)

quo_get_expr(quo)

quo_get_env(quo)

quo_set_expr(quo, expr)

quo_set_env(quo, env)

Arguments

x

An object to test.

quo

A quosure to test.

name

The name of the symbol or function call. If NULL the name is not tested.

n

An optional number of arguments that the call should match.

ns

The namespace of the call. If NULL, the namespace doesn't participate in the pattern-matching. If an empty string "" and x is a namespaced call, is_call() returns FALSE. If any other string, is_call() checks that x is namespaced within ns.

Can be a character vector of namespaces, in which case the call has to match at least one of them, otherwise is_call() returns FALSE.

expr

A new expression for the quosure.

env

A new environment for the quosure.

Empty quosures

When missing arguments are captured as quosures, either through enquo() or quos(), they are returned as an empty quosure. These quosures contain the missing argument and typically have the empty environment as enclosure.

Life cycle

  • is_quosure() is stable.

  • quo_get_expr() and quo_get_env() are stable.

  • is_quosureish() is deprecated as of rlang 0.2.0. This function assumed that quosures are formulas which is currently true but might not be in the future.

See also

quo() for creating quosures by quotation; as_quosure() and new_quosure() for constructing quosures manually.

Examples

quo <- quo(my_quosure) quo
#> <quosure> #> expr: ^my_quosure #> env: 0x78f6570
# Access and set the components of a quosure: quo_get_expr(quo)
#> my_quosure
quo_get_env(quo)
#> <environment: 0x78f6570>
quo <- quo_set_expr(quo, quote(baz)) quo <- quo_set_env(quo, empty_env()) quo
#> <quosure> #> expr: ^baz #> env: empty
# Test wether an object is a quosure: is_quosure(quo)
#> [1] TRUE
# If it is a quosure, you can use the specialised type predicates # to check what is inside it: quo_is_symbol(quo)
#> [1] TRUE
quo_is_call(quo)
#> [1] FALSE
quo_is_null(quo)
#> [1] FALSE
# quo_is_missing() checks for a special kind of quosure, the one # that contains the missing argument: quo()
#> <quosure> #> expr: ^ #> env: empty
quo_is_missing(quo())
#> [1] TRUE
fn <- function(arg) enquo(arg) fn()
#> <quosure> #> expr: ^ #> env: empty
quo_is_missing(fn())
#> [1] TRUE