mayor - Análisis del operador de asignación “->” en R

o en r

Question

Mi pregunta es acerca de analizar expresiones en lenguaje R Déjame saltar a la derecha en un ejemplo:

fun_text <- c("
0 -> var
f1 <- function()
{
    0 -> sum_var
    sum_var2 = 0
    sum_var3 <- 0
}

(function()
{
    0 -> sum_var
    sum_var2 = 0
    sum_var3 <- 0
})->f2

f3 = function(x)
{
  0 -> sum_var
  sum_var2 = 0
  sum_var3 <- 0
}

")

fun_tree <- parse(text=fun_text)
fun_tree 
fun_tree[[1]]
fun_tree[[2]]
fun_tree[[3]]
fun_tree[[4]]

Después de eso, obtenemos esos resultados:

expression(0 -> var, f1 <- function()
{
    0 -> sum_var
    sum_var2 = 0
    sum_var3 <- 0
}, (function()
{
    0 -> sum_var
    sum_var2 = 0
    sum_var3 <- 0
})->f2, f3 = function(x)
{
    0 -> sum_var
    sum_var2 = 0
    sum_var3 <- 0
})

y

var <- 0

y

f1 <- function() {
    sum_var <- 0
    sum_var2 = 0
    sum_var3 <- 0
}

y

f2 <- (function() {
    sum_var <- 0
    sum_var2 = 0
    sum_var3 <- 0
})

y

f3 = function(x) {
    sum_var <- 0
    sum_var2 = 0
    sum_var3 <- 0
}

Como puede ver, todos los operadores de asignación "->" se cambian a "<-", pero no en el primer ejemplo (solo "fun_tree"). Mi pregunta es: ¿por qué es eso? y ¿puedo estar seguro de que siempre tengo el operador "<-" en el árbol de sintaxis, por lo que no puedo molestarme en implementar el caso "->"?

Answer 1

puedo estar seguro de que siempre obtengo el operador "<-" en el árbol de sintaxis

Veamos …

> quote(b -> a)
a <- b
> identical(quote(b -> a), quote(a <- b))
[1] TRUE

Entonces, sí, la asignación -> siempre se analiza como <- (lo mismo no es cierto cuando se invoca -> como nombre de función! ¹ ).

Su primera visualización es al revés debido al argumento keep.source de parse :

> parse(text = ''b -> a'')
expression(b -> a)
> parse(text = ''b -> a'', keep.source = FALSE)
expression(a <- b)

¹ Invocar <- como una función es lo mismo que usarlo como operador:

> quote(`<-`(a, b))
a <- b
> identical(quote(a <- b), quote(`<-`(a, b)))
[1] TRUE

Sin embargo, no hay ninguna función -> (aunque puede definir una), y escribir b -> a nunca llama a -> , siempre se analiza como a <- b , que, a su vez, invoca la función <- o primitivo.

Answer 2

Este es un tema ligeramente fuera de lugar, pero creo que un operador de asignación de izquierda a derecha se puede usar en casos que van más allá de la escritura rápida en la línea de comandos. Entonces, aquí hay una manera de definir tal operador:

"%op%"<- function(a,b) eval(substitute(b<-a), parent.frame())

Estoy usando esto para evitar duplicar el código R al almacenar / cargar un conjunto de matrices y vectores a / desde un vector ( Error: objeto ''->'' no encontrado en R ).