Mostrar código-fonte de Haskell/Casamento de padrões, if e let

{{Em tradução}}

{{clear}}
{{HaskellÍndice|Introdução}}

Este capítulo introduz expressões <code>if</code>, ''casamento de padrões'' e a palavra-chave <code>let</code>.

== <code>if</code> / <code>then</code> / <code>else</code> ==

Haskell suporta expressões de condicionais simples, da forma ''se <tt>x</tt> então <tt>p</tt> senão <tt>q</tt>''. A estrutura é a mesma que a de muitas linguagens de programação. Por exemplo, considere uma função que: retorna -1 e seu argumento for menor 0; 0 se o argumento for igual a 0; ou 1 se o argumento for maior que 0:

<syntaxhighlight lang="haskell">
minhaSignum x =
    if x < 0 
        then -1
        else if x > 0
            then 1
            else 0
</syntaxhighlight>

O fato é que Haskell já possui a função <code>signum</code> que faz exatamente isso, mas vamos usá-la para exemplificar expressões condicionais.

Em qualquer expressão <code>if</code> (''if'' em inglês significa "se"), a primeira condição e avaliada: se ela for verdadeira, a expressão dentro de <code>then</code> (''then'' em inglês significa "então") é avalidada; se ela for falsa, a expressão dentro de <code>else</code> (''else'' em inglês significa "senão"), que pode ou não existir, é avaliada.

No caso de <code>minhaSignum</code>:
# A condição avaliada é <code>x < 0</code>.
# Se a condição retornar um Bool <code>True</code>, a expressão dentro de <code>then</code> é avaliada: a função <code>minhaSignum</code> retornará <code>-1</code>
# Se a condição retornar um Bool <code>False</code>, a expressão dentro de <code>else</code> é avaliada: uma nova expressão ''if then else'' deve ser avaliada.
## A condição avaliada é <code>x > 0</code>.
## Se a condição retornar um Bool <code>True</code>, a expressão dentro de <code>then</code> é avaliada: a função <code>minhaSignum</code> retornará <code>1</code>;
## Se a condição retornar um Bool <code>False</code>, a expressão dentro de <code>else</code> é avaliada: a função <code>minhaSignum</code> retornará <code>0</code>.

Aqui tivemos o exemplo de duas expressões condicionais ''aninhadas'', isto é, uma dentro de outra, o que é perfeitamente possível e bastante comum em programação.<ref group=nota>Se você já tem experiência com outras linguagens, já deve ter usado <code>elseif</code> ou algo parecido. Em Haskell, entretanto, não há esta funcionalidade, portanto precisamos aninhar as expressões de forma explícita.</ref>

Qualquer função que precise usar expressões condicionais também pode ser escrita usando [[Haskell/Verdadeiro ou falso#Guardas|guardas]]:

<syntaxhighlight lang="haskell">
minhaSignum x
    | x < 0     = -1
    | x > 0     = 1
    | otherwise = 0
</syntaxhighlight>

Da mesma forma, qualquer função que use guardas também pode ser escrita com expressões ''se'' explícitas. Vejamos a função <code>absoluto</code> que definimos em [[Haskell/Verdadeiro ou falso#Guardas|Verdadeiro ou falso]]:

<syntaxhighlight lang="haskell">
absoluto x =
    if x < 0 
        then -x
        else x
</syntaxhighlight>

Mas por que há duas maneiras de se escrever expressões condicionais? Por que não usar somente <code>if</code> ou somente guardas? Apesar de serem a mesma coisa, com o mesmo desempenho computacional, sua experiência lhe dirá qual das duas formas é mais legível. Não há melhor ou pior, só mais ou menos legível.

=== Tipos numa expressão condicional ===

É importante observar os tipos das expressões usadas dentro de <code>if</code> / <code>then</code> / <code>else</code>:
# As condições avaliadas por <code>if</code> devem ''sempre'' retornar um Bool.
# Os valores finais das expressões dentro de <code>then</code> e <code>else</code>, podem ser de ''qualquer tipo'', mas ambos devem ser do ''mesmo tipo''.

Esta é uma função válida em Haskell:
<syntaxhighlight lang="haskell">
possivel x =
    if x == 0
        then "zero"     -- then retorna um String
        else "não-zero" -- else retorna um String
</syntaxhighlight>

Esta é uma função inválida em Haskell:
<syntaxhighlight lang="haskell">
impossivel x =
    if x == 0
        then 0          -- then retorna um Num
        else "não-zero" -- else retorna um String
</syntaxhighlight>

{{Exercício|1=
Por que as expressões dentro de ''then'' e ''else'' contidas num mesmo ''if'' devem possuir o mesmo tipo?}}

== Casamento de padrões: introdução ==

Considere um programa que analisa dados estatísticos de uma competição de corrida na qual cada piloto recebe pontos de acordo com sua posição final. As regras são:
* 1° lugar: 10 pontos
* 2° lugar: 6 pontos
* 3° lugar: 4 pontos
* 4° lugar: 3 pontos
* 5° lugar: 2 pontos
* 6° lugar: 1 pontos
* Nenhum ponto para os demais.
Podemos escrever uma função que recebe a classificação final de um piloto (representada por um número inteiro), e que retorna quantos pontos devem ser creditados.

<syntaxhighlight lang="haskell">
pts :: Int -> Int
pts x =
    if x == 1
        then 10
        else if x == 2
            then 6
            else if x == 3
                then 4
                else if x == 4
                    then 3
                    else if x == 5
                        then 2
                        else if x == 6
                            then 1
                            else 0
</syntaxhighlight>

Por simplicidade, não vamos nos preocupar com o que aconteceria se o argumento fosse um número negativo, ou zero, por exemplo. Entretanto, numa aplicação real, deve-se sempre pensar nestes casos improváveis. Aqui simplesmente dissemos que o resultado é 0 para qualquer argumento que não seja maior que ou igual a 1 e menor que ou igual a 6.

Observe função que acabamos de escrever. Ela contem seis expressões ''if''aninhadas. Mesmo podendo copiar e colar texto, esta implementação ainda é propensa a erros, além de ser difícil de entender. Poderíamos escrever usando guardas, o que seria um pouco melhor, mas ainda seria necessário escrever todos os seis testes de igualdade. Fica como exercício.

{{Exercício|1=
Reescreva a função <code>pts</code> usando guardas.}}

Uma maneira muito mais fácil e legível seria:
<syntaxhighlight lang="haskell">
pts :: Int -> Int
pts 1 = 10
pts 2 = 6
pts 3 = 4
pts 4 = 3
pts 5 = 2
pts 6 = 1
pts _ = 0
</syntaxhighlight>

''Muito'' melhor. Faça o teste desta nova implementação e veja que funciona da mesma forma que o método anteiror. 

O acontece aqui é o que chamamos de ''casamento de padrões''. Quando a função é chamada com um certo argumento <code>x</code>, o compilador vai buscar qual dos ''padrões'' de argumentos mostrados do lado esquerdo são ''iguais'' a <code>x</code>. Quando encontrar, vai executar a expressão do lado direito: 
# Ao executar <code>pts 3</code>, o comiplador passará por <code>pts 1</code>, <code>pts 2</code> e chegará a <code>pts 3</code>.
# Como o argumento de chamada é igual ao argumento do padrão, (<code>3 == 3</code>), a expressão do lado direito é executada, e a função retorna <code>4</code>.

É bastante comum que o último padrão use <code>_</code> como argumento para indicar ''qualquer valor'', isto é, se o padrão não se encaixar em nenhum caso anterior, então se encaixará no caso em que ''qualquer valor'' é válido:
# Ao executar <code>pts 0</code>, o comiplador passará por <code>pts 1</code>, <code>pts 2</code>, <code>pts 3</code>, <code>pts 4</code>, <code>pts 5</code>, <code>pts 6</code> e chegará a <code>pts _</code>.
# Como <code>_</code> indica ''qualquer valor'' e <code>0</code> é um valor qualquer, a expressão do lado direito é executada, e função retorna <code>0</code>.

A ordem dos padrões é importante para a execução correta da função. Verifique você mesmo o que acontece se o padrão <code>_</code> for definido entre <code>2</code> e <code>3</code>, por exemplo. Ignore qualquer mensagem de erro que possa aparecer e tente executar <code>pts 5</code>.

Perceba que não usamos nenhuma varíavel na definição de <code>pts</code>, apenas valores. Isso é perfeitamente possível, uma vez que todos os valores retornados são constantes. Entretanto, olhando mais de perto, <code>pts</code> obedece a seguinte fórmula matemática:

<math>
\text{pts}(x) =
 \begin{cases}
     10,    & \mbox{se } x = 1 \\
     6,     & \mbox{se } x = 2 \\ 
     7 - x, & \mbox{se } 2 < x \le 6 \\
     0,     & \mbox{se } x > 6    
 \end{cases}
</math>

A notação matemática já nos dá uma indicação do que podemos tentar: misturar casamento de padrões e guardas. De fato, Haskell nos permite fazer exatamente isso:

<syntaxhighlight lang="haskell">
pts :: Int -> Int
pts 1 = 10
pts 2 = 6
pts x
    | x <= 6    = 7 - x
    | otherwise = 0
</syntaxhighlight>

Fica fácil perceber que agora, em vez de usarmos <code>_</code> para capturar qualquer padrão não especificado, temos <code>otherwise</code> fazendo isso.

{{Exercício|1=
A versão de casamento de padrões de <code>pts</code> e esta última versão mista são ligeiramente diferentes. Você consegue ver a diferença? Conseguiria reescrever a versão mista para que as duas retornem os mesmos resultados sempre? Dica: compare a definição matemática e a implementação em Haskell e preste atenção a condição implícita da definição matemática.
}}

Além de número inteiros, casamento de padrões funciona qualquer tipo de dado. Um bom exemplo é o operador lógico ''ou'', <code>(||)</code>, que vimos em [[Haskell/Verdadeiro ou falso|Verdadeiro ou falso]]. Ele poderia ser definido como sendo:

<syntaxhighlight lang="haskell">
(||) :: Bool -> Bool -> Bool
True || _    = True
_    || True = True
_    || _    = False
</syntaxhighlight>

ou

<syntaxhighlight lang="haskell">
(||) :: Bool -> Bool -> Bool
True  || _ = True
False || y = y
</syntaxhighlight>

Ou ainda:

<syntaxhighlight lang="haskell">
(||) :: Bool -> Bool -> Bool
False || False = False
_     || _     = True
</syntaxhighlight>

Se usarmos casamento de padrões em funções de mais de um argumento, as expressões só serão avaliadas se ''todos'' os argumentos se encaixarem em algum padrão. E se os argumentos não se encaixarem em nenhum padrão, teremos um erro de execução. Por isso, como dito anteriormente, é sempre bom ter um caso <code>_</code> ou <code>otherwise</code> para capturar padrões inesperados ou indesejados.

Vejamos um exemplo de padrão que não funciona. A função lógica ''E'' não poderia ser definida assim:

<syntaxhighlight lang="haskell">
(&&) :: Bool -> Bool -> Bool
x && x = x
_ && _ = False
</syntaxhighlight>

Mesmo que usemos <code>x</code> nos dois argumentos para indicar que eles devem ser iguais, o compilador não compara argumentos entre si. A primeira linha é, portanto, equivalente a segunda. Além disso, ainda teremos um erro do compilador dizendo que <code>x</code> foi definido múltiplas vezes.

== Padrões com n-uplas e listas ==

Os exemplos anteriores mostram que usar casamento de padrões para escrever funções resultam num código muito mais legível e elegante. Entretanto, eles não ilustram por que este método é tão importante. Primeiro, considere que você precisa implementar a função <code>fst</code>, que extrai o primeiro elemento de uma dupla. Esta parece ser uma tarefa impossível com os conhecimentos básicos de Haskell, já que a única maneira de acessar o primeiro elemento de uma dupla é usando a própria função <code>fst</code>. Entretanto, veja a função <code>fst'</code> a seguir, que realiza o mesmo trabalho que <code>fst</code>:

<syntaxhighlight lang="haskell">
fst' :: (a, b) -> a
fst' (x, _) = x
</syntaxhighlight>

Parece mágica, mas é apenas casamento de padrões com n-uplas (uma dupla, neste caso). Em <code>fst'</code>, se aplicarmos um argumento <code>(1,2)</code>, por exemplo, o primeiro elemento <code>1</code> seria associado a variável <code>x</code>, enquanto que <code>2</code> seria associado a <code>_</code> e descartado. Depois disso, pode-se fazer qualquer operação com <code>x</code> do lado direito.

{{Exercício|1=
Escreva uma função <code>quarto</code> que extraia o quarto elemento de uma 10-upla.}}

Um padrão semelhante pode ser usado em listas. Vejamos a definição de <code>head</code> e <code>tail</code>

<syntaxhighlight lang="haskell">
head             :: [a] -> a
head (x:_)       =  x
head []          =  error "Prelude.head: empty list"

tail             :: [a] -> [a]
tail (_:xs)      =  xs
tail []          =  error "Prelude.tail: empty list"
</syntaxhighlight>

A lista, assim como uma dupla, é dividia em dois elementos: cabeça e cauda. A cabeça é o elemento que aparece à esquerda do cons (<code>(:)</code>), e a cauda, o que aparece à direita. No caso de <code>head</code> e <code>tail</code>, ainda precisamos de um padrão específico para o caso de uma lista vazia, o qual usa a função <code>error</code> para exibir uma mensagem de erro durante a execução da aplicação.

Resumindo, a verdadeira vantagem de usar casamento de padrões é o fato de facilitar o acesso a valores contidos em estruturas de dados mais complexas. Casamento de padrões com listas são bastante usados em Haskell, especialmente em funções recursivas, como veremos no capítulo [[Haskell/Recurssão|Recurssão]].

== Associações <code>let</code> ==

Para concluirmos, uma breve introdução a associações <code>let</code>, que nada mais são que uma alternativa ao uso de <code>where</code>, sendo elas intercambiáveis muitas das vezes.

A sintaxe de <code>where</code> é: <code><expressões> '''where''' <associações></code>. No caso de <code>let</code>, temos o contrário: <code>'''let''' <associações> '''in''' <expressões></code>. Para se lembrar melhor, basta traduzir do inglês:'' '''seja''' <associações> '''em''' <expressões>''.

Vejamos um problema simples: encontrar as soluções da equação <math>ax^2 + bx + c = 0</math>. A soluções são dadas por: <math>x = \frac {-b \pm \sqrt{b^2 - 4 a c}}{2a}</math>. Uma função para calcular a dupla de soluções de <math>x</math> poderia ser:

<syntaxhighlight lang="haskell">
solucao a b c = 
    ( (-b + sqrt(b * b - 4 * a * c)) / (2 * a)
    , (-b - sqrt(b * b - 4 * a * c)) / (2 * a) )
</syntaxhighlight>

Perceba a repetição de <code>sqrt(b * b - 4 * a * c)</code>. Poderíamos usar <code>where</code> para definir <code>raizDelta = sqrt(b * b - 4 * a * c)</code> uma única vez na função:

<syntaxhighlight lang="haskell">
solucao a b c = 
    ( (-b + raizDelta) / (2 * a)
    , (-b - raizDelta) / (2 * a) )
        where aizDelta = sqrt(b * b - 4 * a * c)
</syntaxhighlight>

Ou podemos usar <code>let</code>:

<syntaxhighlight lang="haskell">
solucao a b c =
    let raizDelta = sqrt(b * b - 4 * a * c)
    in  ( (-b + raizDelta) / (2 * a)
        , (-b - raizDelta) / (2 * a) )
</syntaxhighlight>

{{aviso|Fique atento à indentação! Haskell é sensível a indentação do código, e é sempre recomendável usar espaços em branco em vez de tabulação. Em Haskell usam-se dois ou quatros espaços. Se você quiser insistir em usar tabulação, assegure-se de que todas tenham o mesmo comprimento. Falaremos mais sobre este assunto em [[Haskell/Indentação|Indentação]].}}

== Notas ==
<references group=nota />

[[en:Haskell/Next steps]]