Uma das funcionalidades mais interessantes do R é a possibilidade de estender a linguagem para domínios específicos. A non-standard evaluation garante que até modificações à estrutura fundamental do R podem ser realizadas sem problema. Hoje vamos falar de um assunto que muita gente quer aprender, mas que pouca gente entende de verdade: funções anônimas.
Se você não souber o que é uma função anônima, pode ser que você conheça esse
conceito por outro nome. Também chamada de “função lambda”, “notação de fórmula”
ou “notação de til”, ela aparece principalmente em programas que usam o {purrr}
apesar de não serem exclusividade desse pacote. Resumindo, se você já viu algo
do tipo ~.x e não entendeu do que se tratava, este post é para você.
Introdução
Funções anônimas são, essencialmente, um jeito de simplificar a criação de
funções pequenas. Em poucas palavras, o nosso objetivo é não ter que declarar
uma função nova inteira com function() { ... } para poder usá-la dentro de
um programa.
O exemplo que será utilizado na explicação a seguir será a função conta_na()
que (não surpreendentemente) conta o número de NAs em um vetor. Vamos usá-la
dentro de um map() para que ela seja aplicada a todas as colunas de um data
frame. Sendo assim, partiremos da forma mais verborrágica possível desse código
e tentaremos chegar, intuitivamente, nas funções anônimas.
Uma ressalva importante é que a notação explicada aqui só funciona dentro do
{tidyverse}! No final do texto será apresentada uma alternativa que funciona
fora desse contexto, mas, por enquanto, a notação abaixo só pode aparecer nos
argumentos .f, .fn e .fns utilizados dentro do {tidyverse}.
Conceito
Vamos imaginar uma função conta_na() que conta o número de NAs em uma coluna
de um data frame. Para aplicá-la a todas as colunas do data frame, podemos, por
exemplo, utilizar a função map() do pacote {purrr} como no exemplo abaixo:
conta_na <- function(vetor) {
sum(is.na(vetor))
}
map_dbl(starwars, conta_na)#> name height mass hair_color skin_color eye_color birth_year
#> 0 6 28 5 0 0 44
#> sex gender homeworld species films vehicles starships
#> 4 4 10 4 0 0 0No R, quando temos uma função simples de uma linha, é perfeitamente possível não colocar o seu corpo em uma linha separada. Veja como o código já fica um pouco mais compacto (saída omitida daqui em diante):
conta_na <- function(vetor) { sum(is.na(vetor)) }
map_dbl(starwars, conta_na)Agora, se temos uma função que cabe inteira em uma linha, o R nos permite também
omitir as chaves: por exemplo, m if-else pode ser escrito
if (cond) resp1 else resp2 se as respostas não tiverem mais de uma linha. No
nosso caso, vamos reduzir ainda mais a conta_na():
conta_na <- function(vetor) sum(is.na(vetor))
map_dbl(starwars, conta_na)O próximo passo seria encurtar o nome do argumento da função, utilizando algo
mais genérico. Poucas pessoas sabem, mas o R permite nomes começando com .!
Por motivos que ficarão claros a seguir, vamos escolher .x para ser o nome do
nosso argumento:
conta_na <- function(.x) sum(is.na(.x))
map_dbl(starwars, conta_na)Agora vem a grande sacada. Tudo que fizemos até agora funciona no R como um todo, mas, se atendermos algumas condições extras, podemos reduzir ainda mais essa função.
Vamos lá: se a função i) tiver apenas uma linha, ii) tiver apenas 1 argumento,
iii) tiver .x como seu único argumento .x e iv) estiver sendo utilizada como
argumento de uma função do {tidyverse}, então podemos omitir o function(.x)
(já que isso é informação redundante dadas as condições) e trocá-lo por um
singelo ~:
conta_na <- ~ sum(is.na(.x))
map_dbl(starwars, conta_na)O último passo é o motivo de chamarmos essa notação de “função anônima”. Dado
que nossa função já é tão pequena e utilizamos ela em apenas um lugar, por que
precisamos dar um nome para ela? É mais fácil declará-la diretamente dentro do
map() sem um nome, ou seja, “anonimamente”:
map_dbl(starwars, ~ sum(is.na(.x)))#> name height mass hair_color skin_color eye_color birth_year
#> 0 6 28 5 0 0 44
#> sex gender homeworld species films vehicles starships
#> 4 4 10 4 0 0 0Pronto, agora você sabe o que significa uma função do tipo ~.x. Para treinar,
tente fazer o processo reverso como no caso abaixo:
# Fração de valores distintos dentre todos
map_dbl(starwars, ~ length(unique(.x)) / length(.x))
# Desanonimizar
frac_distintos <- ~ length(unique(.x)) / length(.x)
map_dbl(starwars, frac_distintos)
# Remover a notação de til (não é mais necessário mexer no map())
frac_distintos <- function(.x) length(unique(.x)) / length(.x)
# Utilizar um nome melhor para o argumento
frac_distintos <- function(vec) length(unique(vec)) / length(vec)
# Recolocar as chaves
frac_distintos <- function(vec) { length(unique(vec)) / length(vec) }
# Identar o corpo da função
frac_distintos <- function(vec) {
length(unique(vec)) / length(vec)
}Agora fica bem mais fácil de entender o que faz o map() lá do começo.
Futuro
A pergunta óbvia agora é: existe um jeito de fazer algo assim fora do {tidyverse}? A resposta é sim e não.
Desde o
R 4.1,
o R introduziu a sua própria notação anônima. Ela funciona de maneira muito
similar ao ~, com a diferença de que você precisa dizer o nome do seu
argumento. Abaixo deixo vocês com o processo de simplificação da função
conta_na() para a sua versão anônima que pode ser utilizada em qualquer
lugar e não só no {tidyverse}:
# Conta o número de NAs em um vetor
conta_na <- function(vetor) {
sum(is.na(vetor))
}
# Usar uma linha só
conta_na <- function(vetor) { sum(is.na(vetor)) }
# Sem necessidade de usar chaves
conta_na <- function(vetor) sum(is.na(vetor))
# Se a função tem uma linha, podemos usar a nova notação
conta_na <- \(vetor) sum(is.na(vetor))
# O nome do argumento pode ser qualquer coisa, não importa
conta_na <- \(v) sum(is.na(v))
# Anonimizar
map_dbl(starwars, \(v) sum(is.na(v)))#> name height mass hair_color skin_color eye_color birth_year
#> 0 6 28 5 0 0 44
#> sex gender homeworld species films vehicles starships
#> 4 4 10 4 0 0 0Quase tão bom quanto a notação de til!
