P funcional
Transferir como DOCX, PDF0 gostou182 visualizações
O documento introduz o paradigma funcional de programação, descrevendo suas características principais como tratamento da computação como avaliação de funções matemáticas e evitação de estado mutável. Explica a história do paradigma funcional e fornece exemplos de código funcional em Haskell, incluindo funções como soma de lista e quicksort.
![3
Exemplos de Haskell
Apesar de existirem várias funções pré-definidas em Haskell, a grande ideia da
programação funcional é que o programador defina as suas próprias funções. As
funções do usuário são definidas em scripts e contém definições associando nomes
com valores e tipos. Também existem comentários que facilitam uma leitura
posterior. Tudo o que for escrito depois de dois travessões (--) é considerado
comentário e não é interpretado. Segue um exemplo de script:
- -
- - exemplo.hs
- - Neste script apresentam-se algumas definições simples
- -
idade :: Int -- Um valor inteiro constante
idade = 17
maiorDeIdade :: Bool -- Usa a definição de idade
maiorDeIdade = (idade>=18)
quadrado :: Int -> Int -- função que eleva um número ao quadrado
quadrado x = x * x
Haskell> maiorDeIdade quadrado idade
True
Na maioria das definições sobre listas irá se usar a recursão para se percorrer todos
os elementos. Uma função simples seria a função para somar todos os elementos
de uma lista de números inteiros:
somaLista :: [Int] -> Int
somaLista [] = 0
somaLista (a:x) = a + somaLista x
Haskell> somaLista [1,2,3,4,5]
15
A variável “a” é o início da lista (chamado de head) enquanto o x é o resto da lista
(chamado de tail).
O comando é avaliado da seguinte maneira:
somaLista [1, 2, 3, 4, 5]
= 1 + somaLista [2, 3, 4, 5]
= 1 + ( 2 + somaLista [3, 4, 5])
= 1 + (2 + ( 3 + somaLista [4, 5]))
= 1 + (2 + ( 3 + ( 4 + somaLista [5])))
= 1 + (2 + ( 3 + ( 4 + ( 5 + somaLista [] ))))
= 1 + (2 + ( 3 + ( 4 + ( 5 + 0 ))))
= 15
Apesar de Haskell ser muito utilizado como funções matemáticas, também pode ser
usado para decisões, e input e output de dados, como no exemplo abaixo:
module Main where](https://image.slidesharecdn.com/pfuncional-130525201157-phpapp01/85/P-funcional-5-320.jpg)
![4
factorial n = if n == 0
then 1
else n * factorial (n - 1)
main = do putStrLn "Quanto e 5! ?"
x <- readLn
if x == factorial 5
then putStrLn "Voce acertou!"
else putStrLn "Voce errou!"
Planilhas e SQL são ambos linguagens razoavelmente especializadas. Linguagens
de programação funcional seguem as mesmas idéias das linguagens de propósito
geral. Para se ter uma idéia de como é uma linguagem de programação funcional,
vamos olhar os seguintes programas quicksort. Ambos ordenam uma sequência de
números em ordem ascendente usando um método padrão chamado "quicksort". O
primeiro programa é escrito em Haskell e o segundo em C.
Considerando que o programa C descreve os todos os passos de como a máquina
deve fazer para realizar a ordenação - a maior parte código lida com os detalhes de
baixo nível da manipulação de dados - o programa Haskell codifica o algoritmo de
ordenação em um nível muito mais alto, melhorando a velocidade e clareza do
resultado.
Quicksort em Haskell
qsort [] = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)
Quicksort em C
void qsort(int a[], int lo, int hi) {
{
int h, l, p, t;
if (lo < hi) {
l = lo;
h = hi;
p = a[hi];
do {
while ((l < h) && (a[l] <= p))
l = l+1;
while ((h > l) && (a[h] >= p))
h = h-1;
if (l < h) {
t = a[l];
a[l] = a[h];
a[h] = t;
}
} while (l < h);
t = a[l];
a[l] = a[hi];](https://image.slidesharecdn.com/pfuncional-130525201157-phpapp01/85/P-funcional-6-320.jpg)
![5
a[hi] = t;
qsort( a, lo, l-1 );
qsort( a, l+1, hi );
}
}
No exemplo em Haskell, A primeira linha lê-se: "Quando você classifica uma lista
vazia ( [] ), o resultado é uma outra lista vazia".
A segunda linha diz: "Para ordenar uma lista cujo primeiro elemento é chamado x e
o resto do que é chamado xs, classificar os elementos de xs, que são menos de x,
classificar os elementos de xs , que são iguais ou superiores a x , e concatenar ( +
+ ) os resultados, com x “colada no meio”.](https://image.slidesharecdn.com/pfuncional-130525201157-phpapp01/85/P-funcional-7-320.jpg)
P funcional
- 1. Paradigma funcional PARADIGMAS DE ANÁLISE E DESENVOLVIMENTO Graduação em Sistemas de Informação Carla Caroline Diego Ventura Pedro Soares Rafael Pablo Raphael Mathias Renato Mendes Rio de Janeiro, 21 de agosto de 2012
- 2. SUMÁRIO 1. INTRODUÇÃO ..................................................................................... ERROR! BOOKMARK NOT DEFINED. 1.1 HISTÓRIA........................................................................................................ ERROR! BOOKMARK NOT DEFINED. 1.2 DEFINIÇÃO DE LINGUAGEM DE PROGRAMAÇÃO...................................................... ERROR! BOOKMARK NOT DEFINED. 2. CARACTERÍSTICAS DAS LINGUAGENS DE PROGRAMAÇÃO.................. ERROR! BOOKMARK NOT DEFINED. 2.1 LINGUAGENS DE ALTO E BAIXO NÍVEL................................................................... ERROR! BOOKMARK NOT DEFINED. 2.1.1 Baixo Nível .........................................................................................Error! Bookmark not defined. 2.1.2 Alto Nível ...........................................................................................Error! Bookmark not defined. 2.2 LINGUAGENS NÃO ESTRUTURADAS...................................................................... ERROR! BOOKMARK NOT DEFINED. 2.3 LINGUAGENS ESPECÍFICAS DE APLICAÇÕES............................................................. ERROR! BOOKMARK NOT DEFINED. 2.3.1 Linguagem de Script ..........................................................................Error! Bookmark not defined. 2.3.2 Linguagens Visuais.............................................................................Error! Bookmark not defined. 2.3.3 Linguagens de Formatação de Texto.................................................Error! Bookmark not defined. 2.3.4 Linguagens para Simulação...............................................................Error! Bookmark not defined. 2.3.5 Linguagens para Banco de Dados.....................................................Error! Bookmark not defined. 2.4 LINGUAGENS PROCEDURAIS ............................................................................... ERROR! BOOKMARK NOT DEFINED. 2.5 LINGUAGENS FUNCIONAIS.................................................................................. ERROR! BOOKMARK NOT DEFINED. 2.6 LINGUAGENS ORIENTADAS A OBJETO ................................................................... ERROR! BOOKMARK NOT DEFINED. 3. EVOLUÇÃO DAS LINGUAGENS DE PROGRAMAÇÃO............................. ERROR! BOOKMARK NOT DEFINED. 3.1 POR QUE ESTUDAR A EVOLUÇÃO DAS LINGUAGENS DE PROGRAMAÇÃO?...................... ERROR! BOOKMARK NOT DEFINED. 3.2 ALGUMAS CURIOSIDADES SOBRE A ORIGEM DA LINGUAGEM DE PROGRAMAÇÃO........... ERROR! BOOKMARK NOT DEFINED. 3.2.1 O Tear de Jacquard............................................................................Error! Bookmark not defined. 3.2.2 Ada Lovelace......................................................................................Error! Bookmark not defined. 3.2.3 Cartões Perfurados ............................................................................Error! Bookmark not defined. 3.3 HISTÓRICO DAS PRINCIPAIS LINGUAGENS DE PROGRAMAÇÃO.................................... ERROR! BOOKMARK NOT DEFINED. 3.3.1 Programação Estruturada .................................................................Error! Bookmark not defined. 3.3.2 Modularização...................................................................................Error! Bookmark not defined. 3.3.3 Programação Orientada a Objeto .....................................................Error! Bookmark not defined. 4. O QUE SÃO PARADIGMAS DE PROGRAMAÇÃO?................................. ERROR! BOOKMARK NOT DEFINED. 4.1 PARADIGMA IMPERATIVO .................................................................................. ERROR! BOOKMARK NOT DEFINED. 4.2 PARADIGMA FUNCIONAL ................................................................................... ERROR! BOOKMARK NOT DEFINED. 4.3 PARADIGMA LÓGICO......................................................................................... ERROR! BOOKMARK NOT DEFINED. 4.4 PARADIGMA ESTRUTURADO ............................................................................... ERROR! BOOKMARK NOT DEFINED. 4.5 PARADIGMA ORIENTADO A OBJETOS ................................................................... ERROR! BOOKMARK NOT DEFINED. 5. BIBLIOGRAFIA......................................................................................................................................... 6
- 3. 1 Introdução ao paradigma funcional Programação funcional é um paradigma que trata a computação como uma avaliação de funções matemáticas e que evita estado ou dados mutáveis. Ela enfatiza a aplicação de funções, em contraste da programação imperativa, que enfatiza mudanças no estado do programa. Uma função, neste sentido, pode ter ou não ter parâmetros e um simples valor de retorno. Os parâmetros são os valores de entrada da função, e o valor de retorno é o resultado da função. A definição de uma função descreve como a função será avaliada em termos de outras funções. Histórico do paradigma funcional 1970 - Robin Milner desenvolve o ML, a primeira linguagem funcional com polimorfismo e inferência de tipos. 1987 – Um comité académico inicia o desenvolvimento do Haskell, uma linguagem funcional Lazy padronizada e aberta. 2003 – Publicação do Haskell 98, uma definição padronizada da linguagem. 2010 – Publicação do padrão da linguagem Haskell 2010.
- 4. 2 Programação Funcional X Programação Imperativa As linguagens que seguem o Paradigma Imperativo se baseiam diretamente no modelo Von Neumann ( Arquitetra de computador que contém: Memória, CPU, Unidade de Controle, Unidade Lógica e aritmética e registradores.) tornando assim um tanto trabalhosa, trazendo a preocupação com a arquitetura da máquina para o programador, porém consegue-se programas que executam com muita eficiência.Na programação imperativa o sistema recebe uma sequencia de ordens chamadas comandos ou instruções que devem ser executadas, assim como em uma receita de bolo. Nas linguagens que seguem o paradigma puramente funcional não há declaração explícita de variáveis nem alocação explícita de memória. Na programação Funcional são definidas funções como as matemáticas e os programas nascem da interação entre as funções. O resultado de uma função é passado como parâmetro para outras. Resultado disso muito menos esforço despendido em programação, mas também programas muito menos eficientes. As linguagens funcionais têm uma estrutura sintática muito simples, contrastando com a estrutura sintática complexa que normalmente são encontradas nas linguagens que seguem o Paradigma Imperativo de programação. Vantagens O paradigma funcional tem como característica principal a eficiência para cálculo recursivo, porém não tem só essa vantagem, a grande flexibilidade e modularização , o alto nível de abstração, especialmente quando as funções são utilizadas. E a ausência de operações de atribuição,a qual torna os programas funcionais muito mais simples para provas e análises matemáticas , também se destacam nesse paradigma Desvantagens Como todos os paradigmas,esse também tem seus pontos fracos como: Ilegibilidade do código Os programas podem ser menos eficientes. Problemas que envolvam muitas variáveis (ex. contas de banco) ou muitas atividades sequenciais são muitas vezes mais fáceis de se trabalhar com programas procedurais ou programas orientados a objeto.
- 5. 3 Exemplos de Haskell Apesar de existirem várias funções pré-definidas em Haskell, a grande ideia da programação funcional é que o programador defina as suas próprias funções. As funções do usuário são definidas em scripts e contém definições associando nomes com valores e tipos. Também existem comentários que facilitam uma leitura posterior. Tudo o que for escrito depois de dois travessões (--) é considerado comentário e não é interpretado. Segue um exemplo de script: - - - - exemplo.hs - - Neste script apresentam-se algumas definições simples - - idade :: Int -- Um valor inteiro constante idade = 17 maiorDeIdade :: Bool -- Usa a definição de idade maiorDeIdade = (idade>=18) quadrado :: Int -> Int -- função que eleva um número ao quadrado quadrado x = x * x Haskell> maiorDeIdade quadrado idade True Na maioria das definições sobre listas irá se usar a recursão para se percorrer todos os elementos. Uma função simples seria a função para somar todos os elementos de uma lista de números inteiros: somaLista :: [Int] -> Int somaLista [] = 0 somaLista (a:x) = a + somaLista x Haskell> somaLista [1,2,3,4,5] 15 A variável “a” é o início da lista (chamado de head) enquanto o x é o resto da lista (chamado de tail). O comando é avaliado da seguinte maneira: somaLista [1, 2, 3, 4, 5] = 1 + somaLista [2, 3, 4, 5] = 1 + ( 2 + somaLista [3, 4, 5]) = 1 + (2 + ( 3 + somaLista [4, 5])) = 1 + (2 + ( 3 + ( 4 + somaLista [5]))) = 1 + (2 + ( 3 + ( 4 + ( 5 + somaLista [] )))) = 1 + (2 + ( 3 + ( 4 + ( 5 + 0 )))) = 15 Apesar de Haskell ser muito utilizado como funções matemáticas, também pode ser usado para decisões, e input e output de dados, como no exemplo abaixo: module Main where
- 6. 4 factorial n = if n == 0 then 1 else n * factorial (n - 1) main = do putStrLn "Quanto e 5! ?" x <- readLn if x == factorial 5 then putStrLn "Voce acertou!" else putStrLn "Voce errou!" Planilhas e SQL são ambos linguagens razoavelmente especializadas. Linguagens de programação funcional seguem as mesmas idéias das linguagens de propósito geral. Para se ter uma idéia de como é uma linguagem de programação funcional, vamos olhar os seguintes programas quicksort. Ambos ordenam uma sequência de números em ordem ascendente usando um método padrão chamado "quicksort". O primeiro programa é escrito em Haskell e o segundo em C. Considerando que o programa C descreve os todos os passos de como a máquina deve fazer para realizar a ordenação - a maior parte código lida com os detalhes de baixo nível da manipulação de dados - o programa Haskell codifica o algoritmo de ordenação em um nível muito mais alto, melhorando a velocidade e clareza do resultado. Quicksort em Haskell qsort [] = [] qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs) Quicksort em C void qsort(int a[], int lo, int hi) { { int h, l, p, t; if (lo < hi) { l = lo; h = hi; p = a[hi]; do { while ((l < h) && (a[l] <= p)) l = l+1; while ((h > l) && (a[h] >= p)) h = h-1; if (l < h) { t = a[l]; a[l] = a[h]; a[h] = t; } } while (l < h); t = a[l]; a[l] = a[hi];
- 7. 5 a[hi] = t; qsort( a, lo, l-1 ); qsort( a, l+1, hi ); } } No exemplo em Haskell, A primeira linha lê-se: "Quando você classifica uma lista vazia ( [] ), o resultado é uma outra lista vazia". A segunda linha diz: "Para ordenar uma lista cujo primeiro elemento é chamado x e o resto do que é chamado xs, classificar os elementos de xs, que são menos de x, classificar os elementos de xs , que são iguais ou superiores a x , e concatenar ( + + ) os resultados, com x “colada no meio”.