Programação Funcional em Haskell3a Reunião — Listas

Conteúdo e objetivos

Introdução à programação funcional usando Haskell Objetivos de aprendizagem

Fundamentos sobre listas;

Noções sobre listas;

Construção de lista por compreensão;

Funções sobre listas;

Fundamentos

Uma lista é uma estrutura de dados que representa umacoleção de objetos homogêneos em sequência.

Para alcançar qualquer elemento, todos os anteriores aele devem ser recuperados.

Em programação, uma lista vazia (representada por [ ] emHaskell) é a estrutura-base da existência de uma lista..

Listas em Haskell

Uma lista é composta sempre de dois segmentos: cabeça(head) e corpo (tail). A cabeça da lista é sempre o primeiroelemento.

[ 'a', 'b', 'c', 'd' ] 'a': [ 'b', 'c', 'd' ] ‘a’ 1° elemento ['b', 'c', 'd' ] corpo da lista

> ['a','b','c','d']"abcd"> 'a':['b','c','d']"abcd“

Operador (:)

O símbolo (:) é o operador de construção de listas. Toda lista éconstruída através deste operador. Podemos verificar que esteoperador é polimórfico, usando o comando type:

> :type (:)(:) :: a -> [a] -> [a]

O operador deve ser aplicado á argumentos de ummesmo tipo.

Prelude> 'a':['b','c','d']"abcd"Prelude> 2:[4,6,8][2,4,6,8]

Listas em HaskellPrelude> 'a':['b','c','d']"abcd"Prelude>1:[2,3][1,2,3]Prelude>['a','c','f'] == 'a':['c','f']TruePrelude>[1,2,3] == 1:2:3:[]TruePrelude>1:[2,3] == 1:2:[3]TruePrelude> “Quixada" == ‘Q':[‘u',‘i',‘x',‘a‘ ,’d’, ‘a’]TruePrelude> “Ruth" == ‘R':[‘u',‘t',‘h']True

Listas e TiposUma lista é uma coleção de elementos de um dado tipo. Paratodo tipo t existe uma lista [t] para seus elementos. [1,2,3]

Prelude> [1,2,3]::[Int][1,2,3]

Prelude> [True,True,False]::[Bool][True,True,False]

Prelude> [(1,2),(4,5),(0,8)]::[(Int,Int)][(1,2),(4,5),(0,8)]

Prelude> [[2,3,4],[5],[],[3,3]]::[[Int]][[2,3,4],[5],[],[3,3]]

Escrevendo ListasPode-se definir uma lista indicando os limites inferior e superiorde um conjunto conhecido, onde existe uma relação de ordementre os elementos, no seguinte formato:

[ <limite-inferior> .. <limite-superior> ]

> [1..4] [1,2,3,4]

> ['m'..'n']"mn"

> [1,3..6] [1,3,5]

> ['a','d'..'p']"adgjmp"

Escrevendo Listas

Podemos definir qualquer progressão aritmética em uma listautilizando a seguinte notação:

[ <1o. termo>, <2o. termo> .. <limite-superior> ]

> [7,6..3] > [6,5..0][7,6,5,4,3] [6,5,4,3,2,1,0]

> [-5,2..16] > [5,6..5][-5,2,9,16] [5]

> [1,1.1 .. 2][1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2.0]

Listas por CompreensãoDefiniçãoA 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:

A = { E(x) | x C P1(x) ^ ... ^ Pn(x) }

sendo E(x) uma expressão em x, C um conjunto inicial para os valores de x e os vários Pi (x) são proposições em x.

O conjunto A é escrito em Haskell da seguinte forma:A = [ E(x) | x <- lista, P1(x), ... , Pn(x) ]

Listas por Compreensão

O conjunto dos quadrados dos números inteiros é definido pelaexpressão:

A = { x | x }

Em Haskell, podemos escrever A para listas finitas ou infinitasda seguinte forma:

listaQuad = [ x^2 | x <- [1..30] ]

listaQuadInf = [ x^2 | x <- [1..] ]

Listas por CompreensãoPrelude> [2*x | x <- [1..10]] [2,4,6,8,10,12,14,16,18,20]

Prelude> [2*x | x <- [1..10] , 2*x >= 12] [12,14,16,18,20]

Prelude> [x+y | x <- [1..10] , y <- [11..20]] [12,13,14,15,16,17,18,19,20,21,13,14,15,16,17,18,19,20,21,22,14,15,16,17,18,19,20,21,22,23,15,16,17,18,19,20,21,22,23,24,16,17,119,20,21,22,23,24,25,17,18,19,20,21,22,23,24,25,26,18,19,20,21,22,23,24,25,26,27,19,20,21,22,23,24,25,26,27,28,20,21,22,23,24,526,27,28,29,21,22,23,24,25,26,27,28,29,30]

Prelude>

Listas por Compreensão--Defina uma função divisores de n que retorna uma --lista dos divisores de n.

Prelude> let divisores n = [ x| x <- [1..n] , mod n x == 0 ]

Prelude> divisores 12 [1,2,3,4,6,12]

Listas por Compreensão--Defina uma função mdc a b que calcula o máximo --divisor comum múltiplo comum de a e b.

Prelude> let comum a b = [ x | x <- [1..a] , mod a x ==0 , mod b x ==0 ]

Prelude> comum 12 24 [1,2,3,4,6,12]

Prelude> let mdc a b = maximum ( comum a b )

Prelude> mdc 12 24 12

Prelude> mdc 12 153

Listas por Compreensão--Calcule a soma de todos os números múltiplos de 3 --ou 5 menores que 1000.

Prelude> sum [ x | x <- [1..1000] , mod x 3 ==0 || mod x 5 ==0 ] 234168

--Crie uma função que imprima apenas --os caracteres maiúsculos de uma string.

Prelude> let imprimaMaiusculas st = [c | c <- st , elem c ['A'..'Z'] ]

Prelude> imprimaMaiusculas “PhonoRrjOetGvirtusRamicusAMlaeticiaAÇÃO FUNCIONAL USANDO HASKELL“ “PROGRAMAÇÃOFUNCIONALUSANDOHASKELL“

Prelude> imprimaMaiusculas “HaprendAerSeKhEumaLLvirCtuAdePIT VsaIbTerAeEhApoMIdeCUrS “ “HASKELLCAPITVITAEAMICUS“

Funções sobre listasfunção descrição exemplo

(++) Concatena duas ou mais listas

> [1,2,3]++[4,5,6][1,2,3,4,5,6]

concat Recebe uma lista de listas e as concatena

> concat [[1,2],[3,4]] [1,2,3,4]

Elem Verifica se um elemento pertence a lista

>elem 5 [1,5,10]True

null Retorna verdadeiro (True) se uma lista é vazia

>null []True

length Tamanho de uma lista

>length “wesley“6

Funções sobre listasfunção descrição exemplo

head Retorna o 1°elemento

> head “thiago"‘t'

tail Retorna o corpo da lista

> tail “Ricardo"“icardo"

last Retorna o último elemento da lista

> last [4,3,2]2

(!!) Operador de índice da lista, retorna o elemento mantido numa posição

>[1,3,5,7,9] !!01> (!!)[‘c',‘a',‘i‘,’k’,’e’] 2‘i'

reverse Reverso da lista > reverse [4,5,2,2][2,2,5,4]

Funções sobre listasfunção descrição Exemplo

replicate Constrói uma lista pela replicação de um elemento

> replicate 4 'c“cccc”

product Retorna o produto dos elementos da lista

> product [5,3,6,1]90

sum Retorna a soma dos elementos

> sum [4,5,7,2,1]19

maximum Retorna o maior elemento

> Maximum [4,5,2,-20,4,2]5

minimum Retorna o menor elemento

> minimum [5.2,0.3,7.2]0.3

Funções sobre listasfunção descrição Exemplo

take Gera uma lista com os n 1°s elementos da lista original

> take 4 [‘c',‘r',‘i',‘s‘, ‘l‘,‘a‘,‘n‘, ‘i‘, ‘o‘]“cris”

drop Retira n elementos do início da lista

> drop 3 [3,3,4,4,5,5][4,5,5]

takeWhile Retorna o maior segmento inicial de uma lista que satisfaz uma condição

>takeWhile (<10) [1,3,13,4][1,3]

dropWhile Retira o maior segmento inicial de uma lista que satisfaz uma condição

>dropWhile (<10) [1,3,13,4][13,4]

Funções sobre listasfunção Descrição Exemplo

splitAt Divide uma lista num par de sub-listas fazendo a divisão numa determinada posição

>splitAt 2 [3,4,2,1,5]([3,4],[2,1,5])

zip Recebe duas listas como entrada e retorna > zip [1,2] ['a','b']uma lista de pares

>zip [1,2] ['a','b'][(1,'a'),(2,'b')]

Bibliografia

Haskell - Uma abordagem prática. Cláudio César de Sá eMárcio Ferreira da Silva. Novatec, 2006.

Agradecimentos

Ao Prof°- Ricardo Reis e a todos os participantes do projeto haskell ufc.