Haskell/Programas completos

Origem: Wikilivros, livros abertos por um mundo aberto.
< Haskell
Saltar para a navegação Saltar para a pesquisa


Translation arrow.svg Este módulo encontra-se em processo de tradução. A sua ajuda é bem vinda.

Programas completos(standalone programs) são programas que não precisam de nem um módulo ou biblioteca externa. Ou seja, eles já contém todo o código necessário para serem executados.

Então, vamos construir alguns programas completos.

O módulo Main[editar | editar código-fonte]

O requisito básico para termos programas completos é ter o módulo Main e ele deve conter uma função chamada main do tipo IO ().

-- cumprimento.hs
module Main where

main = putStrLn "Olá amigos!"

Agora, vamos compilar este código e executá-lo independente:

$ ghc --make meuPrimeiroExecutavel cumprimento.hs
$ ./meuPrimeiroExecutavel 
Olá amigos!

Voilà, agora temos um programa completo construído em Haskell.

Outros Módulos[editar | editar código-fonte]

Muitos programas são divididos em diferentes arquivos. A seguir, um pequeno exemplo de um programa que usa dois módulos.

-- Nome.hs
module Nome where

meuNome = "Maria"
-- cumprimento.hs
module Main where

import Nome

main = putStrLn ( "olá, eu sou " ++ meuNome)

Nós podemos compilar este pequeno programa da mesma forma que foi feito antes. A flag --make diz ao GHC para detectar automaticamente dependências nos arquivos que estão sendo compilados. Ou seja, como cumprimento.hs importa o módulo Nome o GHC irá buscar no diretório atual pelo arquivo que contém o módulo Nome e compilá-lo também. Caso Nome também dependa de outros módulos o GHC fará o mesmo processo novamente.

$ ghc --make -o cumprimentoComNome cumprimento.hs
$ ./cumprimentoComNome 
olá, eu sou Maria

Você pode ter notado que o arquivo com o módulo Main, cumprimento.hs, tem seu nome diferente do nome do módulo, isso vai contra o que foi falado no capítulo Módulos. Isso não é um problema porque ter o nome do arquivo igual ao nome do módulo é útil para fazer o GHC buscar os arquivos automaticamente. Porém, no caso do módulo Main isso não é necessário, pois já especificamos qual o nome deste módulo quando pedimos ao GHC para compilá-lo.

Se você quer buscar por arquivos haskell em outros diretórios ( incluindo uma estrutura de diretórios e arquivos aninhados) você pode usar a flag -i com os diretórios que você quer adicionar (separados por dois pontos), isto irá indicar os diretórios onde o GHC buscará por código fonte.

Como um simples exemplo, o seguinte programa possui três arquivos, todos no diretório src/, essa é a estrutura de diretórios deste programa fictício:


HaskellProgram/
   src/
      Main.hs
      GUI/
           Interface.hs
      Functions/
           Mathematics.hs

O módulo Main importa suas dependências pesquisando por arquivos com nome semelhante ao nome do módulo. Por exemplo, import GUI.Interface fará uma pesquisa por GUI/Interface (com a extensão apropriada).

Para compilar esse programa no diretório HaskellProgram, faça o seguinte:

$ ghc --make -isrc -o sillyprog Main.hs

Perceba que não se deve pôr espaço entre a flag -i e o nome do diretório. Da mesma forma, não se coloca espaço para separar múltiplos diretórios, e sim :(dois pontos). Por exemplo, caso precisassemos adicionar outro local onde o GHC buscará código fonte, faríamos dessa forma:

$ ghc --make -isrc:outroDiretorio -o sillyprog Main.hs

De forma geral, essa é a sintaxe: -i⟨dir⟩[:⟨dir⟩]*

Ver também[editar | editar código-fonte]