These functions parse and transform text into R expressions. This is the first step to interpret or evaluate a piece of R code written by a programmer.
parse_expr() returns one expression. If the text contains more
than one expression (separated by semicolons or new lines), an
error is issued. On the other hand parse_exprs() can handle
multiple expressions. It always returns a list of expressions
(compare to base::parse() which returns a base::expression
vector). All functions also support R connections.
parse_quo() and parse_quos() are variants that create a
quosure that inherits from the global environment by
default. This is appropriate when you're parsing external user
input to be evaluated in user context (rather than the private
contexts of your functions).
Unlike quosures created with enquo(), enquos(), or {{, a
parsed quosure never contains injected quosures. It is thus safe
to evaluate them with eval() instead of eval_tidy(), though
the latter is more convenient as you don't need to extract expr
and env.
parse_expr(x) parse_exprs(x) parse_quo(x, env = global_env()) parse_quos(x, env = global_env())
| x | Text containing expressions to parse_expr for
|
|---|---|
| env | The environment for the quosures. The global environment (the default) may be the right choice when you are parsing external user inputs. You might also want to evaluate the R code in an isolated context (perhaps a child of the global environment or of the base environment). |
parse_expr() returns an expression,
parse_exprs() returns a list of expressions. Note that for the
plural variants the length of the output may be greater than the
length of the input. This would happen is one of the strings
contain several expressions (such as "foo; bar"). The names of
x are preserved (and recycled in case of multiple expressions).
The _quo suffixed variants return quosures.
# parse_expr() can parse any R expression: parse_expr("mtcars %>% dplyr::mutate(cyl_prime = cyl / sd(cyl))") #> mtcars %>% dplyr::mutate(cyl_prime = cyl/sd(cyl)) # A string can contain several expressions separated by ; or \n parse_exprs("NULL; list()\n foo(bar)") #> [[1]] #> NULL #> #> [[2]] #> list() #> #> [[3]] #> foo(bar) #> # Use names to figure out which input produced an expression: parse_exprs(c(foo = "1; 2", bar = "3")) #> $foo #> [1] 1 #> #> $foo #> [1] 2 #> #> $bar #> [1] 3 #> # You can also parse source files by passing a R connection. Let's # create a file containing R code: path <- tempfile("my-file.R") cat("1; 2; mtcars", file = path) # We can now parse it by supplying a connection: parse_exprs(file(path)) #> [[1]] #> [1] 1 #> #> [[2]] #> [1] 2 #> #> [[3]] #> mtcars #>