Programação Funcional

• Paradigma de programação baseado em

Funções Matemáticas
Programação Funcional
• Essência de Programação: combinar
funções para obter outras mais poderosas

PLP 2010/1
Profa. Heloisa

1/2010 1 1/2010 2

LISP
• Programa Funcional (puro): • LISt Processing
– definições de funções
– chamada de funções
• Linguagem de Programação Funcional
• Versões mais atuais:
– introduziram características imperativas • LISP Original – proposto por John MacCarthy e
– estenderam o conceito de função para um grupo em 1960 no Massachussets Institute
procedimento of technology (MIT). Lisp puro, completamente
funcional.
• Linguagens Funcionais:LISP, SCHEME,
HOPE, ....
1/2010 3 1/2010 4
 Conceitos Básicos
• Características: • Função: regra que associa elementos de um
conjunto (domínio) com elementos de outro
conjunto (codomínio).
– linguagem funcional
– linguagem simbólica
• Definição de Função: especifica o domínio,
– linguagem interpretada
codomínio e a regra de associação para a
– linguagem declarativa e procedural função

Ex: quadrado(x) = x*x

1/2010 5 1/2010 6

• Aplicação de Função: quando uma função • Forma Funcional: método de combinar funções
é aplicada a um elemento do domínio para obter outra função como resultado.
fornece um resultado do codomínio. Na
Ex: Composição de funções
aplicação, um argumento substitui o
parâmetro.
F = G°H F(x) = G(H(x))

Outras formas funcionais: condicional, recursão

Ex: quadrado (2) = 4

1/2010 7 1/2010 8
 Tipos de Dados (objetos) do LISP
• Átomos – elementos indivisíveis: • Listas – série de átomos ou listas separadas por
A, F68, 27 espaços e delimitadas por parêntesis:

(1 2 3 4)
– Números (Átomos numéricos) – (MARIA)
átomos só com números: 27, 3.14, -5. (JOAO MARIA)
() Lista vazia, também denotada por NIL
((v-1 valor-1) (v-2 valor-2) (v-3 valor-3))
– Símbolos (Átomos Simbólicos) –
átomos que não são números: A NOME, X1

1/2010 9 1/2010 10

S-expressões Procedimentos e Funções

• determinam o que deve ser feito em LISP
• Átomos ou listas são chamados de S-
expressões ou Expressões Simbólicas • são representados em forma de lista

S-Expressões
A mesma sintaxe representa tanto dados quanto
programas:
Átomos Listas (a b c)

Números Símbolos (* 7 9)

Inteiros Ponto flutuante (- (+ 3 4) 7)

1/2010 11 1/2010 12
 Interpretador LISP
Exemplos
• Quando o interpretador LISP é ativado, o > (+ 2 1)
usuário passa a interagir com ele. 3
>
• Ciclo Lê-calcula-imprime:
(executado pelo interpretador) > (* 7 9)
63
>
– apresenta um sinal de pronto;
– lê a entrada fornecida pelo usuário;
>(- (+ 3 4) 7)
– executa essa entrada;
0
– se a execução obteve sucesso, imprime o
resultado. >

1/2010 13 1/2010 14

Avaliação de listas
• A notação (f x y) equivale a notação de função matemática • Regra de avaliação de expressões:
f(x,y)

• O avaliador LISP quando recebe uma lista tenta interpretar o – Avalia primeiro os argumentos
primeiro elemento da lista como o nome de uma função e e os – Aplica a função indicada pelo primeiro elemento da
restantes como seus argumentos expressão
– Se os argumentos forem expressões funcionais, aplica a
• Se o primeiro elemento da lista não for uma função definida regra recursivamente
ocorre um erro
> (a b c) • Exemplos:
Error: invalid function: a >(* (+ 2 5) (- 7 (/ 21 7)))
28
• Forma geral:
(f a1 a2 a3 ....an) >(= (+ 2 3) 5)
t
1/2010 15 1/2010 16
 Convenções nas regras para avaliar
expressões
• Por default, tudo é avaliado
• Números são avaliados como eles mesmos
• Símbolos como x podem ter um valor ligado. Se
tiver, esse valor é retornado
Dados “versus” funções
• Para que a lista represente dados é necessário impedir sua
avaliação pelo interpretador LISP
• Para isso é usada uma função especial de nome quote, que
também pode ser representada por aspas simples antes da
expressão.
• Quote recebe um argumento e retorna esse argumento sem
avaliar.

> (quote (a b c))

• Se um símbolo for avaliado e não tiver um valor (a b c)
ligado, retorna um erro > (quote (+ 1 3))
(+ 1 3)

1/2010 17 1/2010 18

Forma abreviada de quote Funções que operam sobre listas

> ´(a b c) • List – recebe qualquer número de argumentos e constrói
uma lista a partir desses elementos
(a b c)
> (list 1 2 3 4 5)
> ´(+ 1 3) (1 2 3 4 5)
(+ 1 3)
> (list (+ 1 2) (+ 3 4))
> ´(- (+ 3 4) 7) (3 7)
(- (+ 3 4) 7)
>(list ´(+ 1 2) ´(+ 3 4))
((+ 1 2) (+ 3 4))

1/2010 19 1/2010 20
 • nth – recebe como argumentos um número e uma • Length – retorna o número de elementos de uma lista
lista e retorna o elemento da lista na posição
indicada pelo número, começando a partir do zero > (length ´(a b c d))
4
> (length ´(1 2 (3 4) 5 6))
> (nth 2 ´(a b c d)) 5
c
• Member – recebe como argumento uma expressão e uma lista
> (nth 1 (list 1 2 3 4 5)) e verifica se a expressão é membro da lista
2
> (member 5 ´(1 2 3 4 5))
> (nth 2 ´((a 1) (b 2) (c 3) (d 4))) t
>(member ´a ´(1 2 3 4 5))
(c 3)
nil

1/2010 21 1/2010 22

Listas como estruturas recursivas

• Algumas funções permitem tratar listas com número
• Nil – símbolo especial desconhecido de elementos, recursivamente
• Car – recebe um único argumento que deve ser lista e retorna
o primeiro elemento dessa lista
• Cdr – recebe um único argumento que deve ser uma lista e
• Representa o valor “falso” e a lista vazia retorna essa lista sem o primeiro elemento

> (car ´(a b c))

a
• É o único símbolo que é átomo e lista ao > (cdr ´(a b c))
(b c)
mesmo tempo > (car ´((a b) (c d)))
((c d))
(car (cdr ´(a b c d)))
b

1/2010 23 1/2010 24
 Composição de CAR e CDR Exemplo
> (CAR (CDR ‘(A B C)))
B (CAR (CAR (CDR (CDR ‘(HOJE E (DIA DE) AULA)))))

Podemos substituir as funções CAR e CDR por DIA

uma primitiva composta como
Usando a forma combinada:
CXXR ou CXXXR ou CXXXXR
(CAADDR ‘(HOJE E (DIA DE) AULA))
onde X pode ser A (significando CAR)
ou R (significando CDR)
DIA
1/2010 25 1/2010 26

Funções para construir listas

CONS – recebe duas s-expressões como argumento, > (CONS ‘(A B C) ‘(A B C))
avalia e retorna uma lista que é o resultado de
adicionar a primeira expressão no início da segunda, ((A B C) A B C)
que é uma lista.
> (CONS ‘NADA ( ))
Argumentos: 1) qualquer S-expressão (NADA)
2) lista
> (CONS ‘((PRIM SEG) TER) ‘( ))
> (CONS ‘A (B C))
(((PRIM SEG) TER))
(A B C)

Cons é a operação inversa de car e cdr

1/2010 27 1/2010 28
LIST – constrói uma lista a partir dos seus argumentos APPEND – constrói uma lista com os elementos
das listas dadas como argumentos. Argumentos
> (LIST ‘A ‘B ‘C) devem ser listas.
(A B C)
> (APPEND ‘(A B) ‘(C))
> (LIST ‘(A) ‘B ‘C) (A B C)
((A) B C)
> (APPEND ‘(A) ‘( ) ‘(B) ‘( ))
> (LIST ‘(A B) ‘((C) D)) (A B)
((A B) ((C) D))
> (LIST ‘(A) ‘( ) ‘(B) ‘( ))
((A) ( ) (B) ( ))

1/2010 29 1/2010 30

Atribuição de valores a átomos

SETQ – faz o primeiro argumento passar a ter o valor do O valor dessa função é o último valor atribuído
segundo. mas o mais importante é o efeito colateral de
Argumentos: 1) símbolo L que fica com valor (A B).
2) qualquer S-expressão

> (SETQ L ‘(A B))

(A B ) Efeito Colateral: algo que o procedimento faz
que persiste depois que seu valor é
> (SETQ L1 ‘(A B) L2 ‘(C D) N 3) retornado.
3

1/2010 31 1/2010 32
 Criar novas funções
Um Símbolo com valor pode aparecer como argumento de • A programação em Lisp consiste em definir novas funções a
um procedimento. partir de funções conhecidas

> (SETQ L ‘(A B)) • Depois de definidas, as funções podem ser usadas da mesma
(A B) forma que as funções embutidas na linguagem

> (CDR L) • Defun – função para definir outras funções

(B)
• Argumentos:
> (SETQ L1 5 L2 2)
2 – Nome da função
– Lista de parâmetros formais da função (átomos simbólicos)
> (+ L1 L2) – Corpo da função (0 ou mais expressões s que definem o que a
função faz)
7

1/2010 33 1/2010 34

Chamada de funções
> (defun quadrado (x) • A função definida por defun deve ser chamada com o mesmo
(* x x)) número de argumentos (parâmetros reais) especificados na
quadrado definição

• Defun retorna como resultado o nome da função • Os parâmetros reais são ligados aos parâmetros formais

• Não avalia os argumentos • O corpo da função é avaliado com essas ligações

• Efeito colateral: cria uma nova função e adiciona ao ambiente • A chamada:

Lisp > (quadrado 5)

• Forma geral: • Faz com que 5 seja ligado ao parâmetro

(defun <nome da função> (<parâmetros formais>)
<corpo da função>) • Na avaliação de (* x x), a avaliação de x resulta em 5,
causando a avaliação de (* 5 5)
1/2010 35 1/2010 36
 Uso de funções Exemplos
• Uma função definida por defun pode ser usada da mesma > (defun F-to-C (temp)
forma que as funções embutidas (pré-definidas na linguagem) (/ (- temp 32) 1.8))
F-to-C
• Definir uma função que calcula o comprimento da hipotenusa
de um triângulo reto dados os outros dois lados do triângulo > (F-to-C 100)
37.77
(defun hipotenusa (x y) > (defun TROCA (par)
(sqrt (+ (quadrado x) (list (cadr par) (car par)))
(quadrado y))))) TROCA

>(TROCA ´(a b))

Sqrt – função embutida que calcula a raiz quadrada (b a)

1/2010 37 1/2010 38

Predicados
• Um predicado é uma função que retorna T (verdadeiro) ou Nil • LISTP – verifica se seu argumento é uma lista
(falso)
• T e NIL são átomos especiais com valores pré-definido
> (listp ´(a b c))
• ATOM – verifica se seu argumento é um átomo T
> (atom 5) > (setq L ´(a b c))
T (a b c)
> (atom ´L) > (listp L)
T
> (setq L ´(a b c))
T
(a b c) > (listp ´L)
> (atom L) nil
Nil

1/2010 39 1/2010 40
• Equal – recebe dois argumentos e retorna T se eles são
iguais e NIL se não são. • Null – verifica se seu argumento é uma lista vazia

> (equal `a `a) > (null ´( ))

T T
> (equal L L)
T (null L)
> (equal L ´(a b)) Nil
T
> (equal L ´L)
(null ´L)
nil
Nil

1/2010 41 1/2010 42

• GREATERP – argumentos devem ser números. Verifica se estão

• NUMBERP – verifica se seu argumento é um número em ordem decrescente
> (greaterp 5 4 3 2 1)
>(numberp 5) T
T > (greaterp 3 1 4)
> (setq N 5) Nil
5
> (numberp N) • LESSP – argumentos devem ser números. Verifica se estão em
T ordem crescente
> (setq Digitos ´(1 2 3 4 5)) > (lessp 1 2 3 4 5)
(1 2 3 4 5) T
> (numberp Digitos) >(lessp 3 6 2)
Nil nil

1/2010 43 1/2010 44
 Controle de fluxo em Lisp
• ZEROP – argumento deve ser número. Verifica se é zero • Os desvios em Lisp também são baseados em
avaliações de funções, com o auxílio dos
> (setq zero 0) predicados
0
> (zerop zero)
• Função cond – implementa desvio condicional
T

• MINUSP – argumento deve ser número. Verifica se é negativo • Argumentos: pares do tipo condição-ação (qualquer
número)
> (setq N -5)
-5 (cond (<condição1> <ação1>)
> (minusp N) (<condição1> <ação1>)
T
....
(<condição1> <ação1>))
1/2010 45 1/2010 46

Definição de funções usando cond

• Condições e ações podem ser s-expressões com cada par • Lisp tem uma função pré-definida para cálculo do valor
entre parênteses absoluto de um número: abs

• Cond não avalia todos os argumentos • Vamos redefinir essa função para ilustrar o uso de cond

• Avalia as condições até que uma retorne valor diferente de nil > (defun valor-absoluto (x)
(cond ((< x 0) (-x))
• Quando isso acontece, avalia a expressão associada à ((>= x 0) x)))
condição e retorna esse resultado como valor da expressão
cond valor-absoluto
• Nenhuma das outras condições ou ações são avaliadas > (valor-absoluto -5)
5
• Se todas as condições são avaliadas como nil, cond retorna nil

1/2010 47 1/2010 48
 Ação default Valores nil e “não nil”
• Definição alternativa para valor-absoluto:
• Os predicados em Lisp são definidos de forma que qualquer
expressão diferente de NIL é considerada verdadeira
> (defun valor-absoluto (x)
(cond ((< x 0) (-x)) • Member – recebe dois argumentos, o segundo deve ser lista
(t x)))
• Se o primeiro for membro do segundo retorna o sufixo do
• Nessa versão, a última condição (>= x 0) é substituída por t, segundo argumento que tem o primeiro argumento como
pois é sempre verdadeira se a primeira for falsa elemento inicial

• Quando existem mais de dois pares de condição-ação, o uso > (member 3 ´(1 2 3 4 5))
de t na última condição serve par forçar a execução de alguma (3 4 5)
ação, quando todas as outras são falsas (valor nil)
> (member 6 ´(1 2 3 4 5))
nil

1/2010 49 1/2010 50