ISBC. José Angel Bañares. II-1998. clos.ppt 24/02/98 1 CLOS Representación estructurada del...

ISBC. José Angel Bañares. II-1998. clos.ppt 24/02/98 1

CLOSCLOS Representación estructurada del conocimiento

Representación estructurada del Conocimiento.CLOS: The Common Lisp Object System

Representación estructurada del Conocimiento.CLOS: The Common Lisp Object System

Copyright © 1998 José Angel Bañares

Última revisión: Nov. 2003

Departamento de Informática e Ingeniería de SistemasC.P.S. Universidad de ZaragozaDepartamento de Informática e Ingeniería de SistemasC.P.S. Universidad de Zaragoza

J.A. Bañares Bañares


CLOSCLOS Índice

1. Introducción

2. Elementos CLOS– 2.1 Clases e Instancias

– 2.2 Funciones Genéricas y Métodos

3. Programación con Métodos– 3.1 Combinación de métodos

– 3.2 Multi-métodos

4. Herencia– 4.1 Lista de precedencia de clases

– 4.2 Herencia de slots y opciones de slots

5. Implementación de demons 6. Control del selector de métodos

– Técnicas imperativas

– Técnicas declarativas

7. Ejemplo de programación CLOS


CLOSCLOS 1. Introducción

CLOS: Common Lisp Object Systems.– Supone la incorporación de la programación

orientada a objeto al lenguaje Common-lisp

» Integración de la programación funcional y la programación orientada a objeto.

» Como resultado del proceso de estan-darización del Common LISP se incorpora CLOS.

ANSI X3J13, DRAFT 1988 Guy L. Steele, J.R. “Common Lisp. The Language (segunda edición)”

Introducción


CLOSCLOS Introducción

Objetivos en el diseño de CLOS: (Sonya E., Keen 89. “Object Oriented programming in Common Lisp. A programmers guide to CLOS.”)

1 Extensión del estándar Common Lisp que inclu-ya aspectos del paradigma de POO.

2 La interfaz que ofrezca CLOS a los programa-dores debe ser sencillo y potente:

» El programa se estructura reflejando la estructura del sistema que se está modelando.

» Los usuarios utilizan un programa a través de una interfaz bien definida.

» Utilización de las clases como elemento básico de modularidad.

3 CLOS debe ser diseñado como un protocolo extensible. El “Meta Object protocol” permite adaptar el lenguaje.

4 CLOS no fuerza la utilización de un estilo orien-tado a objeto.

Introducción


CLOSCLOS

2. Elementos CLOS(Interfaz del Programador)

2.1. Clases e Instancias:– Una clase define un nuevo TIPO Common

Lisp: Las instancias de una clase tienen la misma estructura, comportamiento y son del mismo tipo. Además cada instancia tiene una identidad separada.

(DEFCLASS nombre-clase (nombres-superclases)*(descripción-slots)opciones-clase*)

Descripción-slots= (nombre-slot opciones-slot*)

Cada opción es una “Keyword”: :ACCESSOR nombre-función :INITFORM expresión :INITARG symbol

2. Elementos CLOS


CLOSCLOS Clases e Instancias

Comparación con DEFSTRUCT(DEFSTRUCT persona

(nombre Juan)(edad 26))

DEFSTRUCT define automáticamente * Los atributos con los valores por defecto* funciones de acceso como PERSONA-NOMBRE para leer y modificar el valor del atributo y la función MAKE-PERSONA para crear instancias e inicializar los valores con Keywords :

(MAKE-PERSONA :nombre ‘Pepe :edad 3)

(DEFCLASS persona ()((nombre :accessor nombre-persona :initform Juan :initarg :nombre)(edad :accessor edad-persona :initform 26 :initarg :edad)))

DEFCLASS define * Los atributos con los valores por defecto en :initform* funciones de acceso como indicadas en :accesor* keywords para inicializar la instancia en :initarg

(MAKE-INSTANCE ‘persona :nombre ‘Pepe :edad 3)

2.1 Elementos CLOS


CLOSCLOS¿Porqué definir tipos mediante Clases?

Las clases permiten definir TADs, separan-do claramente la interfaz de un objeto de la implementación.

– El mecanismo que permite definir la interfaz de una clase son las FUNCIONES GENERICAS

CLOS permite la definición de una clase a partir de otras clases mediante herencia múl-tiple.

– Las clases HEREDAN tanto la estructura (atributos) como el comportamiento (la interfaz y la implementación) de las clases padres (*).

OOP = TADs +HerenciaOOP = TADs +Herencia

2.1 Elementos CLOS

(*) Defstruct permite definir una nueva estructura a partir de otra estructura (sólo una) definida previa- mente. Sólo se heredan las funciones de acceso a los atributos, y no es posible especializar dichas funciones. Una estructura no encapsula el comportamiento de un TAD.


CLOSCLOSFunciones Genéricas y Métodos

2.2. Las funciones genéricas son funciones que se comportan de diferente manera dependiendo del tipo e identidad de los argumentos.

- Ejemplo con funciones ordinarias:

(defun tipo-de (x) (typecase x (number (format T "~% ~a es un numero"x)) (list (format T "~% ~a es una lista"x)) (symbol (format T "~% ~a es un simbolo"x))))

- Ejemplo con funciones genéricas:

(defgeneric tipo-de (x) (:documentation"Indica el tipo de un objeto"))

(defmethod tipo-de ((x number)) (format T "~% ~a es un numero"x))

(defmethod tipo-de ((x list)) (format T "~% ~a es una lista" x))

(defmethod tipo-de ((x symbol)) (format T "~% ~a es un simbolo" x))

2.2 Elementos CLOS


CLOSCLOSFunciones Genéricas y Métodos

Sin funciones genéricas hay que localizar y modificar las funciones que se vean afectadas por la introducción del nuevo tipo (utilización de “cond”, typecase”, “case”)

Con funciones genéricas es fácil contemplar el comportamiento de una función para nuevos tipos

(DEFCLASS persona () ((nombre :accessor nombre-persona :initform 'Juan :initarg :nombre)(edad :accessor edad-persona :initform 26 :initarg :edad)))

(defmethod tipo-de ((x persona)) (format T "~% ~a es una persona" x))

? (setf pepe (make-instance 'persona :nombre 'pepe :edad 22))#<PERSONA #x319A29>? (tipo-de pepe) #<PERSONA #x319A29> es una personaNIL?

2.2 Elementos CLOS


CLOSCLOS Funciones Genericas

2.2 Elementos CLOS

Para el usuario, las funciones genéricas son exáctemente igual a una función ordinaria: La sintáxis para invocar ambas es exactemente igual.

La semántica es diferente: Una función ordinaria especifica el interfaz y

la implementación de la operación:

valores

efectos laterales

Implementación e interfaz

argumentos

(defun nombre lambda-list {form}* )

Función Lisp ordinaria


CLOSCLOS Funciones genéricas

Una función genérica sólo especifica el interfaz. La implementación se distribuye en un conjunto de métodos:

2.2 Elementos CLOS

(defgeneric nombre lambda-list )

interfazargumentos

valores

efectos laterales

valores

efectos laterales

valores

efectos laterales

ImplementacionesImplementacionesFunción Genérica


CLOSCLOS Métodos

Los métodos definen las distintas implemen-taciones de una función genérica:

2.2 Elementos CLOS

Método list

symbolMétodo

numberMétodo

personaMétodo

tipo-de

(defmethod nombre-genérico lambda-list-especializado {form}* )

Métodos de tipo-de


CLOSCLOS

Funciones Genéricas como soporte de la POO

El papel de las funciones genéricas como soporte de LOOs es relativamente nuevo:

– El modelo clásico se basa en el paso de men-saje:

» (send instancia nombre-operación arg*)

» La instancia que recibe el mensaje es la responsable de “interpretar “ y “ofrecer” el servicio.

– El modelo basado en funciones genéricas se le denomina Modelo de objetos generalizado.

En el modelo generalizado es más adecuado cuando no se sabe como descomponer la aplicación en componentes individuales.

2.2 Elementos CLOS


CLOSCLOS

Funciones Genéricascomo soporte de la POO

Ventajas del uso de func. genéricas:1 Extensión natural de las funciones genéricas

preexistentes en Common Lisp.

2 Todas las funciones se llaman con la misma sintáxis.

3 Permiten definir operaciones para nuevos tipos (Extensibilidad).

4 Son la base para la herencia del compor-tamiento entre clases.

2.2 Elementos CLOS

(DEFCLASS trabajador (persona))

(defmethod tipo-de ((x persona)) (format T "~% ~a es una persona" x))

? (setf Juan (make-instance 'trabajador :nombre 'Juan :empresa 'ACME))#<TRABAJADOR #x2DD5B9>? (tipo-de Juan) #<TRABAJADOR #x2DD5B9> es una personaNIL?


CLOSCLOS3. Programación con Métodos

Cuando una función genérica es invocada CLOS selecciona el conjunto de métodos aplicables, y se ejecuta el más específico.

– Cuando los métodos de una función genérica especializan un único parámetro se habla de la herencia de métodos. Un método está ligado a una clase o instancia.

– Cuando los métodos especializan más de un parámetro es más adecuado hablar de la aplicabilidad de un método. Un método está ligado a más de una clase o instancia: (MULTI-METODOS)

3 Programación con métodos


CLOSCLOSProgramación con métodos

Aplicabilidad de un método:1. Se seleccionan médodos aplicables:Un método es aplicable si cada uno de sus parámetros especializados es satisfecho por los argumentos corres-pondientes de la función genérica. 2.Se clasifican los métodos en orden de precedencia:Especializar con un valor es más especifico que especializar con una clase. Cuando se especializa con clases, la lista de precedencia de clases indica cual es más específica.

Herencia de un método:Cuando una función genérica tiene un método para una instancia se aplica. Sino, CLOS busca entre los métodos aplicables en las clases padres, y sino encuentra un métodoaplicable continúa con las superclases de los padres, y así sucesivamente.




Ejemplo: (Inventario de un almacen)

?(defclass mercancia () ((nombre :initarg :nombre :accessor nombre) (PVP :initarg :precio :accessor precio) (coste :initarg :coste :accessor coste) (cantidad :initarg :cantidad :accessor cantidad :initform 0)))#<STANDARD-CLASS MERCANCIA>?(setf Naranjas (make-instance 'mercancia :nombre 'Naranjas :precio 100 :coste 80 :cantidad 200))#<MERCANCIA #x346271>?(describe Naranjas)#<MERCANCIA #x346271>Class: #<STANDARD-CLASS MERCANCIA>Wrapper: #<CCL::CLASS-WRAPPER MERCANCIA #x30CB99>Instance slotsNOMBRE: NARANJASPVP: 100COSTE: 80CANTIDAD: 200




(defmethod describe((objeto standard-object)) ...)

(defmethod describe((objeto mercancia)) ...)

Parámetro especializado

clase

(defgeneric describe (objeto) (:documentacion “Predefinido”)

STANDARD-OBJECT

MERCANCIA

Naranjas

(defmethod describe((objeto (eql Naranjas)) ...)

Parámetro especializado

valor

?(defmethod describe ((objeto mercancia)) (format t "~% NOMBRE: ~a" (nombre objeto)) (format t "~% PVP: ~a" (precio objeto))(values))#<STANDARD-METHOD DESCRIBE (MERCANCIA)>?(describe naranjas)NOMBRE: NARANJASPVP: 100?(defmethod describe ((objeto (eql Naranjas))) (format t "~% Las Naranjas están a ~a/kg" (precio objeto)))#<STANDARD-METHOD PRINT-OBJ ((EQL #<MERCANCIA #x346271>))>?(describe Naranjas) Las Naranjas están a 100/kg



CLOSCLOSCombinación de Métodos

CLOS permite dividir la implementación de una función genérica, para unos argumentos dados, en varios métodos. Para ello utiliza:

– La clase de método (“Role method”)

» Método primario: Hace la mayor parte del trabajo. Devuélve el valor que devolvera la función genérica.

» Métodos before: Son llamados antes del método primario. No devuelve valor.

» Metodos after: Son llamados después del método primario. No devuelve valor.

– La herencia de métodos: Dado que las clases heredan métodos, este esquema permite dividir la labor entre clases y superclases.

3 .1 Programación con métodos


CLOSCLOSCombinación de métodos

(defvar *caja* 1000000) ;Dinero en caja;;; Clase Mercancia

;;; Funciones para manejar el almacen(defgeneric vender (producto))(defgeneric comprar (producto))

(defmethod vender ;método primario ((producto mercancia)) (if (< (cantidad producto) 1) (format T "~S está agotado.~%" (nombre producto)) (progn

(decf (cantidad producto))(incf *caja* (precio producto)))producto))

(defmethod comprar ;método primario ((producto mercancia) cantidad) (decf *caja* (* cantidad (precio producto))) (incf (cantidad producto) cantidad) producto)




;;; La mercancia puede llevar o no IVA;;; El vendedor apunta la parte correspon-;;; diente de IVA en *impuestos-a-pagar*

(defconstant *impuesto* 0.08)(defvar *impuestos-a-pagar* 0)

(defclass mercancia_con_IVA (mercancia)()) ;;; Reescritura del método primario

(defmethod vender ((producto mercancia_con_IVA)) (if (< (cantidad producto) 1) (format T "~S está agotado.~%" (nombre producto)) (progn

(decf (cantidad producto))(incf *caja* (precio producto)))

(incf *impuestos-a-pagar* (* precio producto *impuesto*)) producto )))




;;; La mercancia puede llevar o no IVA;;; El vendedor apunta la parte correspon-;;; diente de IVA en *impuestos-a-pagar*

(defconstant *impuesto* 0.08)(defvar *impuestos-a-pagar* 0)

(defclass mercancia_con_IVA (mercancia)()) ;;; Utilizando un método after(defmethod vender :after ((producto mercancia_con_IVA)) (incf *impuestos-a-pagar* (* precio producto *impuesto*)))

NOTA: Si ya hemos definido el método primario para mercancia_con_IVA, y queremos retirarlo:

(remove-method (symbol-function ‘vender) (find-method (symbol-function ‘vender)) nil (list (find-class ‘mercancia_con_IVA))))




vender

Métodoprimario

Métodoafter

Devuelve valor+

Efectos laterales

Efectos laterales

CLOS encuentra todos los métodos aplicables, que pueden ser primary, after, before. A continuación invoca a los métodos aplicables de la siguiente manera:

1. Todos los métodos before, invocando primero los más específicos.2. El método primario más específico.3. Todos los métodos after, invocando primero los menos específicos.

1º Invoca primario de vender para mercancia2º El método after para mercancia_con_IVA

(vender ‘instancia_mercancia_con_IVA)


mercancia

mercancia_con_IVA



Imaginemos mercancia y mercancia_con_IVA tienen definidos métods primarios, before y after para vender:

after

vender

mercancia

mercancia_con_IVA

before

primario

before

primario

after

mercancia_con_IVA

mercancia_con_IVA

mercancia

mercancia

(vender ‘instancia_mercancia_con_IVA)método before para mercancia_con_IVA método before para mercancia método primary para mercancia_con_IVA método after para mercanciamédotodo after mercancia_con_IVA



CLOSCLOS Multi-Métodos

Operaciones cuya implementación depende del tipo de más de un argumento.

Ejemplo: Programa instalación software:Una compañia tiene dos productos “Contabilidad” y“Aventura” sobre dos sistemas operativo, UNIX y GENERA.La compañia espera contar con más productos, y para másplataformas, así que el programa de instalación debe serextensible.

Clases:

STANDARD-OBJECT

PRODUCTO SO

CONTABILIDAD AVENTURA UNIX GENERA



CLOSCLOSArgumentos de los multi-métodos

(defgeneric instala (prod-soft sist-op) (:documentation “Instala software sobreel sistema operativo”))

;;; Método 1(defmethod instala ((soft producto) (sist-op so)) body)

;;; Método 2(defmethod instala ((soft producto) no-so) (error “No se puede instalar porque ~A no es un sistema operativo reconocido” no-so))

;;; Método 3(defmethod instala (no-soft (sist-op so)) (error “No se puede instalar porque ~A no es un producto reconocido” no-soft))

;;; Método 4(defmethod instala (no-soft no-so)) (error “No se puede instalar porque ~A no es un producto reconocido, y ~A no es

un sistema operativo reconocido” no-soft no-so))



CLOSCLOS Aplicabilidad de Multi-métodos

Método Lambda-list

Método 1 ((soft producto) (sist-op so))Método 2 ((soft producto) no-so)Método 3 (no-soft (sist-op so))Método 4 (soft no-so)

CLOS permite especializar cualquier parámetro:

Un método es aplicable si cada parámetro especializado es “SATISFECHO”.

SATISFECHO significa:

- El argumento es del tipo del parámetro especializado, es decir, es una instancia de la clase o una instancia de una subclase.

Todos los objetos son del tipo t , por lo tanto un parámetro no especializado es satisfecho por cualquier argumento. Por lo tanto,el método 4, es satisfecho por cualquier par de argumentos.

Supongamos que “instala” es llamada con dos argumentos válidos: una instancias *contabilidad* de CONTABILIDAD, y otra *genera*de GENERA. Para estos argumentos los 4 métodos son APLICABLES.



CLOSCLOSOrden de Precedencia de Multi-métodos

CLOS ordena los métodos aplicables en orden de precedencia, considerando los argumentos requeridos del método de izquierdaa derecha, con respecto a sus especializadores de parámetro.

Método Primer parámetro especializado por

Método 1 producto Método 2 producto Método 3 tMétodo 4 t

1. Clase del especializador del primer parámetro requerido:

La lista de precedencia de clases del correspondiente argumentodetermina cual de estas clases es más específica.

La clase del primer argumento *Contabilidad*, es CONTABILIDAD, y su lista de precedencia de clases es: (CONTABILIDAD PRODUCTO t)PRODUCTO es más específico que t => métodos 1 y 2 son más especí-ficos.

Método Segundo parámetro especializado por

Método 1 SO Método 2 t

2. Clase del especializador del segundo parámetro requerido:

La clase del segundo argumento *genera*, es GENERA, y su lista de precedencia de clases es: (GENERA SO t).SO es más específico que t => métodos 1es más específico.



CLOSCLOSOrden de precedenciade Multi-métodos

3. Clase del especializador del segundo parámetro requerido para ordenar métodos 3 y 4:

Método Segundo parámetro especializado por

Método 3 SO Método 4 t

La clase del segundo argumento *genera*, es GENERA, y su lista de precedencia de clases es: (GENERA SO t).SO es más específico que t => método 3 es más específico que el 4.

La precedencia de métodos es: (Método1 Método2 Método3 Método4)

Intuitivamente:- Método1 es el más específico por especializar más parámetros, y Método4 el menos específico. - Entre Método2 y Método3, el Método 2 es más específico porque el oden de los parámetros en la Lambda-list afecta la precedencia de métodos: Por defecto los parámetros a la izq. son más específicos.

Método Lambda-list

Método 2 ((soft producto) no-so)Método 3 (no-soft (sist-op so))

NOTA: 1. La precedencia de los parámetros a la izquierda se puede cambiar con la opción :argument-precedence-order. 2. Los parámetros especializados con valores son más específicos.



CLOSCLOSImplementación Multi-métodos

;;;La instalación tiene 4 pasos;;; Método 1(defmethod instala ((soft producto) (sist-op so)) (lee-disco soft sist-op) (compila-soft soft sist-op) (configura-soft soft sist-op) (verifica-soft))

;;; lee-disco dependerá del so

(defmethod lee-disco (soft (so genera)) body)

(defmethod lee-disco (soft (so unix)) body)

;;; La única parte de lee-disco que depen-;;; de del producto es el path(defgeneric path-fuente (producto sist-op)(:documentation “Devuelve un string”))

(defmethod path-fuente ((p contabilidad) (so unix)) “/bin/finanzas/contabilidad.lsp”))(defmethod path-fuente ((p contabilidad) (so genera)) “sys:finanzas;contabilidad.lsp”))

.............



CLOSCLOS4. Herencia: La lista de Precedencia de Clases

CLOS calcula la lista de precedencia de clases para cada clase:

– Regla1 : Cada clase tiene precedencia sobre sus superclases

– Regla2: En la definición de una clase se establece el orden de precedencia de sus superclases

Casos:– Caso 1. Es posible encontrar una única lista de

precedencia de clases:

4 .1. Herencia

Ejemplo:

(defclass stream () ())(defclass input-stream (stream) ())(defclass char-stream (stream) ())(defclass char-input-stream (char-stream input-stream)())

input-stream>>stream 1 input-streamchar-stream>>stream 1 char-streamchar-input-stream>>char-stream 1 char-input-streamchar-input-stream>>input-stream 1 char-input-streamchar-stream>>input-stream 2 char-input-stream

Rescricción Regla Clase

(char-input-stream char-stream input-stream stream standard-object t)


CLOSCLOSLa lista de precedencia de clases

– Caso 2. Es posible encontrar varias listas que satisfacen las restricciones

– CLOS usa un algoritmo que siempre da un orden determinado.

– El algoritmo intenta mantener juntas las clases de un árbol (family trees).

Ejemplo:

(defclass stream () ())(defclass buffered-stream (stream) ())(defclass disk-stream(buffered-stream) ())

(defclass char-stream (stream)())(defclass ascii-stream (char-stream)())

(defclass ascii-disk-stream (ascii-stream disk-stream)())

buffered-stream>>stream 1 buffered-streamdisk-stream>>buffered-stream 1 disk-streamchar-stream>>stream 1 char-streamascii-stream>>char-stream 1 ascii-streamascii-disk-stream>>ascii-stream 1 ascii-disk-streamascii-disk-stream>>disk-stream 1 ascii-disk-streamascii-stream>>disk-stream 2 ascii-disk-stream


4 .1. Herencia



Tres posibles ordenaciones:No hay restricciones sobre la precedencia entre char-stream y buffered-stream, ni entre char-stream y disk-stream.

(ascii-disk-stream ascii-stream char-stream disk-stream buffered-stream stream standard-object t)

(ascii-disk-stream ascii-stream disk-stream buffered-stream char-stream stream standard-object t)

(ascii-disk-stream ascii-stream disk-stream char-stream buffered-stream stream standard-object t)

t

standard-object

stream

ascii-disk-stream

char-stream

ascii-stream

buffered-stream

disk-stream

family tree 1 family tree 2

CLOS elige la primera ordenación porque mantiene las “family trees”.

4 .1. Herencia



Algunas veses no es posible mantener intactas las “family trees”, pero si dos superclases tienen una “raiz común”, esta es movida al final de la lista.

Ejemplo: A tiene a B y C como superclases directas, y las listas de precedencia de B y C son. La raíz común es movida al final.

B (B B1 B2 B3 B4 D D1 D2 standard-object t) C (C C1 C2 D D1 D2 standard-object t)

Clase Lista de precedencia de clases

(A B B1 B2 B3 B4 C C1 C2 D D1 D2 standard-object t)

Ejemplo: Queremos que disk-stream preceda a char-stream, y que la clase char-stream preceda a buffered-stream.

(defclass ascii-disk-stream (ascii-stream disk-stream char-stream buffered-stream)())

disk-stream>>char-stream 2 ascii-disk-streamchar-stream>>buffered-stream 2 ascii-disk-stream


(ascii-disk-stream ascii-stream disk-stream char-stream buffered-stream stream standard-object t)

Si preferimos un determinado orden entre los posibles se debe hacer explícito.

4 .1. Herencia



– Caso 3. No es posible encontrar una lista que satisfaga las restricciones.

Ejemplo:

(defclass stream ()())(defclass buffered-stream (stream) ())(defclass disk-stream (buffered-stream) ())(defclass char-stream (stream) ())(defclass ascci-stream (char-stream) ())

(defclass ascii-disk-stream (ascii-stream buffered-stream disk-stream)())

disk-stream>>buffered-stream 1 disk-streambuffered-stream>>disk-stream 2 ascii-disk-stream


Nota:1. Dos clases pueden tener listas con ordenes opuestos si no se intenta construir clases con ambas clases como padres.2. (CLASS-PRECEDENCE-LIST class) devuelve la lista de precedencia de una clase. (CLASS-DIRECT-SUPERCLASSES class) devuelve la lista de padres directos. (CLASS-DIRECT-SUBCLASSES class) devuelve la lista de subclases.

4 .1. Herencia


CLOSCLOSHerencia de slots y opciones de slots

Una clase puede modificar o reescribir “aspectos” heredados de un slot, mediante la especificación de un slot local con el mismo nombre.

4. 2. Herencia

Ejemplo:

(defclass persona () ((edad :initarg :edad))) (defclass mayor-edad (persona) ((edad :initform 18)))

Características Slot De la clase

El propio slot edad persona :initarg :edad persona:initform 18 mayor-edad


CLOSCLOSHerencia de slots y opciones de slots

Herencia de cada opción:

:accessor, :reader, :writer (No se heredan)

Crean métodos que se heredan, pero estas opciones no son heredadas.

:allocation (herencia por “shadowing”)

Si se el más específico es :allocation :instance o no se especifica, el slot es local. Si es :allocation :class el slot

es compartido.

:documentation (herencia por “shadowing”)

:initarg (herencia por “union”)

Si varias clases en la lista de precedencia tienen esta opción

el slot puede ser inicializado con cualquiera de los initargs

:initform (herencia por “shadowing”)

El valor por defecto del slot viene dado por el initform más

específico.

:type (herencia por “and”)

El tipo del slot es controlado por todos los especificadores

que aportan la opción :type. Por ejemplo si tres clase espe-

cifican el tipo como number, rational e integer, entonces el slot debe satisfacer:

(typep value ‘(and number rational integer))

Por lo tanto una clase no puede “relajar” el tipo de un slot.

.

4. 2. Herencia


CLOSCLOS5. Implementación de “Demons”

Un “demon” es una acción que se ejecuta cuan-do se realiza alguna acción básica como leer o escribir el valor de un slot.

– Un “demon” puede ser fácilmente implemen-tado mediante un método after o before que especializa los métodos generados por :Accessor, :write o :read.

5 Demons


CLOSCLOSImplementación de “demons”

5 Demons

Ejemplo:

(defclass triangulo (figura) ((lado-a :accessor lado-a :initarg :lado-a) (lado-b :accessor lado-b :initarg :lado-b) (lado-c :accessor lado-c :initarg :lado-c) (area :reader :initarg :area) (lados :reader lados :initform 3 :allocation :class)))

;;; Funciones (defun area-de-triangulo (a b c) ;;; area = ab(sin c)/2 (let ((angulo-C (angulo-triangulo c a b))) (* a b (sin angulo-C) .5)))(defun angulo-triangulo (a b c) ;;; Ley del coseno: a^2=b^2+c^2-2bc(cos a) (acos (/ (- (+ (expt b 2) (expt c 2)) (expt a 2)) (* 2 b c))));;; Método(defmethod area ((tri triangulo))

(area-de-triangulo (lado-a tri) (lado-b tri) (lado-c tri)))


CLOSCLOSImplementación de “demons”

Queremos que cada vez que se modifique el valor de un ladose recalcule el área:

(defmethod (setf lado-a) :after (a-nuevo (tri triangulo)) (setf (area tri) ;;;!!! (area-de-triangulo a-nuevo (lado-b tri) (lado-c tri))))

;;; lo mismo para los otros lados.

NOTA: :writer, :read y :accesor permiten definir métodos para acceder a los slots. Pero estos se pueden definir directamentede la siguiente manera:

;;; Definiendo el reader lado-a.

(defmethod lado-a ((tri triangulo)) (slot-value tri ‘lado-a))

;;; Definiendo el writer (setf lado-a).

(defmethod (setf lado-a) (a-nuevo (tri triangulo)) (setf (slot-value tri ‘lado-a) a-nuevo))

5 Demons


CLOSCLOS6. Control del selector de Métodos

Programación declarativa e Imperativa– CLOS ofrece técnicas de “Programación decla-

rativa”. Cuando se declaran métodos de distintos tipos (primary, after, before) se confía en que “CLOS “ combinará los métodos de forma preestablecida. Ejemplo: la implementación de demons: Un método before se ejecutará siempre después de un método primario, por lo que no es necesario invocar explí-citamente el código del demon.

» CLOS permite además:• Utilizar otras formas de combinar métodos

predefinidas

• O definir nuevas formas de combinación de métodos

– CLOS ofrece también técnicas de “Programa- ción imperativa” que permiten controlar ex- plícitamente que método será llamado a conti- nuación:

» Around-methods: Controlan que método va a ser invocado a continuación.

» Call-next-method en métodos primarios permite invocar al método primario reescrito (más específico).

6 Control del selector de métodos


CLOSCLOS Métodos Around

6.1 Control del selector de métodos

Comportamiento con métodos around:1. CLOS llama al método around más específico.2. Cuando un método around llama a call-next-method *Si hay otros métodos around aplicables son invocados, y sus valores devueltos por call-next-method *Sino, CLOS utiliza el comportamiento por defecto: se llama a los métodos before, primary after.

Ejemplo: Método para instalar cualquier producto en cualquier sistemaoperativo. El tipo del método :around es adecuado para calcular el tiempode la instalación

(defmethod instala :around ((soft producto) (sist-op so)) (declare (ignore soft sist-op)) (let* ((start-time (get-internal-real-time))

(result (call-next-method))(if (null result) (format t "~% Instalación completada en

~A segundos." (round (- (get-internal-real-time) start-time) internal-time-units-per-second))(format t "~% Instalación fallida."))

result))


CLOSCLOS Métodos Around

Aspectos de los métodos around:

– Comunicación entre métodos: Un método around puede utilizar los valores devueltos por call-next-method.

– Un método around permite definir código asociado a clases menos específicas que realicen cómputos anteriores para métodos definidos para clases más específicas.

– El uso de métodos around puede llevar código no modular. Es preciso tener conocimiento de otros métodos aplicables. En el ejemplo, si hubiera otro método around más específico sería llamado antes, y el tiempo devuelto podría no ser el tiempo completo de la instalación.

– Un método around puede decidir el llamar o no a call-next-method.

6 .1 Control del selector de métodos


CLOSCLOSTipos de combinación de métodos

Cada función genérica tiene un tipo de combi-nación de métodos:

– El tipo de combinación de métodos controla:» Los tipos de métodos soportados (after, before,

primary, around)

» El orden en que son llamados (Como se combi- nan los métodos aplicables en el método efec-tivo)

» La forma en que se devuelven los valores de la función genérica.

– Tipos de combinación de métodos predefinidos:» standard + and append list

max min nconc or progn



CLOSCLOSCombinación standard de métodos

Tipos de métodos soportados: after, befor, around y primary (calificadores :after, :around, :before)

– Soporta la invocación de call-next-method en métodos primarios y around.

Flujo de control del método de combinación:


PASO BEFORE: Hay algú método before no invocado?SI: Llama al método before no invocado más especifico. Cuando el método acaba, repite este paso. NO:

PASO AROUND: Hay algún método around no invocado?SI: Llama al método around no invocado más especifico. Si el método utiliza call-next-method, repite este paso Si el método no utiliza call-next-method, ir a HECHO Cuando el método acaba, devuelve valores al que invocóNO:

START: La entrada es una lista de métodos aplicables.

PASO PRIMARY: Hay algú método primary no invocado?SI: Llama al método primary no invocado más especifico. Si el método usa call-next-method, repite este paso. Cuando el método acaba, devuelve valores al que invocó NO:

PASO AFTER: Hay algú método after no invocado?SI: Llama al método before no invocado menos especifico. Cuando el método acaba, repite este paso. NO:

HECHO:Devuelve control y valores al que invocó


CLOSCLOS

Otros tipos decombinación de métodos

Soportan métodos primary y around , pero no before y after.

Soportan el uso de call-next-method en métodos around, pero no en métodos primarios

Llama a todos los métodos primarios aplicables de más a menos específico

Todos los tipos tienen nombres iguales a funciones LISP, que nos indican como combinar las llamadas a los métodos primarios:


Ejemplo: (defclass Componente ()())(defclass Componente1 (componente)())(defgeneric total-energia (Componente) (:method-combination +))(defmethod total-energia + ((C Componente))1)(defmethod total-energia + ((C Componente1))2)

?(total-energia (make-instance 'Componente1))3

(operador (método-primario1 args) (método-primario2 args) ... (método-primarion args))


CLOSCLOS

Definición de un nuevo tipo de combinación de métodos

6 .2Control del selector de métodos

Ejemplo: Si el tipo progn no estuviera definido se podría definir así:

(define-method-combination progn:operator progn:identity-with-one-argument t)

* :operator especifica el operador que recibirá los valores de los métodos.*:identity-with-one-argument, indica que si sólo hay un argumento se devuelva el valor del método en vez de aplicar el operador.

NOTAS:- Los tipos de combinación definidos soportan métodos primarios y around, pero no after y before. Métodos around pueden llamar call-next-method, pero no los primarios. - Se pueden definir tipos de combinación más sofisticados (ver manual) .


CLOSCLOS7. EJEMPLO de programa CLOS

Modelado de un circuito electrónico: El circuito consta de puertas AND, OR, NOT, divisores, etc. El objetivo es definir un circuito componiendo puertas, y que al cambiar el valor de las entradas el circuito actualice automáticamente las salidas.

•Definición de clases

•Definición del interfaz

•Definición de la implementación


CLOSCLOSEjemplo de programa CLOS

1. Definición de clases Componentes circuito

puerta-and

puerta-xor

puerta-or

standard-object

sin-salidas sin-entradas

componente

dos-salidas

circuito

una-entrada

led

puerta-nand

puerta-not

fuente

dos-entradas

una-salida

sumidero

divisor

7.1 Ejemplo


CLOSCLOS Clases

Ejemplo definición de clases

(defclass COMPONENTE () ((ID# :accessor id# :initarg :id#)))

;;; DEFINICION DE LAS SALIDAS

(defclass SIN-SALIDAS () ((numero-de-salidas :reader :num-salidas :initform 0 :allocation :class)))

(defclass UNA-SALIDA (SIN-SALIDAS) ((numero-de-salidas :reader :num-salidas :initform 1 :allocation :class) (salida-1 :accessor sal-1 :initform 'INDEFINIDA) (salida-1-enlace :accessor sal-1-enl :initform 'TIERRA) (salida-1-enlace-pin :accessor sal-1-pin :initform '1)))

(defclass DOS-SALIDAS (UNA-SALIDA) ((numero-de-salidas :reader :num-salidas :initform 2 :allocation :class) (salida-2 :accessor sal-2 :initform 'INDEFINIDA) (salida-2-enlace :accessor sal-2-enl :initform 'TIERRA) (salida-2-enlace-pin :accessor sal-2-pin :initform '1)))

7.1 Clases


CLOSCLOS Clases

;;; DEFINICION DE LAS ENTRADAS

(defclass SIN-ENTRADAS () ((numero-de-entradas :reader :num-entradas :initform 0 :allocation :class)))

(defclass UNA-ENTRADA (SIN-ENTRADAS) ((numero-de-entradas :reader :num-entradas :initform 1 :allocation :class) (entrada-1 :accessor ent-1 :initform 'INDEFINIDA) (entrada-1-enlace :accessor ent-1-enl :initform 'TIERRA) (entrada-1-enlace-pin :accessor ent-1-pin :initform '1)))

(defclass DOS-ENTRADAS (UNA-ENTRADA) ((numero-de-entradas :reader :num-entradas :initform 2 :allocation :class) (entrada-2 :accessor ent-2 :initform 'INDEFINIDA) (entrada-2-enlace :accessor ent-2-enl :initform 'TIERRA) (entrada-2-enlace-pin :accessor ent-2-pin :initform '1)))

7.1 Clases


CLOSCLOS Clases

;;; DEFINICION DE LAS COMPONENTES INSTANCIABLES

(defclass PUERTA-NOT (UNA-ENTRADA UNA-SALIDA COMPONENTE)())(defclass PUERTA-AND (DOS-ENTRADAS UNA-SALIDA COMPONENTE)())(defclass PUERTA-OR (DOS-ENTRADAS UNA-SALIDA COMPONENTE)())(defclass PUERTA-NAND (DOS-ENTRADAS UNA-SALIDA COMPONENTE)())(defclass PUERTA-XOR (DOS-ENTRADAS UNA-SALIDA COMPONENTE)())(defclass DIVISOR (UNA-ENTRADA DOS-SALIDAS COMPONENTE)())(defclass LED (UNA-ENTRADA SIN-SALIDAS COMPONENTE)())

;;; DEFINICION DE OBJETO COMPUESTO CIRCUITO

(defclass circuito () ((componentes ...) (entradas...) (salidas...) (num-entradas...) (num-salidas...)))

7.1 Clases


CLOSCLOS 2. Interfaz

;;; PROTOCOLO (INTERFAZ INTERNA);;; Funciones genéricas para puertas

(defgeneric poner-entrada (elemento pin segnal) (:documentation"Pone segnal en el pin del elemento indicado"))(defgeneric calcula-salida (elemento) (:documentation "C'alcula las salidas del elemento en funci'on del tipode elemento y de las entradas"))(defgeneric conecta (salida pin-salida entrada pin-entrada) (:documentation "Conecta dos componentes."))

;;; Funciones genéricas para circuito

(defgeneric poner-entradas (circuito entradas)(:documentation "Da valor a las entradas del circuito."))(defgeneric leer-salidas (circuito)(:documentation "Devuelve las salidas del cicuito."))

;;; Constructor para circuito(defun make-circuito (&key (entradas NIL) (componentes NIL) (conexiones NIL) (salidas NIL)) (let* ((circuito (make-instance 'CIRCUITO :entradas entradas :componentes componentes :conexiones conexiones :salidas salidas))) circuito))

7.2Interfaz


CLOSCLOS Interfaz

;;; /---N1>--\ /---------L1;;; F1>--D1>-| O1>---D2>--|;;; \--------/ |;;; |;;; |;;; \---\;;; X1>--L2;;; F2>-------------------------------/;;;

(setf *circuito* (make-circuito :entradas '(F-1 F-2) :componentes '((F-1 Fuente) (F-2 Fuente) (D-1 divisor) (D-2 divisor) (N-1 puerta-not) (O-1 puerta-or) (X-1 puerta-xor) (L-1 LED) (L-2 LED)) :salidas '(L-1 L-2) :conexiones '((F-1 1 D-1 1) (F-2 1 X-1 2) ( D-1 1 N-1 1) ( D-1 2 O-1 2) ( N-1 1 O-1 1) ( O-1 1 D-2 1) ( D-2 1 L-1 1) ( D-2 2 X-1 1) ( X-1 1 L-2 1))))

;;; Ej. (poner-entradas *circuito* '(1 1)) -> (1 0);;; (leer-salidas *circuito*) (1 0))

7.2Interfaz


CLOSCLOS Interfaz

;; Protocolo definido con defclasss;; Elementos con una salida;; -------------- ;; - sal-1: accessor salida;; - sal-1-enl: accessor a siguiente elemento;; - sal-1-pin: accessor al pin por el que entra la ;; salida al siguiente elemento. ;; Elementos con dos salida;; -------------- ;; - sal-2: accessor salida;; - sal-2-enl: accessor a siguiente elemento;; - sal-2-pin: accessor al pin por el que entra la ;; salida al siguiente elemento;; Elementos con una entrada;; -------------- ;; - ent-1: accessor salida;; - ent-1-enl: accessor a siguiente elemento;; - ent-1-pin: accessor al pin por el que entra la ;; salida al siguiente elemento. ;; Elementos con dos entradas;; -------------- ;; - ent-2: accessor salida;; - ent-2-enl: accessor a siguiente elemento;; - ent-2-pin: accessor al pin por el que entra la ;; salida al siguiente elemento.;; Circuito;; ---------;; reader para: componentes, entradas, salidas, ;; num_entradas, num_salidas.

7.2 Interfaz


CLOSCLOS Interfaz

;;; PROTOCOLO (INTERFAZ EXTERNA)

;;;======================================================;;; PAQUETE ELECTRO

(defpackage :electro ;;; Creación del paquete (:export ;classes ;;; S'imbolos exportados circuito fuente sumidero puerta-not puerta-and puerta-or puerta-nand puerta-xor divisor led) (:export ;Generic-functions poner-entradas leer-salidas componentes entradas salidas num-entradas num-salidas) (:export ;Funciones make-circuito)) (in-package "ELECTRO")

;;;======================================================

7.2 Interfaz


CLOSCLOS 3. Implementación

;;; Implementaci’on m’etodos para puertas;;; Implementaci’on calcula-salida(defmethod calcula-salida ((elemento SIN-SALIDAS)) NIL)...;;; Implementaci’on poner-entrada(defmethod poner-entrada (elemento (pin (eql 1)) segnal) (setf (ent-1 elemento) segnal))

(defmethod poner-entrada (elemento (pin (eql 2)) segnal) (setf (ent-2 elemento) segnal))

;;; Implementaci’on conecta(defmethod conecta (?salida (?pin-salida (eql 1)) ?entrada (?pin-entrada (eql 1))) (declare (ignore ?pin-salida ?pin-entrada)) (setf (sal-1-enl ?salida) ?entrada) (setf (sal-1-pin ?salida) 1) (setf (ent-1-enl ?entrada) ?salida) (setf (ent-1-pin ?entrada) 1))...

;;; Implementaci’on m’etodos para circuito(defmethod initialize-instance :after ((cir circuito) &key (entradas NIL) (componentes NIL) conexiones NIL) (salidas NIL)) ;(1) Crea Instancias de componentes ;(2) Establece conexiones ;(3) Segnala entradas y salidas ...)

(defmethod poner-entradas ...)(defmethod leer-salidas ...)

7.3 Implementación


CLOSCLOS Implementación

;; Implementación DEMONS:;; -Asociado a poner sal-1: ;; Transmite salida 1 a la entrada del siguiente ;; componente conectado a esta salida.;; -Asociado a poner sal-2: ;; Transmite salida 2 a la entrada del siguiente ;; componente conectado a esta salida.;; -Asociado a poner ent-1: ;; Obliga a recomputar la salida cada vez que ;; cambia la entrada 1.;; -Asociado a poner ent-2: ;; Obliga a recomputar la salida cada vez que ;; cambia la entrada 2.

7.3 Implementación


CLOSCLOS Objeto Agregado

(defmethod initialize-instance :after

((cir circuito)

&key (entradas NIL) (componentes NIL)

(conexiones NIL) (salidas NIL))

(let* ((a-list-componentes nil)

; Lista asociaci—n componentes

(lentradas nil)

(lsalidas nil))

; (1) Crea instancias de los componentes

(setf (slot-value cir 'componentes)

(dolist

(componente componentes a-list-componentes)

(setf a-list-componentes

(acons (first componente)

(make-instance (second componente)

:id# (first componente))

a-list-componentes))

))

; (format t "~% ~a" (componentes cir))



; (2) Establece conexiones

(dolist (conexion conexiones)

(apply #'conecta

(let* ((entrada (car conexion))

(salida (third conexion))

(C-entrada (cdr

(assoc entrada

(componentes cir))))

(C-salida (cdr

(assoc salida

(componentes cir)))))

(let* ((con

(substitute C-salida salida

(substitute C-entrada

entrada conexion))))

;(format t "~% ~a" con)

con)

))



; (3) Segnala entradas y salidas

(setf (slot-value cir 'entradas)

(reverse

(dolist (entrada entradas lentradas)

(setf lentradas

(append

(list

(cdr

(assoc entrada

(componentes cir))))

lentradas)))))

(setf (slot-value cir 'salidas)

(reverse

(dolist (salida salidas lsalidas)

(setf lsalidas

(append

(list

(cdr

(assoc salida (componentes cir))))

lsalidas)))))

cir ;;; Da igual lo que devuelva

)

)

ISBC. José Angel Bañares. II-1998. clos.ppt 24/02/98 1 CLOS Representación estructurada del...

Documents

Transcript of ISBC. José Angel Bañares. II-1998. clos.ppt 24/02/98 1 CLOS Representación estructurada del...