Escolar Documentos
Profissional Documentos
Cultura Documentos
p p
Em vez disso, as linguagens de
PROGRAMAÇÃO FUNCIONAL baseiam-se na
TEORIA DAS FUNÇÕES MATEMÁTICAS
ppp
p p
ë
A motivação das linguagens funcionais
não é a eficiência da execução
e sim os seguintes aspectos:
ë
1
Inicialmente, serão abordadas as principais
diferenças da programação funcional, ilustradas
pelos conceitos básicos da programação imperativa
ë
ë
As linguagens de programação imperativa
são caracterizadas por três conceitos:
variáveis, atribuição e seqüência de execução
ë
As linguagens de programação imperativa
são caracterizadas por três conceitos:
variáveis, atribuição e seqüência de execução
ë
FUNÇÃO MATEMÁTICA é
um conjunto de pares ordenados que relaciona cada
elemento no domínio com um único correspondente
elemento na faixa
FUNÇÃO na PROGRAMAÇÃO IMPERATIVA é
descrita como algoritmo que especifica
como computar os valores da faixa
para um valor de domínio em uma
DETERMINADA SEQÜÊNCIA DE PASSOS
Lembrando que as linguagens de programação
imperativa são caracterizadas por três conceitos:
variáveis, atribuição e seqüência de execução
p p
pp
"
p p
ë
REPETIÇÃO (LOOP) é uma outra característica das
linguagens imperativas, usada, freqüentemente, para
computar os valores desejados
ë
As LINGUAGENS IMPERATIVAS
são chamadas de BASEADAS EM ESTADO
ou
ORIENTADA A COMANDO
As LINGUAGENS FUNCIONAIS
são chamadas de
BASEADAS EM VALORES
ou
APLICATIVAS
p p
CONCEITO p p
p
p p #
$ %
ë
Uma função é uma regra para mapeamento de
membros de um conjunto domínio para um conjunto
faixa Ex. função quadrado poderia mapear elementos
do conjunto inteiro p/conjunto natural
Tradicionalmente, as linguagens de
programação funcional oferecem um
mecanismo de estruturação de dados
exclusivo de alto nível tal como uma lista ou
um array
p p
ppp
p p
& ë
Por exemplo:
Por exemplo:
( reducing + sobre um array produz a soma dos
elementos do array
( reducing * sobre o array produz o produto dos
elementos do array
6. Máquinas de Turing p
Máquina de Turing mT
Modelo matemático do processo de
computação
6. Máquinas de Turing
Tese de Church
1- Todos os modelos razoáveis de
procedimento são equivalentes
6. Máquinas de Turing
p p
p p
pp
&
p p p'
( ë
&#
p p
& pp
Lambda calculus captura o comportamento de
funções com um conjunto de regras de
reescrita de expressões lambda
ë
A reescrita de uma expressão modela
um
passo na computação de uma função
p p p)
*
ë
p p
&
(SEM ITERAÇÕES
Expressões
A execução de programas funcionais é baseada
Em Haskell,
sobre as expressões
dois mecanismos são especificadas
fundamentais:
com os seguintes símbolos ou construções:
(Constantes
(Operadores
(Aplicação de funções
(Parênteses ( )
p p
pp
"
ë
p
p ppp)
*
&
(Constantes
Expressões (Operadores
(Aplicação de funções
A execução de programas funcionais
é baseada
(Parênteses ( )
sobre dois mecanismos fundamentais:
Constantes:
True
2009
Aplicação de Funções:
28876543212125
12.589
primo 53
¶b·
seno 30
´cadeiaµ
[4,8,9]
p p
pp
ë
p
p ppp)
*
&
Operadores
A execução de programas funcionais é baseada
sobre
. dois mecanismos fundamentais:
composição de funções
*, /, ^ produto, divisão, potência
+, - adição, subtração
:, ++ composição de listas, concatenação
-- P
A execução de programas funcionais é baseada
sobre dois mecanismos fundamentais:
-- @``
@`
p
significa em lambda calculus ´ð @`
Opµ
Uma aplicação: ´@` µ
-- á `
p
significa em lambda calculus ´ ð
Opµ
Uma aplicação: ´ µ
p p
pp
ë
p
p ppp)
*
&
Tipos básicos
A execução de programas funcionais é baseada
Bool dois mecanismos
sobre booleano fundamentais:
Char caracter
Int inteiro de 32 bits
Integer inteiro sem limite no tamanho.
Float ponto flutuante
Double precisão dupla
p p
p p p)
* pp
Tipos em Haskell
p p
&
ë
Toda expressão deve ter um tipo associado
Tipos
A podem
execução deser explícitos
programas ou inferidos
funcionais é baseada
sobre dois mecanismos
@` fundamentais:
->` ->`
@Ñ
Ñ
@p` ->`
@p
@p
@`` ->`
@`
p
` ->`
p
p p
p p p)
* pp
ë
pTuplas
p
&
` ` ->
` `
p
` ->
`
þ ` `
p p
p p p)
* pp
ë
pFunções Uma função é um mapeamento de
p
&
valores de um tipo em outro tipo
`#``->#``
!" ->#``
Matemática Haskell
ðÑ ðÑ
ðÑ ðÑ
ðÑ ðÑ
ðÑ ðÑ
ðÑmultiplica ðÑ
ð ð
p p
p p p)
* pp
Função Currificada Observações ë
importantes
p p
&
ð `ð Ñ
Ñ
ðð Ñ
Ñ
A execução
Essa abstração, de programas funcionais é baseada
sobre
seguindodois
a mecanismos
&
fundamentais:
§ >ðð %
associatividade § >ðð %
esq./dir., em que o &
valor 3 foi o primeiro § >ðð %
a ser avaliado e o valor &
6 o último a ser § >ðð %
avaliado, reforça o &
conceito de avaliação § >ðð %
preguiçosa, em que &
§ >ð `ð %
nada é calculado até
&
que seja efetivamente
necessário.
p p
p p p)
* pp
ë
Função Currificada Observações importantes
p p
&
ð `ð Ñ
Ñ
ðð Ñ
Ñ
A execução de programas funcionais é baseada
§ >ðð %
sobre
Em outrasdois mecanismos
palavras, & fundamentais:
na avaliação preguiçosa, § >ðð %
transformações abstratas &
intermediárias foram § >ðð %
adiadas, até que a &
disponibilidade dos § >ðð %
&
termos numéricos fosse
§ >ðð %
necessária na expressão. &
§ >ð `ð %
&
p p
p p p)
* pp
ë
Função Currificada Observações importantes
p p
&
ð `ð Ñ
Ñ
ðð Ñ
Ñ
A execução de programas funcionais é baseada
A associatividade à esquerda é observada e para o
sobre dois mecanismos fundamentais:
caso de 4 argumentos em uma função f, note que:
f a b c d = ( f a ) b c d = ( ( f a ) b ) c d = ( ( ( f a ) b ) c) d
ððpÑ
Ñ
p p
p p p)
* pp
ë
Função Currificada
p p
&
Execução da função equivalente em uma notação
préfixa
ððpÑ
Ñ
A execução de programas funcionais é baseada
sobre dois mecanismos fundamentais:
§ >ððp %
&
§ >ððp %
&
p p
p p p)
* pp
Recursão
Indução Matemática é
uma definição generalizada
para um conjunto de objetos
com uma propriedade comum
p p
p p p)
* pppp!
Indução é !
uma definição generalizada
Recursão
para um conjunto de objetos
com uma propriedade comum
Deve-se conhecer o caso trivial,
geralmente, para n=0, n=1,
que são os valores²base ou triviais
1 + 2 + 3 + ... + (n-1) + n,
representado por soma (n)
soma (5) = 1 + 2 + 3 + 4 + 5 = 15
p p
p p p)
* pp
Recursão
p
Raciocínio p/ soma dos n
primeiros inteiros 1+ 2 + 3 + 4 + ... + n
soma 1 = 1
soma 1 = 1
soma n = soma (n-1) + n
p p
p p p)
* pp
Recursão Outro exemplo clássico de recursão é
o fatorial de um número inteiro.
fatorial 1 = (fatorial 0) * 1
fatorial 2 = (fatorial 1) * 2
fatorial 3 = (fatorial 2) * 3
...
fatorial n = (fatorial (n-1)) * n
fatorial 0 = 1
fatorial n = fatorial (n-1) * n
p p
p p p)
* pp
Cuidados com a Recursão
O aterramento da função deve aparecer antes da
chamada da função recursiva geral.
Cuidado: caso se inverta,
ocorre uma seqüência infinita de chamadas.
fatorial 0 = 1
fatorial n = fatorial (n-1) * n
p p
p p p)
* pp
Uso de guardas |
para aterramento e regra geral
Uma guarda é uma condição lógica para que a
definição da função seja executada
@((
@(Ñ COM
@(
'Ñ>
))Ñ
%
@(
'`"
@(Ñ-(
@(p
@(
@(
SEM
@(
@(%
@((
@(Ñ
@(Ñ-(
p p
p p p)
* pp
!
Exemplo com e sem uso de guarda, para a
especificação de uma função que retorna quantos
múltiplos de 7 há em x (no intervalo de 0 a n):
@(
@(
@((
COM
@(p
@(Ñ
@(
'Ñ>
))Ñ
%
@(
'`"
@(Ñ-(
@(
@(%
SEM
@((
@(Ñ
@(Ñ-(
@(
@(
@((
COM
@(p
@(Ñ
@(
'Ñ>
))Ñ
%
@(
'`"
@(Ñ-(
@(
@(%
SEM
@((
@(Ñ
@(Ñ-(
A variável x (arg) na função multi_7 fez um
casamento condicional com valores de 0 a 6,
retornando 0, enquanto que para os demais valores,
recursivamente segue na busca de mais múltiplos.
p p
p p p)
* pp
CASAMENTO DE PADRÕES
Casamento de Padrão é
um recurso de alto nível para
a declaração das diferentes condições,
nas quais se baseiam as execuções
das diferentes ações especificadas
p p
p p p)
* pp
CASAMENTO DE PADRÕES - exemplo
p
'*' ''Ñ' '`@
` ->#`` A função
`
* ` é
definida por uma série
``@
* de casos.
`
Dependendo do valor,
no argumento com o
Pelo ex, vimos que há dois efeitos: qual a função é
p 1) O argumento é amarrado ao invocada, o caso
padrão quando há casamento; apropriado será
2) a ação é escolhida, baseada selecionado.
no argumento. Os casos são
verificados
seqüencialmente , do
A variável amarrada (arg) pode ser primeiro em diante.
usada no mapeamento.
p p
p p p)
* pp
CASAMENTO DE PADRÕES
@(
@(
@((
@(p
@(Ñ
@(
'Ñ>
))Ñ
%
@(
'`"
@(Ñ-(
@(
@(%
@((
@(Ñ
@(Ñ-(
ðÑ 'Ñ
(
Casamento de padrão
'
&
p (pattern matching) pode ser
visto como uma
'
generalização de passagem
'`"
de parâmetro convencional.
p p
p p p)
*
emprego de variável anônima, identificada por _ pp
ðÑ 'Ñ
(
'
&
p EQUIVALENTES
'
'`"
(
Ñ&
p
Ñ
Ñ' Ñ+
(''+
&''+
p p
p p p)
* pp
ðÑ (
"(
'Ñ
(
Ñ&
p "&
p
'
&
p Ñ
"
'
Ñ' "
'`"
Ñ+
(''
+
&''
+
(
Ñ&
p "&
p
'
&
p Ñ
"
'
Ñ' "
'`"
Ñ+
(''
+
&'' f, g e h são
Pq, as execuções,
+
equivalentes
abaixo, ðe "
com (&
por causa da associatividade à esquerda
resultam em ? na currificação
!
$-
,`@
! ! ! !
ð `@ `,`@
ð `@ `
V `` `P@ V `
!
$-
,`@
! ! ! !
ð `@ `,`@
ð `@ `
V `` `P@ V `
ð-` `
` `! `p%( `
ð@
§ . p p(*
p p
p p p)
* pp!
Tipos Compostos com Tuplas
p
P`
`
P`
P`
ð-` `ð@ P` $- + ð
ð-` `
` `! `p%( `
ð@
§ . p p(*
p pTipos
Compostos com Tuplasp p p)
* pp!
Funções que extraem ou relacionam partes de uma tupla são
especificadas usando casamento de padrões, realizado, pela
seleção do campo desejado na tupla de 4, de modo que a mesma
tenha um tipo compatível com o que foi definido nesta função.
ð-` `ð@ P` $- + ð
ð-` `
` `! `p%( `
ð@
§ . p p(*
§ >ð-` ` § >`ð@
` `! `p%( ` p(
§ >ð@ § > ð-` `
§ . p p(* p
§ > `@ð-` ` § >`ð@
` `! ` *
p p
p p p)
* pp!
Principais funções pré-definidas para listas
ë
p p
&
Operador
inclui um elemento no início da lista
P>p
p
P>p
p
P>p
p
p p
p p p)
* pp!
!
ë
Tratando lista e o operador :
Em cada passo n,
é invocada uma chamada ao sucessor n-1, e
esta sucessão de passos
é feita com o uso do operador :
que opera sobre o argumento lista,
separando
sua cabeça do seu tail (resto)
p p
p p p)
* pp
""
ë
Notas para o caso geral de funções recursivas
complementadas para o caso de listas
p p
p p p)
* pp
"p
ë
Notas para o caso geral de funções recursivas
complementadas para o caso de listas
p p
p p p)
* p pp"
p
"
ë
Validação de uma estrutura do tipo lista
p p
p p p)
* p pp"
p
"
ë
Reescrevendo em Haskell as seguintes definições:
*-- ð `
Ñ
Ñ-- ð `p
*-- ð `
Ñ
Ñ-- ð `p
`@`
-- ð `
`@` Ñ
`@`Ñ$- ð `p
p p
p p p)
* p p "
Função que devolve o comprimento de uma lista
`@`
--ð `
`@` Ñ
`@`Ñ$-ð `p
*
'`"
Ñ
§ > p
*
§ > p
§ >
p p
p p p)
*
Função que um objeto na lista, sem pp
repetições, i.e, se já existir, então, não insere.
ë
Ñ'
Ñ
'`"
Ñ
A recursão prossegue até que:
1) a lista tenha se resumido a uma lista vazia [ ], quando
retorna , uma lista com um objeto, o argumento .
2) o argumento coincida com uma cabeça de uma sublista,
retornando então a lista resultante da concatenação de com
a sublista Ñ.
3)Em todas as voltas,
cada cabeça volta a fazer parte da lista,
pela concatenação com a lista retornada da chamada.
p p
p p p)
*
Testando a função que um objeto na lista, p p
p
sem repetições, i.e, se já existir, então, nãoëinsere.
Ñ'
Ñ
'`"
Ñ
§ > p
p
§ > pp
p
§ > p
p
pFunção
p
que devolve o elemento de maior p p p)
*
valor pp
ë
São apresentadas três versões equivalentes
@ `
@ ` Ñ
ð >@ `Ñ Decapita
duas
" cabeças,
@ `Ñ 1º e 2º
elementos
@ `p
e
@ `p Ñ' >
@ `p Ñ
'`"
@ `p Ñ
@ `
@ ` Ñ' >@ ` Ñ
'`"
@ ` Ñ
pFunção
p
que ` uma lista p p p)
* pp
ë
São empregadas duas funções:
@ ` devolve o menor elemento de uma lista;
p@`V@ `, devolve uma lista sem o menor
@ `
@ ` '
@ `
'`"
@ `
@`V@ `
@`V@ ` '
P>p
p
*
p p
p p p)
* pp
Principais funções pré-definidas para listas
ë
pp "
&
- comprimento de uma lista
p p
p p p)
* pp
Principais funções pré-definidas para listas
p p-
&
concatena duas listas
P>
*
p p
p p p)
* p p !
p p
&
V ² devolve o reverso da lista
P>Vp(
(p