NSE lazyeval::lazy vs. substitute when referring to variable names - r

Question

I'm still trying to wrap my head around non-standard evaluation and how it's used in dplyr. I'm having trouble understanding why lazy evaluation is important when the function arguments are variable names, and so the original context's environment doesn't seem important.
In the code below, the function select3() uses lazy evaluation, but fails (I believe) because it tries to follow the variable name order all the way to base::order.
Is it okay to use substitute as I have in my select4(), or is there some other way I should implement this function? When would it actually be important to save the original environment, when I really want those arguments to refer to variables?
Thank you!
library(dplyr)
library(lazyeval)
# Same as dplyr::select
select2 <- function(.data, ...) {
select_(.data, .dots = lazy_dots(...))
}
# I want to have two capture groups of variables, so I need named arguments.
select3 <- function(.data, group1, group2) {
out1 <- select_(.data, .dots = lazy(group1))
out2 <- select_(.data, .dots = lazy(group2))
list(out1, out2)
}
df <- data.frame(x = 1:2, y = 3:4, order = 5:6)
# select3 seems okay at first...
df %>% select2(x, y)
df %>% select3(x, y)
# But fails when the variable is a function defined in the namespace
df %>% select2(x, order)
df %>% select3(x, order)
# Error in eval(expr, envir, enclos) : object 'datafile' not found
# Using substitute instead of lazy works. But I'm not sure I understand the
# implications of doing this.
select4 <- function(.data, group1, group2) {
out1 <- select_(.data, .dots = substitute(group1))
out2 <- select_(.data, .dots = substitute(group2))
list(out1, out2)
}
df %>% select4(x, order)
PS on a related note, is this a bug or intended behavior?
select(df, z)
# Error in eval(expr, envir, enclos) : object 'z' not found
# But if I define z as a numeric variable it works.
z <- 1
select(df, z)
Update
A. Webb points out below that the environment is important for select because the special functions like one_of can use objects from it.
Update 2
I used to have an ugly hack as a fix, but here's a much better way; I should've known that even lazy has a standard evaluation counter-part lazy_
select6 <- function(.data, group1, group2) {
g1 <- lazy_(substitute(group1), env = parent.frame())
g2 <- lazy_(substitute(group2), env = parent.frame())
out1 <- select_(.data, .dots = g1)
out2 <- select_(.data, .dots = g2)
list(out1, out2)
}
# Or even more like the original...
lazy_parent <- function(expr) {
# Need to go up twice, because lazy_parent creates an environment for itself
e1 <- substitute(expr)
e2 <- do.call("substitute", list(e1), envir = parent.frame(1))
lazy_(e2, parent.frame(2))
}
select7 <- function(.data, group1, group2) {
out1 <- select_(.data, .dots = lazy_parent(group1))
out2 <- select_(.data, .dots = lazy_parent(group2))
list(out1, out2)
}

Answer 1

The problem here is that lazy by default follows promises, and order is a promise due to lazy loading of packages.
library(pryr)
is_promise(order)
#> TRUE
The default for lazy_dots, as used in select, is the opposite.
But there is something else going on here too, where the nature of the special ... is used to extract unevaluated expressions. While your use of substitute will work in many situations, attempts at renaming as available via select will fail.
select4(df,foo=x,bar=order)
#> Error in select4(df, foo = x, bar = order) :
#> unused arguments (foo = x, bar = order)
However, this works
select5 <- function(.data, ...) {
dots<-lazy_dots(...)
out1 <- select_(.data, .dots=dots[1])
out2 <- select_(.data, .dots=dots[2])
list(out1, out2)
}
select5(df,foo=x,bar=order)
#> [[1]]
#> foo
#> 1 1
#> 2 2
#>
#> [[2]]
#> bar
#> 1 5
#> 2 6
As another example, where substitute fails more directly, due to lack of carrying an environment, consider
vars<-c("x","y")
select4(df,one_of(vars),order)
#>Error in one_of(vars, ...) : object 'vars' not found
select5(df,one_of(vars),order)
#> [[1]]
#> x y
#> 1 1 3
#> 2 2 4
#>
#> [[2]]
#> order
#> 1 5
#> 2 6
The select4 version fails because it cannot find vars, where select5 succeeds due to lazy_dots carrying around the environment. Note select4(df,one_of(c("x","y")),order) is okay, as it uses literals.