How do you manipulate a list of unknown name in R without using parse?

Question

I am considering keeping the data (vectors, lists, etc.) and code (functions) for my problem in a tree structure (a list of lists of lists of...). I do not want to commit to a name for the root node, nor for the next level of nodes. The lists just below the root node are different versions of each other, and I want to be able to compare them in different ways, and build them in different ways, and give them different, arbitrary names. I am presently using the following to build the overall structure:

foo <- function(ref.txt, val.txt) eval(parse(text=paste0(ref.txt, ' <<- ', val.txt)))

A trivial example might be:

root = list()
foo('root$v1', '42')
foo('root$v2', '43')
root
# $v1
# [1] 42
#
# $v2
# [1] 43

A little less trivial, continuing from the previous example:

v3 <- c(42, 43)
foo('root$v3', 'v3')
root
# $v1
# [1] 42
#
# $v2
# [1] 43
#
# $v3
# [1] 42 43

Again, I can't hard code e.g., root$v3 <- v3, because I won't know the name of the root of the list or the names of the next-level nodes until run time.

I am asking for alternatives in part because of @'Joris Meys' comment in the Stack Overflow article, "Why doesn't assign() values to a list element work in R?," who is apparently quoting Lumley's post, "Re: [R] RE: Using a number as a name to access a list." These suggest avoiding parse. However, If I do not know the names until runtime, and do not even know the depth of the path (see Lumley), how is avoiding parse possible?

Answer 1

How about an additional argument for your root list? No paste trickery, no eval trickery, and no need to use <<-, which you should usually avoid...

foo <- function(lst, ref, val) { lst[[ref]] <- val; return(lst) }

root <- list()
root <- foo(root, "v1", 42)
root <- foo(root, "v2", 43)
root

v3 <- c(42, 43)
root <- foo(root, "v3", v3)
root

Edit based on the comments: Here is a function that assigns values to arbitrary entries of nested lists. The ref argument should be a vector of indices, one for each level:

foo <- function(lst, ref, val) {

  lvl <- length(ref)

  # extract the list at depth lvl - 1 from lst,
  # add val to this list and replace val with it,
  # repeat, now descending one level less deep,
  # and so on, until reaching the top level

  for (i in seq_len(lvl)) {

    res <- lst
    for (j in seq_len(lvl - i)) res <- res[[ref[j]]]
    res[[ref[lvl - i + 1]]] <- val
    val <- res

  }

  return(res)

}

(root <- list(a = list(a = 1, b = list(a = 1, b = 2)),
              b = list(a = 1), c = 3))

## $a
## $a$a
## [1] 1
## 
## $a$b
## $a$b$a
## [1] 1
## 
## $a$b$b
## [1] 2
## 
## 
## 
## $b
## $b$a
## [1] 1
## 
## 
## $c
## [1] 3

foo(lst = root, ref = c("a", "b", "c"), val = 3)

## $a
## $a$a
## [1] 1
## 
## $a$b
## $a$b$a
## [1] 1
## 
## $a$b$b
## [1] 2
## 
## $a$b$c
## [1] 3
## 
## 
## 
## $b
## $b$a
## [1] 1
## 
## 
## $c
## [1] 3

And finally, here is a benchmark that compares my function to parse + eval. With three levels of nesting, my function is significantly faster, but that may change with a different list structure:

bar <- function(lst, ref, val) {

  eval(parse(text = paste(paste(c("lst", ref), collapse = "$"), "<- val")))
  return(lst)

}

library(microbenchmark)
microbenchmark(foo(lst = root, ref = c("a", "b", "c"), val = 3),
               bar(lst = root, ref = c("a", "b", "c"), val = 3))

## Unit: microseconds
##                                              expr     min       lq
##  foo(lst = root, ref = c("a", "b", "c"), val = 3)  47.089  48.6700
##  bar(lst = root, ref = c("a", "b", "c"), val = 3) 127.401 128.9505
##       mean  median       uq     max neval
##   55.98703  50.795  53.0640 191.575   100
##  134.71502 130.325 132.1755 291.400   100