Haskell é uma linguagem de programação funcional pura. Programas em Haskell são funções que avaliam expressões para produzir valores. Haskell tem tipagem estática forte, suporte a abstrações poderosas como funções de alta ordem, e avaliação preguiçosa.

1. Haskell Seminário de Linguagens de Programação GUILHERME GOMES NEVES DE OLIVEIRA RENZO AUGUSTO LAPELLIGRINI PETRI

7. Histórico 1930: Alonzo Church desenvolveu o cálculo de lambda , um simples, mas poderoso teorema de funções.

8. Histórico 1950: John McCarthy desenvolveu Lisp , a primeira linguagem funcional, com influência da teoria de lambda mas aceitando atribuições de variáveis.

9. Histórico 1970: Robin Milner e outros desenvolveram a ML , a primeira linguagem funcional moderna, com introdução de inferência de tipos e tipos polimórficos.

10. Histórico 1987:

13. Histórico

14. 2003: O comitê publicou Haskell 98 , definindo uma versão estável da linguagem. Histórico

15. Influência Haskell foi fortemente influenciada por ML Algol 60 Algol 68 ML Modula Pascal Haskell Lisp

16. Atualmente

17. Nova vida ? Usuários 1,000,000 1 100 10,000 1990 1995 2000 2005 2010

20. Arquitetura IDE Haskell (Kernel) Haskell Service (Modules) Interface Link Direto GHC (Compilador)

35. Quem usa ? Microprocessor verification

36. Estrutura Léxica e Sintática

37. Module

38. Export

39. Definitions

40. Declaration Functions

41. Decls

42. Expression

43. Expr

44. Patroon

45. Type Typ

46. Context Classe

47. Literal Char

48. Var e outros

49. Simbols

51. Sintaxe

53. Equivalência Matematicamente Haskell f(x) f(x,y) f(g(x)) f(x,g(y)) f(x)g(y) f x f x y f (g x) f x (g y) f x * g y

56. Regras de Layout a = 10 b = 20 c = 30 a = 10 b = 20 c = 30 a = 10 b = 20 c = 30

57. a = b + c where b = 1 c = 2 d = a * 2 a = b + c where {b = 1; c = 2} d = a * 2 Implícito Explícito Regras de Layout =

58. O que é um TIPO? Um tipo é um nome para uma coleção de valores relacionados (propriedades em comum) Por exemplo, em Haskell , um tipo básico é: True Bool False

60. Tipos Básicos Bool True, False Char 'a', 'x', '34', '' String “oi”, “Sim” Int 0, 94, -45 Float 3.0, 0.54422 Double 3.1415 Bool - Valores Lógicos Char - Caracteres simples Integer - Inteiros de precisão arbitrária Float - Números de ponto flutuante String - String de caracteres Int - Inteiros de precisão fixa

61. Operadores Básicos > maior >= maior ou igual == igual /= diferente < menor <= menor ou igual + Soma - Subtração * Multiplicação ^ Potência div Divisão inteira mod resto da divisão abs valor absoluto de um inteiro negate troca o sinal do valor && e | | ou not negação

62. Tipo Lista Em geral: Uma lista é uma sequência de valores do mesmo tipo : [t] é um tipo de litsta com elementos do tipo t . [1,2,3,4] :: [Int] [False,True,False] :: [Bool] [‘a’,’b’,’e’] :: [Char]

64. Operação com Listas length ghci> length [5,4,3,2,1] 5 reverse ghci> reverse [5,4,3,2,1] [1,2,3,4,5] elem ghci> 4 `elem` [3,4,5,6] True ghci> 10 `elem` [3,4,5,6] False Retorna o comprimento da lista. Inverte os elementos da lista. Verifica se um elemento está presente na lista.

65. Operação com Listas ghci> [1..20] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] ghci> ['a'..'z'] &quot;abcdefghijklmnopqrstuvwxyz“ ghci> ['K'..'Z'] &quot;KLMNOPQRSTUVWXYZ&quot; Selecionando intervalo de elementos em listas.

70. Criando Funções É possível também chamar funções dentro de funções. doubleUs y = x *2 + y *2 ghci> doubleUs 4 9 26 ghci> doubleUs 2,3 34,2 73,0 ghci> doubleUs 28 88 + doubleMe 123 478 Sendo assim é possível redefinir uma função. doubleUs x y = doubleMe x + y doubleMe

73. Verificação de Tipos Tanto os compiladores quanto os interpretadores Haskell implementam o mecanismo de checagem forte de tipos de dados , devido a tamanha variedade de tipos. Monomórfico Polimórfico

76. Verificação de Tipos- Polimórficos Para realizar a verificação de tipos em funções polimórficas, o Haskell lança mão do conceito de unificação . Assim como em linguagens lógicas, uma unificação ocorre quando o analisador de expressões do compilador/interpretador consegue determinar quais variáveis assumirão um determinado argumento genérico, e também de qual tipo dedado será este argumento.

78. Exemplos

79. Main

80. Declaração Os símbolos “—” “{- -}” comentários. Declara uma nova função, especificando seu tipo. O símbolo :: pode ser lido como “é do tipo...&quot; Determina que valor tem o valor 35. Determina que square é uma função de Int para Int . Equação que define a função. Define o resultado, x*x , da aplicação de square sobre x (argumento). Nomes de funções começam com letras minúsculas. Nomes de tipos começam com letras maiúsculas. 1 {----------------------------} 2 -- example.hs 3 ---------------------------- 4 valor :: Int 5 valor = 35 6 7 square :: Int -> Int 8 square x = x * x 9

84. Quick Sort em Haskell Se a lista é vazia, não há nada a ordenar . s é o 1 o elemento da lista que é utilizado com pivo. xs representa o restante da lista. A lista restante é dividida em 2 partes: a primeira contém apenas os elementos de xs que são menores ou igual a s. A segunda, contém apenas os elementos de xs que são maiores. As duas listas são ordenadas recursivamente e o resultado é obtido concatenando a primeira lista (ordenada), com a lista que contém s e a segunda lista (ordenada.) qsort [] = [] qsort ( s : xs ) = qsort [ x | x <- xs , x < s] ++ [s] ++ qsort [ x|x <- xs, x >= s ]

85. Interação Para escrever programas interativos que leem dados a partir do teclado e escrevem na tela, são necessários: IO Programas interativos podem ser escritos em Haskell usando tipos que podem envolver efeitos colaterais - IO . interactive program inputs outputs keyboard screen

94. GHC : Storage Manager

101. Layout da pilha O SRT = Campo de ponteiro para a tabela de referência estático (SRT);

108. Garbage Collection - Estruturas

109. Garbage Collection - Estruturas

110. Espaço das Classes Normal Overlap Closed Local Normal Global Implicit Parameters Haskell GHC Methods Dependência local

112. Fluxograma Coerção

114. verification : bytecode :: typechecking : source code YHC

115. YHC

120. Comparação

124. Curiosidades

130. Dúvidas