Programação Funcional. Aula 6. Listas. José Romildo Malaquias. Departamento de Computação Universidade Federal de Ouro Preto 2011.

Transcrição

1 Programação Funcional Aula 6 Listas José Romildo Malaquias Departamento de Computação Universidade Federal de Ouro Preto /104

2 1 Listas 2 Strings 3 Seqüências aritméticas 4 Casamento de padrão com listas 5 Operações com listas null head e tail, init e last elem length e (!!) take, drop e splitat (++) e concat reverse zip e zipwith map e filter foldl e foldr, foldl1 e foldr1 6 List comprehension 2/104

3 Layout 1 Listas 2 Strings 3 Seqüências aritméticas 4 Casamento de padrão com listas 5 Operações com listas null head e tail, init e last elem length e (!!) take, drop e splitat (++) e concat reverse zip e zipwith map e filter foldl e foldr, foldl1 e foldr1 6 List comprehension 3/104

4 Listas Lista é uma seqüência de elementos de um mesmo tipo. [a] é o tipo das listas cujos elementos são do tipo a Estruturalmente a forma de uma lista pode ser: lista vazia nenhum elemento na seqüência construtor de dado: (constante) [] :: [a] lista não vazia formada por dois componentes: cabeça: o primeiro elemento da lista cauda: lista de todos os demais elementos, a partir do segundo construtor de dado: (dois argumentos) infixr 5 : (:) :: a -> [a] -> [a] O primeiro argumento é a cabeça da lista. O segundo argumento é a cauda da lista. 4/104

5 Exemplos de listas [] seqüência vazia (nenhum elemento) não tem cabeça e nem cauda tipo: [a] é um valor polimórfico, pois pertence a todos os tipos lista 5/104

6 Exemplos de listas (cont.) False : [] seqüência: False cabeça: False cauda: [] tipo: [Bool] 6/104

7 Exemplos de listas (cont.) a : ( b : []) seqüência: a, b cabeça: a cauda: b : [] tipo: [Char] 7/104

8 Exemplos de listas (cont.) 15 : (9 : (42 : [])) seqüência: 15, 9, 42 cabeça: 15 cauda: 9 : (42 : []) tipo: Num a => [a] 8/104

9 Exemplos de listas (cont.) 15 : (9.45 : (15 : (0 : []))) seqüência: 15, 9.45, 15, 0 cabeça: 15 cauda: 9.45 : (15 : (0 : [])) tipo: Fractional a => [a] 9/104

10 Exemplos de listas (cont.) 15 : ( H : (False : [])) não é uma expressão válida, uma vez que todos os elementos de uma lista devem ser de um mesmo tipo. 10/104

11 Notações de listas O construtor constante [] denota a lista vazia. O construtor : constrói uma lista não vazia a partir da cabeça e da cauda. : é um operador binário infixo com precedência 5 e associatividade à direita. Isto significa que os parênteses no segundo argumento geralmente são desnecessários. Exemplo: o valor 100 : 200 : 300 : 400 : [] é idêntido a 100 : (200 : (300 : (400 : []))) 11/104

12 Notações de listas (cont.) Uma lista finita pode ser denotada escrevendo os seus elementos entre colchetes e separados por vírgula: [ exp 1,..., exp n ] Esta é uma notação simplificada para listas finitas, sendo equivalente a exp 1 :... : exp n : [] 12/104

13 Notações de listas (cont.) Exemplo: A lista de 6 números [10, 20, 30, 40, 50, 60] é apenas uma abreviação sintática para 10 : 20 : 30 : 40 : 50 : 60 : [] 13/104

14 Notações de listas (cont.) Exemplo: A lista [[]] que é uma abreviação para [] : [] é a lista unitária cujo único elemento é a lista vazia. O seu tipo é [[a]]. 14/104

15 Exercícios Exercício 1 Dê um exemplo de uma expressão que contenha duas ocorrências da lista vazia, sendo a primeira ocorrência do tipo [Bool] e a segunda do tipo [Char]. 15/104

17 Strings Em Haskell strings (cadeias de caracteres) são simplesmente listas de caracteres. O tipo String é um sinônimo para [Char]. Existe uma notação especial para constantes strings: a seqüência de caracteres é escrita entre aspas ". Exemplos: A string "UFOP" é apenas uma sintaxe conveniente para a lista de caracteres [ U, F, O, P ] A string vazia "" é o mesmo que [], a lista vazia, do tipo [Char]. 17/104

18 Strings (cont.) Códigos de escape podem ser usados em constantes caracter e constantes strings para representar alguns caracteres. Exemplos: \n \\ "bom\ndia\nbrasil" "abcd\tefg" "\"aspas\" dentro da string" "tabulador:\tou\^iou\9." 18/104

19 Strings (cont.) Códigos de escape de 1 caracter: Escape Unicode Character \0 U+0000 null character \a U+0007 alert \b U+0008 backspace \f U+000C form feed \n U+000A newline (line feed) \r U+000D carriage return \t U+0009 horizontal tab \v U+000B vertical tab \" U+0022 double quote \& n/a no character \ U+0027 single quote \\ U+005C backslash 19/104

20 Strings (cont.) Códigos de controle: Escape Escape Unicode Meaning \NUL U+0000 null character \SOH \Â U+0001 start of heading \STX \^B U+0002 start of text \ETX \^C U+0003 end of text \EOT \^D U+0004 end of transmission \ENQ \Ê U+0005 enquiry \ACK \^F U+0006 acknowledge \BEL \^G U+0007 bell \BS \^H U+0008 backspace \HT \Î U+0009 horizontal tab \LF \^J U+000A line feed (newline) \VT \^K U+000B vertical tab \FF \^L U+000C form feed \CR \^M U+000D carriage return 20/104

21 Strings (cont.) \SO \^N U+000E shift out \SI \^O U+000F shift in \DLE \^P U+0010 data link escape \DC1 \^Q U+0011 device control 1 \DC2 \^R U+0012 device control 2 \DC3 \^S U+0013 device control 3 \DC4 \^T U+0014 device control 4 \NAK \^U U+0015 negative acknowledge \SYN \^V U+0016 synchronous idle \ETB \^W U+0017 end of transmission block \CAN \^X U+0018 cancel \EM \^Y U+0019 end of medium \SUB \^Z U+001A substitute \ESC \^[ U+001B escape \FS \^\ U+001C file separator \GS \^] U+001D group separator \RS \^^ U+001E record separator 21/104

22 Strings (cont.) \US \^_ U+001F unit separator \SP U+0020 space \DEL U+007F delete 22/104

23 Strings (cont.) Códigos de escape numéricos: \decimal código decimal \o octal código octal \x hexa código hexadecimal Exemplos: \1234 \xbeef \o1234 O valor numérico máximo é \ , que também pode ser escrito \x10ffff ou \o /104

24 Strings (cont.) Seqüência de escape vazia: \& Literais string podem conter a seqüência de esccape vazia, escrita \&. Ela não é um caracter real, mas serve para separar uma seqüência de escape numérica de um dígito decimal que vem logo em seguida. Exemplo: A string "\130\&12" é formada pelos caracteres \130, 1 e 2. Já a string "\13012" é formada apenas pelo caracter \ /104

25 Strings (cont.) Seqüência de escape gap: \brancos\ Esta seqüência pode aparecer em literais strings. É formada por uma seqüência de caracteres brancos (espaços, mudanças de linha, tabulações,...) delimitada pelo caracter \. Ela não reprsenta nenhum caracter e é ignorada. É útil para escrever um literal string em várias linhas. Exemplo: A string "uma longa \ \string, escrita\ \ em muitas linhas" é a idêntica a "uma longa string, escrita em muitas linhas" 25/104

26 Instância de classes Tipos listas são instâncias de várias classes: instance Eq a => Eq [a] instance Ord a => Ord [a] instance Read a => Read [a] instance Show a => Show [a] Duas listas são iguais se e somente se os seus elementos correspondentes são iguais. A comparação de listas é lexicográfica (da mesma maneira que palavras são organizadas em um dicionário). 26/104

27 Instância de classes (cont.) Exemplos: [1,2,3,4,5] == [1,2,3,4,5] True [1,2] == [1,2,3] False "Maria" /= "maria" True "elegante" <= "elefante" False [1,2,3] > [1,2] True compare "Abracadabra" "Zebra" LT show [1,2,3,4] "[1,2,3,4]" show "Bom dia!" "\"Bom dia!\"" read "[6,0,32]" :: [Int] [6,0,32] read "[ f, i, m ]" :: String "fim" read "\"fim\"" :: String "fim" 27/104

29 Seqüências aritméticas Haskell tem uma sintaxe especial para seqüências aritméticas. 29/104

30 Seqüências aritméticas (cont.) [ exp 1, exp 2.. exp 3 ] É a seqüência aritmética que começa com exp 1, continua com exp 2 e cujos elementos não ultrapassam exp 3. Para tipos numéricos, a razão da progressão é exp 2 exp 1. Exemplos: [4,6..14] [4,6,8,10,12,14] [5,10..44] [5,10,15,20,25,30,35,40] [18,15..0] [18,15,12,9,6,3,0] [4.0, ] [4.0,4.4, , ] [ m, o.. x ] "moqsuw" [ 0, ] "02468" [ m, o.. a ] "" 30/104

31 Seqüências aritméticas (cont.) [ exp 1.. exp 2 ] É a seqüência aritmética que começa com exp 1 e cujos elementos não ultrapassam exp 2. Para tipos numéricos, a razão da progressão é 1. Exemplos: [5..10] [5,6,7,8,9,10] [7..19] [7,8,9,10,11,12,13,14,15,16,17,18,19] [7..5] [] [ M.. P ] "MNOP" [False.. True] [False,True] 31/104

32 Seqüências aritméticas (cont.) [ exp 1, exp 2.. ] É a seqüência aritmética que começa com exp 1 e cujo segundo elemento é exp 2. Para tipos numéricos, a razão da progressão é exp 2 exp 1. Pode ser infinita. Exemplos: [5,7..] [5,7,9,11,13,15,17,... (seqüência infinita) [0,6..] [0,6,12,18,24,30,36,... (seqüência infinita) [7,2..] [7,2,-3,-8,-13,-18,... (seqüência infinita) [9,9..] [9,9,9,9,9,9,9,9,9,... (seqüência infinita) 32/104

33 Seqüências aritméticas (cont.) [ exp 1.. ] É a seqüência aritmética que começa com exp 1. Para tipos numéricos, a razão da progressão é 1. Pode ser infinita. Exemplos: [5..] [5,6,7,8,9,10,11,12,13,... (seqüência infinita) [3..] [3,4,5,6,7,8,9,10,11,12,... (seqüência infinita) [1.1..] [1.1,2.1,3.1,4.1,5.1,6.1,... (seqüência infinita) [LT..] [LT,EQ,GT] [5..] :: (Enum a, Num a) => [a] [ B..] :: [Char] 33/104

34 Seqüências aritméticas (cont.) A notação de lista para seqüências aritméticas é simplesmente uma abreviação sintática para aplicações de métodos da classe Enum: [ a, b.. c ] enumfromthento a b c [ a.. b ] enumfromto a b [ a, b.. ] enumfromthen a b [ a.. ] enumfrom a Exemplo: [10,15..44] [10,15,20,25,30,35,40] enumfromthento [10,15,20,25,30,35,40] Portanto seqüências aritméticas só podem ser usadas para listas de elementos de um tipo que seja instância da classe Enum. 34/104

35 Seqüências aritméticas (cont.) A classe Enum: class Enum a where succ pred toenum fromenum enumfrom enumfromthen enumfromto :: a -> a :: a -> a :: Int -> a :: a -> Int :: a -> [a] :: a -> a -> [a] :: a -> a -> [a] enumfromthento :: a -> a -> a -> [a] instance Enum Int instance Enum Integer instance Enum Float instance Enum Double instance Enum Char instance Enum Bool instance Enum Ordering instance Enum () 35/104

37 Casamento de padrão com listas Casamento de padrão é a operação básica de Haskell para decompor valores estruturados. Para cada construtor de dados existe uma forma de padrão correspondente. 37/104

38 Casamento de padrão com listas (cont.) Estruturalmente uma lista pode ser vazia ou não vazia: padrão lista vazia [] é um padrão constante o casamento sucede se e somente se o valor for a lista vazia padrão lista não vazia pad 1 : pad 2 é formado por dois padrões pad 1 e pad 2 o casamento sucede se e somente se o valor for uma lista não vazia cuja cabeça casa com pad 1 e cuja cauda casa com pad 2 38/104

39 Casamento de padrão com listas (cont.) Exemplo: O padrão [] casa somente com a lista vazia. padrão valor casamento variáveis [] [] sucede [] [1,2,3] falha 39/104

40 Casamento de padrão com listas (cont.) Exemplo: O padrão x:xs casa com qualquer lista não vazia, associando as variáveis x e xs com a cabeça e a cauda da lista, respectivamente. padrão valor casamento variáveis x:xs [] falha x:xs [1,2,3] sucede x 1, xs [2,3] x:xs [ A ] sucede x A, xs [] 40/104

41 Casamento de padrão com listas (cont.) Exemplo: O padrão x:y:_ casa com qualquer lista que tenha pelo menos dois elementos, associando as variáveis x e y ao primeiro e segundo elementos da lista, respectivamente. padrão valor casamento variáveis x:y:_ [] falha x:y:_ ["ana"] falha x:y:_ [1,2] sucede x 1, y 2 x:y:_ [1,2,3] sucede x 1, y 2 41/104

42 Casamento de padrão com listas (cont.) Exemplo: O padrão x:_:z:[] casa com qualquer lista que tenha exatamente três elementos, associando as variáveis x e z ao primeiro e terceiro elementos da lista, respectivamente. padrão valor casamento variáveis x:_:z:[] [] falha x:_:z:[] ["ana"] falha x:_:z:[] [1,2,3] sucede x 1, z 3 x:_:z:[] [1,2,3,4,5] falha 42/104

43 Casamento de padrão com listas (cont.) Exemplo: O padrão 0:a:_ casa com qualquer lista de números que tenha pelo menos dois elementos, sendo o primeiro igual a zero, associando a variável a ao segundo elemento da lista. padrão valor casamento variáveis 0:a:_ [] falha 0:a:_ [0] falha 0:a:_ [0,2,3] sucede a 2 0:a:_ [0,10,6,3] sucede a 10 0:a:_ [7,0,8] falha 43/104

44 Casamento de padrão com listas (cont.) Exemplo: O padrão (m,_):_ casa com qualquer lista de pares não vazia, associando a variável m ao primeiro componente do par que é o primeiro elemento da lista. padrão valor casamento variáveis (m,_):_ [] falha (m,_):_ [("fim",true)] sucede m "fim" (m,_):_ [(10, M ),(20, F )] sucede m 10 44/104

45 Casamento de padrão com listas (cont.) A forma [ padrao 1,..., padrao n ] é uma abreviação sintática para padrao 1 :... : padrao n : [] cujo casamento sucede somente se a lista tiver exatamente n elementos. 45/104

46 Casamento de padrão com listas (cont.) Exemplo: O padrão [1,alfa] casa com qualquer lista de dois números que começa com 1, associando a variável alfa ao segundo elemento da lista. padrão valor casamento variáveis [1,alfa] [] falha [1,alfa] [1] falha [1,alfa] [1,5] sucede alfa 5 [1,alfa] [9,5] falha [1,alfa] [1,2,3] falha 46/104

47 Casamento de padrão com listas (cont.) Exemplo: A expressão case tail [10] of [] -> "vazia" _ -> "nao vazia" resulta em "vazia", pois o valor da expressão tail [10] casa com o padrão para lista vazia []. 47/104

48 Casamento de padrão com listas (cont.) Exemplo: A expressão case [10,20,30,40] of [] -> "lista vazia" x:xs -> "cabeca: " ++ show x ++ " cauda: " ++ show xs resulta em "cabeca: 10 cauda: [20,30,40]", pois a lista [10,20,30,40] casa com o padrão para lista não vazia x:xs, associando x com 10 e xs com [20,30,40]. 48/104

49 Casamento de padrão com listas (cont.) Exemplo: A expressão case [10..20] of x:y:z:_ -> x + y + z _ -> 0 resulta em 33, pois a lista [10..20] casa com o padrão x:y:z:_, associando x com 10, y com 11 e z com /104

50 Casamento de padrão com listas (cont.) Exemplo: A expressão case [10,20] of x:y:z:_ -> x + y + z _ -> 0 resulta em 0, pois a lista [10,20] não casa com o primeiro padrão x:y:z:_, mas casa com o segundo _. Observe que o primeiro padrão casa somente com listas que tenham pelo menos três elementos. 50/104

51 Casamento de padrão com listas (cont.) Exemplo: A expressão case [10,20,30] of [x1,_,x3] -> x1 + x3 _ -> 0 resulta em 40, pois a lista [10,20,30] casa com o primeiro padrão [x1,_,x3]. Observe que este padrão casa somente com listas que tenham exatamente três elementos. 51/104

52 Casamento de padrão com listas (cont.) Exemplo: A expressão case [100,20,3] of a:b:xs a > b -> b:a:xs xs a = b -> a:xs -> xs resulta em [20,100,3], pois a lista [100,20,3] casa com o primeiro padrão a:b:xs e o primeiro elemento é maior do que o segundo. 52/104

53 Exercícios Exercício 2 Defina uma função usando casamento de padrão que retorna o sucessor do primeiro elemento de uma lista, se houver, e zero caso contrário. Exercício 3 Usando casamento de padrão, defina uma função que retorna a soma dos dois primeiros elementos de uma lista se a lista tiver pelo menos dois elementos, a cabeça da lista se ela contiver apenas um elemento, e zero caso contrário. Exercício 4 Resolva os exercícios 2 e 3 usando funções da biblioteca ao invés de casamento de padrão. 53/104

55 Operações com listas As listas são muito importantes na programação funcional. Serão apresentadas as operações principais com listas. 55/104

57 Operações com listas: null null retorna True se o seu argumento é a lista vazia ([]) e False caso contrário. Exemplos: null [] True null [1,2,3,4,5] False null "" True null "FIM" False null :: [a] -> Bool null [] = True null _ = False 57/104

59 Operações com listas: head head seleciona o primeiro elemento de uma lista não vazia. Exemplos: head [10,20,30,40,50] 10 head "FIM" F head [] erro head "" erro head :: [a] -> a head (x:_) = x 59/104

60 Operações com listas: tail tail seleciona a cauda de uma lista não vazia, isto é, todos os elementos exceto o primeiro. Exemplos: tail [10,20,30,40,50] [20,30,40,50] tail "Aroma" "roma" tail [] erro tail "" erro tail :: [a] -> a tail (_:xs) = xs 60/104

61 Operações com listas: init init seleciona todos os elementos de uma lista não vazia, exceto o último elemento. Exemplos: init [15] [] init [True,False] [True] init [1,2,3,4,5] [1,2,3,4] init "Brasil" "Brasi" init [] erro init :: [a] -> [a] init [_] = [] init (x:xs) = x : init xs 61/104

62 Operações com listas: last last seleciona o último elemento de uma lista não vazia. Exemplos: last [15] 15 last [True,False] False last [1,2,3,4,5] 5 last "Brasil" l last [] erro last :: [a] -> a last [x] = x last (_:xs) = last xs 62/104

64 Operações com listas: elem elem recebe um valor e uma lista e retorna True se e somente se o valor é um elemento da lista. Exemplos: elem 5 [] False elem 5 [5] True elem 5 [4,5] True elem d "Pedro" True 8 elem [2,4,6,8,10] True # elem "Pedro" False infixl 4 elem elem :: Eq a => a -> [a] -> Bool elem _ [] = False elem x (y:ys) = x == y elem x ys 64/104

66 Operações com listas: length length retorna o número de elementos de uma lista finita. Exemplos: length [] 0 length [15] 1 length [div 2 0, mod 3 0] 2 length [1,2,3,4,5] 5 length "Brasil" 6 length :: [a] -> Int length [] = 0 length (_:xs) = 1 + length xs 66/104

67 Operações com listas: (!!) (!!) recebe uma lista e um número inteiro e retorna o elemento da lista cuja posição é dada pelo número. A posição do primeiro elemento é zero. A posição do último elemento é o tamanho da lista menos um. Se a posição for inválida ocorre um erro. Exemplos: [1,2,3,4,5]!! 0 1 [1,2,3,4,5]!! 1 2 "Brasil"!! 3 s [35,46]!! 8 erro [35,46]!! (-2) erro infixl 9!! (!!) :: [a] -> Int -> a (x:_)!! 0 = x (_:xs)!! n = xs!! (n-1) 67/104

69 Operações com listas: take take recebe um número inteiro n e uma lista xs e retorna o prefixo de tamanho n da lista xs. Exemplos: take take 5 "Hello World!" "Hello" take 3 [1,2,3,4,5] [1,2,3] take 3 [1,2] [1,2] take 3 [] [] take (-9) [1,2] [] take 0 [1,2] [] take n _ n <= 0 = [] take _ [] = [] take n (x:xs) :: Int -> [a] -> [a] = x : take (n-1) xs 69/104

70 Operações com listas: drop drop recebe um número inteiro n e uma lista xs e retorna o sufixo da lista xs após os n primeiros elementos. Exemplos: drop drop 6 "Hello World!" "World!" drop 3 [1,2,3,4,5] [4,5] drop 3 [1,2] [] drop 3 [] [] drop (-9) [1,2] [1,2] drop 0 [1,2] [1,2] drop n xs n <= 0 = xs drop _ [] = [] drop n (_:xs) :: Int -> [a] -> [a] = drop (n-1) xs 70/104

71 Operações com listas: splitat splitat recebe um número inteiro n e uma lista xs e retorna um par onde o primeiro elemento é um prefixo de tamanho n de xs e o segundo elemento é o resto da lista. Exemplos: splitat 6 "Hello World!" ("Hello ","World!") splitat 3 [1,2,3,4,5] ([1,2,3],[4,5]) splitat 1 [1,2,3] ([1],[2,3]) splitat 3 [1,2,3] ([1,2,3],[]) splitat 4 [1,2,3] ([1,2,3],[]) splitat 0 [1,2,3] ([],[1,2,3]) splitat (-9) [1,2,3] ([],[1,2,3]) 71/104

72 Operações com listas: splitat (cont.) splitat :: Int -> [a] -> ([a],[a]) splitat n xs n <= 0 = ([],xs) splitat _ [] = ([],[]) splitat n (x:xs) = (x:xs,xs ) where (xs,xs ) = splitat (n-1) xs 72/104

74 Operações com listas: (++) (++) concatena duas listas. Exemplos: [] ++ [20,10] [20,10] [4] ++ [20,10] [4,20,10] [1,2,3,4,5] ++ [20,10] [1,2,3,4,5,20,10] "ana" ++ " carolina" "ana carolina" [(10,True),(5,False)] ++ [] [(10,True),(5,False)] [1,2] ++ [] ++ [1] ++ [0,3] [1,2,1,0,3] infixr 5 ++ (++) :: [a] -> [a] -> [a] [] ++ ys = ys (x:xs) ++ ys = x : (xs ++ ys) 74/104

75 Operações com listas: concat concat aplicada a uma lista de listas, concatena as listas em uma única lista Exemplos: concat [] [] concat [[1,2,3]] [1,2,3] concat [[1,2,3], [4]] [1,2,3,4] concat [[1,2,3], [4], [], [5,6,7,8]] [1,2,3,4,5,6,7,8] concat ["we"," ","like"," ","lists"] "we like lists" concat :: [[a]] -> [a] concat [] = [] concat (xs:xss) = xs ++ concat xss 75/104

77 Operações com listas: reverse reverse recebe uma lista finita e retorna uma lista com os mesmos elementos, porém em ordem reversa. Exemplos: reverse reverse [] [] reverse [1] [1] reverse [1,2] [2,1] reverse [1,2,3] [3,2,1] reverse [1,2,3,4,5] [5,4,3,2,1] reverse "ROMA" "AMOR" reverse [] = [] :: [a] -> [a] reverse (x:xs) = reverse xs ++ [x] 77/104

79 Operações com listas: zip zip recebe duas listas e retorna a lista dos pares formados pelos elementos correspondentes da primeira e da segunda lista. Se as listas forem de tamanhos diferentes, o tamanho do resultado é o menor tamanho. Exemplos: zip [] [] [] zip [1,2,3] [] [] zip [] [1,2,3] [] zip [True] [1] [(True,1)] zip [1,2] ["ana","pedro"] [(1,"ana"),(2,"pedro")] zip [1,2,3] "ABC" [(1, A ),(2, B ),(3, C )] zip [1,2,3,4,5] [0.5,0.6] [(1,0.5),(2,0.6)] zip [1,2,3] "BRASIL" [(1, B ),(2, R ),(3, A )] zip :: [a] -> [b] -> [(a, b)] zip (x:xs) (y:ys) = (x,y) : zip xs ys zip = [] 79/104

80 Operações com listas: zipwith zipwith recebe uma função binária e duas listas e retorna a lista formada pelos resultados da aplicação da função aos elementos correspondentes da listas dadas. Se as listas forem de tamanhos diferentes, o tamanho do resultado é o menor tamanho. Exemplos: zipwith zipwith (+) [] [] [] zipwith (+) [1,2,3,4,5] [3,3,4,1,5] [4,5,7,5,10] zipwith (++) ["AB","cde"] ["?","123"] ["AB?","cd123"] zipwith (^) [5,6,7,8] [2,3,4,5] [25,216,2401,32768] zipwith (*) [5,6,7,8] [2,3] [10,18] :: (a -> b -> c) -> [a] -> [b] -> [c] zipwith f (x:xs) (y:ys) = f x y : zipwith f xs ys zipwith _ = [] 80/104

82 Operações com listas: map map recebe uma função e uma lista e retorna a lista formada pela aplicação da função em cada elemento da lista dada. Exemplos: map map sqrt [0,1,4,9] [0.0,1.0,2.0,3.0] map succ "HAL" "IBM" map head ["bom","dia","turma"] "bdt" map (<3) [1,2,3] [True,True,False] map (+2) [2,5,6,0] [4,7,8,2] map (\x -> 2*x+1) [2,5,6,0] [5,11,13,1] map _ [] = [] :: (a -> b) -> [a] -> [b] map f (x:xs) = f x : map f xs 82/104

83 Operações com listas: filter filter recebe uma função f e uma lista xs e retorna a lista formada pelos elementos de xs para os quais a função f retorna True. Exemplos: filter filter even [0,1,4,9,10,11,15] [0,4,10] filter (<10) [0,1,4,9,10,11,15] [0,1,4,9] filter (not. null) ["abc","","d"] ["abc","d"] filter _ [] = [] filter f (x:xs) :: (a -> Bool) -> [a] -> [a] f x = x : filter f xs otherwise = filter f xs 83/104

85 Operações com listas: foldl foldl reduz uma lista, usando uma função binária e um valor inicial, de forma associativa à esquerda. foldl ( ) e [x 0,x 1,...,x n 1 ] (...((e x 0 ) x 1 )...) x n 1 Exemplos: foldl (+) 0 [] 0 foldl (+) 0 [1] 1 foldl (+) 0 [1,2] 3 foldl (+) 0 [1,2,4] 7 foldl (*) 1 [5,2,4,10] 400 foldl (&&) True [2>0,even 6,odd 5,null []] True foldl ( ) False [2>3,even 6,odd 5,null []] True foldl (\a x -> 2*a+x) 0 [1,2,3,4,5] 57 85/104

86 Operações com listas: foldl (cont.) foldl :: (a -> b -> a) -> a -> [b] -> a foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs 86/104

87 Operações com listas: foldr foldr reduz uma lista, usando uma função binária e um valor inicial, de forma associativa à direita. foldr ( ) e [x 0,...,x n 2,x n 1 ] x 0 (... (x n 2 (x n 1 e))...) Exemplos: foldr (+) 0 [] 0 foldr (+) 0 [1] 1 foldr (+) 0 [1,2] 3 foldr (+) 0 [1,2,4] 7 foldr (*) 1 [5,2,4,10] 400 foldr (&&) True [2>0,even 6,odd 5,null []] True foldr ( ) False [2>3,even 6,odd 5,null []] True foldr (\x a -> 2*a+x) 0 [1,2,3,4,5] /104

88 Operações com listas: foldr (cont.) foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) 88/104

89 Operações com listas: foldl1 foldl1 reduz uma lista não vazia usando uma função binária, de forma associativa à esquerda. foldl1 é uma variante de foldl que não tem valor inicial, e portanto deve ser aplicada a listas não-vazias. Exemplos: foldl1 foldl1 (+) [] erro foldl1 (+) [1] 1 foldl1 (+) [1,2,4] 7 foldl1 (*) [5,2,4,10] 400 foldl1 (&&) [2>0,even 6,odd 5,null []] True foldl1 max [1,8,6,10,-48,5] 10 :: (a -> a -> a) -> [a] -> a foldl1 f (x:xs) = foldl f x xs 89/104

90 Operações com listas: foldr1 foldr1 reduz uma lista não vazia usando uma função binária, de forma associativa à esquerda. foldr1 é uma variante de foldr que não tem valor inicial, e portanto deve ser aplicada a listas não-vazias. Exemplos: foldr1 foldr1 (+) [] erro foldr1 (+) [1] 1 foldr1 (+) [1,2,4] 7 foldr1 (*) [5,2,4,10] 400 foldr1 (&&) [2>0,even 6,odd 5,null []] True foldr1 max [1,8,6,10,-48,5] 10 foldr1 _ [x] :: (a -> a -> a) -> [a] -> a = x foldr1 f (x:xs) = f x (foldr1 f xs) 90/104

91 Exercícios Exercício 5 Defina a função recursiva product :: Num a => [a] -> a que retorna o produto de uma lista de números. Exercício 6 Defina as funções recursivas and :: [Bool] -> Bool or :: [Bool] -> Bool que retornam respectivamente a conjunção e a disjunção de uma lista de valoresl lógicos. 91/104

93 List comprehension Em Matemática, a notação de compreensão pode ser usada para construir novos conjuntos a partir de conjuntos já conhecidos. Exemplo: {x 2 x [1...5]} é o conjunto {1,4,9,16,25} de todos os números x 2 tal que x é um elemento do conjunto {1,2,3,4,5}. 93/104

94 List comprehension (cont.) Em Haskell também há uma notação de compreensão similar que pode ser usada para construir novas listas a partir de listas conhecidas. Exemplo: [ x^2 x <- [1..5] ] é a lista [1,4,9,16,25] de tdos os números x^2 tal que x é um elmento da lista [1,2,3,4,5]. 94/104

95 List comprehension (cont.) A expressão x <- [1..5] é chamada gerador, já que ela informa como gerar valores para a variável x. Compreensões podem ter múltiplos geradores, separados por vírgula. Exemplo: [(x,y) x <- [1,2,3], y <- [4,5]] [(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)] 95/104

96 List comprehension (cont.) Se a ordem dos geradores for trocada, a ordem dos elementos na lista resultante também é trocada. Exemplo: [(x,y) y <- [4,5], x <- [1,2,3]] [(1,4),(2,4),(3,4),(1,5),(2,5),(3,5)] 96/104

97 List comprehension (cont.) Geradores múltiplos são semelhantes a loops aninhados: os últimos geradores são como loops mais profundamente aninhados cujas variáveis mudam mais freqüentemente. Exemplo: [(x,y) y <- [4,5], x <- [1,2,3]] [(1,4),(2,4),(3,4),(1,5),(2,5),(3,5)] Como x <- [1,2,3] é o último gerador, o valor do componente x de cada par muda mais frequentemente. 97/104

98 List comprehension (cont.) Geradores posteriores podem depender de variáveis introduzidas em geradores anteriores. Exemplo: [(x,y) x <- [1..3], y <- [x..3]] [(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)] a lista [(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)] de todos os pares de números (x,y) tal que x e y são elementos da lista [1..3] e y >= x. 98/104

99 List comprehension (cont.) Exemplo: Usando geradores dependentes pode-se definir a função que concatena uma lista de listas: concat :: [[a]] -> [a] concat xss = [x xs <- xss, x <- xs] concat [[1,2,3],[4,5],[6]] [1,2,3,4,5,6] 99/104

100 List comprehension (cont.) List comprehensions podem usar guardas para restringir os valores produzidos por geradores anteriores. Exemplo: [x x <- [1..10], even x] [2,4,6,8,10] a lista de todos os números x tal que x é um elemento da lista [1..10] e x é par. 100/104

101 List comprehension (cont.) Exemplo: Usando uma guarda podemos definir uma função que mapeia um número inteiro positivo à sua lista de fatores: factors :: Int -> [Int] factors n = [x x <- [1..n], n mod x == 0] Exemplos de aplicação da função: factors 15 [1,3,5,15] factors 120 [1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120] 101/104

102 List comprehension (cont.) Exemplo: Um número inteiro positivo é primo se seus únicos fatores são 1 e ele próprio. Assim, usando fatores que podemos definir uma função que decide se um número é primo: prime :: Int -> Bool prime n = factors n == [1,n] Exemplos de aplicação da função: prime 15 False prime 7 True 102/104

103 List comprehension (cont.) Exemplo: Usando um guarda agora podemos definir uma função que retorna a lista de todos os números primos até um determinado limite: primes :: Int -> [Int] primes n = [x x <- [2..n], prime x] Exemplos de aplicação da função: primes 40 [2,3,5,7,11,13,17,19,23,29,31,37] primes 12 [2,3,5,7,11] 103/104

104 Fim 104/104