common-lisp
CLOS - Common Lisp Object System

Tworzenie podstawowej klasy CLOS bez rodziców

Klasę CLOS opisuje:

• imię
• lista nadklas
• lista automatów
• inne opcje, takie jak dokumentacja

Każde miejsce ma:

• imię
• formularz inicjalizacji (opcjonalnie)
• argument inicjalizacji (opcjonalnie)
• typ (opcjonalnie)
• ciąg dokumentacji (opcjonalnie)
• funkcje akcesorium, czytnika i / lub zapisu (opcjonalnie)
• inne opcje, takie jak przydział

Przykład:

(defclass person ()
  ((name
    :initform      "Erika Mustermann" 
    :initarg       :name 
    :type          string
    :documentation "the name of a person"
    :accessor      person-name)
   (age
    :initform      25
    :initarg       :age
    :type          number
    :documentation "the age of a person"
    :accessor      person-age))
  (:documentation "a CLOS class for persons with name and age"))

Domyślna metoda drukowania:

(defmethod print-object ((p person) stream)
  "The default print-object method for a person"
  (print-unreadable-object (p stream :type t :identity t)
    (with-slots (name age) p
      (format stream "Name: ~a, age: ~a" name age))))

Tworzenie instancji:

CL-USER > (make-instance 'person)
#<PERSON Name: Erika Mustermann, age: 25 4020169AB3>

CL-USER > (make-instance 'person :name "Max Mustermann" :age 24)
#<PERSON Name: Max Mustermann, age: 24 4020169FEB>

Mixiny i interfejsy

Common Lisp nie ma interfejsów w takim sensie, jak niektóre języki (np. Java), i istnieje mniejsze zapotrzebowanie na ten typ interfejsu, biorąc pod uwagę, że Common Lisp obsługuje wiele funkcji dziedziczenia i funkcje ogólne. Jednak ten sam typ wzorców można łatwo zrealizować za pomocą klas mixin. Ten przykład pokazuje specyfikację interfejsu kolekcji z kilkoma odpowiednimi funkcjami ogólnymi.

;; Specification of the COLLECTION "interface"

(defclass collection () ()
  (:documentation "A collection mixin."))

(defgeneric collection-elements (collection)
  (:documentation "Returns a list of the elements in the collection."))

(defgeneric collection-add (collection element)
  (:documentation "Adds an element to the collection."))

(defgeneric collection-remove (collection element)
  (:documentation "Removes the element from the collection, if it is present."))

(defgeneric collection-empty-p (collection)
  (:documentation "Returns whether the collection is empty or not."))

(defmethod collection-empty-p ((c collection))
  "A 'default' implementation of COLLECTION-EMPTY-P that tests
whether the list returned by COLLECTION-ELEMENTS is the empty
list."
  (endp (collection-elements c)))

Implementacja interfejsu jest tylko klasą, w której mixin jest jedną z jego superklas oraz definicje odpowiednich funkcji ogólnych. (W tym miejscu zauważ, że klasa mixin jest tak naprawdę tylko do sygnalizowania zamiaru, że klasa implementuje „interfejs”. Ten przykład działałby równie dobrze z kilkoma ogólnymi funkcjami i dokumentacją, która stwierdza, że istnieją metody dla funkcji klasa.)

;; Implementation of a sorted-set class

(defclass sorted-set (collection)
  ((predicate
    :initarg :predicate
    :reader sorted-set-predicate)
   (test
    :initarg :test
    :initform 'eql
    :reader sorted-set-test)
   (elements
    :initform '()
    :accessor sorted-set-elements
    ;; We can "implement" the COLLECTION-ELEMENTS function, that is,
    ;; define a method on COLLECTION-ELEMENTS, simply by making it
    ;; a reader (or accessor) for the slot.
    :reader collection-elements)))

(defmethod collection-add ((ss sorted-set) element)
  (unless (member element (sorted-set-elements ss)
                  :test (sorted-set-test ss))
    (setf (sorted-set-elements ss)
          (merge 'list
                 (list element)
                 (sorted-set-elements ss)
                 (sorted-set-predicate ss)))))

(defmethod collection-remove ((ss sorted-set) element)
  (setf (sorted-set-elements ss)
        (delete element (sorted-set-elements ss))))

Wreszcie możemy zobaczyć, jak wygląda użycie instancji klasy zestawu posortowanego podczas korzystania z funkcji „interfejs”:

(let ((ss (make-instance 'sorted-set :predicate '<)))
  (collection-add ss 3)
  (collection-add ss 4)
  (collection-add ss 5)
  (collection-add ss 3)
  (collection-remove ss 5)
  (collection-elements ss))
;; => (3 4)