support (df$var@attr) <- value

[garyfeng]

R allows for Replacement functions (http://adv-r.had.co.nz/Functions.html#replacement-functions, or https://cran.r-project.org/doc/manuals/R-lang.html#Subset-assignment) like levels(var)<-c(...). We can extend the syntax to allow for such attribute assignment. According to https://cran.r-project.org/doc/manuals/R-lang.html#Subset-assignment,

names(x) <- c("a","b")

is equivalent to

`*tmp*` <- x
x <- "names<-"(`*tmp*`, value=c("a","b"))
rm(`*tmp*`)

The proposal is something like ``%@%(x, key, value), or `x%@%key <- value`.

x@key <- val

[update: yes!] should be interpreted as

`@`(x, key) <- val
`@<-`(x, key, value=val)

[update: no!] or if evaluation starts from <- first.

`x@key<-` () <- val

which won't make any sense.

[garyfeng]

Here's some tests:

`@<-` <- function(x, key, value=val) {
  # print(x); print(key); print(value); 
  lapply(x, function(l) {
    l$key <- value; 
    names(l)<-key; 
    invisible(l)
   }) -> x
}

x<-list(list(key="val1"), list(key="val2"))

x@"key"<-1

print(x)

>>>
[[1]]
[[1]]$key
[1] 1


[[2]]
[[2]]$key
[1] 1

Result is as expected. But

> x<-list(list(key="val1"), list(key="val2"))
> x@"key2"<-1
> x
[[1]]
[[1]]$key2
[1] 1


[[2]]
[[2]]$key2
[1] 1

We need to return the original x members if the new key is not in the list.

[garyfeng]

Also unexpected:

> x<-list(list(key="val1"), list(key="val2"))
> 
> x@"key"[1]<-1
> x
[[1]]
[[1]]$key
[1] "1"    "val2"


[[2]]
[[2]]$key
[1] "1"    "val2"

If we print out the debugging messages in @<-, we get:

x@"key"[1] <-1
[[1]]
[[1]]$key
[1] "val1"


[[2]]
[[2]]$key
[1] "val2"


[1] "key"
[1] "1"    "val2"

That is, val now becomes c("1", "val2").

So let's parse this:

`@<-` <- function(x, key, value=val) {
  print(x); print(key); print(value); print("====")
  lapply(x, function(l) {
    l$key <- value; 
    names(l)<-key; 
    print(l)
    invisible(l)
  }) -> x
}

x<-list(list(key="val1"), list(key="val2"), list(key="val3"))

# This works as expected
print(x@"key"<-1)
print(x)

# but the following is surprising
print(x@"key"[2]<-"something")
print(x)

# parsing:
#   x@"key"[2] <- "something"
# per https://cran.r-project.org/doc/manuals/R-lang.html#Subset-assignment,
# example names(x)[3] <- "Three"
# which translates to 
#  `*tmp*`  <-  x
#  x  <-  "names<-"(`*tmp*`, value="[<-"(names(`*tmp*`), 3, value="Three"))
# we have then `*tmp*` <- x, "key" (possibly `*tmp1*` <- x, `*tmp2*` <- key)
#   x <- `@<-`(x, "key", value= `[`( `@`(x, "key"), 2, value="something") )
#   x <- `@<-`(x, "key", value= `[`( c("val1", "val2", "val3"), 2, value="something") )
#   x <- `@<-`(x, "key", value= c("val1", "something", "val3") )
# which gives:
#   x@"key" <- c("val1", "something", "val3")

[garyfeng]

Hey, the solution, then, is:

• check if val is a scalar or a vector
• if it's a scalar, proceed as usual
• else if it's a vector that is the same size as x, then assign each element to the corresponding element of the list.

This should solve the semantic problem, albeit in a very strange way.