Mostrar código-fonte de Haskell/Lambdas e operadores

{{Em tradução}}
{{HaskellÍndice|Básico}}

Em Haskell existe um tipo de expressão extremamente importante chamada '''expressões lambdas''', comumente chamadas de '''funções anônimas''', as quais vamos introduzir neste módulo. Além disso, aprenderemos um pouco sobre '''operadores''' e  '''notação infixa'''.

== Expressões lambdas ==

Relembrando os exemplos do capítulo [[Haskell/Listas II|Listas II]], suponha que queiramos dobrar todos os elementos de uma lista. Uma possível função para este trabalho seria:

<syntaxhighlight lang="haskell">
dobrarLista ls = map dobro ls
    where dobro x = 2 * x
</syntaxhighlight>

Ou ainda:

<syntaxhighlight lang="haskell">
dobrarLista ls = let dobro x = 2 * x
                 in map dobro ls
</syntaxhighlight>

Outra solução, porém, seria usar uma ''expressão lambda'' para representar a função auxilar <code>dobro</code> sem precisar usar <code>let</code> ou <code>where</code>:

<syntaxhighlight lang="haskell">
dobrarLista ls = map (\x -> 2 * x) ls
</syntaxhighlight>

Antes de entendermos a notação, precisamos fazer uma breve correlação entre Matemática e Computação.

Na Matemática, a função que dobra seu argumento pode ser representada por <math>f(x) = 2x</math>. Com isso, ela passa a se chamar "<math>f</math>", sendo que poderia ter sido qualquer outro nome, como "<math>g</math>" ou "<math>\text{dobro}</math>".

Já nas Ciências da Computação existe um área de estudo chamada ''[[w:Cálculo lambda|Cálculo lambda]]''. É a partir dela que muitas linguagens de programação funcional são desenvolvidas, inclusive Haskell. O Cálculo lambda, por sua vez, não exige que as funções tenham nomes, e por isso elas podem ser chamadas de ''funções anônimas''. Toda função é denotada por <math>\lambda</math> seguido das variáveis de entrada, um sinal de gráfico e a expressão matemática da função. A função <math>f(x)</math> pode se escrita como:
# <math>\lambda x \rightarrow 2 x</math>, ou;
# <math>\lambda x . \, 2 x</math>.

A notação usada em Haskell se assemelha com a primeira opção:
# <code>\</code> é usada para representar o <math>\lambda</math>;
# <code>-></code> substitui a seta <math> \rightarrow </math>.

A aplicação de funções anônimas também é semelhante em Haskell e no Cálculo lambda:
* No Cálculo lambda, <math>(\lambda x \rightarrow 2x) \, 7</math> resulta em <math>14</math>.
* Em Haskell, <code>(\x -> 2 * x) 7</code> resulta em <code>14</code>.

Portanto, expressões lambdas funcionam como qualquer outras funções, mas, por não possuirem um nome, não podemos chamá-las em diferentes lugares do código. Isso as torna "descartáveis", o que é bastante útil quando precisamos usar certa função apenas uma vez como em <code>map</code> ou alguma ''fold'', por exemplo.

Há um jeito, porém, de dar nomes às funções anônimas. Basta declarar uma variável que seja a função anônima. Por exemplo:

<syntaxhighlight lang="haskell">
pitagoras = \x y -> sqrt (x^2 + y^2)
</syntaxhighlight>

Acabamos de criar a função <code>pitagoras</code> a partir de uma expressão lambda que possui dois argumentos. Podemos testar no GHCi:

{{HaskellGHCi|1=Prelude> let pitagoras = \x y -> sqrt (x^2 + y^2)
Prelude> pitagoras 3 4
5.0}}

{{Exercícios|1=Reescreva as seguintes expressões usando lambdas:
* <code>map f xs where f x = x * 2 + 3</code>
* <code>let f x y = read x + y in foldr f 1 xs</code>}}

== Operadores ==

Em Haskell, um ''operador'' é qualquer função de dois argumentos que possuir um nome que consista apenas de caracteres não-alfanuméricos. Os operadores mais comuns são os aritméticos, como a adição, <code>(+)</code>, a subtração, <code>(-)</code>. Diferente de outras funções, que usam a notação de ''prefixos'', operadores são ''infixos'', isto é, são escritos entre os argumento, como <code>2 + 3</code> e <code>5 * 7</code>. Mesmo assim, eles ainda podem ser usados com a notação de prefixos, bastando para isso envolvê-los entre parênteses:

{{HaskellGHCi|Prelude> (+) 1 2
3
Prelude> (^) 2 10
1024}}

Novos operadores podem ser definidos como quaisquer outras funções, basta não usar caracteres alfanuméricos em seus nomes e colocando parênteses na assinatura de tipo. Por exemplo, vejamos a definição da função <code>(\\)</code> do módulo <code>Data.List</code>, a qual elimina os elementos iguais de duas listas:

<syntaxhighlight lang="haskell">
(\\) :: (Eq a) => [a] -> [a] -> [a]
xs \\ ys = foldl (\zs y -> delete y zs) xs ys
</syntaxhighlight>

A segunda linha também poderia ser escrita de forma infixa, mas é opcional:
<syntaxhighlight lang="haskell">
(\\) xs ys = foldl (\zs y -> delete y zs) xs ys
</syntaxhighlight>

=== Seções ===

''Seções'' são um tipo de açúcar sintático que permite criamos novas funções a partir da aplicação parcial de operadores. Por exemplo, a função <code>dobro</code> que vimos antes pode ser definida como:

<syntaxhighlight lang="haskell">
dobro x = (2*) x
</syntaxhighlight>

Ou ainda, usando a notação de ponto livre:

<syntaxhighlight lang="haskell">
dobro = (2*)
</syntaxhighlight>

Assim sendo, podemos escrever a função <code>dobrarLista</code> de maneira ainda mais concisa, sem usar expressões lambda:

<syntaxhighlight lang="haskell">
dobrarLista ls = map (*2) ls
</syntaxhighlight>

Deve-se notar, entretanto, que para a maioria dos operadores, a ordem do argumento fixo importa:

{{HaskellGHCi|1=Prelude> let f = (2^)
Prelude> let g = (^2)
Prelude> f 10
1024
Prelude> g 10
100
Prelude> let k = (!! 4)
Prelude> let h = ([10,20..] !!)
Prelude> k [10,20..]
50
Prelude> h 10
110}}

Se tentássemos definir <code>(4 !!)</code>, por exemplo, teríamos um erro dizendo que o esperado é uma lista do lado esquerdo de <code>(!!)</code>, e não um número.

=== Notação infixa com funções comuns ===

Se você tiver uma função comum, que deve ser usada na forma de prefixo, é possível usá-la na forma infixa, como um operador. Basta cercá-la de acentos graves <code>`</code>. 

Um exemplo bastante comum é a função <code>elem</code>, que retorna True se um valor estiver contido numa lista, ou False, caso contrário:

{{HaskellGHCi|Prelude> 1 `elem` [10..100]
False
Prelude> 'h' `elem` "haskell"
True}}

Este truque geralmente é usado para melhorar a leitura do código, e só pode ser usado com funções de dois argumentos.

{{Exercício|# Seções são açúcar sintático para expressões lambdas. Reescreva as seguintes seções na forma de lambdas determine seus tipos:
#* <code>(4+)</code>
#* <code>(1 `elem`)</code>
#* <code>(`notElem` "abc")</code>
# 
# Teste as seguintes linhas no GHCi:
:: <syntaxhighlight lang="haskell">
norma3D  x y z = sqrt (x^2 + y^2 + z^2)
nomra3D' a b   = a `norma3D` b
</syntaxhighlight>
:: Se a notação infixa só pode ser usada com funções de dois argumentos, por que a definição de <code>norma3D'</code> é válida? Dica: observe os tipos de cada uma das funções e lembre-se de ''[[Haskell/Listas II#Currying|currying]]''.}}