Carlos Cunha Joabe Jesus {ceac,

Carlos Cunha Joabe Jesus {ceac, jbjj}@cin.ufpe.br
Lisp & Common Lisp Carlos Cunha Joabe Jesus {ceac,

Roteiro Motivação Histórico Common Lisp Linguagem CLOS Aplicações

Motivação Poder de Abstração de Linguagens Funcionais
Relacionada ao projeto de pesquisa - Linguagem da implementação do núcleo do Z-EVES (provador de teoremas)

Histórico Concebida por John McCarthy no MIT em 1959
Influenciado pelo Cálculo Lambda de Alonzo Church Manipulação formal de funções matemáticas Acrônimo para List Processing

Histórico - Lisp e seus dialétos
Existiam vários dialetos: MacLisp Common Lisp Scheme ... Hoje LISP está padronizado e referenciado como COMMON LISP

O que é o Common Lisp? Uma das implementações de Lisp
Um “SDK” de domínio público Interpretador Compilador para executáveis até 5 vezes mais rápidos Conjunto de funções padrões

Common Lisp - Modularidade
Lisp permite: O empacotamento (packaging) de programas em módulos Sistema de objetos, funções genéricas com a possibilidade de combinação de métodos Definição de Macros

Common Lisp Tipos de dados

Common Lisp - Tipos de dados
números, caracteres, strings, arrays, listas, símbolos, estruturas, streams, ... Todos com tamanho ilimitado (a precisão e o tamanho de uma variável não necessita de ser declarado, o tamanho de listas e arrays altera-se dinamicamente) Integers de precisão arbitrária, precisão de ponto flutuante ilimitada

Common Lisp - “API” Funções genéricas:
88 funções aritméticas para todos os tipos de número (integers, ratios, floating point numbers, complex numbers) 44 funções de busca/filtro/ordenação para listas, arrays e strings

Common Lisp - Características
Tipagem em tempo de execução O programador geralmente não precisa se preocupar com declarações de tipo, mas ele recebe mensagens de erro caso haja violações de tipo (operações ilegais) Gerenciamento automático de memória (garbage collection)

Common Lisp - Tipos de Dados
Booleano LISP utiliza t e nil para representar verdadeiro e falso Lisp tem funções booleanas-padrão, como and, or e not. Sendo os conetivos and e or são curto-circuitantes

Símbolos Um símbolo é somente um string de caracteres a b c1 foo bar Qualquer símbolo cujo nome inicia com dois pontos (:_) é uma palavra-chave Simbolos auto avaliantes – t, nil, :___

Exemplo - Símbolos Ex: > (setq a 5) ; store a number as the value of a symbol 5 > a ; take the value of a symbol > (let ((a 6)) a) ;bind the value of a symbol temporarily to 6 6 > a ; the value returns to 5 once the let is finished > (+ a 6) ; use the value of a symbol as an argument 11 > b ; try to take the value of a symbol which has no value Error: Attempt to take the value of the unbound symbol b.

Números Um inteiro é um string de dígitos opcionalmente precedido de um + ou -. Um real parece com um inteiro, só que possui um ponto decimal e pode opcionalmente ser escrito em notação científica. Um racional se parece com dois inteiros com um / entre eles. LISP suporta números complexos que são escritos como: #c(r i)

Conses – Associações Produto Cartesiano -> Dupla Os campos são chamados de "car" e "cdr", ao invés de first e second > (cons 4 5) ; Aloca uma dupla, car = 4 e cdr = 5 (4 . 5) > (car (cons 4 5)) 4 > (cdr (cons 4 5)) 5

Listas (encadeadas) Construídas a partir de conses O car de cada cons aponta para um dos elementos da lista e O cdr aponta ou para outro cons ou para nil. Ex: > (list 4 5 6) (4 5 6) OBS: LISP imprime listas de uma forma especial, omitindo os pontos e parênteses internos dos conses

Listas (encadeadas) nil corresponde à lista vazia O car e cdr de nil são definidos como nil. O car de um átomo é o próprio átomo. O cdr de um átomo é nil. Se o cdr de um cons é nil, Lisp não se preocupa em imprimir o ponto ou o nil Se o cdr de cons A é cons B, então lisp não se preocupa em imprimir o ponto para A nem o parênteses para B

Listas (encadeadas) e Conses Ex: > (cons 4 nil) (4) > (cons 4 (cons 5 6)) ( ) > (cons 4 (cons 5 (cons 6 nil))) (4 5 6)

Ordenação de Listas LISP provê duas primitivas para ordenação: sort e stable-sort. O primeiro argumento para sort é uma lista, o segundo é a função de comparação. Ex: > (sort '( ) #'<) ( ) > (sort '( ) #'>) ( ) OBS: A função de comparação não garante estabilidade: se há dois elementos a e b tais que (and (not (< a b)) (not (< b a))), sort vai arranjá-los de qualquer maneira

A função stable-sort é exatamento como sort, só que ela garante que dois elementos equivalentes vão aparecer na lista ordenada exatamente na mesma ordem em que aparecem lista original

Funções de Lista Úteis > (append '(1 2 3) '(4 5 6)) ;concatena listas ( ) > (reverse '(1 2 3)) ;reverte os elementos (3 2 1) > (member 'a '(b d a c)) ;pertinência a conjunto ;retorna primeira cauda cujo car é o elemento desejado (A C) > (find 'a '(b d a c)) ;outro set membership A > (find '(a b) '((a d) (a d e) (a b d e) ()) :test #'subsetp) (A B D E) ;find é mais flexível

Funções de Lista Úteis > (subsetp '(a b) '(a d e)) ;set containment NIL > (intersection '(a b c) '(b)) ;set intersection (B) > (union '(a) '(b)) ;set union (A B) > (set-difference '(a b) '(a)) ;diferença de conjuntos

Common Lisp Igualdade

Common Lisp - Igualdade
LISP tem muitos conceitos diferentes de igualdade. Igualdade numérica é denotada por = Como em Smalltalk ou em Prolog, existem os conceitos de identidade (mesmo objeto) e igualdade (objetos distintos, porém iguais)

Dois símbolos são eq se e somente se eles forem idênticos (identidade). Duas cópias da mesma lista não são eq (são dois objetos diferentes) mas são equal (iguais) > (eq 'a 'a) T > (eq 'a 'b) NIL > (= 3 4) > (eq '(a b c) '(a b c)) > (equal '(a b c) '(a b c)) > (eql 'a 'a) > (eql 3 3)

O predicado eql é equivalente a eq para símbolos e a = para números. É a identidade que serve tanto para números como para símbolos. O predicado equal é equivalente eql para símbolos e números. Ele é verdadeiro para dois conses, se e somente se, seus cars são equal e seus cdrs são equal. Ele é verdadeiro para duas estruturas se e somente se as estruturas forem do mesmo tipo e seus campos correspondentes forem equal.

Common Lisp Funções

Common Lisp - Funções Definindo uma função:
> (defun foo (x y) (+ x y 5)) FOO > (foo 5 0) ;chamando a função 10 > (defun HELLO-WORLD () (print (list 'HELLO 'WORLD))) HELLO WORLD

Common Lisp - Funções Funcall, Apply, e Mapcar
São funções que pedem como argumento uma função: > (funcall #'+ 3 4) 7 > (apply #'+ 3 4 '(3 4)) 14 > (mapcar #'not '(t nil t nil t nil)) (NIL T NIL T NIL T)

Common Lisp - Funções Funcall chama seu primeiro argumento com os argumentos restantes como argumentos deste. Apply é semelhante a Funcall, exceto que seu argumento final deverá ser uma lista. Os elementos desta lista são tratados como se fossem argumentos adicionais ao Funcall. O primeiro argumento a mapcar deve ser uma função de um argumento. mapcar aplica esta função a cada elemento de uma lista dada e coleta os resulatdos em uma outra lista.

Utilidade de Funcall, apply e Mapcar
Funcall e apply são principalmente úteis quando o seu primeiro argumento é uma variável. Por exemplo, uma máquina de inferência poderia tomar uma função heurística e utilizar funcall ou apply para chamar esta função sobre uma descrição de um estado. As funções de ordenação de listas utilizam funcall para chamar as suas funções de comparação Mapcar, juntamente com funções sem nome (lambda) pode substituir muitos laços

Common Lisp - Funções Lambda
É uma função temporária e não nomeada > #'(lambda (x) (+ x 3)) (LAMBDA (X) (+ X 3)) > (funcall * 5) 8

Common Lisp - Funções Lambda
O poder de Lambda Ex: > (do ((x '( ) (cdr x)) (y nil)) ((null x) (reverse y)) (push (+ (car x) 2) y) ) ( ) > (mapcar #'(lambda (x) (+ x 2)) '( ))

Common Lisp Forms

Common Lisp - Forms Forms e o Laço Top-Level
Um Form é qualquer trecho digitado pelo usuário para o interpretador read-eval-print loop Lisp salva os três últimos resultados de forms previamente digitados. Ele os armazena sob os símbolos *, ** e ***.

Common Lisp - Forms Forms e o Laço Top-Level
Em geral, um form é ou um átomo (p.ex.: um símbolo, um inteiro ou um string) ou uma lista. Se o form for um átomo, LISP o avalia imediatamente. Símbolos avaliam para seu valor, inteiros e strings avaliam para si mesmos. Se o form for uma lista, LISP trata o seu primeiro elemento como o nome da função, avaliando os elementos restantes de forma recursiva. Então chama a função com com os valores dos elementos restantes como argumentos.

Common Lisp - Forms especiais
quote ‘ e function parecem chamadas a funções mas não são! Ex. quote: > (setq a 3) 3 > a > (quote a) A > 'a ; 'a is an abbreviation for (quote a)

Common Lisp Forms especiais Ex. function: > (setq + 3) 3 > +
> '+ + > (function +) #<Function #x-fbef9de> > #'+ ; #'+ is an abbreviation for (function +)

Common Lisp Binding

Common Lisp - Binding Binding é uma atribuição escopada lexicamente
Forms especiais let e let*: (let ((var1 val1) (var2 val2) ... ) body ) Let “atribui” val1 a var1, ..., e então executa os comandos de seu corpo Let* permite que sejam referenciadas variáveis definidas anteriormente

Common Lisp - Dynamic Scoping
No escopo dinâmico se você atribui um valor a uma variável, TODA menção desta variável vai retornar aquele valor até que você atribua outro valor à mesma variável Usa o form defvar

Common Lisp - Dynamic Scoping
Ex: > (defvar *special* 5) *SPECIAL* > (defun check-special () *special*) CHECK-SPECIAL > (check-special) 5 > (let ((*special* 6)) (check-special)) 6

Common Lisp Fluxo de controle

Common Lisp - Fluxo de controle
Execução seqüencial em Lisp O form progn permite blocos de comandos em seu corpo, que são executados sequencialmente e retornando o valor do último Permite também declaração explícita de variáveis locais, além de retorno explícito

Common Lisp - Fluxo de controle
Ex: (defun F2.17a nil (prog (i j) ;define i e j como variáveis locais inic. com nil (setq i (read)) (setq j (read) (return (print (- i j))) )

Common Lisp - Condicionais
Lisp possui um função para representar condicionais: > (if t 5 6) 5 > (if nil 5 6) 6 > (if 4 5 6) OBS: nil significa falso e qualquer outra coisa verdadeiro.

If’s sem then ou sem else podem ser escritos utilizando-se when ou unless, respectivamente: > (when t 3) 3 > (when nil 3) NIL > (unless t 3) > (unless nil 3)

Else If’s são descritos usando o form cond: Um cond consiste de símbolo con seguido por um número de cláusulas-cond, cada qual é uma lista. O primeiro elemento de uma cláusula-cond é a condição, os lementos restantes são a ação.

Ex: > (setq a 3) 3 > (cond ((evenp a) a) ; if a is even return a ((> a 7) (/ a 2)) ; else if a > 7 return a/2 ((< a 5) (- a 1)) ; else if a < 5 return a-1 (t 17) ; else return 17 ) 2 OBS: Se não há nenhuma ação na cláusula cond selecionada, cond retorna o valor verdadeiro

Form case Ex: > (setq x 'b) B > (case x (a 5) ((d e) 7) ((b f) 3) (otherwise 9) ) 3

Common Lisp - Iteração Lisp permite a utilização da função loop:
> (setq a 4) 4 > (loop (setq a (+ a 1)) (when (> a 7) (return a)) ) 8 > (loop (setq a (- a 1)) (when (< a 3) (return)) NIL

Common Lisp - Iteração dolist - ata uma variável aos elementos de uma lista na sua ordem e termina quando encontra o fim da lista: > (dolist (x '(a b c)) (print x)) A B C NIL

Common Lisp - Iteração Iteração com do e do*:
> (do ((x 1 (+ x 1)) ;variável x, com valor inicial 1 (y 1 (* y 2)) ; variável y, com valor inicial 1 ) ((> x 5) y) ;retorna valor de y quando x > 5 (print y) ; corpo (print 'working) ; corpo 1 WORKING 2 4 8 16 32

Common Lisp - Sáidas Não-Locais
O form especial return na seção de iteração é um exemplo de um return não-local. Outro exemplo é o form return-from, o qual retorna um valor da função que o envolve: > (defun foo (x) (return-from foo 3) x ) FOO > (foo 17) 3

Common Lisp - Blocos nomeados
Ex: > (block foo (return-from foo 7) 3 ) 7

Common Lisp - Gerando Erros
Ex: > (error "This is an error") Error: This is an error

Common Lisp - Extensões
Dados Avançados

Common Lisp - Dados Avançados
Estruturas: análogas a structs em "C" ou records em PASCAL O exemplo abaixo define um tipo de dado chamado FOO contendo 2 campos: > (defstruct foo bar quux ) FOO Define também 3 funções que operam neste tipo de dado: make-foo, foo-bar e foo-quux

Common Lisp - Dados Avançados
Estruturas: make-foo - cria um novo objeto FOO. As outras acessam os campos de um objeto do tipo FOO > (make-foo) #s(FOO :BAR NIL :QUUX NIL) > (make-foo :baa 3) #s(FOO :BAR 3 :QUUX NIL) > (foo-bar *) 3 > (foo-quux **) NIL

Common Lisp - “Atribuição”
O form especial setf usa seu primeiro argumento para definir um lugar na memória, avalia o seu segundo argumento e armazena o valor resultante na locação de memória resultante Setf é a única maneira de se setar os valores de um array ou os campos de uma estrutura

Common Lisp - “Atribuição”
Ex: > (setf a (make-array 1)) ; setf on a variable is equivalent to setq #(NIL) > (push 5 (aref a 1)) ;push can act like setf (5) > (pop (aref a 1)) ; so can pop 5 > (setf (aref a 1) 5) > (incf (aref a 1)) ; incf reads from a place, increments, and writes back 6 > (aref a 1)

Common Lisp A extensão CLOS

CLOS Extensão do Common Lisp para Orientação a Objetos
Características: Herança múltipla Funções genéricas Meta-classe e meta-objeto Técnica de criação e iniciação de objetos que permite controle do processo por parte do usuário

Classes CLOS Definida usando o form DEFCLASS Ex:
(DEFCLASS nodeDeClasse (nomeDeSuperclasse*) (slot*) opções* ) Se nomeDeSuperclasse* for vazio a superclasse padrão é STANDARD-OBJECT

Slots em CLOS Um slot tem a forma: As opções mais úteis são:
(nomeDoSlot slotOption*) As opções mais úteis são: :ACCESSOR function-name :INITFORM expression :INITARG symbol

Exemplo DEFCLASS Um DEFCLASS: (defclass person ()
((name :accessor person-name :initform 'bill :initarg :name) (age :accessor person-age :initform 10 :initarg :age)) )

DEFCLASS  DEFSTRUCT Sintaxe um pouco diferente Considere o DEFSTRUCT:
(defstruct person (name 'bill) (age 10) )

DEFCLASS  DEFSTRUCT DEFSTRUCT definiria automaticamente campos com expressões para: computar valores iniciais default funções de acesso (get e set) como PERSON-NAME e uma função de inicialização (MAKE-PERSON) que pegaria argumentos com palavras-chave como abaixo: (make-person :name 'george :age 12)

DEFCLASS  DEFSTRUCT DEFCLASS dá maior controle sobre quais coisas são chamadas, pois: Permite especificar quais funções auxiliares queremos, sendo mais flexível que o DEFSTRUCT

Objetos em CLOS Instâncias são criadas através da função MAKE-INSTANCE
Similar às funções MAKE-x definidas por DEFSTRUCT Permite que você passe a classe a ser instanciada como argumento EX: (MAKE-INSTANCE class {initarg value}*)

Objetos de Classe (“static”)
Uma classe, uma vez definida, também é um objeto Para obter um objeto-classe a partir de seu nome, usa-se: (FIND-CLASS name)

Métodos em CLOS Um DEFMETHOD (DEFMETHOD generic-function-name
specialized-lambda-list form*)

Métodos em CLOS Ex.: (defmethod test ((x number) (y number)) '(num num)) (defmethod test ((i integer) (y number)) '(int num)) (defmethod test ((x number) (j integer)) '(num int)) (test 1 1) => (int num), not (num int) (test 1 1/2) => (int num) (test 1/2 1) => (num int) (test 1/2 1/2) => (num num)

Combinação de Métodos :before :after :around
methods are all called before the primary method, with the most specific :before method called first :after methods are all called after the primary method, with the most specific :after method called last. :around methods run before the other methods. As with primary methods, only the most specific is called and call-next-method calls the next most specific

Combinação de Métodos - Ex.
(defclass food () ()) (defmethod cook :before ((f food)) (print "A food is about to be cooked.")) (defmethod cook :after ((f food)) (print "A food has been cooked.")) (defclass pie (food) ((filling :accessor pie-filling :initarg :filling :initform 'apple))) (defmethod cook ((p pie)) (print "Cooking a pie.") (setf (pie-filling p) (list 'cooked (pie-filling p)))) (defmethod cook :before ((p pie)) (print "A pie is about to be cooked.")) (defmethod cook :after ((p pie)) (print "A pie has been cooked.")) (setq pie-1 (make-instance 'pie :filling 'apple))

Combinação de Métodos – Ex.
Saída > (cook pie-1) "A pie is about to be cooked." "A food is about to be cooked." "Cooking a pie.“ "A food has been cooked." "A pie has been cooked." (cooked apple)

Lisp & Common Lisp Aplicações

Aplicações Utilizado para desenvolver o primeiro sistema computacional de matématica simbólica, o MACSYMA. Linguagem de extensão do software do AutoCAD, desenvolvido pela AutoDesk; e do editor de textos Emacs Estudos de semântica formal das línguas naturais e de programação

Aplicações Sistema de reserva de passagens Orbitz da ITA. Utilizado por diversas companhias aérias A Simbolics criou um sistema de modelagem 3D, adquirido pela IZWare e renomeado para Mirai, que foi utilizado nos efeitos de Senhor dos Anéis Sistema de e-commerce da viaweb (por Paul Graham) que posteriormente foi vendida para o Yahoo por US$ 40 milhões, na época da bolha da internet

Referências Introdução à Linguagem Lisp Common Lisp CLOS
Common Lisp CLOS

Lisp & Common Lisp Dúvidas?

Carlos Cunha Joabe Jesus {ceac,

Apresentações semelhantes

Apresentação em tema: "Carlos Cunha Joabe Jesus {ceac,"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Carlos Cunha Joabe Jesus {ceac,

Apresentações semelhantes

Apresentação em tema: "Carlos Cunha Joabe Jesus {ceac,"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback