Discussion :

[bcaro]

Bonjour à tous et à toutes, me revoilà...

J'étudie en ce moment la partie théorique du cours (pour ceux qui suivrait ) et il y a un passage que je ne comprends pas très bien, pour ne pas dire pas du tout.
Pour vous situer le contexte, nous voyons dans ce chapitre comment faire 'cohabiter' différentes représentations d'un seul et même type d'objet, l'exemple choisi étant un nombre complexe qui peut donc être représenté via ses coordonnées polaires et rectangulaires.
L'une des façons présentée est de 'tagger' chaque représentation affin de pouvoir créer des sélecteurs (selectors) génériques, qui font donc appel au bon sélecteur grâce au tag. Aucun problème de ce côté.

Ensuite, voila ce qui inscrit dans mon cours :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
;;DATA DIRECTED PROGRAMMING
;;INSTAL RECTANGULAR PACKAGE

(define install-rectangular-package)
  	;;; internal procedures
  	(define (make-from-rect x y) (cons x y))
  	(define (real-part z) (car z))
  	(define (imag-part z) (cdr z))
  	(define (angle z) (atan (cdr z) (car z)))
  	(define (magnitude z)
    		(sqrt (+ 	(square (car z)) 
             			(square (cdr z)))))
  	(define (make-from-polar r a)
    		(cons	 (* r (cos a)) (* r (sin a))))
        ;;; interfacing
  (define (tag x) (attach-type 'rectangular x)
  (put 'real-part '(rectangular) real-part)
  (put 'imag-part '(rectangular) imag-part)
  (put 'magnitude '(rectangular) magnitude)
  (put 'angle '(rectangular) angle)
  (put 'make-from-rect 'rectangular 
       (lambda (x y) 
         	(tag (make-from-rect x y))))
  (put 'make-from-polar 'rectangular 
       (lambda (x y) 
        	(tag (make-from-polar x y))))
  'done)

;;DATA DIRECTED PROGRAMMING
;;INSTALL POLAR PACKAGE
  
(define install-polar-package)
  ;;; internal procedures
  (define (make-from-polar r a) (cons r a))
  (define (angle z) (car z))
  (define (magnitude z) (cdr z))
  (define (real-part z) (* (car z) (cos (cdr z))))
  (define (imag-part z) (* (car z) (sin (cdr z))))
  (define (make-from-rect x y)
    	(cons	(sqrt (+ (square x) (square y)))
          		(atan y x)))
  ;;; interfacing
  (define (tag x) (attach-type 'polar x)
  (put 'real-part '(polar) real-part)
  (put 'imag-part '(polar) imag-part)
  (put 'magnitude '(polar) magnitude)
  (put 'angle '(polar)  angle)
  (put 'make-from-rect 'polar
       (lambda (x y) 
         	(tag (make-from-rect x y))))
  (put 'make-from-polar 'polar 
       (lambda (x y) 
        	(tag (make-from-polar x y))))
  'done)

;;APPLY OPERATORS
  
  (define (apply-generic  op . args)
  	(let ((types (map type args))) ;; type est la fonction qui renvoi à partir
                                                 ;; d'un objet 'taggé' le tag (enfin c'est
                                                 ;; ce que je suppose car défini ainsi
                                                 ;; précédemment)
    		(let ((proc (get op types)) )
      		(if proc
          		(apply proc (map contents args))
          		(error "operator not defined on these types 
                 			-- APPLY-GENERIC" (list op types))

 (define (real-part z) 
   	(apply-generic 'real-part z))
 (define (imag-part z) 
   	(apply-generic 'imag-part z))
 (define (magnitude z) 
   	(apply-generic 'magnitude z))
 (define (angle z) 
   	(apply-generic 'angle z))
 (define  (make-from-rect x y)
   	((get 'make-from-rect 'rectangular) x y))
 (define  (make-from-polar r a)
   	((get 'make-from-polar 'polar) r a))

Et la c'est l'incompréhension la plus totale

Elle note cependant qu'il faut assumer l'existence de
(put <op> <type> <item>) et (get <op> <type>), sans donner plus de détailles.

J'aimerais juste comprendre le concept qui se cache derrière ce charabia, pas besoin de m'expliquer ligne par ligne.

Un grand merci d'avance !
(désolé de monopoliser ainsi le forum, mais bon faut dire qu'il n'y a pas foule)

[Garulfo]

Je n'ai pas lu le code — trop long —, mais je suppose que ta prof te présente ce que je présente aussi. En fait, c'est dans le livre de Sussman et al. Alors l'idée est simple. En fait tu l'expliques toi-même.

Quand tu vas vouloir obtenir la partie réelle — disons — tu vas appeler une commande qui va chercher la bonne fonction puis l'appliquer à l'argument. Pour choisir la bonne fonction, on va se servir d'un tag. Ce tag sera défini par la donnée qui indiquera ainsi sa représentation interne sans que l'utilisateur ne le voit explicitement.

Le get et le put seront simplement les commandes permettant de travailler avec la structure qui sauvegardera les fonctions associées au nom de la fonction et au tag correspondant. En général, le get et le put seront associés à une hashtable.

Maintenant, si tu as déjà un peu étudié la prog objet, tu vois que c'est de cette manière qu'on pourrait implémenter un tel langage. Et pour cause, c'est ainsi que c'est fait en général. Bien sûr il manque pour l'instant des choses pour en faire du vrai OO mais la partie data-oriented est là.

Ne comptes pas sur moi pour passer le code pour te l'expliquer. Si tu as des questions précises par contre, pas de problème.