Your SlideShare is downloading. ×
0
Paradigma Funcional
Caso de Estudo: Haskell
Prof. Sérgio Souza Costa

“Life is too short for imperative
programming”
Sobre mim
Sérgio Souza Costa
Professor - UFMA
Doutor em Computação Aplicada (INPE)
prof.sergio.costa@gmail.com

https://si...
John McCarthy (Boston, 4 de setembro de 1927 — 23 de outubro de
2011[1])
Criador da linguagem Lisp, segunda linguagem de p...
“

Life is too short for imperative
programming”
John Hughes
Programação funcional
●

Um paradigma sem
●
●
●
●

Váriaveis
Loops
Ponteiros
...
Mudança de paradigma
PARADIGMAS DE PROGRAMAÇÃO
Como
programar ?

• Modelo, padrão ou estilo de
programação suportado por linguagens
que agrupam...
É dificil programar em linguagem
funcional ?
Basta abrir a cabeça
Orientação a objetos Vs Funcional
Programação orientada a objetos é um estilo de
Programação que permite:
●
●

Reuso de có...
Orientação a objetos Vs Funcional
Programação funcional é um estilo de
programação
que permite:
- Reuso de código (composi...
Programaçao funcional
● Não existem variáveis
○ Expressões
● Não existem comandos
○ Funções
● Não existem efeitos colatera...
Vantagens
● Códigos suscintos e concisos
○ Menor tempo de desenvolvimento
○ Manutenabilidade
● Códigos seguros
● Reusabili...
Vantagens – Suscintos e
Concisos
Quick sort – Haskell
qs [] = []
qs (x:xs) = qs [y | y <- xs, y < x]
++ [x]
++ qs [y | y <...
Quick sort em C ...
int particao(int vec[], int inicio, int
fim) {
int i, j;
i = inicio;
for (j = inicio + 1; j <= fim; ++...
Quick sort em C ...
void quickSort(int vec[], int inicio,
int fim)
{
int p;
if (fim > inicio) {
p = particao(vec, inicio, ...
Desvantagens
O computador não é funcional
●

●

Maior custo de processamento
Maior consumo de memória
Trade-off
Tempo de desenvolvimento
Versus
tempo de execução
Conceitos chaves
● Expressões
● Funções
● Polimorfismo paramétrico
●
●E
●

em algumas linguagens:

● Abstração de dados
● ...
Conceitos chaves
●

Expressão é um conceito chave, pois seu
proposito é computar novos valores a partir
de valores antigos...
Conceitos chaves
Abstração de dados é o conceito chave nas linguagens funcionais
modernas, tais como ML e HASKELL. Todas a...
Caso de Estudo: Haskell
Haskell: Uma abordagem prática:

●

●

●

Real World Haskell

●

http://book.realworldhaskell.org/...
Haskell
●

Uma linguagem puramente funcional
●
●

●

Funções puras
Funções são valores de primeira ordem

Linguagem com di...
Haskell na Industria

http://www.haskell.org/haskellwiki/Haskell_in_industry
Elementos básicos
●
●
●
●

Expressões e funções
Tipos e valores
Tuplas
Listas
Expressões
●

●

●

●

●

Em Haskell, construimos expressões a partir
de:
constantes
operadores
aplicação de funções
(parê...
Expressões
●

Constantes:

-3.459
True
'a'
"hello"
[1,2,4,9]
●

Aplicação de funções:

even 47
twice (-2)
Operadores
.

Composição de funções

*, /, ^

multip, divisão, potência

+,-

adição, subtração

:, ++

composição de list...
Avaliação preguiçosa
• Estratégia call-by-value --- Avalia primeiro o argumento antes de
aplicar a função (Pascal, C, Java...
Tipos em Haskell
●

O que é um tipo?
Tipo é um conjunto de valores que possuem um
comportamento uniforme sobre dadas opera...
Tipos em Haskell
●
●

Tipo é uma restrição
Descreve os limites do resultado final de uma
computação
“The fundamental purpo...
Tipos em Haskell - Primitivos
Bool
●Char
●Int
●Integer
●Float
●Double
●

Boleanos
Caracteres
Inteiros de 32-bits
Inteiros ...
Toda expressão tem um tipo
Os tipos podem ser enferidos
Prelude> :t (4 > 5)
(4 > 5) :: Bool
Prelude> :t (5+4)
(5+4) :: (Nu...
Função
● Correspondência biunívoca de membros do conjunto
domínio para membros do conjunto imagem
● Ordem de avaliação de ...
Função
Definição de Função
● Nome lista de parâmetros = expressão de correspondência
○ cubo x = x * x * x

● Um elemento do conju...
Definição de funções
●

A definicao de uma funçao deve obedecer a sintaxe
seguinte:

● nome_função :: tipo_arg1 -> ... -> ...
Funções e constantes
●

Funções generalizam as expressões
através de variáveis.
-- PI
pi = 3.14159

-- area e circunferenc...
Aplicação de funções em Haskell e na
matemática
Matemática
f (x)
f (x,y)
f (g(x))
f (x, g(y))
f (x) g(y)
f(a,b) + c d

Has...
Funções como valores de primeira classe
Significa que as funções têm um estatuto tão importante
como o dos inteiros, reais...
Expressão de seleção
Considere uma função que dado dois valores, ela retorna o
menor:
A estratégia para resolução do probl...
Expressão de seleção
if <condição> then <resultado 1>
else <resultado2>

menor :: Int -> Int -> Int
menor x y = if x <= y ...
Casamento de padrões
Podemos especificar o comportamento de uma função
descrevendo sua resposta a diferentes situações de
...
Listas
●

Uma lista é uma sequencia de valores ordenados

●

Listas são homogêneas:
todos os elementos da lista tem o mesm...
Listas
Uma lista é composta sempre de dois segmentos: cabeça
(head) e corpo (tail). A cabeça é sempre o primeiro emento
e ...
Listas em Haskell
●

●

●

●

Três tipos de notação:
construtores:
1 : 1 : 2 : 3 : 5 : 8 : []
“colchetes":
[1, 1, 2, 3, 5,...
Listas
Pode se definir uma lista indicando os
limites inferior e superior:
[<limite-inferior> .. <limite-superior>]
Listas
Podemos definir qualquer progressão aritmética em uma
lista utilizando a seguinte notação:
[<termo1>, <termo2> .. <...
Listas por compreensão
A definição de listas por compreensão é feita por um
construtor de listas que utiliza conceitos e n...
Listas por compreensão
●

●

Um construtor de processamento de listas em
linguagem de programação, a notação
matemática é ...
Listas por compreensão
Exemplo:
[x | x <- [1..1000], even x, x < 100 ]
[2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,...
Listas por compreensão
Listas com mais um gerador
Comportamento situacional em funções sobre
Listas

isempty :: [a] -> Bool
isempty [] = True
isempty anythingElse = False

...
Recursão
Um conceito básico em Haskell é o uso de
recursão para definição de funções
length :: [a] -> Int
length [] = 0
le...
Recursão
● Sem loops explícitos, o fluxo em Haskell é usualmente
expresso por recursão.
● Como garantir que recursão termi...
Recursão
● Soma de todos os números de uma lista

sumAll :: [Integer] -> Integer

A soma dos números de uma lista vazia

s...
Recursão
●

Concatenação de listas de caracteres

concat :: [[Char]] -> [Char]
Concatenar uma lista vazia:

concat [] = []...
Avaliação de Funções
Recursivas
length [] = 0
length (x : xs) = 1 + length xs
length (1 : 2 : 4 : [])
Avaliação de Funções
Recursivas
length [] = 0
length (x : xs) = 1 + length xs
length (1 : 2 : 4 : [])
1 + length (2 : 4 : ...
Avaliação de Funções
Recursivas
length [] = 0
length (x : xs) = 1 + length xs
length (1 : 2 : 4 : [])
1 + 1 + length (4 : ...
Avaliação de Funções
Recursivas
length [] = 0
length (x : xs) = 1 + length xs
length (1 : 2 : 4 : [])
1 + length (2 : 4 : ...
Avaliação de Funções
Recursivas
length [] = 0
length (x : xs) = 1 + (length xs)
length (1 : 2 : 4 : [])
1 + length (2 : 4 ...
Recursos avançados
●

1.
2.
3.
4.

Definições locais,
Importando bibliotecas externas,
Funções de segunda ordem
Trabalhand...
Definições locais
Para melhor a legibilidade de um código, podemos
usar a clausula “where” para fazer definiçoes visíveis
...
Type sinonimos
●

Em Haskell, é possível criar sinonimos de
tipos, ex:
type Point = (Int, Int)
type Polygon = [Point]
p1 :...
Avaliação parcial
Haskell distingue entre operadores and funções:
Operadores tem noção infixa (e.g. 1 + 2),
Funções usam n...
Avaliação parcial
multThree :: (Num a) => a -> a -> a -> a
multThree x y z = x * y * z

ghci> let multTwoWithNine = multTh...
Avaliação parcial
A função divideByTen 200 é equivalente a 200 /
10, ou (/10) 200
divideByTen :: (Floating a) => a -> a
di...
Funções são valores de primeira classe
● Em linguagens funcionais, funções são valores de
primeira classe.
● Não existe re...
Funções como argumentos
Uma característica poderosa de Haskell é funções
podem ser argumentos de outras funções.
Estas fun...
Map
A função map aplica uma função a todos os
elementos de uma lista.
map :: (a -> b) -> [a] -> [b]

Main> map double [1,3...
Map
Map pode ser definido por recursão ou por
compreensão de listas
map :: (a -> b) -> [a] -> [b]

Ou por compreensão de l...
Map – Mais exemplos
ghci> map (+3) [1,5,3,1,6]
[4,8,6,4,9]
ghci> map (++ "!") ["BIFF", "BANG", "POW"]
["BIFF!","BANG!","PO...
Map com avaliação parcial
Main> map (*5) [1,3,5,7]
[5,15,25,35]

incAll = map (1 +)
addNewlines = map (++ "n")
halveAll = ...
Filter
A função filter seleciona os elementos de uma
lista que satisfazem a um predicado

●

filter :: (a -> Bool) -> [a] ...
Filter
Pode ser definido como compreensão de listas ou
por recursão

●

filter :: (a -> Bool) -> [a] -> [a]
filter p xs = ...
Comprimindo para um único valor
Um grande número de funções em listas podem ser definidas a partir
de um padrão simples de...
Comprimindo para um único valor
sum [] = 0
sum (x:xs) = x + sum xs
product [] = 1
product (x:xs) = x * product xs
and [] =...
Comprimindo para um unico valor
A função foldr (“fold right”) encapsula este padrão de recursão
em listas, com a função da...
Definição do foldr
foldr::(a -> b -> b) -> b -> [a] -> b
foldr f v []

=v

foldr f v (x:xs) =
f x (foldr f v xs)
Composição de Funções
(f . g) x = f (g x)

> ( (*2) . (*5) ) 8
> 80
Abstração de dados
Tipos enumerados (enumerated no C),
Tipos cartesianos (struct no C),
Uniões disjunta (union no C)
Tipos...
O que vimos até então...
Usamos os tipos existentes em Haskell
● Primitivos: Int, String, Bool
● Compostos: Listas e tupla...
Qual o problema com os sínonimos?

11/4/11
Considerem os seguintes códigos
type Matricula = Int
type Nome = String
type Salario = Double
type Funcionario = (Matricul...
Usando tipos algébricos do Haskell
●

Nós definimos um novo tipo de dado usando o
palavra-chave data.

Data Funcionario = ...
Tipos Compostos
Os tipos algebricos do Haskell permite estruturas diversos
tipos a partir de valores mais simples.
● Produ...
Tipos algébricos
●

Diferenças entre nome de tipos e construtor
de tipos:
O nome do tipo e dos construtores não precisa se...
Tipos algébricos
● O Haskell dispõe diversas classes que podem ser
derivadas para os novos tipos.
●Show, permite vizualiza...
Tipos algébricos – Registro
Comparação com C
C

struct Point {
x,y: double;
};
Haskell

data Point = Pt Double Double
deri...
Tipos algébricos – Registro
●

Usando casamento de padrão para pegar
um dado valor
data Point = Pt Double Double
deriving ...
Enumerados
●

Comparação com C
C

enum Dias {Segunda, Terça, Quarta,
Quinta, Sexta}
Haskell

data Dias = Segunda | Terça |...
Tipo Booleano
●

Criando e usando o seu próprio tipo
booleano
data Booleano = Falso | Verdadeiro deriving (Show, Eq)
e :: ...
União Disjunta em Haskell
data Number = Exact Int | Inexact Float

●

Valores:

Cada valor consiste de uma tag, junto ou c...
Exemplo de união disjunta
data Number = Exact Int | Inexact Float deriving (Show)
pi2 = Inexact 3.1416
rounded :: Number -...
União Disjunta – Tratando erro
●

Em Haskell existe um tipo de dado muito util em
casos onde uma função pode nao ter retor...
União Disjunta – Tratando erro
●

Exemplo, buscando em uma lista
type Aluno = (Int, String)
busca :: Int -> [Aluno] -> May...
União Disjunta
Comparando com a linguagem C
C
union {
int exact;
int inexact;
};

Haskell
data Number = Exact Int |
Inexac...
Tipos Recursivos
Exemplos de tipos recursivos:
data Nat = Zero | Succ Nat
data Lista = Nil | Cons Int Lista
data ArvoreBin...
Tipos Recursivos

Números naturais
data Nat = Zero | Succ Nat

Nat é um novo tipo com dois construtores
Zero :: Nat e Succ...
Tipos recursivos
●

Implementando as operações básicas.
data Nat = Zero | Succ Nat deriving (Show)
soma :: Nat -> Nat -> N...
Tipos Recursivos - Lista
●

A implementação mínima de uma lista:
data List =
Nil |
Cons Int List
deriving (Show)
first (Co...
Atividade
A partir da lista dada anteriormente,
implemente as seguintes funções:
ultimo :: List -> Int
soma :: List -> Int...
Polimorfismo Paramétrico
C++
template <typedef T>
T maior (T a, T b) {
return ( (a>b)? a : b );
}

Java
public class Pair<...
Polimorfismo paramétrico

●

●

Funções paramétricas
Tipos de dados paramétrico
Tipos Paramétricos em Haskell
● Uma característica importante de Haskell é o uso de
tipos paramétricos
● Muitas funções po...
Tipos Paramétricos em Haskell
Lista de inteiros

Lista paramétrica

data List Int =
Nil |
Cons Int List
deriving (Show)

d...
Tipos Paramétricos em Haskell
data ArvBin a = Vazia | Nodo a (ArvBin a) (ArvBin a)
deriving Show
elem :: ArvBin a -> a
ele...
Definindo as funções de acesso
diretamento na definição
●

Equivalente a implementação anterior
data ArvBin a = Vazia |
No...
Restrição no polimorfismo
●

Considere a seguinte função,
●

somar todos os valores de uma lista
somatodos :: [a] -> a
som...
Restrição no polimorfismo
●

Considere a seguinte função,
●

somar todos os valores de uma lista
somatodos :: [a] -> a
som...
Restrição no polimorfismo
●

Usando “type classes”
A função somatodos funciona sobre qualquer
“a”, desde que ele seja um N...
Type class em Haskell
Uma classe é uma coleção de tipos que suportam
certas operações (métodos) comuns
●Uma classe define ...
Classes Básicas em Haskell
Eq

- tipos com igualdade

Ord

– tipos ordenados

Show – tipos mostráveis
Read – tipos legívei...
Instanciando type class

data Point = Point Int Int deriving (Show, Eq, Ord, Read)
instance Num Point where
(+) (Point x1 ...
Instanciando type class
●

Podemos instanciar qualquer uma das classes
pré definidas, mesmo as que são derivaveis,
como Re...
Hierarquia - type class
Programas e operações
de entrada e saída
Operações de entrada e saída
Até então, vimos como usar o Haskell via ghci,
mas como gerar um programa compilável?
Como o ...
O problema ...

Um programa em
Haskell consiste num
conjunto de funções,
sem
efeitos colaterais

Tensão

O objetivo de exe...
A solução
Escrever programas interativos em Haskell usando tipos
que fazem distinção entre expressões funcionais “puras”
d...
I/O em Haskell
Exemplos de IOs
IO Char

IO ()

O tipo das ações de IO que retornam
um caracter

O tipo das ações que não t...
IO em Haskell: O tipo (IO a)
Um valor do tipo (IO t) é uma ação que, quando realizada, pode
fazer alguma forma de IO antes...
Meu Primeiro Programa
Para rodar interpretado use o runghc:
module Main where
main = putStrLn "Hello World!"

Ou, compile ...
Funções da biblioteca
Funções para escrever na tela
putStr :: String -> IO ()
putStrLn :: String -> IO ()
Para ler uma lin...
Combinando ações
Para combinar ações podemos usar a notação
“do”;
Cada ação é nessa forma:
Meu segundo programa
Lê uma entrada do usuário e imprime na
tela
module Main where
main = do
input <- getLine
putStrLn inp...
Incrementando um pouco mais
module Main where
ask :: String -> IO String
ask question = do
putStrLn question
getLine
main ...
Lendo outros tipos, e uso de funções
dentro de um IO
ask :: String -> IO Double
ask question = do
putStrLn question
readLn...
Trabalhando com arquivos
Converte todo um arquivo texto para letras maiusculas.
A função readfile retorna uma string conte...
Funções para string
Função lines, quebra uma string pelo marcador de fim de
linha
lines “linha1nlinha2” → [“linha1”,linha ...
Trabalhando com arquivos
●

Número de palavras e de linhas de um
arquivo:
main = do
str <- readFile "input.txt"
print (len...
Trabalhando com arquivos
●

Usando a função “iterative”, convertendo todas as
letras de um arquivo para maiuscula.
main = ...
Trabalhando com argumentos
import System.Environment
main:: IO()
main = do
args <- getArgs
let arg1 = head args
print ("o ...
FIM
Upcoming SlideShare
Loading in...5
×

Paradigma Funcional - Caso de Estudo Haskell

3,522

Published on

Published in: Technology
1 Comment
1 Like
Statistics
Notes
No Downloads
Views
Total Views
3,522
On Slideshare
0
From Embeds
0
Number of Embeds
8
Actions
Shares
0
Downloads
102
Comments
1
Likes
1
Embeds 0
No embeds

No notes for slide

Transcript of "Paradigma Funcional - Caso de Estudo Haskell"

  1. 1. Paradigma Funcional Caso de Estudo: Haskell Prof. Sérgio Souza Costa “Life is too short for imperative programming”
  2. 2. Sobre mim Sérgio Souza Costa Professor - UFMA Doutor em Computação Aplicada (INPE) prof.sergio.costa@gmail.com https://sites.google.com/site/profsergiocosta/home http://www.slideshare.net/skosta/presentations?order=popular https://twitter.com/profsergiocosta http://gplus.to/sergiosouzacosta
  3. 3. John McCarthy (Boston, 4 de setembro de 1927 — 23 de outubro de 2011[1]) Criador da linguagem Lisp, segunda linguagem de programação.
  4. 4. “ Life is too short for imperative programming” John Hughes
  5. 5. Programação funcional ● Um paradigma sem ● ● ● ● Váriaveis Loops Ponteiros ...
  6. 6. Mudança de paradigma
  7. 7. PARADIGMAS DE PROGRAMAÇÃO Como programar ? • Modelo, padrão ou estilo de programação suportado por linguagens que agrupam certas características comuns IMPERATIVO PROCEDURAL ORIENTADO A OBJETOS DECLARATIVO FUNCIONAL LÓGICO
  8. 8. É dificil programar em linguagem funcional ?
  9. 9. Basta abrir a cabeça
  10. 10. Orientação a objetos Vs Funcional Programação orientada a objetos é um estilo de Programação que permite: ● ● Reuso de código (via classes) Eliminação de bugs (via encapsulamento, ocultação de dados )
  11. 11. Orientação a objetos Vs Funcional Programação funcional é um estilo de programação que permite: - Reuso de código (composição de função) - Eliminação de bug (via imutabilidade (não existe mudança de valores de váriáveis))
  12. 12. Programaçao funcional ● Não existem variáveis ○ Expressões ● Não existem comandos ○ Funções ● Não existem efeitos colaterais ○ Declarações ● Não há armazenamento ○ Funções de alta ordem ○ Lazy evaluation ○ Recursão ● Fluxo de controle: expressões condicionais + recursão
  13. 13. Vantagens ● Códigos suscintos e concisos ○ Menor tempo de desenvolvimento ○ Manutenabilidade ● Códigos seguros ● Reusabilidade ● Facilidade de escrita, suporte a abstrações ● Confiabilidade, segurança
  14. 14. Vantagens – Suscintos e Concisos Quick sort – Haskell qs [] = [] qs (x:xs) = qs [y | y <- xs, y < x] ++ [x] ++ qs [y | y <- xs, y >= x]
  15. 15. Quick sort em C ... int particao(int vec[], int inicio, int fim) { int i, j; i = inicio; for (j = inicio + 1; j <= fim; ++j) { if (vec[j] < vec[inicio]) { ++i; troca(&vec[i], &vec[j]); } } troca(&vec[inicio], &vec[i]); return i; }
  16. 16. Quick sort em C ... void quickSort(int vec[], int inicio, int fim) { int p; if (fim > inicio) { p = particao(vec, inicio, fim); quickSort(vec, inicio, p - 1); quickSort(vec, p + 1, fim); }
  17. 17. Desvantagens O computador não é funcional ● ● Maior custo de processamento Maior consumo de memória
  18. 18. Trade-off Tempo de desenvolvimento Versus tempo de execução
  19. 19. Conceitos chaves ● Expressões ● Funções ● Polimorfismo paramétrico ● ●E ● em algumas linguagens: ● Abstração de dados ● Avaliação preguiçosa.
  20. 20. Conceitos chaves ● Expressão é um conceito chave, pois seu proposito é computar novos valores a partir de valores antigos, que é a essência da programação funcional. ● Função é um conceito chave, pois funções generalizam(abstrai) expressões. Além disso, funções são valores de primeira classe, dado que podem ser argumento e resultado de outras funções, fazer parte de valores compostos ..
  21. 21. Conceitos chaves Abstração de dados é o conceito chave nas linguagens funcionais modernas, tais como ML e HASKELL. Todas as operações de tipos abstratos são constantes e funções. Polimorfismo paramétrico é um conceito chave, pois ele permite que uma função opere sobre valores de uma familia de tipos, ao invés de apenas um tipo. Na pratica, muitas funções são naturalmente polimorficas, e o polimorfismo parametrico incrementar o poder e a expressividade das linguagens funcionais Avaliação preguiçosa e baseada na noção que uma expressão só será avaliada se for usada.
  22. 22. Caso de Estudo: Haskell Haskell: Uma abordagem prática: ● ● ● Real World Haskell ● http://book.realworldhaskell.org/read/ ● ●
  23. 23. Haskell ● Uma linguagem puramente funcional ● ● ● Funções puras Funções são valores de primeira ordem Linguagem com diversos recursos avançados: ● ● ● ● Casamento de padrões Compreensão de lista Avaliação preguiçosa Polimorfismo parametrico
  24. 24. Haskell na Industria http://www.haskell.org/haskellwiki/Haskell_in_industry
  25. 25. Elementos básicos ● ● ● ● Expressões e funções Tipos e valores Tuplas Listas
  26. 26. Expressões ● ● ● ● ● Em Haskell, construimos expressões a partir de: constantes operadores aplicação de funções (parênteses)
  27. 27. Expressões ● Constantes: -3.459 True 'a' "hello" [1,2,4,9] ● Aplicação de funções: even 47 twice (-2)
  28. 28. Operadores . Composição de funções *, /, ^ multip, divisão, potência +,- adição, subtração :, ++ composição de listas, concatenação ==,/=,<=,... igual, desigual, comparação && E || OU
  29. 29. Avaliação preguiçosa • Estratégia call-by-value --- Avalia primeiro o argumento antes de aplicar a função (Pascal, C, Java, etc). (x -> x+1) (2+3) = (x+1)+ 5 = 5+1 =6 • Estratégia call-by-name (ou AVALIAÇÃO PREGUIÇOSA) --- Aplica imediatamente a função ao argumento, adiando para mais tarde a avaliação desse argumento (Haskell e Miranda) (x -> x+1) (2+3) = (2+3)+1 = 5+1 =6
  30. 30. Tipos em Haskell ● O que é um tipo? Tipo é um conjunto de valores que possuem um comportamento uniforme sobre dadas operações. (David Watt) ● “A program variable can assume a range of values during the execution of a program. An upper bound of such a range is called a type of the variable” (Cardelli) ●
  31. 31. Tipos em Haskell ● ● Tipo é uma restrição Descreve os limites do resultado final de uma computação “The fundamental purpose of a type system is to prevent the occurrence of execution errors during the running of a program” (Cardelli).
  32. 32. Tipos em Haskell - Primitivos Bool ●Char ●Int ●Integer ●Float ●Double ● Boleanos Caracteres Inteiros de 32-bits Inteiros de tam ilimitado Ponto flutuante Dupla precisão
  33. 33. Toda expressão tem um tipo Os tipos podem ser enferidos Prelude> :t (4 > 5) (4 > 5) :: Bool Prelude> :t (5+4) (5+4) :: (Num t) => t Prelude> :t [1.2,5.0] [1.2,5.0] :: (Fractional t) => [t]
  34. 34. Função ● Correspondência biunívoca de membros do conjunto domínio para membros do conjunto imagem ● Ordem de avaliação de suas expressões é controlada por expressões condicionais ○ Não pela seqüência ou pela repetição iterativa ● Não têm efeitos colaterais ○ Sempre definem o mesmo valor dado o mesmo conjunto de argumentos, diferentemente de um procedimento em linguagens imperativas.
  35. 35. Função
  36. 36. Definição de Função ● Nome lista de parâmetros = expressão de correspondência ○ cubo x = x * x * x ● Um elemento do conjunto imagem é obtido para cada par: Nome da função + um elemento particular do conjunto domínio ○ cubo 2.0 = 8.0 ● Definição de uma função separada da tarefa de nomeá-la ○ Notação lambda (Church, 1941) ○ λ(x) x * x * x
  37. 37. Definição de funções ● A definicao de uma funçao deve obedecer a sintaxe seguinte: ● nome_função :: tipo_arg1 -> ... -> tipo_argN -> tipo_saída ● nome_função arg1 ... argN = <expressão_resultado> ● Sendo tipo1,...,tipoN os tipos dos parametros de entrada da função. ● f1 :: Int → Int → Int f1 x y = x*y
  38. 38. Funções e constantes ● Funções generalizam as expressões através de variáveis. -- PI pi = 3.14159 -- area e circunferencia de circulo circumf r = 2 * pi * r area rad = pi * rad^2
  39. 39. Aplicação de funções em Haskell e na matemática Matemática f (x) f (x,y) f (g(x)) f (x, g(y)) f (x) g(y) f(a,b) + c d Haskell fx fxy f (g x) ou f $ g x f x (g y) ou f $ g y fx*gy fab+c*d
  40. 40. Funções como valores de primeira classe Significa que as funções têm um estatuto tão importante como o dos inteiros, reais, e outros tipos predefinidos. Concretamente, numa linguagem funcional as funções podem ... Ser passadas como argumento para outras funções; Podem ser retornadas por outras funções; Podem ser usadas como elementos constituintes de estruturas de dados; Prelude>map (x->2*x) [1,2,3] [2,4,6]
  41. 41. Expressão de seleção Considere uma função que dado dois valores, ela retorna o menor: A estratégia para resolução do problema é com uso de uma expressão de seleção menor x y = se x <= y então o resultado da expressão é x senão o resultado é y
  42. 42. Expressão de seleção if <condição> then <resultado 1> else <resultado2> menor :: Int -> Int -> Int menor x y = if x <= y then x else y
  43. 43. Casamento de padrões Podemos especificar o comportamento de uma função descrevendo sua resposta a diferentes situações de entrada. ● Podemos ter múltiplas definições ● Alternativa mais elegante aos “ifs” -- fatorial fat :: Integer -> Integer fat 0 = 1 fat n = fat (n-1) * n
  44. 44. Listas ● Uma lista é uma sequencia de valores ordenados ● Listas são homogêneas: todos os elementos da lista tem o mesmo tipo ● ● Listas são dinâmicas: ●não há restrição no tamanho de listas (incluindo listas infinitas)
  45. 45. Listas Uma lista é composta sempre de dois segmentos: cabeça (head) e corpo (tail). A cabeça é sempre o primeiro emento e corpo é uma lista com os demais elementos. Prelude> ['a','b','c','d'] "abcd" Prelude> 'a':['b','c','d'] "abcd"
  46. 46. Listas em Haskell ● ● ● ● Três tipos de notação: construtores: 1 : 1 : 2 : 3 : 5 : 8 : [] “colchetes": [1, 1, 2, 3, 5, 8] strings (apenas para listas de caracteres): ['h', 'e', 'l', 'l', 'o'] = "hello"
  47. 47. Listas Pode se definir uma lista indicando os limites inferior e superior: [<limite-inferior> .. <limite-superior>]
  48. 48. Listas Podemos definir qualquer progressão aritmética em uma lista utilizando a seguinte notação: [<termo1>, <termo2> .. <limite-superior> Prelude> [0,3..21] [0,3,6,9,12,15,18,21] Prelude> [0,2..20] [0,2,4,6,8,10,12,14,16,18,20]
  49. 49. Listas por compreensão A definição de listas por compreensão é feita por um construtor de listas que utiliza conceitos e notações da teoria dos conjuntos. Assim, para um conjunto A temos: Sendo E(x) uma expressão em X, onde X pertence a lista, dados um conjunto de preposições Pi(x) A = [E(x) | x <- lista, P1(x), ..., Pn(x)] Por exemplo: [x | x <- l1, even x, x < 100 ], todos pares menos que 100 pertencentes a l1
  50. 50. Listas por compreensão ● ● Um construtor de processamento de listas em linguagem de programação, a notação matemática é a sequinte: Outros exemplos S = [ x | x<-[0..], x^2>3 ] Por exemplo, as 10 primeiras potências de 2: [2 ^ x | x <- [1..10] ] ● Todos os numeros pares maiores que 1 e menores que 100: [ x | x <- [1..100] , par x ] ●
  51. 51. Listas por compreensão Exemplo: [x | x <- [1..1000], even x, x < 100 ] [2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,4 2,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,8 0,82,84,86,88,90,92,94,96,98]
  52. 52. Listas por compreensão Listas com mais um gerador
  53. 53. Comportamento situacional em funções sobre Listas isempty :: [a] -> Bool isempty [] = True isempty anythingElse = False head [] = error "head []" head (x:xs) = x length [] = 0 length (x : xs) = 1 + length xs
  54. 54. Recursão Um conceito básico em Haskell é o uso de recursão para definição de funções length :: [a] -> Int length [] = 0 length (x : xs) = 1 + length xs
  55. 55. Recursão ● Sem loops explícitos, o fluxo em Haskell é usualmente expresso por recursão. ● Como garantir que recursão termine? ○ Escolha uma “entidade” para focar o processo ○ Garanta que a próxima chamada estará mais próxima de uma condição de término Exemplos: ● Decremente um valor para cada chamada ● Tome um valor de uma lista a cada chamada
  56. 56. Recursão ● Soma de todos os números de uma lista sumAll :: [Integer] -> Integer A soma dos números de uma lista vazia sumAll [] = 0 Soma dos números de uma lista x : xs sumAll (x : xs) = x + sumAll xs
  57. 57. Recursão ● Concatenação de listas de caracteres concat :: [[Char]] -> [Char] Concatenar uma lista vazia: concat [] = [] --- = “” Concatenar uma lista a partir de um elemento: concat (s : ss) = s ++ concat ss
  58. 58. Avaliação de Funções Recursivas length [] = 0 length (x : xs) = 1 + length xs length (1 : 2 : 4 : [])
  59. 59. Avaliação de Funções Recursivas length [] = 0 length (x : xs) = 1 + length xs length (1 : 2 : 4 : []) 1 + length (2 : 4 : [])
  60. 60. Avaliação de Funções Recursivas length [] = 0 length (x : xs) = 1 + length xs length (1 : 2 : 4 : []) 1 + 1 + length (4 : [])
  61. 61. Avaliação de Funções Recursivas length [] = 0 length (x : xs) = 1 + length xs length (1 : 2 : 4 : []) 1 + length (2 : 4 : []) 1 + 1 + length (4 : []) 1 + 1 + 1 + length []
  62. 62. Avaliação de Funções Recursivas length [] = 0 length (x : xs) = 1 + (length xs) length (1 : 2 : 4 : []) 1 + length (2 : 4 : []) 1 + 1 + length (4 : []) 1 + 1 + 1 + length [] 1+1+1+0
  63. 63. Recursos avançados ● 1. 2. 3. 4. Definições locais, Importando bibliotecas externas, Funções de segunda ordem Trabalhando com entrada e saída
  64. 64. Definições locais Para melhor a legibilidade de um código, podemos usar a clausula “where” para fazer definiçoes visíveis somente por uma dada função. raizes (a, b, c) = (x1,x2) where delta = sqrt ( b^2 - 4*a*c) x1 = ((-b) + delta) / (2*a) x2 = ((-b) - delta) / (2*a)
  65. 65. Type sinonimos ● Em Haskell, é possível criar sinonimos de tipos, ex: type Point = (Int, Int) type Polygon = [Point] p1 :: Point P1 = (1,4) pol1:: Polygon pol1 = [(1,1),(1,2),(3,1),(1,1)]
  66. 66. Avaliação parcial Haskell distingue entre operadores and funções: Operadores tem noção infixa (e.g. 1 + 2), Funções usam notação prefixa (e.g. plus 1 2). Operadores podem ser convertidos em funções colocando-os entre parênteses: (+) m n = m + n. Haskell aceita operadores com avaliação parcial. E.g.: (+ m) n = m + n (: 0) l = 0 : l
  67. 67. Avaliação parcial multThree :: (Num a) => a -> a -> a -> a multThree x y z = x * y * z ghci> let multTwoWithNine = multThree 9 ghci> multTwoWithNine 2 3 54 ghci> let multWithEighteen = multTwoWithNine 2 ghci> multWithEighteen 10 180
  68. 68. Avaliação parcial A função divideByTen 200 é equivalente a 200 / 10, ou (/10) 200 divideByTen :: (Floating a) => a -> a divideByTen = (/10)
  69. 69. Funções são valores de primeira classe ● Em linguagens funcionais, funções são valores de primeira classe. ● Não existe restrição sobre o uso de funções em linguagens funcionais, ● Podem ser argumentos de funções ● Saídas de funções ● Elementos de estrutura de dados
  70. 70. Funções como argumentos Uma característica poderosa de Haskell é funções podem ser argumentos de outras funções. Estas funções são chamadas funções de segunda ordem. twice :: (a -> a) -> a -> a twice f x = f (f x)
  71. 71. Map A função map aplica uma função a todos os elementos de uma lista. map :: (a -> b) -> [a] -> [b] Main> map double [1,3,5,7] [2,6,10,14]
  72. 72. Map Map pode ser definido por recursão ou por compreensão de listas map :: (a -> b) -> [a] -> [b] Ou por compreensão de lista map f [] = [] ● map f (x : xs) = (f x) : map f xs map :: (a -> b) -> [a] -> [b] map f xs = [f x | x xs]
  73. 73. Map – Mais exemplos ghci> map (+3) [1,5,3,1,6] [4,8,6,4,9] ghci> map (++ "!") ["BIFF", "BANG", "POW"] ["BIFF!","BANG!","POW!"] ghci> map (replicate 3) [3..6] [[3,3,3],[4,4,4],[5,5,5],[6,6,6]] ghci> map (map (^2)) [[1,2],[3,4,5,6],[7,8]] [[1,4],[9,16,25,36],[49,64]] ghci> map fst [(1,2),(3,5),(6,3),(2,6),(2,5)] [1,3,6,2,2]
  74. 74. Map com avaliação parcial Main> map (*5) [1,3,5,7] [5,15,25,35] incAll = map (1 +) addNewlines = map (++ "n") halveAll = map (/2) squareAll = map (^2) stringify = map (: [])
  75. 75. Filter A função filter seleciona os elementos de uma lista que satisfazem a um predicado ● filter :: (a -> Bool) -> [a] -> [a] Main> filter even [1..10] [2,4,6,8,10]
  76. 76. Filter Pode ser definido como compreensão de listas ou por recursão ● filter :: (a -> Bool) -> [a] -> [a] filter p xs = [x | x xs, p x] filter p [] = [] filter p (x : xs) |px = x : filter p xs | otherwise = filter p xs 11/4/11
  77. 77. Comprimindo para um único valor Um grande número de funções em listas podem ser definidas a partir de um padrão simples de recursão ●A lista vazia recebe para um valor final, e uma lista ●não vazia é mapeada para um operador : que ●combina o primeiro elemento com a aplicação da função ●no resto da lista f [] = v f (x:xs) = x f xs
  78. 78. Comprimindo para um único valor sum [] = 0 sum (x:xs) = x + sum xs product [] = 1 product (x:xs) = x * product xs and [] = True and (x:xs) = x && and xs 11/4/11
  79. 79. Comprimindo para um unico valor A função foldr (“fold right”) encapsula este padrão de recursão em listas, com a função dada e o valor v como argumentos sum = foldr (+) 0 product = foldr (*) 1 and = foldr (&&) True
  80. 80. Definição do foldr foldr::(a -> b -> b) -> b -> [a] -> b foldr f v [] =v foldr f v (x:xs) = f x (foldr f v xs)
  81. 81. Composição de Funções (f . g) x = f (g x) > ( (*2) . (*5) ) 8 > 80
  82. 82. Abstração de dados Tipos enumerados (enumerated no C), Tipos cartesianos (struct no C), Uniões disjunta (union no C) Tipos recursivos
  83. 83. O que vimos até então... Usamos os tipos existentes em Haskell ● Primitivos: Int, String, Bool ● Compostos: Listas e tuplas Aprendemos criar sinonimos : type Matricula = Int type Nome = String type Salario = Double type Funcionario = (Matricula, Nome, Salario)
  84. 84. Qual o problema com os sínonimos? 11/4/11
  85. 85. Considerem os seguintes códigos type Matricula = Int type Nome = String type Salario = Double type Funcionario = (Matricula, Nome, Salario) funcionarios :: [Funcionario] funcionarios = [(1235,"joao", 580), (256,"jose", 590)] aumentaSalario :: Funcionario -> Funcionario aumentaSalario (m,n,s) = (m,n,s+(0.1*s)) type Nota = Double type Alunos = (Matricula, Nome, Nota) alunos :: [Alunos] alunos = [(1,"antonio", 50.6), (6,"maria", 70)] – eu poderia aplicar aumentaSalario a alunos, pois são a mesma tupla, – apenas com nomes diferentes 11/4/11
  86. 86. Usando tipos algébricos do Haskell ● Nós definimos um novo tipo de dado usando o palavra-chave data. Data Funcionario = Funcionario Int String Double type Matricula = Int type Nome = String type Salario = Double Data Funcionario = Funcionario Matricula Nome Salario
  87. 87. Tipos Compostos Os tipos algebricos do Haskell permite estruturas diversos tipos a partir de valores mais simples. ● Produto cartesiano ( registros) ● Tipos enumerados ● Uniões disjuntas (variantes e uniões) ● Tipos recursivos (estruturas de dados dinâmicas)
  88. 88. Tipos algébricos ● Diferenças entre nome de tipos e construtor de tipos: O nome do tipo e dos construtores não precisa ser iguais. Construtor de tipo data InfoLivro = Livro Int String [String] Nome do tipo 11/4/11
  89. 89. Tipos algébricos ● O Haskell dispõe diversas classes que podem ser derivadas para os novos tipos. ●Show, permite vizualizar os dados na tela ●Ord, permite fazer comparaçoes, < e > ●Eq, permite verificar se dois tipos são iguais Palavra chave para derivar classes 11/4/11 data Matricula = Matricula Int deriving (Show, Ord, Eq)
  90. 90. Tipos algébricos – Registro Comparação com C C struct Point { x,y: double; }; Haskell data Point = Pt Double Double deriving (Show)
  91. 91. Tipos algébricos – Registro ● Usando casamento de padrão para pegar um dado valor data Point = Pt Double Double deriving (Show) getX :: Point → Double getx Pt x y = x getY :: Point → Double getY Pt x y = x 11/4/11
  92. 92. Enumerados ● Comparação com C C enum Dias {Segunda, Terça, Quarta, Quinta, Sexta} Haskell data Dias = Segunda | Terça | Quarta | Quinta | Sexta deriving (Show) 11/4/11
  93. 93. Tipo Booleano ● Criando e usando o seu próprio tipo booleano data Booleano = Falso | Verdadeiro deriving (Show, Eq) e :: Booleano -> Booleano -> Booleano e Falso _ = Falso e Verdadeiro b = b maior :: Int -> Int -> Booleano maior a b | a > b = Verdadeiro | otherwise = Falso -- a é maior que b e c maior3 a b c = (maior a b) `e` (maior a c) -- maior3 7 5 6
  94. 94. União Disjunta em Haskell data Number = Exact Int | Inexact Float ● Valores: Cada valor consiste de uma tag, junto ou com um valore inteiro (se a tag is Exact) ou um valor Float (se a tag é Inexact). Number = Exact Integer + Inexact Float … Exact(–2) Exact(–1) Exact 0 Exact 1 Exact 2 … … Inexact(–1.0) … Inexact 0.0 … Inexact 1.0 … 11/4/11
  95. 95. Exemplo de união disjunta data Number = Exact Int | Inexact Float deriving (Show) pi2 = Inexact 3.1416 rounded :: Number -> Int rounded (Exact i) = i rounded (Inexact r) = round r 11/4/11
  96. 96. União Disjunta – Tratando erro ● Em Haskell existe um tipo de dado muito util em casos onde uma função pode nao ter retorno. ● ex. buscar um elemento em uma lista data Maybe a = Nothing | Just a
  97. 97. União Disjunta – Tratando erro ● Exemplo, buscando em uma lista type Aluno = (Int, String) busca :: Int -> [Aluno] -> Maybe String busca mat [] = Nothing busca mat ((x,y):xys) | mat == x = Just y | otherwise = busca mat xys
  98. 98. União Disjunta Comparando com a linguagem C C union { int exact; int inexact; }; Haskell data Number = Exact Int | Inexact Float
  99. 99. Tipos Recursivos Exemplos de tipos recursivos: data Nat = Zero | Succ Nat data Lista = Nil | Cons Int Lista data ArvoreBin = Vazia | Nodo Int ArvoreBin ArvoreBin
  100. 100. Tipos Recursivos Números naturais data Nat = Zero | Succ Nat Nat é um novo tipo com dois construtores Zero :: Nat e Succ :: Nat -> Nat
  101. 101. Tipos recursivos ● Implementando as operações básicas. data Nat = Zero | Succ Nat deriving (Show) soma :: Nat -> Nat -> Nat soma Zero n = n soma (Succ m) n = Succ (soma m n) mult :: Nat -> Nat -> Nat mult Zero m = Zero mult (Succ m) n = soma n (mult n m)
  102. 102. Tipos Recursivos - Lista ● A implementação mínima de uma lista: data List = Nil | Cons Int List deriving (Show) first (Cons a s) = a first Nil = error "vazio" rest (Cons a s) = s rest Nil = error "vazio"
  103. 103. Atividade A partir da lista dada anteriormente, implemente as seguintes funções: ultimo :: List -> Int soma :: List -> Int mapeia :: (Int->Int) -> List -> List – equivalente ao “map”
  104. 104. Polimorfismo Paramétrico C++ template <typedef T> T maior (T a, T b) { return ( (a>b)? a : b ); } Java public class Pair<T, S>{ public Pair(T f, S s){ first = f; second = s; } }
  105. 105. Polimorfismo paramétrico ● ● Funções paramétricas Tipos de dados paramétrico
  106. 106. Tipos Paramétricos em Haskell ● Uma característica importante de Haskell é o uso de tipos paramétricos ● Muitas funções podem ser definidas em termos de tipos genéricos ● Convenção: usamos a, b, c para tipos genéricos ● Tipos paramétricos comuns, listas e tuplas length :: [a] → Int Pode ser lista de inteiros, de listas ..
  107. 107. Tipos Paramétricos em Haskell Lista de inteiros Lista paramétrica data List Int = Nil | Cons Int List deriving (Show) data List a = Nil | Cons a List deriving (Show) first :: List → Int first (Cons a s) = a first Nil = error "vazio" first :: List a → a first (Cons a s) = a first Nil = error "vazio" rest :: List → List rest (Cons a s) = s rest Nil = error "vazio" rest :: List a → List a rest (Cons a s) = s rest Nil = error "vazio"
  108. 108. Tipos Paramétricos em Haskell data ArvBin a = Vazia | Nodo a (ArvBin a) (ArvBin a) deriving Show elem :: ArvBin a -> a elem Vazia = error "arvore vazia" elem (Nodo e _ _) = e esq :: ArvBin a -> ArvBin a esq Vazia = error "arvore vazia" esq (Nodo _ e _) = e dir :: ArvBin a -> ArvBin a dir Vazia = error "arvore vazia" dir (Nodo _ _ d) = d
  109. 109. Definindo as funções de acesso diretamento na definição ● Equivalente a implementação anterior data ArvBin a = Vazia | Nodo { elem :: a, esq :: (ArvBin a), dir :: (ArvBin a) } deriving Show
  110. 110. Restrição no polimorfismo ● Considere a seguinte função, ● somar todos os valores de uma lista somatodos :: [a] -> a somatodos (x:xs) = x + somatodos xs Qual o problema nessa definição ?
  111. 111. Restrição no polimorfismo ● Considere a seguinte função, ● somar todos os valores de uma lista somatodos :: [a] -> a somatodos (x:xs) = x + somatodos xs Qual o problema nessa definição ?
  112. 112. Restrição no polimorfismo ● Usando “type classes” A função somatodos funciona sobre qualquer “a”, desde que ele seja um Num. somatodos :: (Num a) => [a] -> a somatodos (x:xs) = x + somatodos xs
  113. 113. Type class em Haskell Uma classe é uma coleção de tipos que suportam certas operações (métodos) comuns ●Uma classe define uma assinatura ● class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool
  114. 114. Classes Básicas em Haskell Eq - tipos com igualdade Ord – tipos ordenados Show – tipos mostráveis Read – tipos legíveis, que pode ser convertido Num 11/4/11 – tipos numéricos
  115. 115. Instanciando type class data Point = Point Int Int deriving (Show, Eq, Ord, Read) instance Num Point where (+) (Point x1 y1) (Point x2 y2) = Point (x1 + x2) (y1 + y2)
  116. 116. Instanciando type class ● Podemos instanciar qualquer uma das classes pré definidas, mesmo as que são derivaveis, como Read, Show ... data Point = Point Int Int instance Show Point where show (Point x y) = show (x,y) Prelude> Point 4 5 > (4,5)
  117. 117. Hierarquia - type class
  118. 118. Programas e operações de entrada e saída
  119. 119. Operações de entrada e saída Até então, vimos como usar o Haskell via ghci, mas como gerar um programa compilável? Como o Haskell consegue lidar com operações de entrada e saída. Esse tipo de operação tem efeitos colaterais.
  120. 120. O problema ... Um programa em Haskell consiste num conjunto de funções, sem efeitos colaterais Tensão O objetivo de executar qqer programa é ter algum efeito colateral
  121. 121. A solução Escrever programas interativos em Haskell usando tipos que fazem distinção entre expressões funcionais “puras” de ações “impuras” que podem envolver efeitos colaterais IO a O tipo das ações de IO que retornam um valor do tipo a
  122. 122. I/O em Haskell Exemplos de IOs IO Char IO () O tipo das ações de IO que retornam um caracter O tipo das ações que não tem valor de retorno
  123. 123. IO em Haskell: O tipo (IO a) Um valor do tipo (IO t) é uma ação que, quando realizada, pode fazer alguma forma de IO antes de devolver um resultado do tipo t. type IO a = World -> (a, World) result::a IO a World in World out
  124. 124. Meu Primeiro Programa Para rodar interpretado use o runghc: module Main where main = putStrLn "Hello World!" Ou, compile em código nátivo. runghc hello.hs Hello World! ghc hello.hs -o prg1 ./prg1 Hello World!
  125. 125. Funções da biblioteca Funções para escrever na tela putStr :: String -> IO () putStrLn :: String -> IO () Para ler uma linha de caracteres do teclado, podemos usar a função: getLine :: IO(String)
  126. 126. Combinando ações Para combinar ações podemos usar a notação “do”; Cada ação é nessa forma:
  127. 127. Meu segundo programa Lê uma entrada do usuário e imprime na tela module Main where main = do input <- getLine putStrLn input
  128. 128. Incrementando um pouco mais module Main where ask :: String -> IO String ask question = do putStrLn question getLine main :: IO () main = do nome <- ask "Qual eh o seu nome? " matr <- ask "Qual eh a sua matricula?" putStrLn ("Benvindo "++ nome ++ "!") putStrLn ("Sua matricula eh "++matr)
  129. 129. Lendo outros tipos, e uso de funções dentro de um IO ask :: String -> IO Double ask question = do putStrLn question readLn main = do a <- ask "valor de a" b <- ask "valor de b" c <- ask "valor de c" let rs = raizes (a,b,c) let r1 = fst rs let r2 = snd rs print ("raiz 1 eh " ++ (show r1) ++ ", raiz 2 eh " ++ (show r2) )
  130. 130. Trabalhando com arquivos Converte todo um arquivo texto para letras maiusculas. A função readfile retorna uma string contendo todo o arquivo e writeFile escreve uma string em um arquivo. import IO import Data.Char main = do str <- readFile "input.txt" writeFile "output.txt" (map toUpper str)
  131. 131. Funções para string Função lines, quebra uma string pelo marcador de fim de linha lines “linha1nlinha2” → [“linha1”,linha 2] Função words, quebra uma string por separador de plavras,”espaço”. words “uma frase”-> [“uma”, frase]
  132. 132. Trabalhando com arquivos ● Número de palavras e de linhas de um arquivo: main = do str <- readFile "input.txt" print (length (words str)) Print (length (lines str))
  133. 133. Trabalhando com arquivos ● Usando a função “iterative”, convertendo todas as letras de um arquivo para maiuscula. main = interact conv where conv s = (map toUpper s) prog1 < arquivoentr.txt > arquivosaida.txt
  134. 134. Trabalhando com argumentos import System.Environment main:: IO() main = do args <- getArgs let arg1 = head args print ("o primeiro argumento eh " ++ arg1) sergio@sergio-laptop:~$ runghc arg.hs teste "o primeiro argumento eh teste"
  135. 135. FIM
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×