Bonjour,

cette année j'ai la joie de devoir apprendre le Scheme. Ce langage me donne pas mal de fil à retordre car je n'avais jamais été confronté à ce genre de langage.

En gros, je suis un cours dans le quel le prof s'est amusé (à l'aide des define-macro) à implémenter un system Orienté Objet à Scheme.

J'ai compris les grandes lignes, mais de petits détails m'échappes, c'est pourquoi je me tourne vers vous.

Voici un petit bout de code :
Code :
1
2
3
4
5
6
7
(define-macro OBJECT 
    (lambda defs
      `(let ((«TAB» '()))
         (define (SELF msg . args)
           (apply (cdr (assoc msg «TAB»)) args))
         ,@defs
         SELF)))
On stock dans <<TAB>> les méthodes (nom => lambda-exp).
SELF est une lambda exp qui permet d'évaluer une fonction.
J'ai compris le code mais il y a un truc qui m'échappe : pourquoi appeler SELF à la fin de la déclaration ?!

Voici la déclaration d'un OBJET point.
Code :
1
2
3
4
5
6
7
8
(define point
    (OBJECT
     (VAR x 0)
     (VAR y 0)
     (METHOD x? () x)
     (METHOD y? () y)
     (METHOD x! (X) (set! x X) SELF)
     (METHOD y! (Y) (set! y Y) SELF)))
Mon hypothèse, c'est que, par exemple, après avoir définit un point p, si je veux connaitre le x de mon point p, je dois faire quelque chose comme
> (p x?)
et que c'est ce SELF au bout de mon macro OBJET qui va récupérer "x?", aller chercher la fonction correspondante et l'évaluer.

Je me trompe ?

Si quelqu'un a pris le temps de tout lire et qu'il a une idée, ça m'aiderait beaucoup !!