LISP

1
LISP Uma Introdução

• Claudio Esperança

2
Por quê LISP?

• É uma linguagem cujos rudimentos podem ser
  explicados em uma aula
• Poucas construções permitem fazer muito
• Permite ilustrar bem os princípios da recursão
• Não vamos usar comandos de repetição
• Estruturas de dados complexas podem ser expressas
  de forma simples
• Não dá margem a encher de lingüiça
• Uma função freqüentemente pode ser verificada
  visualmente

3
Recursos

• Diversas implementações grátis
• Recomendo a implementação de Common Lisp do Dr
  Bruno Haible
• Ver http//clisp.cons.org
• Distribuição binária para MS-Windows na página do
  curso http//www.lcg.ufrj.br/algoritmos
• Diversos livros, alguns grátis
• Recomendo The Little Lisper de Daniel P.
  Friedman e Matthias Felleisen, Mcmillan
  Publishing Company

4
Características do LISP

• LISP LISt Processing
• Inventada por McCarthy (1959)
• Implementa o Cálculo Lambda de Church
• Teoria de funções recursivas
• Linguagem funcional
• Muito usada em Inteligência Artificial

5
Características do LISP

• Manipulação de informação simbólica
• Versão inicial do Lisp era pouco prática (sem
  iteração)
• Muitas versões e dialetos Franz, Mac, Inter,
  Common (praticamente o padrão) e Scheme (variante
  enxuta)

6
Diferenças entre LISP e outras linguagens

• Programas e Dados têm a mesma forma
• É trivial escrever um programa que escreve um
  programa
• Não se trabalha com variáveis armazenadas (embora
  LISP suporte variáveis)
• Em C podemos implementar uma função para
  inserir um elemento X numa variável L do tipo
  lista
• Em LISP, escreve-se uma função que, dados um
  elemento X e uma lista L, retorna uma lista igual
  a L com X inserido

7
Usando LISP

• LISP é freqüentemente implementada por um
  interpretador
• Usuário entra com uma expressão
• Interpretador avalia expressão e imprime o
  resultado
• Exemplo
• gt ( 3 4 5 6)
• 18
• gt ( ( 3 4) ( ( 4 5) 6))
• 22

8
Usando o intepretador CLISP

• Ajuda a qualquer momento durante a interação
  digite help
• O interpretador numera os comandos
• Ao cometer um erro, o interpretador escreve uma
  mensagem de erro e entra num break loop, isto
  é, num depurador (debugger)
• No nosso curso, não é necessário realmente
  aprender a usar o depurador, por isso, digite
  quit para voltar ao modo de interação normal
• Para sair do programa, digite (bye)

9
Exemplo de sessão com o CLISP
10
Átomos

• São os elementos mais simples da linguagem
• Podem ser
• Símbolos
• a b c xxx x1 x-1
• Constantes
• Números 1 2 1.33 -2.95
• Cadeias abc de x y z
• Um símbolo pode ser associado a um valor
• Conceito semelhante ao de variável em
  linguagens imperativas

11
NIL e T

• Os símbolos nil e t são especiais pois seus
  valores são eles próprios
• Quando o LISP está interpretando uma expressão
  booleana, 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
NIL e T - Exemplo

• gt (lt 2 3)
• T
• gt (gt 3 4)
• NIL
• gt (and 2 t)
• T
• gt (and 2 nil)
• NIL

13
Avaliando Símbolos

• O interpretador sempre tenta avaliar símbolos a
  menos que sejam precedidos por um apóstrofe
  (quote)
• gt b
• - EVAL variable B has no value
• gt 'b
• B
• gt nil
• nil
• gt t
• t

14
Avaliando Listas

• Assim como os símbolos, quando uma lista é
  apresentada ao interpretador, esta é entendida
  como uma função e avaliada a menos que seja
  precedida por um apóstrofe
• gt ( 1 2)
• 3
• gt '( 1 2)
• ( 1 2)
• gt (a b c)
• - EVAL the function A is undefined

15
Listas

• Em LISP, se algo não é um átomo, então é uma
  lista
• Uma lista é uma seqüência de átomos ou listas
  entre parênteses. Por exemplo
• (a b c) Lista com 3 elementos
• (d (e f) g) Lista com 3 elementos
• Observe que os elementos das listas têm que estar
  separados por um ou mais espaços em branco
• Observe também que ponto-e-vírgula denota o
  início de um comentário em LISP

16
Funções

• O primeiro elemento de uma lista pode portanto
  denotar o nome de uma função
• Nesse caso, os demais elementos são os argumentos
  da função
• Muitas funções são pré-definidas em LISP
• As seguintes são as que usaremos mais
• Aritmética - /
• Relacionais gt lt gt lt
• Lógicas and or not
• Manipulação de listas cons car cdr
• Condicionais if cond

17
Definindo Funções

• A forma especial defun é usada para definir uma
  função
• (defun nome lista-de-argumentos expressão)
• Define uma função chamada nome que avalia
  expressão substituindo os símbolos da
  lista-de-argumentos pelos valores passados quando
  a função for invocada
• Exemplo
• gt (defun test (a b) ( 2 ( a b)))
• TEST
• gt (test 3 4)
• 14

18
Examinando 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
Examinando Listas - Exemplo

• gt (car '(a b))
• A
• gt (cdr '(a b))
• (B)
• gt (car (cdr '(a b)))
• B
• gt (cdr (cdr '(a b)))
• NIL

20
Cons- truindo Listas

• (cons elem lista) retorna uma cópia de lista com
  elem inserido como seu primeiro elemento
• Exemplo
• gt (cons 'a '(b c))
• (A B C)
• gt (cons 'a '(b))
• (A B)
• gt (cons 'a nil)
• (A)
• Teorema (cons (car L) (cdr L)) L

21
Cons

• O que acontece se passarmos um átomo como segundo
  argumento de cons?
• gt (cons 'a 'b)
• (A . B)
• De onde veio o ponto entre A e B?
• Resposta
• O ponto sempre existe num cons, mas nem sempre é
  impresso
• Para entender, precisamos rever um conceito
  anterior ...

22
Conses (S-Expressions)

• Em LISP, se algo não é um átomo, então é um cons
  ou S-expression
• Um cons nada mais é que um registro com dois
  campos, o primeiro é chamado de car e o segundo
  de cdr
• A regra do ponto
• O cons é escrito com o valor dos dois campos
  entre parênteses ou separados por um ponto
• Entretanto, se o campo cdr é nil ou um cons, o
  ponto pode ser omitido

23
Conses Exemplos

• gt (cons 'a 'b)
• (A . B)
• gt '(a . b)
• (A . B)
• gt '(a . nil)
• (A)
• gt '(a . (b . (c . nil)))
• (A B C)
• gt '(a . (b . c))
• (A B . C)
• gt '((a . b) . c)
• ((A . B) . C)
• gt '((a . b) . (b . c))
• ((A . B) B . C)

24
Conses e Listas

• Podemos ver então que listas são conses que nunca
  são escritos com pontos
• Muitos autores preferem ignorar conses que não
  são listas
• Afinal, o que é então uma lista?
• Eis uma resposta formal
• Axioma nil é uma lista
• Teorema Se L é uma lista, e elem é um átomo ou
  uma lista, então (cons elem L) é uma lista

25
Cond -icionais

• A forma especial cond permite escrever funções
  que envolvem decisões
• Forma geral
• (cond (bool1 expr1)
• (bool2 expr2)
• ...
• (boolN exprN)
• )
• Funcionamento
• 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

26
If then else

• O cond pode ser usado como um if-then-else
• (cond (bool1 expr1)
• (bool2 expr2)
• (bool3 expr3)
• (t expr4))
• É equivalente à seguinte construção
• if bool1 then expr1
• else if bool2 then expr2
• else if bool3 then expr3
• else expr4

27
Exemplo

• gt (cond (( 1 2) 'a)
• ((gt 2 3) 'b)
• ((lt 3 4) 'c)
• )
• C
• gt (defun f (lista elem)
• (cond ((eq lista nil) nil)
• ((eq (car lista) elem) t)
• (t (f (cdr lista) elem))
• )
• )
• F
• gt (f '(a b c) 'c)
• T
• gt (f '(a b c) 'd)
• NIL

28
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 gt lt gt lt
• Argumentos devem ser números
• Para comparar símbolos usa-se o predicado eq
• Para comparar conses estruturalmente usa-se o
  predicado equal

29
Expressões Lógicas - Exemplos

• gt (or (lt 2 3) (gt 2 3))
• T
• gt ( 'a 'b)
• - argument to should be a number A
• gt (eq 'a 'b)
• NIL
• gt (eq 'a 'a)
• T
• gt (eq '(a b) '(a b))
• NIL
• gt (equal '(a b) '(a b))
• T

30
Exercícios

• Escreva as funções
• (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
• gt (apaga (a b c d a) a)
• (b c d)
• (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
• gt (acresc (a b c d a) a k)
• (a k b c d a k)