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.

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”.

8. 6
Bibliografia
http://informacaocomdiversao.blogspot.com.br/2009/02/paradigma-funcional.html
http://www.din.uem.br/~ia/ferramen/lisp/Paradigma.html
http://pt.wikipedia.org/wiki/Programação_funcional
http://www.cesarkallas.net/arquivos/apostilas/programacao/Lisp_Prolog.pdf
http://www.inf.ufsc.br/~barreto/trabaluno/PF_haskell.pdf
http://www.haskell.org/haskellwiki/Haskell_em_10_minutos#Express.C3.B5es_simple
s
http://www.portugal-a-programar.pt/topic/3786-tutorial-de-haskell/
http://www.cin.ufpe.br/~dclal/monitoria/duBois.pdf
http://www.dcc.fc.up.pt/~pbv/aulas/pf/slides/aula1.pdf
http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_funcional