Réalisation par Objets

Notre dernière réalisation pour la pile utilise le système orienté objets d'OpenScheme, OO, basé sur CLOS, le Common Lisp Object System. En utilisant ce système, on bénéficie d'un véritable système orienté objet méta-circulaire permettant la définition de classes, l'héritage, l'agrégation, la définition de méthodes.

Nous proposons la réalisation suivante :

; définition de la classe
(define-class <pile> #f
  [données~:initform '()])

; déclaration des fonctions génériques
(define-generic vide?)
(define-generic empile)
(define-generic dépile)
(define-generic sommet)
(define-generic affiche)

; prédicat
(define-method (vide? (pile <pile>))
  (null? (<pile>:données pile)))

; méthode d'empilage
(define-method (empile (pile <pile>) élément)
  (<pile>:données! pile
                   (cons élément
                         (<pile>:données pile))))

; méthode de dépilage
(define-method (dépile (pile <pile>))
  (check (not (vide? pile)))
  (<pile>:données! pile
                   (cdr (<pile>:données pile))))

; retourne le sommet
(define-method (sommet (pile <pile>))
  (check (not (vide? pile)))
  (car (<pile>:données pile)))

; méthode d'affichage
(define-method (affiche (pile <pile>))
  (for-each (lambda (donnée)
             (display donnée)
             (display #\space))
             données)
  (newline))

Nous avons maintenant une nouvelle classe . Avant d'être définies, les méthodes doivent être déclarées avec la macro define-generic. Cette déclaration doit avoir lieu une seule fois par programme.

Le prédicat est défini avec la classe. La méthode d'empilage prend comme argument une pile et un élément dont la classe n'est pas spécifiée. Elle ajoute l'élément à la liste des valeurs. La méthode de dépilage se contente de supprimer la tête de la liste des données, après avoir vérifié que la liste n'est pas vide. De même, la méthode retournant le sommet de la pile vérifie que la pile n'est pas vide. La méthode prédicat vide? retourne vrai si la pile est vide et faux sinon. Enfin, la méthode d'affichage affiche le contenu de la pile.

Une utilisation pourrait être :

(define  pile (build <pile>)) 
(affiche pile)
(empile  pile 123)
(affiche pile)
(empile  pile (list 1 2 3 4))
(affiche pile)
(dépile  pile)
(affiche pile)

Le programme affichera les mêmes résultats que dans les réalisations précédentes.

Maintenant, on pourrait définir une pile d'entiers exclusivement. Pour cela, il faut définir une nouvelle classe, et surcharger la méthode d'empilage :

; définition de la classe
(define-class <pile-entier> <pile>)

; méthode d'empilage
(define-method (empile (pile <pile-entier>) élément)
  (check (<integer>? élément))
  (next-method))

La classe hérite des propriétés de la classe  ; elle ne définit pas de nouveaux attributs.

La méthode empile est redéfinie pour la nouvelle classe. Elle contrôle que son argument élément appartient à la classe en utilisant le prédicat . Si l'argument est un entier, la méthode suivante est invoquée ; dans ce cas, ce sera la méthode empile pour la classe . Les autres méthodes de la classes sont applicables aux objets de la classe .