Is it possible to construct an assignment expression using rlang? - r

Question

I'm trying to use the rlang package to construct an expression that does an assignment, given a right-hand side expression (the value to assign) and a left-hand side expression (the place to assign it to). For example, let's say I want to construct and evaluate the expression a <- 5:
> library(rlang)
> a <- "Not 5"
> lhs <- quo(a)
> rhs <- quo(5)
> eval_tidy(quo( (!!lhs) <- (!!rhs)) ) # Error
Error in (~a) <- (~5) : could not find function "(<-"
> eval_tidy(quo(`<-`(!!lhs, !!rhs))) # Error
Error in ~a <- ~5 : could not find function "~<-"
> eval_tidy(quo(`<-`(!!f_rhs(lhs), !!rhs))) # No error, but no effect
[1] 5
> stopifnot(a == 5)
Error: a == 5 is not TRUE
> print(a)
[1] "Not 5"
As you can see, none of the above methods of constructing and evaluating this assignment have the desired effect. Is there any way to do this correctly?
Edit: Using assign instead of <- is not a good solution, because it only works for variables, not elements of objects. For example, it won't work for:
> a <- list(ShouldBeFive="Not 5")
> lhs <- quo(a$ShouldBeFive)
Edit 2: I have written a proof of concept that demonstrates what I'm trying to accomplish. It defines an assign_general function that allows arbitrary left-hand sides, e.g. assign_general(a[[1]], 5) is equivalent to a[[1]] <- 5. However, my implementation seems kind of hackish, I don't know what corner cases I may have missed, and I'm still not sure if there's a more direct way to do it, so I'm still interested to see if anyone has a better solution.

Answer 1

1) rlang::lang We can use rlang::lang like this:
library(rlang)
# inputs
a <- "Not 5"
lhs <- quote(a)
rhs <- 5
L <- lang("<-", lhs, rhs)
eval(L)
a
## [1] 5
2) call or without rlang use call in place of lang:
# inputs
a <- "Not 5"
lhs <- quote(a)
rhs <- 5
cc <- call("<-", lhs, rhs)
eval(cc)
a
## [1] 5
2a) Both of the above also work in the case that lhs is an appropriate expression. For example using the built-in data frame BOD:
# inputs
BOD2 <- BOD
lhs <- quote(BOD2$xyz)
rhs <- 5
cc <- call("<-", lhs, rhs)
eval(cc)
names(BOD2)
## [1] "Time" "demand" "xyz"
2b) assign_general
assign_general <- function(lhs, rhs, envir = parent.frame()) {
cc <- call("<-", substitute(lhs), substitute(rhs))
eval(cc, envir = envir)
}
# test
a <- 1:5
assign_general(a[3], 5)
a
## [1] 1 2 5 4 5
Some alternatives to the call statement would be:
cc <- substitute(call("<-", lhs, rhs))
or
cc <- substitute(lhs <- rhs)
2c) Of course this would be sufficient:
assign_general2 <- `<-`
a <- 1:5
assign_general2(a[3], 5)
## [1] 1 2 5 4 5
3) rlang version of assign_general An rlang implementation of assign_general in (2b) can be obtained by replacing call with lang and substitute with enexpr:
library(rlang)
assign_general3 <- function(lhs, rhs, envir = parent.frame()) {
L <- lang("<-", enexpr(lhs), enexpr(rhs))
eval(L, envir = envir)
}
# test
a <- 1:5
assign_general3(a[3], 5)
a
## [1] 1 2 5 4 5
4) strings Another possibility is to deparse the arguments into strings:
assign_general4 <- function(lhs, rhs, envir = parent.frame()) {
s <- paste(deparse(substitute(lhs)), "<-", deparse(substitute(rhs)))
p <- parse(text = s)
eval(p, envir = envir)
}
# test
a <- 1:5
assign_general4(a[3], 5)
a
## [1] 1 2 5 4 5

Answer 2

The advantage of meta programming is using expressions as strings and being able to perform assignments to an L-value which can also be declared as a string. The assign function is reusable in meta programming in some cases.
rhs <- "1 > 0"
assign("lhs", eval(eval_tidy(parse(text=rhs))))
lhs
[1] TRUE
Above you can see that both lhs and rhs are passed as strings and an expression is assigned to an L-value.

Answer 3

With a little bit of dark magic and some luck I was able to achieve what you are after:
library(rlang)
expr<-quote(x<-1) # just some sample assignment operator to modify
a <- list(ShouldBeFive="Not 5")
lhs <- quo(a[[1]])
rhs <- quo(5)
expr[[2]] <-UQE(eval(lhs))
expr[[3]] <-UQE(eval(rhs))
expr
>a[[1]] <- 5
eval(expr)
a$ShouldBeFive
>5
Here's hopefully cleaner alternative that does not depend on rlang:
b <- list(ShouldBeSix="Not 6")
lhs <- quote(b[[1]])
rhs <- quote(6)
eval(substitute(x <- value,list(x = lhs, value = eval(rhs))))
b$ShouldBeSix