01_lisp.pdf

Paradigmas de Programação
Ronaldo F. Ramos
Instituto Federal do Ceará
6 de novembro de 2023

Histórico da Linguagem Uso básico do Interpretador Conceitos Básicos Avaliação de Símbolos e Variáveis Listas Funções
PARTE 3 - PARADIGMA FUNCIONAL
PROGRAMAÇÃO FUNCIONAL EM LISP
AULA 1/
2 / 41

Roteiro
1 Histórico da Linguagem
2 Uso básico do Interpretador
3 Conceitos Básicos
4 Avaliação de Símbolos e Variáveis
5 Listas
6 Funções
3 / 41

Histórico
• Inventada por John McCarthy em 1958 (MIT)
• Primeira implementação em um IBM 704 por Steve Russel
• Segunda Linguagem de Programação da História (1a é Fortran)
• Muito popular na área de pesquisa em IA nos EUA.
• Implementa o cálculo lambda criado por Alonzo Church (1903-1995)
• LISP = LISt Processing
4 / 41

Dialeto Mais Popular
O dialeto Lisp mais popular é o CLisp que pode ser baixada de clisp.org. Pode ser
interpretada e/ou compilada
5 / 41

Entrando e Saindo do Interpretador
1 clisp
2 (exit) ou (bye)
Para rodar um programa no interpretador
1 clisp <nome -programa >
2 clisp hello.lsp
Para compilar o programa
1 clisp -c hello.lsp -o hello # compila porém usa interpretador
para rodar.
6 / 41

Hello World Cearense - Programa 001
Pode-se usar write, print ou format
1 (write "Queima raparigal")
Saída:
1 clisp 001 _alomundo.lsp
2 "Queima raparigal"
7 / 41

Interagindo com o terminal (E/S) - Programa 002
1 (format t "Digite um número: ") ; Exibe uma mensagem para o
usuário
2 (setq numero (read)) ; Lê um número da entrada padrão (teclado)
3 (format t "Você digitou ~A.~%" numero) ; Exibe o número lido
Saída:
1 clisp 002 _terminal.lsp
2 Digite um número: 23
3 Você digitou 23.
8 / 41

Operadores e Expressões Prefixadas
Exemplos de somas, subtrações e divisões:
1 [1]> (+ 2 3)
2 5
3 [2]> (+ 1.2 4.5)
4 5.7
5 [3]> (- 7 90)
6 -83
7 [4]> (* 3 4)
8 12
9 [5]> (/ 5 6)
10 5/6
11 [6]> (/ 5 6.0)
12 0.8333333
9 / 41

Modo Debug
Ao encontrar um erro o interpretador entra no modo debug. Use quit para sair ou leia
as instruções e debug o programa.
10 / 41

Átomos
• Elementos simples da linguagem
• Podem ser símbolos: a b c xx
• Podem ser constantes: 1 2 0.45 -4.3
• Símbolos podem ser associados a valores (variáveis)
• Valores numéricos podem ser inteiros, reais ou complexos #c(real imaginario)
11 / 41

NIL e T
• Os símbolos NIL e T são especiais.
• O átomo nil é usado para denotar o valor “falso”
• T denota o valor booleano “verdadeiro”, mas qualquer valor diferente de nil é
entendido como verdadeiro.
12 / 41

Exemplo de NIL e T
Nil é falso e t é verdadeiro, mas qualquer outra coisa é avaliado como verdadeiro.
1 [3]> (<= 2 3)
2 T
3 [4]> (>= 3 4)
4 NIL
5 [5]> (and 2 T)
6 T
7 [6]> (and 2 NIL)
8 NIL
9 [7]>
13 / 41

Avaliação dos Símbolos
Todos os símbolos que não são precedidos por apostrofo śão avaliados.
Ex.
1 [18]> b
2
3 *** - SYSTEM ::READ -EVAL -PRINT: variable B has no value
4 ...
5 [20]> ’b
6 B
7 [21]> nil
8 NIL
9 [22]> T
10 T
11 [23]>
14 / 41

Atribuindo Valores a Variáveis
1 [43]> (setq a 2)
2 2
3 [44]> a
4 2
15 / 41

Atribuição Temporária
Vejamos o que acontece uma atribuição temporária com retorno.
1 [11]> (setq a 3)
2 3
3 [11]> (let ((a 6)) a) ; atribuição temporária
4 6
5 [11]> a ; valor retornado ao anterior
6 3
7 [11]> (let ((b 5)) b) ; criando b
8 5
9 [11]> b ; b existe?
10 *** - SYSTEM ::READ -EVAL -PRINT: variable B has no value
16 / 41

Funções Predefinidas
sqrt, sin, cos, tan, exp (expoente com base e) , expt (exponenciação com qualquer
base), ceiling, floor, mod, etc
17 / 41

Listas
Definição
Uma lista é uma sequência de átomos ou listas entre parênteses após o uso da palavra
reservada list ou do apóstrofo ´
.
Ex.
1 [69]> (list 1 2 3 4 5)
2 (1 2 3 4 5)
3 [70]> ’(1 2 3 4 5)
4 (1 2 3 4 5)
5 [71]> (setq l (list 1 2 3 4 5))
6 (1 2 3 4 5)
7 [72]> (setq l ’(1 2 3 4 5))
8 (1 2 3 4 5)
18 / 41

Funções que manipulam listas
• (car lista) retorna o primeiro elemento de lista.Um sinônimo de car é first.CAR =
Contents of Address Register.
• (cdr lista) retorna a lista sem o seu primeiro elemento. Um sinônimo de cdr é rest.
CDR= Contents of Decrement Register.
• Uma lista vazia () também pode ser escrita como NIL. NIL é tanto um átomo
como uma lista!
19 / 41

Exemplo de Manipulação de Listas
1 [61]> (car l)
2 1
3 [62]> (first l)
4 1
5 [63]> (car ’(a b c d))
6 A
7 [64]> (cdr ’(a b c d))
8 (B C D)
9 [65]> (car (cdr ’(a b)))
10 B
20 / 41

Listas são Pilhas
Listas podem ser manipuladas como pilhas
1 [34]> (setq l (list 1 2 3 4))
2 (1 2 3 4)
3 [35]> (push 0 l)
4 (0 1 2 3 4)
5 [36]> (pop l)
6 0
7 [37]> l
8 (1 2 3 4)
9 [38]>
21 / 41

Conses
Cons é um elemento utilizado para manipulação de listas.
(cons elem lista) insere um elemento no inicio da lista retornando uma cópia da mesma.
1 [73]> (cons ’a ’(b c))
2 (A B C)
3 [74]> (cons ’a ’(b))
4 (A B)
5 [75]> (cons ’a nil)
6 (A)
7 [76]> (cons (car l) (cdr l))
8 (1 2 3 4 5)
22 / 41

Usando cons com átomos
1 [77]> (cons ’a ’b)
2 (A . B)
O pontos nem sempre são impressos nos cons. Tudo que não é átomo é cons ou
expressão S. (S-expression). Um cons é um registro com dois campos ’(car cdr) ou
car.cdr. O ponto será omitido se um dos componentes é NIL.
23 / 41

Exemplos de Cons
1 [78]> (cons ’a ’b)
2 (A . B)
3 [79]> ’(a . b)
4 (A . B)
5 [80]> ’(a . nil)
6 (A)
7 [81]> ’(a . (b . (c . nil)))
8 (A B C)
9 [82]> ’(a . (b . c))
10 (A B . C)
11 [83]> ’((a . b) . c)
12 ((A . B) . C)
13 [84]> ’((a . b) . (b . c))
14 ((A . B) B . C)
24 / 41

Listas e Conses
Definição
NIL é uma lista.
Teorema
Se L é uma lista então (cons elem L) é uma lista.
Resumindo: Listas são conses sem pontos.
25 / 41

Definindo funções
As funções são definidas com defun. Ex.
1 [56]> (defun test (a b) (* 2 (+ a b)))
2 TEST
3 [57]> (test 2 3)
4 10
5 [58]>
26 / 41

Soma de Dois Números
1 [43]> (defun soma (x y) (+ x y))
2 SOMA
3 [44]> (soma 2 3)
4 5
5 [45]>
27 / 41

Argumentos Nomeados
Toda palavra iniciada por dois pontos é considerada uma palavra-chave e pode ser
usada para nomear argumentos que serão posteriormente fornecidos para funções em
qualquer ordem.
Exemplo de definição de função que recebe lista de parâmetros nomeados:
1 (defun exemplo -funcao (&key parametro1 parametro2 parametro3)
2 (list parametro1 parametro2 parametro3))
A função poderá ser chamada com argumentos em qualquer ordem conquanto sejam
nomeados
1 (exemplo -funcao :parametro1 10 :parametro3 "texto")
28 / 41

Condicional Simples
A sintaxe do if é:
(if condição retorno-caso-positivo retorno-caso-negativo)
Ex.:
1 (if t (print "tamos junto")
2 (print "vá se lascar"))
29 / 41

Condicionais cond
• cond permite escrever funções que envolvem decisões.
• Forma geral:
(cond (bool1 expr1)
(bool2 expr2)
...
(boolN exprN)
)
• As expressões lógicas são avaliadas sucessivamente.
• Se boolI é verdadeira então o cond avalia e retorna exprI
• Se nenhuma expressão lógica for avaliada como verdadeira, o cond retorna nil
30 / 41

Cond como if then else
(cond (bool1 expr1)
(bool2 expr2)
(bool3 expr3)
(t expr4))
É equivalente a:
if bool1 then expr1
else if bool2 then expr2
else if bool3 then expr3
else expr4
31 / 41

Exemplo de Uso do Cond
1 [90]> (cond ((= 1 2) ’a)
2 ((> 2 3) ’b)
3 ((< 3 4) ’c))
4 C
5 [91]> (defun f (lista elem)
6 (cond ((eq lista nil) nil)
7 ((eq (car lista) elem) t)
8 (t (f (cdr lista) elem))
9 )
10 )
11 F
12 [92]> (f ’(a b c) ’c)
13 T
14 [93]> (f ’(a b c) ’d)
15 NIL
32 / 41

Funções Recursivas
Exemplo de cálculo de fatorial de um número.
1 [45]> (defun fact (x)
2 (if (> x 0)
3 (* x (fact (- x 1)))
4 1
5 ) )
6 FACT
7 [46]> (fact 5)
8 120
33 / 41

Funções Mutuamente Recursivas
As funções podem ser mutuamente recursivas. Ex.
1 [51]> (defun a (x) (if (= x 0) t (b (- x))))
2 A
3 [52]> (defun b (x) (if (> x 0) (a (- x 1)) (a (+ x 1))))
4 B
5 [53]> (a 5)
6 T
7 [54]>
34 / 41

Funções com múltiplas expressões em seu corpo
O valor retornado será sempre o valor da última expressão calculada.
1 [54]> (defun bar (x)
2 (setq x (* x 3))
3 (setq x (/ x 2))
4 (+ x 4)
5 )
6 BAR
7 [55]> (bar 6)
8 13
9 [56]>
35 / 41

Expressões Lógicas
• São montadas com o auxílio das funções que implementam os predicados
relacionais e lógicos tradicionais
• Predicados lógicos: and or not
• Predicados relacionais: > = < >= <=
• Argumentos devem ser números
• Para comparar símbolos usa-se o predicado eq ou null que verifica se uma
expressão é nula
• Para comparar conses estruturalmente usa-se o predicado equal
36 / 41

Exemplos de Expressões Lógicas
1 [94]> (or (< 2 3) (> 2 3))
2 T
3 [95]> (= ’a ’b)
4
5 *** - =: A is not a number
6 ...
7 [97]> (eq ’a ’b)
8 NIL
9 [98]> (eq ’a ’a)
10 T
11 [99]> (eq ’(a b) ’(a b))
12 NIL
13 [100] > (equal ’(a b) ’(a b))
14 T
37 / 41

Exercícios
Escreva as funções
1. (apaga L X)
Dada uma lista L e um elemento X , retorna L sem X. Se L não contém elem
inicialmente, retorna uma cópia exata de L
> (apaga ‘(a b c d a) ‘a)
(b c d)
2. (acresc L X Y)
Dada uma lista L, um elemento X e um elemento Y, retorna uma cópia de L onde
um Y é inserido depois de cada X
> (acresc ‘(a b c d a) ‘a ‘k)
(a k b c d a k)
38 / 41

Solução Problema 1 - Programa 003
1 ; definição da função remove -elemento
2 (defun remove -elemento (elemento lista)
3 (cond
4 (( null lista) nil) ; Se a lista estiver vazia, retorne uma lista
vazia
5 ((eql elemento (car lista)) (remove -elemento elemento (cdr
lista))) ; Se o elemento for encontrado, pule -o
6 (t (cons (car lista) (remove -elemento elemento (cdr lista)))))) ;
Caso contrário, mantenha o elemento na nova lista
7 ; Exemplo de uso:
8 (setq lista -original ’(a b c d e f))
9 (setq nova -lista (remove -elemento ’d lista -original))
10 (print nova -lista)
39 / 41

Saída do Problema 1 - Programa 003
1 clisp removeElemento.lsp
2 (A B C E F)
40 / 41

Solução do Problema 2 - Programa 004
1 (defun inserir -y-apos -x (l x y)
2 (if (null l) nil ; Se a lista estiver vazia, retorne uma lista vazia
3 (if (eql (car l) x)
4 (cons x (cons y (inserir -y-apos -x (cdr l) x y)))
5 (cons (car l) (inserir -y-apos -x (cdr l) x y)))))
6 ; Exemplo de uso:
7 (setq minha -lista ’(1 2 3 4 1 5 1 6))
8 (setq x 1)
9 (setq y 7)
10 (print (inserir -y-apos -x minha -lista x y))
41 / 41

01_lisp.pdf

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a 01_lisp.pdf

Semelhante a 01_lisp.pdf (20)

Mais de ronaldo ramos

Mais de ronaldo ramos (20)

Último

Último (20)

01_lisp.pdf