Ainda tentando entrar na lógica R ... qual é a "melhor" maneira de descompactar (no LHS) os resultados de uma função retornando vários valores?

Aparentemente, não posso fazer isso:

R> functionReturningTwoValues <- function() { return(c(1, 2)) }
R> functionReturningTwoValues()
[1] 1 2
R> a, b <- functionReturningTwoValues()
Error: unexpected ',' in "a,"
R> c(a, b) <- functionReturningTwoValues()
Error in c(a, b) <- functionReturningTwoValues() : object 'a' not found

devo realmente fazer o seguinte?

R> r <- functionReturningTwoValues()
R> a <- r[1]; b <- r[2]

ou o programador R escreveria algo mais parecido com isto:

R> functionReturningTwoValues <- function() {return(list(first=1, second=2))}
R> r <- functionReturningTwoValues()
R> r$first
[1] 1
R> r$second
[1] 2

--- editado para responder às perguntas de Shane ---

Eu realmente não preciso dar nomes às partes do valor resultante. Estou aplicando uma função agregada ao primeiro componente e outra ao segundo componente ( mine max. Se fosse a mesma função para os dois componentes, não precisaria dividi-los).

(1) list [...] <- Eu publiquei isso há mais de uma década no r-help . Desde então, ele foi adicionado ao pacote gsubfn. Não requer um operador especial, mas exige que o lado esquerdo seja escrito usando o list[...]seguinte:

library(gsubfn)  # need 0.7-0 or later
list[a, b] <- functionReturningTwoValues()

Se você precisar apenas do primeiro ou do segundo componente, tudo isso funcionará também:

list[a] <- functionReturningTwoValues()
list[a, ] <- functionReturningTwoValues()
list[, b] <- functionReturningTwoValues()

(Claro, se você só precisava de um valor, em seguida, functionReturningTwoValues()[[1]]ou functionReturningTwoValues()[[2]]seria suficiente.)

Veja o tópico r-help citado para mais exemplos.

(2) com Se a intenção é meramente combinar os vários valores subsequentemente e os valores de retorno forem nomeados, uma alternativa simples é usar with:

myfun <- function() list(a = 1, b = 2)

list[a, b] <- myfun()
a + b

# same
with(myfun(), a + b)

(3) anexar Outra alternativa é anexar:

attach(myfun())
a + b

ADICIONADO: witheattach

De alguma forma, eu tropecei nesse truque inteligente da Internet ... Não tenho certeza se é desagradável ou bonito, mas permite criar um operador "mágico" que permite descompactar vários valores de retorno em sua própria variável. A :=função é definida aqui e incluída abaixo para a posteridade:

':=' <- function(lhs, rhs) {
  frame <- parent.frame()
  lhs <- as.list(substitute(lhs))
  if (length(lhs) > 1)
    lhs <- lhs[-1]
  if (length(lhs) == 1) {
    do.call(`=`, list(lhs[[1]], rhs), envir=frame)
    return(invisible(NULL)) 
  }
  if (is.function(rhs) || is(rhs, 'formula'))
    rhs <- list(rhs)
  if (length(lhs) > length(rhs))
    rhs <- c(rhs, rep(list(NULL), length(lhs) - length(rhs)))
  for (i in 1:length(lhs))
    do.call(`=`, list(lhs[[i]], rhs[[i]]), envir=frame)
  return(invisible(NULL)) 
}

Com isso em mãos, você pode fazer o que procura:

functionReturningTwoValues <- function() {
  return(list(1, matrix(0, 2, 2)))
}
c(a, b) := functionReturningTwoValues()
a
#[1] 1
b
#     [,1] [,2]
# [1,]    0    0
# [2,]    0    0

Não sei como me sinto sobre isso. Talvez você ache útil no seu espaço de trabalho interativo. Usá-lo para criar bibliotecas (re) utilizáveis ​​(para consumo em massa) pode não ser a melhor ideia, mas acho que depende de você.

... você sabe o que eles dizem sobre responsabilidade e poder ...

Normalmente, envolvo a saída em uma lista, que é muito flexível (você pode ter qualquer combinação de números, seqüências de caracteres, vetores, matrizes, matrizes, listas, objetos na saída)

assim como:

func2<-function(input) {
   a<-input+1
   b<-input+2
   output<-list(a,b)
   return(output)
}

output<-func2(5)

for (i in output) {
   print(i)
}

[1] 6
[1] 7

functionReturningTwoValues <- function() { 
  results <- list()
  results$first <- 1
  results$second <-2
  return(results) 
}
a <- functionReturningTwoValues()

Eu acho que isso funciona.

Eu montei um fanático do pacote R para resolver esse problema. O zeallot inclui um operador de atribuição múltipla ou de descompactação %<-%,. O LHS do operador é qualquer número de variáveis ​​a serem atribuídas, criadas usando chamadas para c(). O RHS do operador é um vetor, lista, quadro de dados, objeto de data ou qualquer objeto personalizado com um destructuremétodo implementado (consulte ?zeallot::destructure).

Aqui estão alguns exemplos baseados na postagem original,

library(zeallot)

functionReturningTwoValues <- function() { 
  return(c(1, 2)) 
}

c(a, b) %<-% functionReturningTwoValues()
a  # 1
b  # 2

functionReturningListOfValues <- function() {
  return(list(1, 2, 3))
}

c(d, e, f) %<-% functionReturningListOfValues()
d  # 1
e  # 2
f  # 3

functionReturningNestedList <- function() {
  return(list(1, list(2, 3)))
}

c(f, c(g, h)) %<-% functionReturningNestedList()
f  # 1
g  # 2
h  # 3

functionReturningTooManyValues <- function() {
  return(as.list(1:20))
}

c(i, j, ...rest) %<-% functionReturningTooManyValues()
i     # 1
j     # 2
rest  # list(3, 4, 5, ..)

Confira a vinheta do pacote para obter mais informações e exemplos.

Não há resposta certa para esta pergunta. Eu realmente depende do que você está fazendo com os dados. No exemplo simples acima, eu sugeriria fortemente:

1. Mantenha as coisas o mais simples possível.
2. Sempre que possível, é uma prática recomendada manter suas funções vetorizadas. Isso fornece a maior quantidade de flexibilidade e velocidade a longo prazo.

É importante que os valores 1 e 2 acima tenham nomes? Em outras palavras, por que é importante neste exemplo que 1 e 2 sejam nomeados aeb, em vez de apenas r [1] e r [2]? Uma coisa importante a entender neste contexto é que aeb também são vetores de comprimento 1. Portanto, você não está realmente alterando nada no processo de fazer essa atribuição, além de ter 2 novos vetores que não precisam de subscritos para ser referenciado:

> r <- c(1,2)
> a <- r[1]
> b <- r[2]
> class(r)
[1] "numeric"
> class(a)
[1] "numeric"
> a
[1] 1
> a[1]
[1] 1

Você também pode atribuir os nomes ao vetor original se preferir fazer referência à letra do que ao índice:

> names(r) <- c("a","b")
> names(r)
[1] "a" "b"
> r["a"]
a 
1 

[Edit] Como você aplicará min e max a cada vetor separadamente, sugiro usar uma matriz (se aeb tiver o mesmo comprimento e o mesmo tipo de dados) ou quadro de dados (se aeb for o mesmo comprimento, mas podem ser tipos de dados diferentes) ou use uma lista como no seu último exemplo (se eles puderem ter comprimentos e tipos de dados diferentes).

> r <- data.frame(a=1:4, b=5:8)
> r
  a b
1 1 5
2 2 6
3 3 7
4 4 8
> min(r$a)
[1] 1
> max(r$b)
[1] 8

As listas parecem perfeitas para esse fim. Por exemplo, dentro da função que você teria

x = desired_return_value_1 # (vector, matrix, etc)

y = desired_return_value_2 # (vector, matrix, etc)

returnlist = list(x,y...)

}  # end of function

programa principal

x = returnlist[[1]]

y = returnlist[[2]]

Sim para sua segunda e terceira perguntas - é isso que você precisa fazer, pois não pode ter vários 'valores' à esquerda de uma tarefa.

Que tal usar o assign?

functionReturningTwoValues <- function(a, b) {
  assign(a, 1, pos=1)
  assign(b, 2, pos=1)
}

Você pode passar os nomes da variável que deseja que sejam passados ​​por referência.

> functionReturningTwoValues('a', 'b')
> a
[1] 1
> b
[1] 2

Se você precisar acessar os valores existentes, o inverso assigné get.

Se você deseja retornar a saída de sua função para o Global Environment, pode usar list2env, como neste exemplo:

myfun <- function(x) { a <- 1:x
                       b <- 5:x
                       df <- data.frame(a=a, b=b)

                       newList <- list("my_obj1" = a, "my_obj2" = b, "myDF"=df)
                       list2env(newList ,.GlobalEnv)
                       }
    myfun(3)

Esta função criará três objetos no seu ambiente global:

> my_obj1
  [1] 1 2 3

> my_obj2
  [1] 5 4 3

> myDF
    a b
  1 1 5
  2 2 4
  3 3 3

[A] Se cada foo e barra for um único número, não há nada errado com c (foo, barra); e você também pode nomear os componentes: c (Foo = foo, Bar = bar). Então você pode acessar os componentes do resultado 'res' como res [1], res [2]; ou, no caso nomeado, como res ["Foo"], res ["BAR"].

[B] Se foo e bar são vetores do mesmo tipo e comprimento, então novamente não há nada errado em retornar cbind (foo, bar) ou rbind (foo, bar); igualmente nomeado. No caso 'cbind', você acessaria foo e bar como res [, 1], res [, 2] ou como res [, "Foo"], res [, "Bar"]. Você também pode preferir retornar um quadro de dados em vez de uma matriz:

data.frame(Foo=foo,Bar=bar)

e acesse-os como res $ Foo, res $ Bar. Isso também funcionaria bem se foo e bar fossem do mesmo comprimento, mas não do mesmo tipo (por exemplo, foo é um vetor de números, exceto um vetor de cadeias de caracteres).

[C] Se foo e bar forem suficientemente diferentes para não combinar convenientemente como acima, você definitivamente retornará uma lista.

Por exemplo, sua função pode ajustar-se a um modelo linear e também calcular valores previstos, para que você possa ter

LM<-lm(....) ; foo<-summary(LM); bar<-LM$fit

e então você faria return list(Foo=foo,Bar=bar) acessaria o resumo como res $ Foo, os valores previstos como res $ Bar

fonte: http://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html

Para obter várias saídas de uma função e mantê-las no formato desejado, você pode salvar as saídas no disco rígido (no diretório de trabalho) de dentro da função e carregá-las de fora da função:

myfun <- function(x) {
                      df1 <- ...
                      df2 <- ...
                      save(df1, file = "myfile1")
                      save(df2, file = "myfile2")
}
load("myfile1")
load("myfile2")

Com o R 3.6.1, eu posso fazer o seguinte

fr2v <- function() { c(5,3) }
a_b <- fr2v()
(a_b[[1]]) # prints "5"
(a_b[[2]]) # prints "3"