Haskell (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.

Na década de 1980, um comitê foi organizado com o objetivo de construir uma linguagem funcional de programação padronizada com uma semântica não-rígida. Haskell, em homenagem ao lógico Haskell Curry, foi o resultado dessas deliberações. O último semi-oficial padrão desta linguaguem é Haskell 98, destinado a especificar uma versão mínima e portável da linguagem para o ensino e como base para futuras extensões. A linguagem continua a evoluir rapidamente, com Hugs e GHC (veja abaixo) representando os padrões atuais 'de fato'.

Características interessantes do Haskell incluem o suporte a funções recursivas e tipos de dados, casamento de padrões, list comprehensions e guard statements. A combinação destas características pode fazer com que a construção de funções que seriam complexas em uma linguagem procedimental de programação tornem-se uma tarefa quase trivial em Haskell. A linguagem é, em 2002, a linguagem funcional sobre a qual mais pesquisa está sendo realizada. Muitas variantes tem sido desenvolvidas: versões paralelizáveis do MIT e Glasgow, ambas chamadas Parallel Haskell, outras versões paralelas e distribuidas chamadas Distributed Haskell (anteriormente Goffin) e Eden, uma versão chamada Eager Haskell e várias versões orientadas a objetos: Haskell++, O'Haskell e Mondrian.

Uma versão educacional do Haskell chamada Gofer foi desenvolvida por Mark Jones. Ela é oferecida por HUGS, o Haskell User's Gofer System (veja a seção de implementações deste artigo).

[editar] Exemplos

A clássica definição da função fatorial:

fatorial 0 = 1
fatorial n = n * fatorial (n - 1)

Uma bela definição da função fatorial (usando uma notação de lista em Haskell e a função padrão product):

fatorial n = product [1..n]

A mesma função mas agora no estilo point-free. Repare-se que os argumentos desaparecem (o ponto significa composição de funções):

fatorial = product . enumFromTo 1

Uma implementação da função que retorna o n-ésimo termo na seqüência de Fibonacci:

fib 0 = 0 
fib 1 = 1 
fib n = fib (n - 2) + fib (n - 1)

Uma função que retorna uma lista dos números de Fibonacci:

fibs@(_:rest) = 0 : 1 : (zipWith (+) fibs rest)

A função anterior cria uma lista infinita, que é possível graças a lazy evaluation. Poderia-se implementar fib como:

fib n = fibs !! n

(!! é um operador que pega o n-ésimo elemento da lista).

O algoritmo Quicksort pode ser elegantemente escrito em Haskell:

qsort []    = []
qsort (h:t) = qsort menores_que_h ++ [h] ++ qsort maiores_que_h
    where
        menores_que_h   = [x | x <- t, x < h]
        maiores_que_h   = [x | x <- t, x >= h]

(Note que por causa das excessivas cópias e concatenações de listas este código pode ser um tanto lento, dependendo da implementação.)

[editar] Implementações

As seguintes estão totalmente, ou quase, de acordo com o padrão Haskell 98 e são distribuídas sob licenças open source ou free software. Existem atualmente somente implementações não-comerciais do Haskell.

• Hugs (http://www.haskell.org/hugs) é um interpretador de bytecode. Oferece rápida compilação dos programas e razoável velocidade de execução. Também dispõe de uma simples biblioteca gráfica. Hugs é ideal para pessoas que estão aprendendo os básicos de Haskell. É a mais portável e peso leve das implentações.
• GHC (http://www.haskell.org/ghc). O Glasgow Haskell Compiler compila para código nativo de diferentes arquiteturas e pode também compilar para C. GHC é provavalemente o compilador Haskell mais popular, e possui bibliotecas bastante úteis (e.g. bindings to OpenGL) que somente trabalharão com ele.
• nhc98 (http://www.cs.york.ac.uk/fp/nhc98) é outro compilador de bytecodes, mas mais rápido que Hugs. Nhc98 foca na minimização do uso de memória, e é uma boa escolha para máquinas velhas/lentas.
• HBC é outro compilador Haskell para código nativo. Seu desenvolvimento não está ativo, mas ele é funcional.
• Helium (http://www.cs.uu.nl/helium) é um novo dialeto do Haskell. O foco é na facilidade de aprendizado. Atualmente carece de typeclasses, tornando-o incompatível com muitos programas Haskell.

[editar] Linguagens relacionadas

A primeira versão de Haskell surgiu como uma reação a linguagem Miranda, a primeira linguagem não estrita com implementação viável, com diversas características proprietárias. Outra linguagem não estrita similar é Concorrent Clean, cuja principal diferenciação é o uso de tipos únicos, no lugar de monadas, para lidar com entrada e saída.

[editar] Links externos

• The Haskell Home Page
• The Haskell Wiki
• A Gentle Introduction to Haskell 98 ( formato pdf )
• Haskell para Engenheiros e Informatas ( formato pdf, comprimido com gz )
• Um tutorial em português