Eonema's questions

Quando executado via SSH, o R parece tratar caracteres não ASCII de forma diferente, dependendo do sistema operacional do cliente SSH.

Por exemplo, se eu usar um computador executando macOS (14.6.1) para iniciar uma sessão R em uma máquina Ubuntu (22.04.5) e executar:

units::set_units(12.7, "\U00B5m")

Eu entendo:

12.7 [µm]

Mas a mesma expressão executada no mesmo servidor, mas por um cliente Windows (10.0.19045.4170) produz:

Error: In '<U+00B5>m', '<U+00B5>m' is not recognized by udunits.

Pensei que isso poderia ter a ver com a forma como a linha de comando em cada SO envia as representações de caracteres por SSH. No entanto, se eu salvar o seguinte script no servidor (escrito usando vim por SSH da máquina macOS):

#!/bin/Rscript

print(nchar("µm"))

E executá-lo via SSH a partir do cliente macOS (por exemplo, ssh <user>@<host> "./print_micron.R"), obtenho:

[1] 2

ou seja, "µ"é um único caractere de dois bytes. Mas se eu executar isso do cliente Windows, eu obtenho:

[1] 3

ou seja, "µ"torna-se dois caracteres separados, um para cada byte.

Isso está desafiando minha intuição de como a execução de comandos em SSH funciona, pois eu esperaria que o comportamento do R fosse determinado inteiramente pelo servidor. Por que o SO cliente afetaria como caracteres não-ASCII são representados pelo R?

Funções de substituição, como names<-, parecem não usar avaliação preguiçosa quando chamadas como names(x) <- c("a", "b").

Para demonstrar, vamos definir uma função para obter a parte fracionária de um número e uma função de substituição correspondente - mas dentro da função de substituição, inclua uma linha para imprimir o valueargumento neutralizado.

fractional <- function(x) { 
  x %% 1 
}

`fractional<-` <- function(x, value) {
  print(rlang::enexpr(value))
  invisible(x %/% 1 + value)
}

Agora, se chamarmos fractional<-diretamente, ele imprime a expressão que demos para value:

x <- 10.1
`fractional<-`(x, 0.2 + 0.2)
#> 0.2 + 0.2

Mas se o chamarmos no formulário de atribuição, ele imprime o resultado da avaliação da expressão:

x <- 10.1
fractional(x) <- 0.2 + 0.2
#> [1] 0.4

A definição da linguagem explica funções de substituição como:

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

é equivalente a

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

Mas isso não reproduz esse comportamento:

x <- 10.1

`*tmp*` <- x
x <- "fractional<-"(`*tmp*`, value=0.2 + 0.2)
rm(`*tmp*`)

#> 0.2 + 0.2

O que está acontecendo internamente <-que faz com que valueseja passado para fractional<- depois de ser avaliado, e há alguma maneira de contornar esse comportamento?

Edição: @SamR destacou que usar substitutecaptura a expressão da promessa:

x <- 10.1
`fractional<-` <- function(x, value) {
  print(substitute(value))
  invisible(x %/% 1 + value)
}
fractional(x) <- 0.2 + 0.2

#> 0.2 + 0.2

Então, claramente eu estava enganado ao assumir que valueestava sendo avaliado antes de ser passado para fractional<-. No entanto, eu ainda gostaria muito de saber por que base::substitute funciona como esperado aqui enquanto rlang::enexpr e amigos não . Afinal, enexprusa substituteinternamente:

enexpr <- function(arg) {
  .Call(ffi_enexpr, substitute(arg), parent.frame())
}

A depuração no R Studio mostra que, tanto quando chamado na forma de atribuição como fractional(x) <- 0.2 + 0.2quanto na forma de prefixo "fractional<-"(x, 0.2 + 0.2), fractional<-é passada uma promessa não avaliada para value:

Isso permanece não avaliado quando chamado na forma de prefixo:

Mas é avaliado após a chamada para enexprquando chamado no formulário de atribuição:

Estou pensando se isso tem a ver com o fato de que no formulário de atribuição, a função é chamada por uma função primitiva, <-? Mas não está claro por que isso faria diferença.