A quosure is a type of quoted expression that includes a reference to the context where it was created. A quosure is thus guaranteed to evaluate in its original environment and can refer to local objects.
You can access the quosure components (its expression and its environment) with:
quo_get_env(). These getters only work
with quosures and throw an error with other types of input.
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
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)
An object to test.
A quosure to test.
The name of the symbol or function call. If
An optional number of arguments that the call should match.
The namespace of the call. If
Can be a character vector of namespaces, in which case the call
has to match at least one of them, otherwise
A new expression for the quosure.
A new environment for the quosure.
A quosure usually does not carry environments for constant objects like strings or numbers.
enquo() only capture an environment for symbolic expressions. For instance, all of these return the
quo_get_env(quo("constant")) quo_get_env(quo(100)) quo_get_env(quo(NA))
On the other hand, quosures capture the environment of symbolic expressions, i.e. expressions whose meaning depends on the environment in which they are evaluated and what objects are defined there:
When missing arguments are captured as quosures, either through
quos(), they are returned as an empty quosure. These
quosures contain the missing argument and typically
have the empty environment as enclosure.
is_quosure() is stable.
quo_get_env() are stable.
quo <- quo(my_quosure) quo#> <quosure> #> expr: ^my_quosure #> env: 0x894a140# Access and set the components of a quosure: quo_get_expr(quo)#> my_quosurequo_get_env(quo)#> <environment: 0x894a140>#> <quosure> #> expr: ^baz #> env: empty# Test wether an object is a quosure: is_quosure(quo)#>  TRUE# If it is a quosure, you can use the specialised type predicates # to check what is inside it: quo_is_symbol(quo)#>  TRUEquo_is_call(quo)#>  FALSEquo_is_null(quo)#>  FALSE# quo_is_missing() checks for a special kind of quosure, the one # that contains the missing argument: quo()#> <quosure> #> expr: ^ #> env: emptyquo_is_missing(quo())#>  TRUEfn <- function(arg) enquo(arg) fn()#> <quosure> #> expr: ^ #> env: emptyquo_is_missing(fn())#>  TRUE