Transformação de coordenadas

As funções foram apresentadas lá no conceito Básico, com exemplos como este:

squareit <- function(x) {
    x * x
}

squareit(3)
#> [1] 9

# shorter form
squareit_short <- function(x) x ^ 2

Olhando mais de perto a definição de squareit, podemos identificar várias partes:

• A função recebe um argumento formal x.
• Existe um corpo de função, geralmente entre chaves{ }.
• Depois que o objeto de função é criado, ele é atribuído a uma variável squareit.

Uma função é um objeto de primeira classe em R, assim como números e strings. Assim, squareit <- function... é uma atribuição que, sintaticamente, é igual a x <- 42.

Argumentos

O R não faz uma distinção clara entre argumentos posicionais e argumentos nomeados, ao contrário de outras linguagens de script, como Python e Julia.

As chamadas de função podem passar valores de forma posicional ou por nome. Esta última é útil para funções complexas com muitos argumentos, em que é difícil lembrar a ordem deles.

f <- function(x, y) x / y

# call positionally
f(4, 2)
#> [1] 2

# call by name
f(y = 2, x = 4)
#> [1] 2

Argumentos opcionais

Valores padrão para argumentos podem ser especificados na definição da função, mas devem vir depois de todos os argumentos sem valor padrão.

Aí, podemos escolher entre aceitar o padrão ou substituí-lo.

g <- function(x, y = 2) x / y

# default y value
g(6)
#> [1] 3

# explicit y value
g(6, 3)
#> [1] 2

Argumentos extras

Para aceitar um número arbitrário de argumentos adicionais, use um ... (reticências) na definição. É possível converter quaisquer valores extras da chamada de função em um vetor, mas continue lendo para conhecer uma forma alternativa de usar esses "dot args" (chamados de "varargs" em várias outras linguagens).

var_f <- function(x, y, ...) {
  print(c(...))
}

var_f(2, 3, "opt1", "opt2")
#> [1] "opt1" "opt2"

Ambiente da função

Antes, dissemos que os argumentos formais e o corpo são ambos componentes de uma função.

Na verdade, há um terceiro componente: o ambiente em que a função é definida.

Isso pode ser ilustrado com o caso de funções aninhadas:

outer_func <- function(x) {
  inner_func <- function(y) {
    x * y
  }
  
  inner_func(3)
}

outer_func(5)
#> [1] 15

A chamada da função passa x = 5 para a função externa, e esse valor fica disponível dentro do corpo dessa função.

A função interna é parte do corpo da função externa e tem acesso ao valor de x. Dito de outra forma, x = 5 está no ambiente da função interna.

Tecnicamente, isso é conhecido como closure.

O ambiente é especialmente importante com os dot args, já que quaisquer valores fornecidos dessa forma podem ser repassados para chamadas de função no corpo da função. A função externa não precisa saber nem se importar com o que os dot args significam.

f_var <- function(x, ...) {
  sum(x, ...)
}

x <- c(1, 2, NA, 6)

# for sum(), na.rm defaults to FALSE
f_var(x)
#> [1] NA

# pass through the na.rm value
f_var(x, na.rm = TRUE)
#> [1] 9

Essa técnica é muito usada por bibliotecas do Tidyverse, como stringr. Muitas das funções de stringr são um wrapper amigável em torno de funções de baixo nível do stringi e do R base.

Os argumentos extras fornecidos às funções str_*() são simplesmente repassados para essas funções de baixo nível.

Funções como valores de retorno

Uma função externa pode definir uma função interna (nomeada ou anônima, como descrito abaixo) e usá-la como valor de retorno.

A função retornada incluirá o ambiente em que foi definida.

times_y <- function(x) {
  # anonymous function - see next section
  \(y) x * y
}

f <- times_y(3)
class(f)
#> [1] "function"

f(4)
#> [1] 12

Funções anônimas

Quando definimos uma função, normalmente vinculamos o objeto de função resultante a uma variável.

x <- 2

# function definition captures x from the environment
doubleit_short <- function(y) x * y

Isso facilita usar a função mais tarde no script, mas essa vinculação não é necessária. Uma função curta, usada uma única vez, pode ser útil no contexto imediato. Sem a vinculação a um nome, ela é chamada de função anônima.

O uso de funções anônimas é tão comum que (desde o R v4.1.0) existe uma sintaxe abreviada para defini-las: substitua a palavra function por uma barra invertida \.

Um exemplo disso foi usado na seção anterior, sobre valores de retorno.

Cópia ao modificar

O R permite atribuir a elementos individuais de um vetor. Se passarmos um vetor como argumento de uma função e o modificarmos no corpo da função antes de retorná-lo, obtemos um vetor modificado.

Mas o que aconteceu com o vetor original?

f <- function(vec) {
  vec[1] <- 42
  vec
}

vals <- c(1, 3, 4)

# f() returns a modified vector
f(vals)
#> [1] 42  3  4  

# the original vector is unchanged.
vals
#> [1] 1 3 4

O R é uma linguagem projetada para ciência de dados. Coletar esses dados pode custar muito tempo, esforço e, potencialmente, uma quantia exorbitante de dinheiro: é importante não corrompê-los!

A política geral (com algumas exceções) é copiar ao modificar. Se um objeto (como um vetor) é alterado de uma forma que poderia causar problemas depois, o R retorna uma cópia modificada e deixa o original intacto.

Copiar grandes estruturas de dados pode ser computacionalmente caro, mas geralmente isso é o mal menor quando a alternativa é a corrupção dos dados.