Docsity
Docsity

Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity


Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium


Guias e Dicas
Guias e Dicas

Introdução à Programação Funcional em Haskell, Notas de estudo de Análise de Sistemas de Engenharia

Aprenda as principais ideias da programação funcional usando haskell. Saiba as diferenças entre programação imperativa e funcional, definições rápidas, vantagens, por quê escolher haskell e mais. Inclui um tour da linguagem e ferramentas, exemplos de uso e orientações para começar a aprender.

Tipologia: Notas de estudo

2010

Compartilhado em 27/01/2010

ednaldo-miranda-6
ednaldo-miranda-6 🇧🇷

4

(1)

38 documentos

1 / 34

Toggle sidebar

Esta página não é visível na pré-visualização

Não perca as partes importantes!

bg1
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e
pf1f
pf20
pf21
pf22

Pré-visualização parcial do texto

Baixe Introdução à Programação Funcional em Haskell e outras Notas de estudo em PDF para Análise de Sistemas de Engenharia, somente na Docsity!

Data: 04/06/

Programação Funcional Programação Funcional

e a linguagem Haskell e a linguagem Haskell

João Paulo Pizani Flor joaopizani@inf.ufsc.br

Tópicos

  • Definição relâmpago
  • Programação Imperativa vs. Funcional
  • Conceitos fundamentais
  • Conseqüências (boas e “ruins”)
  • Por quê Haskell?
  • Tour da linguagem e ferramentas
  • Exemplos de uso
  • Por onde começar a aprender

Imperativa x Funcional

Recapitulando Prog. Imperativa

  • Na programação imperativa: - Variável →Célula de memória - Statement →Transição de estado - Estruturas de controle →Instruções “test and jump”

Já em Programação Funcional...

  • Não existe a noção de estado
    • Não existe comando de atribuição
    • Não existem variáveis!
  • Cada função é definida como a composição e aplicação de outras funções (ou da própria)

O que é ProgramaçãoO que é Programação

Funcional? Funcional?

Transparência Referencial

  • Duas condições bem simples:
    • O único efeito de chamar uma função é o seu valor de retorno
    • Os únicos fatores que podem influenciar o valor de uma função são seus parâmetros.
  • Def. alternativa: “Like can be replaced by like”

Quem garante?

  • Em linguagens convencionais → Programador
  • Em linguagens funcionais →Compilador
  • É dessa garantia/obrigação que vêm todas as vantagens de performance - E também as “bizarrices” no jeito de programar

Vantagens

  • Compilador pode aplicar várias otimizações
    • Common Subexpression Elimination
    • Avaliação preguiçosa
    • Paralelização automática tam = length([3,2,7,0/0]) //não ocorre erro e tam vale 4 res1 = operacaoBemLonga1(s1) // não tem efeitos colaterais! res2 = operacaoBemLonga2(s2) // também é transparente print(res1+res2)

Para o programador

  • Programas são mais legíveis
    • Código fica mais conciso (exemplo: quicksort)
    • Não é preciso executar mentalmente para entender
  • Gerenciamento automático de memória
    • “No more SIGSEGV's”!
  • Facilidade em encapsular abstrações
    • Map, reduce (fold), compose e cia.

Haskell

Por quê Haskell?

  • Puramente funcional
  • Fortemente e estaticamente tipada
  • Avaliação preguiçosa (lazy evaluation)
  • Classes de tipos
  • MUITAS bibliotecas úteis
  • Comunidade bastante ativa

Avaliação preguiçosa

  • “Uma expressão só será avaliada quando seu valor for necessário.”
  • Exemplos: isInfixOf :: Eq a => [a] -> [a] -> Bool isInfixOf x y = any (isPrefixOf x) (tails y) // incrivelmente ineficiente em uma ling. imperativa g ← getStdGen take 3 (randomRs (0,100) g) // lista infinita de randoms

Classes de tipos

  • Permitem que funções tomem parâmetros de tipos genéricos - Similar ao generics de Java / templates de C++ - Há diferenças...
  • Têm semelhanças com interfaces Java
  • Exemplo: class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool x == y = not (x /= y) x /= y = not (x == y) head :: (Eq a) => [a] → a head (x:xs) = x