tutorial de haskell

tutorial de haskell

(Parte 1 de 7)

tutorial de haskell

http://www.marcosrodrigues6.hpg.ig.com.br/index.htm

Prefácio

A tecnologia dos computadores muda com muita freqüência; os fundamentos, no entanto, permanecem estáticos. A arquitetura de um computador padrão é adaptada de máquinas construídas a meio século. Em programação, idéias modernas como programação orientada a objetos tem décadas de idade para que ter sido adotada no ambiente comercial. Dessa forma, uma linguagem funcional como Haskell é relativamente jovem, mas seu crescimento rápido influencia sua adoção.

Linguagens funcionais são usadas como componentes de sistemas maiores

Linguagens funcionais são providenciam um framework no qual as idéias cruciais da programação moderna estão presentes da forma mais clara possível.

O que é programação funcional?

Programação funcional oferece uma visão de alto nível da programação, tendo com seus usuários uma variedade de recursos que ajudam a criar elegantes e ainda poderosas bibliotecas gerais de funções.

Um exemplo do poder e generalidade da linguagem, é a função map, a qual é usada para transformar todo elemento da lista de objetos de uma forma específica. Por exemplo, map pode ser usada para dobrar todos os números em uma sequência numérica ou inverter as cores de cada figura de uma lista de imagens.

A elegância da programação funcional é um conseqüência da forma que as funções são definidas: uma equação é usada para dizer qual o valor da função para uma entrada arbitrária. Um exemplo simples é a função addDouble a qual adiciona dois inteiros e dobra sua soma. Ele é definida como:

addDouble x y = 2*(x+y)

onde x e y são as entradas e 2*(x+y) é o resultado.

Haskell e Hugs

Haskell começou a ser desenvolvido em 1980 como uma linguagem padrão para programação funcional preguiçosa, e desde então tem sofrido várias atualizações e modificações. Este texto é escrito em Haskell 98, wue consolida o trabalho de Haskell e o qual é suficientemente estável, futuras extensões de resultar no Haskell 2 daqui a alguns anos, mas é esperado implementações que continuem suportando Haskell 98 ainda por um bom tempo.

Por que aprender programação funcional?

Uma linguagem de programação funcional parte de um modelo simples de programação: um valor, o resultado, é computado com base em outras entradas

Porque seu fundamento é simples, uma linguagem funcional tem a visão clara da idéia central na computação moderna, incluindo aabstração (em uma função), abstração de dados (em um tipo abstrado de dados (TAD)), generalidade, polimorfismo e sobrecarga. Tendo isso em vista, as linguagens funcionais provêem uma introdução ideal das técnicas modernas de programação. Por exemplo, Haskell tem uma implementação direta dos tipos de dados como árvores, enquanto outras linguagens são forçadas a a definí-la usando a estrutura de dados de ponteiros.

Haskell não é uma boa "linguagem de ensino"; ela é uma linguagem de programação prática, suportada por ter extensões com interfaces de funções C e programação baseada em componentes, por exemplo. Haskell é também usada em vários projetos do "mundo-real". A Microsoft contratou praticamente toda a equipe que desenvolveu o Haskell para trabalhar na sua plataforma .NET. E existe o Haskell-script, que é uma linguagem alteranativa ao VBA, da própria MS.

Capítulo 1 - Introdução à programação funcional

Nos últimos cinquenta anos os computadores tem evoluído de unidades enormes, caros, raros e lentos para unidades pequenas, baratos, comuns, rápidas e (relativamente) dependentes. Os primeiros computadores eram máquinas 'stand-alone' (isoladas), mas hoje eles também podem seguir diferentes regras, sendo organizados em rede, ou sendo integrados em máquinas domésticas como carros e máquinas de lavar, da mesma forma como aparecem em computadores pessoais e PDAs.

A despeito disso, os funtamentos dos computadores tem mudado muito pouco nesse período: o propósito de um computador é manipular informações simbólicas. Esta informação pode representar uma situação simples, como a compra de um ítem em um supermercado, ou uma mais complicada, como a previsão de tempo na Europa.

Como essas tarefas são arquivadas? Nós precisamos escrever uma descrição de como a informação é manipulada. Isto é chamado programa e é escrito em uma linguagem de programação. Uma linguagem de programação é uma linguagem formal, artificial usada para dar instruções ao computador. Em outras palavras, a linguagem é usada para escrever o software que controla o comportamento do hardware. Enquanto a estrutura dos computadores tem ficado muito semelhante ao que eram em sua concepção, a forma que eles são programados tem desenvolvido substancialmente. Inicialmente programas são escritos usando instruções que controlavam o hardware diretamente. As linguagens de programação modernas tem trabalhado independente desse problema em outro nível (alto nível), especialmente melhor que as de "baixo nível".

Capítulo 2 - Iniciando a programação Haskell em Hugs

O capítulo 1 introduziu os fundamentos da programação funcional em Haskell. Vamos agora usar o sistema Hugs para alguma programação prática, e o principal propósito deste capítulo é dar uma introdução ao Hugs.

Iniciando o programa, vamos aprender os módulos básicos do Haskell, nos quais os programas podem ser escritos em múltipls arquivos interdependentes, e que podem usar as funções "embutidas" nas bibliotecas de prelúdio.

2.1 Um primeiro programa em Haskell

Começaremos o capítulo tomano um primeiro programa Haskell ou script, que consiste de exemplos numéricos do Capítulo 1. Como foi definido, um script pode conter comentários.

{-######################################################

FirstScript.hs

Simon Thompson, Junho 1998

O propósito desse script é:

- ilustrar alguns exemplos com inteiros (Int)

- mostrar o primeiro exemplo de um script

########################################################-}

-- O valor de size é um inteiro (Int), definido como a

-- soma de doze e treze size :: Int size = 12+13

 

-- a função para o quadrado de um inteiro

square :: Int -> Int

square n = n*n

 

-- A função para o dobro de um inteiro

double :: Int -> Int

double n = 2*n

 

-- Um exemplo usando double, square e size

example :: Int

example = double (size - square (2+2))

Figura 2.1. Um exemplo de um script tradicional

Clique aqui para baixar o código fonte de FirstScript.hs

Um comentário em um script é uma peça chave de informação para uma pessoa que estuda o código. Ele pode conter uma explanação informal aobre como uma função trabalha, como ele pode ou não pode ser usada, assim por diante.

Existem dois estilos diferentes de scripts em Haskell, que refletem duas diferentes filosofias de programação.

Tradicionalmente, todo código do programa é interpretado com o texto do programa, exceto onde é explicitamente indicado que é comentário. Este é o estilo de FirstScript.hs, na Figura 2.1. Scripts deste estilo são armazenados em arquivos com a extensão '.hs'.

Comentários são indicados de duas formas. O símbolo '--' começa um comentário que que ocupará o restante da linha à direita do símbolo. Comentários também podem ser delimitados pelos símbolos '{-' e '-}'. Estes comentários podem ser de tamanho arbitrário, podendo ser de mais de uma linha, bem como englobando outros comentários; então eles são chamados de nested comments.

######################################################

FirstScript.hs

Simon Thompson, Junho 1998

O propósito desse script é:

- ilustrar alguns exemplos com inteiros (Int)

- mostrar o primeiro exemplo de um script

########################################################

O valor de size é um inteiro (Int), definido como a

soma de doze e treze > size :: Int > size = 12+13

 

a função para o quadrado de um inteiro

> square :: Int -> Int

> square n = n*n

 

A função para o dobro de um inteiro

> double :: Int -> Int

> double n = 2*n

 

Um exemplo usando double, square e size

> example :: Int

> example = double (size - square (2+2))

Figura 2.2. Um exemplo de um literate script

Clique aqui para baixar o código fonte de FirstScript.lhs

A alternativa, o literate considera que qualquer coisa escrita é um comentário do programa, e o Código do programa precisa ser sinalizado explicitamente da mesma forma. Uma versão literate do script está na Figura 2.2, onde ele pode ser visto em uma linha começando com '>', e é separado do resto do texto por linhas em branco. Literate scrips são armazenados em arquivos de extensão '.lhs'.

As duas formas enfatizam diferentes aspectos da programação. A tradicional preferência para o programa, enquanto o literate enfatiza que existe mais programação que simplesmente criar definições. Projetar decisões precisa ser explicado, condições para o uso de funções a assim por diante precis ser escrito e detalhado - isto é benéfico para ambos, o usuário e o programador e de fatopara nós mesmos se formos olhar para um código escrito no passado, e precisarmos modificá-lo e entendê-lo.

2.2 Usando Hugs

Hugs é uma implementação de Haskell que roda em PCs (sob Windows 9x/NT/2000) e sistemas Unix, incluindo Linux e recentemente em Mac (Mac OS X). Ele é livremente distribuído na Home Page do Haskell

http://www.haskell.org/hugs/

Embora disponível em diversas plataformas, os programas apresentam melhor desempenho na plataforma Unix. Vale lembrar que o Hugs é um interpretador. O compilador Haskell mais usado é o ghc. Mas ainda existe muita pesquisa na área para criar um compilador mais eficiente. Hoje a maioria da equipe que criou o Haskell trabalha para a Microsoft e ajudam a desenvolver a .NET.

Iniciando o Hugs

Para iniciar o Hugs o Unix, digite hugs do prompt; para executar Hugs usando um arquivo particular, digite Hugs seguido do nome do arquivo em questão, como em

hugs FirstLiterate

Em sistemas Windows, Hugs é executado a partir do Menu Iniciar no local designado na hora da instalação; para executar Hugs para um arquivo particular, dê um clique duplo no ícone do arquivo em questão.

Scripts Haskell trazem a extensão .hs ou .lhs (para literate scripts); somente esses arquivos podem ser carregados, e suas extensões podem ser omitidas quando Hugs é chamado ou pelo comando :load command dentro do Hugs.

Figura 2.3. Uma sessão Hugs no Windows

Avaliando expressões em Hugs

Como foi dito anteriormente, o interpretador Hugs avalia expressões digitadas no prompt. Entre no Hugs e carregue o programa de uma das formas expostas. Podemos testar no Hugs a avaliação de size, bem como dois exemplos mais complexos:

Main>double 32 - square (size - double 3) -297 Main>double 320 - square (size - double 6) 471 Main>

Como pode ser visto no exemplo, nós podemos avaliar expressões que usam as definições no script atual. Neste caso, ele é o FirstLiterate.lhs (ou FirstLiterate.hs).

Uma das vantagens da interface do Hugs é que é fácil experimentar as funções, tentando avaliações diferentes simplesmente digitando as expressões no teclado. Se quisermos avaliar uma expressão complexa, ela pode ser fácil adiconar ao programa, como na definição

teste :: Int teste = double 320 - square (size - double 6)

Feito isso, precisamos apenas digitar test no prompt Main>

Comandos Hugs

Comandos hugs começam com dois pontos, ':'. Um resumo dos principais comandos seguem abaixo.

(Parte 1 de 7)

Comentários