Transformação de coordenadas

As funções já foram introduzidas 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

Se olharmos com mais atenção para a definição de squareit, conseguimos identificar várias partes:

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

Em R, uma função é um objeto de primeira classe, tal como os números e as strings. Assim, squareit <- function... é uma atribuição sintaticamente igual a x <- 42.

Argumentos

Ao contrário de outras linguagens de script como Python e Julia, o R não faz uma distinção clara entre argumentos posicionais e argumentos de palavra-chave.

As chamadas a funções podem passar valores posicionalmente ou por nome. Esta última forma é útil para funções complexas com muitos argumentos, em que é difícil recordar a respetiva ordem.

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

Os valores predefinidos dos argumentos podem ser especificados na definição da função, mas têm de vir depois de todos os argumentos sem valor predefinido.

Podemos então escolher se aceitamos o valor predefinido ou se o substituímos.

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

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

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

Argumentos extra

Para aceitar um número arbitrário de argumentos adicionais, usa um ... (reticências) na definição. É possível converter quaisquer valores extra da chamada à função num vetor, mas continua a ler para descobrires uma forma alternativa de usar estes "dot args" (designados por "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

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

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

Isto pode ser ilustrado com o caso das funções aninhadas:

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

outer_func(5)
#> [1] 15

A chamada à função passa x = 5 à função externa, e este valor está disponível dentro desse corpo da 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, isto é conhecido como uma closure.

O ambiente é especialmente importante com os dot args, pois quaisquer valores fornecidos desta forma podem ser passados adiante para chamadas a funções dentro do corpo da função. A função externa não precisa de saber nem de se preocupar com o significado dos dot args.

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

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

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

Funções como valores devolvidos

Uma função externa pode definir uma função interna (com nome ou anónima, como se descreve abaixo) e usá-la como valor devolvido.

A função devolvida 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 associamos o objeto função resultante a uma variável.

x <- 2

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

Isto facilita a utilização da função mais adiante no script, mas essa associação a um nome não é obrigatória. Uma função curta, para usar uma só vez, pode ser útil no contexto imediato. Sem associação a um nome, chama-se 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 as definir: substitui a palavra function por uma barra invertida \.

Foi usado um exemplo disto na secção anterior, sobre valores devolvidos.

Cópia ao modificar

O R permite atribuir valores 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 o devolver, obtemos um vetor modificado.

Mas o que aconteceu ao 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 concebida para a ciência de dados. Recolher esses dados pode custar muito tempo, esforço e, potencialmente, uma quantia exorbitante de dinheiro: é importante não os corromper!

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

Copiar estruturas de dados grandes pode ser computacionalmente dispendioso, mas, em geral, este é o mal menor quando a alternativa é a corrupção dos dados.