Réalisation par Messages

La première réalisation proposée utilise une structure de donnée classique. Nous allons maintenant utiliser la programmation par messages pour réaliser la pile.

La programmation par messages est une première approche de la programmation orientée objet. Elle permet de définir des entités informatiques capables de réagir à des messages comportant ou non des arguments. Lorsqu'un message est reconnu, il est traité ; lorsqu'il n'est pas reconnu, il est ignoré. On peut donc utiliser des noms de messages génériques, et les envoyer aux objets, sans savoir si, a priori, ils sauront les traiter.

Voici un exemple de réalisation de la pile par envoi de messages :

; fonction de création
(define (pile:crée)
  ; variable locale~: le contenu
  ; de la pile
  (let ([données '()])
    ; valeur de retour~: une fonction
    ; représentant l'objet pile
    (lambda (message . arguments)
      ; nombre d'arguments supplémentaires
      (let ([n (length arguments)])
      ; cas selon le message
       (case message
        ; prédicat
       [(vide?)
         (null? données)]
        ; message d'empilage
       [(empile)
         (check (eq? n 1))
         (set! données (cons valeur
                             données))]
        ; message de dépilage
        [(dépile)
         (check (zero? n))
         (check (not (null? données)))
         (set! données (cdr données))]
        ; retourne le sommet
        [(sommet)
         (check (zero? n))
         (check (not (null? données)))
         (car données)]
        ; affiche le contenu de la pile
        [(affiche)
         (check (zero? n))
         (for-each (lambda (donnée)
                    (display donnée)
                   (display #\space))
                   données)
         (newline)]
        ; retourne le nom de l'objet
        [(nom)
         (check (zero? n))
         'pile]))))

; fonction prédicat
(define (pile? objet)
 (and (procedure? objet)
       (eq? (objet 'nom) 'pile)))

Dans cet exemple, la pile est une fonction répondant à des messages. Elle utilise le fait que les fonctions Scheme sont des objets de première classe (comme les autres) et qu'elles sont reliées à l'environnement (les variables visibles) au moment de leur création.

La fonction commence par déclarer la variable locale données qui contient la liste des valeurs dans la pile. Puis elle définit sa valeur de retour qui est une fonction (forme lambda). Cette fonction a au moins un argument, le message, puis des arguments optionnels. Ce qui est intéressant est qui donne au langage Scheme toute sa puissance, c'est que la forme lambda retournée continue de pouvoir accéder à la variable locale données.

La fonction de traitement des messages commence par compter le nombre des arguments pour effectuer dans chaque message une vérification. Nous rappelons que si cette fonction est appelée sans argument, le paramètre arguments vaudra la liste vide ; sinon, sa valeur sera la liste de tous les arguments supplémentaires.

Ensuite, nous entrons dans le traitement des messages avec un traitement par cas. Un message est un symbole. Un traitement est effectué en fonction du type de message reçu.

Par rapport à la spécification, nous avons ajouté le message nom qui retourne le nom de l'objet et permet de réaliser la fonction prédicat.

Lorsqu'un message n'est pas reconnu, cela n'est pas considéré comme une erreur : dans ce cas, le message est ignoré et la valeur #unspecified est retournée car elle est la valeur par défaut du case.

Nous avons donc construit une bibliothèque pour les piles. Voila un exemple d'utilisation :

(define pile (pile:crée)) 
(pile 'affiche)
(pile 'empile 123)
(pile 'affiche)
(pile 'empile! (list 1 2 3 4))
(pile 'affiche)
(pile 'dépile)
(pile 'affiche)

Le programme affichera le même résultat que dans la réalisation précédente.

Cette manière de programmer est assez utilisée en Scheme car elle permet d'avoir une programmation orientée objet à moindre frais. De plus, le code est assez compact, ce qui est une constante dans les programmes en Scheme.