Mostrar código-fonte de Haskell/Composição de funções

{{Em tradução}}

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

Neste capítulo, discutiremos a importância de nos familiarizarmos com funções e bibliotecas básicas de Haskell para escrever programas mais simples e confiáveis. Para isto, usamos ''composição de funções'' para criar funções complexas a partir de partes mais simples.

== A composição de funções ==

''Compor funções'' significa aplicar uma função a um argumento e, depois, aplicar outra função ao resultado da primeira função. Veja:

<syntaxhighlight lang=haskell>
f x = x + 3
quadrado x = x ^ 2
</syntaxhighlight>

Podemos compor <code>f</code> e <code>quadrado</code> de duas maneiras:

{{HaskellGHCi|1=
Prelude> quadrado (f 1) -- f primeiro, quadrado depois
16
Prelude> quadrado (f 2)
25
Prelude> f (quadrado 1) -- quadrado primeiro, f depois
4
Prelude> f (quadrado 2)
7
}}

{{nota|Os parêntesis cercando a função de dentro são importantes. Sem eles, no primeiro exemplo, o compilador diria que <code>quadrado</code> estaria sendo aplicado a dois argumentos, <code>f</code> e <code>1</code>, o que resultaria num erro, pois <code>quadrado</code> recebe apenas um argumento.}}

Compor duas ou mais funções resulta numa nova função. Se for o caso de sempre usarmos <code>quadrado</code> e <code>f</code> de forma composta, poderíamos definir novas funções para facilitar a programação:

<syntaxhighlight lang="haskell">
quadradoDef x = quadrado (f x)
fDeQuadrado x = f (quadrado x)
</syntaxhighlight>

Há também um outro jeito de compor duas funções: usando o operador de composição <code>(.)</code>. Basta adicionar um ponto entre o nome de duas funções:

<syntaxhighlight lang="haskell">
quadradoDef x = (quadrado . f) x
fDeQuadrado x = (f . quadrado) x
</syntaxhighlight>

Note que as funções ainda são aplicadas da direita para a esquerda: <code>(g . f) x == g(f(x))</code>. O símbolo <code>(.)</code> foi escolhido para representar composição de funções por ser semelhando à notação matemática: <math>(g \circ f)(x) = g(f(x))</math>.

Outra simplificação: nossas funções são como expressões matemáticas. Isso quer dizer que ''às vezes'' podemos então escrever
<syntaxhighlight lang="haskell">quadradoDef x = (quadrado . f) x</syntaxhighlight>
e eleminar <code>x</code> de ambos os lados, resultando em:
<syntaxhighlight lang="haskell">quadradoDef = quadrado . f</syntaxhighlight>

Aprenderemos mais sobre funções "sem argumentos" mais tarde. Mas é importante lembra-se desta possibilidade em Haskell desde o começo.

== Porque incrementar seu "vocabulário"  de funções ==

Em Haskell, é bastante simples criar funções compostas e definir variáveis. Mas é claro que antes de compor, precisamos ter as funções elementares em primeiro lugar. Enquanto as funções que criamos podem ser armazenadas e usadas sempre que quisermos, o próprio GHC já possui uma vasta quantidade de bibliotecas (pacotes) com muitas funções nativas prontas para serem usadas. Por isso, para se tornar um programador bem familiarizado com Haskell, é preciso conhecer algumas bibliotecas essenciais. Ou pelo menos, saber como encontrar as que você precisa.

Se usássemos o conteúdo contido no capítulo sobre [[Haskell/Recurssão|Recurssão]] deste livro, já seria possível escrever qualquer tipo de programa para manipular listas, por exemplo. Entretanto, teríamos que escrever muitas funções bastante comuns — e que já estão presentes em algum pacote —, o que tornaria bastante ineficiente e custosa a tarefa de desenvolver certas aplicações. Por isso, ao longo deste wikilivro vamos nos aprofundar cada vez mais nas bibliotecas já disponíveis na comunidade Haskell, principalmente as já contidas no GHC.

== O prelúdio e as bibliotecas ==

Antes de prosseguirmos, algumas informações sobre as bibliotecas de Haskell.

Primeiramente, <code>Prelude</code> (''prelude'' é "prelúdio" em inglês) é a principal biblioteca disponível no GHC, e é a única que é carregada automaticamente em qualquer programa<ref group=nota>Lembra-se de que toda linha do GHCi começa com <tt>Prelude></tt>? Isso significa que o prelúdio foi carregado e está disponível para uso.</ref> (a menos que você não queira).<ref group=nota>Existem extensões na linguagem Haskell que permitem omitir o prelúdio, mas não cobriremos esse tema neste wikilivro.</ref> Além dos tipos de dados mais básicos, ela fornece muitas outras ferramentas bastante usadas: <code>fst</code>, <code>snd</code>, <code>head</code> e <code>tail</code> são alguns exemplos.

Outras bibliotecas são também chamadas de ''módulos'', que podem ser ''importados'' no programa. Mais adiante, em capítulos futuros, falaremos sobre o desenvolvimento de módulos e como eles funcionam. Por enquanto, vamos focar em importar alguns módulos básicos. A função <code>permutations</code>, por exemplo, gera todas as permutações possíveis dos elementos de uma lista. Esta operação pode ser bastante útil, entertanto a função não está disponível no <code>Prelude</code>, mas no módulo <code>Data.List</code>. Para importar o módulo de listas (ou qualquer outro) e poder usar suas funções, você deve adicionar uma chamada no topo do seu arquivo <tt>.hs</tt>:

<syntaxhighlight lang="haskell">
import Data.List

testarPermutations = permutations "Prelude"
</syntaxhighlight>

Para carregar um módulo numa sessão do GHCi, deve-se usar o comando <code>:module +</code> (ou <code>:m +</code>):

{{HaskellGHCi|1=
Prelude> :m + Data.List
Prelude Data.List> :t permutations
permutations :: [a] -> [[a]]
}}

== Exemplo ilustrativo ==

Antes de seguirmos para o próximo capítulo, vejamos um exemplo das vantagens de se usar funções nativas (ou contidas em outros módulos).<ref group=nota>Este exemplo foi inspirado na demonstração [https://wiki.haskell.org/Simple_unix_tools Simple Unix tools] da [https://wiki.haskell.org/Simple_unix_tools HaskellWiki].</ref> Suponha que você queira uma função que inverta a ordem das palavras contidas num String. Por exemplo, se a entrada fosse "O rato roeu a roupa do rei", a saída seria "rei do roupa a roeu rato O". Uma possível solução seria (não tente entender seu funcionamento, é apenas um caso ilustrativo):

<syntaxhighlight lang="haskell">
inverterPalavras :: String -> String
inverterPalavras entrada = reunirNaoInvertidas (dividirRevertidas entrada)
    where
    dividirRevertidas s = go1 [] s
        where
        go1 divididas [] = divididas
        go1 [] (c:cs)
            | testarEspaco c = go1 [] cs
            | otherwise   = go1 [[]] (c:cs)
        go1 (w:ws) [c]
            | testarEspaco c = (w:ws)
            | otherwise   = ((c:w):ws)
        go1 (w:ws) (c:c':cs)
            | testarEspaco c =
                if testarEspaco c'
                    then go1 (w:ws) (c':cs)
                    else go1 ([c']:w:ws) cs
            | otherwise = go1 ((c:w):ws) (c':cs)
    testarEspaco c = c == ' '
    reunirNaoInvertidas [] = []
    reunirNaoInvertidas [w] = inverterLista w
    reunirNaoInvertidas strings = go2 (' ' : inverterLista primeiraPalavra) (outrasPalavras)
        where
        (primeiraPalavra : outrasPalavras) = inverterLista strings
        go2 reunidas ([]:[]) = reunidas
        go2 reunidas ([]:(w':ws')) = go2 (reunidas) ((' ':w'):ws')
        go2 reunidas ((c:cs):ws) = go2 (c:reunidas) (cs:ws)
    inverterLista [] = []
    inverterLista w = go3 [] w
        where
        go3 rev [] = rev
        go3 rev (c:cs) = go3 (c:rev) cs
</syntaxhighlight>

Temos muitos problemas aqui:
* Primeiro, para saber se <code>inverterPalavras</code> realmente funciona, você pode tentar entender seu funcionamento, testar exaustivamente com muitos exemplos, ou simplesmente acreditar. Pela sua extensão da função, já fica claro que não vale a pena tentar entender. E ficar testando funções de outras pessoas é uma tarefa nada produtiva para um programador, a não ser que seja este o seu trabalho.
* Segundo, depois de escrever uma função tão extensa, se tiver que fazer alguma alteração ou corrigir algum ''bug'' mais tarde, você, com certeza, terá que inspecioná-la de cima a baixo, tentando relembrar e entender o que você fez, e procurando onde a mudança desejada deve ser feita.
* Por último, só olhando por cima já é possível ver um possível problema: temos uma função auxiliar chamada <code>testarEspaco</code>, que verifica se um caractere é um espaço em branco que separa palavras. Ela, entretanto, testa ''apenas'' <code>&nbsp;</code>, e não considera tabulações ou quebra de linhas, por exemplo.

Felizmente, supondo que já estamos familiarizados com as funções contidas em <code>Prelude</code>, poderíamos:
* Usar <code>words</code> para criar uma lista de Strings dividindo um String contendo espaços em branco;
* Usar <code>reverse</code> para inverter a ordem dos elementos de uma lista (que é exatamente o mesmo que a função auxiliar <code>inverterLista</code> faz em <code>inverterPalavras</code>), e;
* Usar <code>unwords</code> para recriar um String a partir de uma lista de Strings usando espaços em branco (o oposto de <code>words</code>);

Conhecendo todas essas funções e usando o operador <code>(.)</code>, poderíamos escrever:

<syntaxhighlight lang="haskell">
novaInverterPalavras :: String -> String
novaInverterPalavras entrada = (unwords . reverse . words) entrada
</syntaxhighlight>

Você consegue ver as vantagens?
* É uma implementação bem mais curta.
* Sendo mais curta, é mais fácil inspecionar suas partes, se for preciso.
* Como todas estas funções usadas estão presentes em <code>Prelude</code>, elas são confiáveis, pois já foram testas exaustivamente por milhares de pessoas.
A mensagem final é esta: se você se vir escrevendo funções gigantescas como <code>inverterPalavras</code>, procure outros recursos para facilitar seu trabalho, isto é, procure funções em outras bibliotecas e use composição para construir sua  função final.

== Principais fontes de recurso em Haskell ==

Um bom programador deve saber onde buscar os recursos que achar necessário para seu trabalho. Talvez você ainda não seja experiente o bastante para entender todo tipo de informação que possa aparecer, mas eis alguns lugares importantes na comunidade Haskell:

* Primeiramente, a [http://www.haskell.org/onlinereport/standard-prelude.html documentação do próprio <code>Prelude</code>], e também [http://www.haskell.org/ghc/docs/latest/html/libraries/index.html das bibliotecas contidas no GHC].
* [http://www.haskell.org/hoogle Hoogle] é uma ferramenta de busca. Com ela pode-se fazer pesquisas na documentação de Haskell: buscar nomes de funções, tipos de dados, e até assinaturas de funções.
* [http://hackage.haskell.org Hackage] é o principal arquivo de módulos e bibliotecas da comunidade Haskell, e ele geralmente pode ser acessado via [http://www.haskell.org/cabal/users-guide/ cabal], o gerenciador de pacotes padrão de Haskell.

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

[[en:Haskell/Building vocabulary]]