Linguagem Haskell

Edmilson Almeida Italo Solto Thiago Gondim

INTRODUO

Caractersticas Gerais:

Linguagem Puramente Funcional Possui um compilador e um interpretador Tem como idia principal a avaliao de expresses

Compilador/Interpretador:

Uma particularidade da linguagem a presena de um compilador e um interpretador. Ambos utilizam-se de um editor externo, sendo que o primeiro gera um executvel para a plataforma utilizada e o segundo realiza o trabalho de interpretao do cdigo inserido.

Compilador/Interpretador:

GHC um exemplo de compilador GHCI, e Hugs so exemplos de interpretadores

Exemplos:

Prelude> 7+3 10

(7+3) comando passado pelo programador <- Resposta do Interpretador

ou Prelude> reverse Junior roinuJ

Valores e Tipos

Tipos Primitivos:

Haskell possui os seguintes tipos bsicos:

Tipo Unitrio( = 1): O tipo unitrio, Unit, a implementao do conjunto 1 Tipo Lgico: Bool; Tipo Caracter: Char; Tipos Numricos: Int, Integer, Float, Double

Tipos Compostos:

Produtos Cartesianos:
Em haskell temos a tupla como uma agregao de um ou mais componentes, que podem ser de tipos diferentes:
--- Script com tupla (Os dois traos --" indica comentrio -Type Nome = String -- Sinnimo para String(nome) Type Idade = Int -- Sinnimo para Int(idade) saberIdade :: (Nome,Idade) -> Idade -- Funo que passa a tupla saberIdade :: (a,b) -> b -- e devolve(retorna) a idade

Tipos Compostos

Mapeamento:
Em Haskell existem as funes que funcionam como mapeamento. A operao mais importante das funes a sua aplicao: As funes vo estar subjacentes a todas as manipulaes da linguagem e implementam a exponenciao de conjuntos. Ou seja o conjunto de todas as funes de A para B dado por B A .

Tipos Compostos:

Conjuntos Potncia:
Haskell no possui Conjuntos Potncia

Tipos Recursivos:

Grande parte das definies em Haskell sero recursivas, principalmente as que precisam de algum tipo de repetio.

Partindo da idia que: (Exemplo do Fatorial) . O fatorial de 0 sempre ser 1; . O fatorial de um numero n > 0, ser 1*2*...*(n-1)*n
fatorial :: Int -> Int int fatorial 0 = 1 fatorial n = n*fatorial(n-1) -- Declarao da funo recebendo int e retorna

Strings

Podem sempre ser consideradas como uma lista de elementos do tipo char. Se for digitado uma string entre aspas, no interpretador o retorno ser ela mesma, pois ela j est em sua forma normal. Ex:(Famoso Al Mundo)
Prelude > Alo Mundo Alo Mundo Prelude > reverse Alo Mundo odnuM olA <- Alo mundo comando do usuario <- retorno do sistema <- Aplicando a funo reverse <- retorno do sitema

Sistema de Tipos:

O Haskell uma linguagem de programao com uma disciplina de tipos rigorosa Haskell tem um, e um s, tipo, sendo sempre possvel determinar o tipo de uma determinada entidade Haskell estaticamente tipada

Variveis e Comandos

Variveis:

Haskell no possui:
Variveis Compostas Atualizao Seletiva

As variveis Heap em Haskell existe de forma implcita nos compiladores e/ou interpretadores:

Arquivos:

Haskell trabalha com sistema de arquivos atravs de duas funes :

writeFile :: String -> String -> IO( ) readFile :: String -> IO String

Arquivos:

Exemplo:
main = do putStr(Escreva uma linha e tecle ENTER:) linha <- getLinha nome <- criaArq linha putStr( A linha \n ++linha ++ \nesta no arquivo ++ nome++ !) criaArq :: String -> IO String criaArq linha :: do putStr(Nome do arquivo a ser criado) nome <- getLine writeFile nome linha return(nome)

Arquivos:

A funo principal pega uma linha e usa como parmetro para a funo criaArq. Esta solicita o nome do arquivo a ser criado e o cria com a funo, writeFile, ento devolve o nome do arquivo com a funo

Comandos

Por ser uma linguagem funcional Haskell enfatiza a avaliao de expresses ao invs da execuo de comandos.

Comandos Interativos:

Haskell apresenta interaes, usando recurso, podendo assim trabalhar com entrada de dados ilimitada. Ilustrando esse conceito podemos demonstrar um exemplo de funo que l vrios nomes e os exibe em ordem alfabtica:

Comandos Interativos:
main = do nomes <- lerNomes putStr (unlines (sort nomes)) lerNomes do putStr(Escreva um nome:) nome <- getLine if nome == then return [] else do nomes <- lerNomes return ([nome] ++ nomes) sort[] = [] sort(a:b) = sort[x|x<-b,x < a] ++[a]++ sort(a:b) = sort[x|x<-b,x >= a]

Comandos Interativos:

A funo lerNomes chamada recursivamente , at que encontre uma String vazia. Sendo o controle feito por (if then else), que tem comportamento igual ao de outras linguagens de programao. lerNomes retorna uma lista de strings, que passada depois pela funo sort(ordenao). O resultado exibido depois de passar por essa funo.

Comandos Seqenciais:

Os comandos so executados de maneira obvia, em seqncia. Um exemplo pode ser o programa de calculo do fatorial:

fatorial :: Int -> Int int e retorna int fatorial 0 = 1 fatorial n = n*fatorial(n-1)

-- Declarao da funo recebendo

4. Associaes e Escopo
4.1 Associaes: Feitas atravs das prprias funoes; Identificadores: tm que comear com com uma letra maiscula ou minscula seguida por sequencia opcional de letras, dgitos, sublinhas ou apstrofes. Particularidades: - Definies de valores ou funes ou variveis tm que comear com letra minscula; -Tipos, construtores, mdulos e classes de tipos tm que comear com letras maisculas;

4. Associaes e Escopo

4.1.1. Ambientes: Haskell permite que um mesmo identificador seja declarado em diferentes partes do programa, possivelmente representando diferentes entidades

4. Associaes e Escopo

4.1.2. Escopo e Blocos Como em qualquer outra linguagem, em Haskell cada declarao possui um escopo que o trecho de programa no qual a declarao efetiva; Como em qualquer outra linguagem, em Haskell um bloco um grupo de construes de programa que delimita o escopo das declaraes nele contidas.

4. Associaes e Escopo

4.1.2.1. Estrutura de blocos Haskell apresenta uma estrutura plana; Haskell apresenta associao esttica (o corpo do bloco avaliado no ambiente em que foi definido tempo de compilao)

5. Declaraes

5.1. Definio: Onde produz-se associaes fact1 :: Int -> Int fact1 n

5. Declaraes

5.2. Declarao de Tipo Associa um identificador a um tipo myNot :: Bool -> Bool yNot True = False yNot False = True

5. Declaraes

5.3 Declarao de varivel Para associar um identificador a uma varivel existente

size :: Int nome :: String

5.4. Declarao colateral: Haskell no possui declarao colateral

5. Declaraes
5.5. Declarao sequencial: Como em qualquer outra linguagem que dar suporte a este tipo de declarao, deve ser escrita da forma D1;D2, onde D1 seguida de D2 e as associaes produzidas em D1 podem ser usadas em D2. fatorial :: Integer -> Integer fatorial 0 = 1 fatorial n = n *fatorial(n-1)

5. Declaraes

5.6. Declarao recursiva: Uma declarao recursiva usa das prprias declaraes que ela produz. Um exemplo em Haskell, o exemplo acima citado, com o uso da declarao fatorial.

6. Abstraes
6.1.1. Abstraes de Funes A abstrao de funo contm uma expresso a ser avaliada que, quando chamada, resultar em um valor. Uma funo tem uma assinatura: uma especificao declarando os tipos de argumentos e resultado. increment :: Int -> Int increment x = x + 1

and1 :: Bool -> Bool -> Bool and1 a b = if a == b then a else False

6. Abstraes

6.1.2. Abstraes de procedimentos Uma abstrao de procedimento contm um comando a ser executado que, quando chamado, ser executado, atualizando as variveis. O usurio de uma abstrao de procedimento observa apenas o seu efeito (alterao de variveis), mas ignora que passos internos so executados

6. Abstraes

6.1.3. Princpio das Abstraes possvel construir abstraes sobre qualquer construo sinttica da linguagem Haskell, desde que algum tipo especfico de computao seja especificado. 6.2 Parmetros So usados para permitir que uma abstrao receba valores especficos para realizar sua computao, um argumento um valor passado para uma abstrao, e o identificador usado para denotar um argumento dentro de uma abstrao chamado parmetro formal. J nas expresses que retorna um argumento na chamada de uma abstrao chamado parmetro real.

6. Abstraes

6.2.1. Passagem de parmetro por cpia As formas de passagem dos parmetros, que a associao entre parmetro reais e formais podem ser: por valor (copiado para a abstrao); por resultado (copiado da abstrao); e, por valor/resultado (copiado para/da abstrao). Por valor o parmetro que uma varivel local, criada e inicializada com o valor do argumento e as alteraes neste parmetro no geram efeitos em variveis globais. Por resultado o argumento deve ter acesso a varivel, sendo que no inicio o parmetro formal criado e no final os valores do parmetro so atribudos a varivel recebida como argumento. Por valor/resultado a combinao de por valor e por resultado.

6. Abstraes

6.2.3. Princpio da correspondncia Para cada forma de declarao deve ser provido um mecanismo de passagem de parmetro correspondente.

7. Encapsulamento

Mdulos Para escrever mdulos em Haskell, basta adiciona linha a palavra-reservada module, o nome do mdulo, seguido pela palavra-reservada where. Esta linha deve ser a primeira linha no script escrito em Haskell que no est comentada ou vazia. Um exemplo: -- filename: Test.hs -- project : Haskell Script -- author : Thiago Gondim -- date : 29 Setembro 2006 module Test where data Person = Pers String Int -- etc. -- fim do arquivo Algumas convenes so teis: -- Colocar exatamente 1 (hum) mdulo em um nico arquivo -- Nomear arquivos e mdulos com mesmo nome.

7. Encapsulamento

7.1. Pacotes Em Haskell, um pacote pode ser um procedimento, funo ou um grupo de componentes declarados ( constantes, variveis, etc ) com o propsito comum.

7. Encapsulamento

Tipo Abstrato de Dados data PersonInfo = Person String Int greeting :: PersonInfo -> String greeting (Person nome idade) | idade < 12 = "Seus pais sabem onde voc est, " ++ nome ++ "?" | idade > 80 = "Seus filhos sabem onde voc est, " ++ nome ++ "?" | otherwise = "Al, " ++ nome ++ "!"

7. Encapsulamento

7.3. Classes Quando fala-se de classes em Haskell, falase em classificar tipos de dados, de acordo com quais funes pode-se usar nelas. class Greetable a where greeting :: a -> String greetings :: [a] -> [String] greet :: a -> IO ()

7. Encapsulamento

7.3. Instncias Um tipo de dado admitido por uma classe pelos significados de uma declarao de instncia. Isto , onde define-se as funes requeridas pela classe. Para admitir um tipo de dado PersonInfo em uma classe Greetable, temos: instance Greetable PersonInfo where greeting (Person nome idade) | idade < 12 = "Seus pais sabem onde voc est, " ++ nome ++ "?" | idade > 80 = "Seus filhos sabem onde voc est, " ++ nome ++ "?" | otherwise = "Al, " ++ nome ++ "!"

Sobrecarga
Sobrecarga

sobre operadores. Ocorre em Haskell, o mais comum com o operador +.

1) qsort [] = [] 2) qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

Outro exemplo:
Main> 1.4 +1 2.4 Main> 1+1 2 Main> 1.666 + 1.2 2.866 Hugs> "italo" ++ " a "italo a"

Sobrecarga

Sobrecarga sobre mtodos. No existe em Haskell.

Hugs> :load exemplo.hs ERROR file:exemplo.hs:19 - "incrementa" multiply defined Hugs>

Veja o exemplo:

incrementa :: Int -> Int incrementa x=x+1 incrementa :: String -> String incrementa "x"= "x" +"italo"

Polimorfismo

Com se manifesta em Haskell.

Main> :load qsort.hs Main> qsort [22,1,2,34,56,45] [1,2,22,34,45,56] Main> qsort ["a","j","x","b","s","l"] ["a","b","j","l","s","x"] Main> qsort "bbjsdhlkjahshjk" "abbdhhhjjjkklss" O cdigo: qsort [] = [] qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x where elts_lt_x = [y | y <- xs, y < x] elts_greq_x = [y | y <- xs, y >= x]

Coero

Apresenta-se em Haskell.

Main> sqrt 4 (coero implcita) 2.0 Main> decrementa 4.3 ERROR - Cannot infer instance *** Instance : Fractional Int *** Expression : diminui 4.3 Main> decrementa (round 4.3) 3 O cdigo: decrementa :: Int -> Int decrementa x= x-1 (coero explcita)

Subtipos e Herana

Herana em Haskell.
class (Eq a) => Ord a where (<), (<=), (>=), (>) :: a -> a -> Bool max, min :: a -> a -> a

Tambm existe herana mltipla: Class (Eq t, Show t) => Minhaclasse t where ...

Monomorfismo

Como vimos anteriormente Haskell tem recurso de polimorfismo, vamos ver como se apresenta o monomorfismo:
Main> decrementa 3.5 ERROR - Cannot infer instance *** Instance : Fractional Int *** Expression : decrementa 3.5

O cdigo:
decrementa :: Int -> Int decrementa x= x-1

O mtodo decrementa s aceita parmetros do tipo Inteiro.

Seqenciadores
1. 2. 3. 4.

Comandos Seqenciais: Do tipo c1:c2. mini :: Int -> Int -> Int mini a b | a <= b = a | otherwise = b quadrado :: Int -> Int quadrado x = x * x

5. 6.

Main> mini (quadrado 2) 5 4 Executa-se as linhas 5 e 6, retornando o valor 4, e depois as linhas de 1 a 4, retornando o valor 4. Onde c1 corresponde a (quadrado 2) e c2 a (mini (quadrado 2) 5).

Seqenciadores

Condicional.
Bastante usado em Haskell. Comandos do tipo if exp then c1 else c2.
1. 2. 3. 4.

mini :: Int -> Int -> Int mini a b | a <= b = a | otherwise = b 1 3

Main> mini 1

Defini-se a =1 e b=3, executa-se a linha 3 retornando 1.

Seqenciadores

Comandos Interativos.
Haskell no possui este recurso.
1. 2. 3.

fatorial :: Int -> Int fatorial 0 = 1 fatorial n = n * fatorial (n-1)

fatorial 3 = 3 * (fatorial 2) = 3 * 2 * (fatorial 1) = 3 * 2 * 1 * (fatorial 0) = 3 * 2 * 1 * 1 (1) =6

Seqenciadores

Desvios Incondicionais.
1.

Desvio Incondicionais Um desvio incondicional uma transferncia explicita de controle de um ponto para outro ponto do programa. Haskell no possui este recurso.

2.

Escape Termina a execuo de um comando composto, transferindo o controle da execuo para o comando seguinte. Haskell tambm no possui este recurso

Excees

Diviso por zero.

f :: Int -> Int - >Float fab=a/b

x :: Int f 5 (x -1) t :: -> 0 catch (f 5 (x-1)) t

Protegendo a funo f:

Excees

Criando suas Excees:

catch :: minha_excessao a (Exception -> minha_excessao a) -> minha_excessao -> a raise :: Exception - > a throw :: Exception - > IO ->a

Concorrncia

Bastante usado em Haskell.

p par e. Indica que paralelismo entre as expresses p , e. p seq e. Indica seqencialidade entre as expresses p, e.

pfib n | n <= 1 = 1 | otherwise = n1 par n2 seq n1+n2+1 where n1 = pfib (n-1) n2 = pfib (n-2)