4. Chapitre 4 - Comprendre la syntaxe des messages▲
Bien que la syntaxe des messages Smalltalk soit extrêmement simple, elle n'est pas habituelle pour un développeur qui viendrait du monde C/Java. Un certain temps d'adaptation peut être nécessaire. L'objectif de ce chapitre est de donner quelques conseils pour vous aider à mieux appréhender la syntaxe particulière des envois de messages. Si vous vous sentez suffisamment en confiance avec la syntaxe, vous pouvez choisir de sauter ce chapitre ou bien d'y revenir un peu plus tard.
4-1. Identifier les messages▲
Avec Smalltalk, exception faite des éléments syntaxiques rencontrés dans le chapitre 3 (:= ↑ . ; # () {} [ : | ]), tout se passe par envoi de messages. Comme en C++, vous pouvez définir vos opérateurs comme + our vos propres classes, mais tous les opérateurs ont la même précédence. De plus, il n'est pas possible de changer l'arité d'une méthode : - est toujours un message binaire, et il n'est pas possible d'avoir une forme unaire avec une surcharge différente.
Avec Smalltalk, l'ordre dans lequel les messages sont envoyés est déterminé par le type de message. Il n'y a que trois formes de messages : les messages unaires, binaires et à mots-clefs. Les messages unaires sont toujours envoyés en premier, puis les messages binaires et enfin ceux à mots-clefs. Comme dans la plupart des langages, les parenthèses peuvent être utilisées pour changer l'ordre d'évaluation. Ces règles rendent le code Smalltalk aussi facile à lire que possible. La plupart du temps, il n'est pas nécessaire de réfléchir à ces règles.
Comme la plupart des calculs en Smalltalk sont effectués par des envois de messages, identifier correctement les messages est crucial. La terminologie suivante va nous être utile :
- un message est composé d'un sélecteur et d'arguments optionnels ;
- un message est envoyé au receveur ;
- la combinaison d'un message et de son receveur est appelée un envoi de message comme il est montré dans la figure 4.1.
|
|
 |
Un message est toujours envoyé à un receveur qui peut être un simple littéral, une variable ou le résultat de l'évaluation d'une autre expression.
Nous vous proposons de vous faciliter la lecture au moyen d'une notation graphique : nous soulignerons le receveur afin de vous aider à l'identifier. Nous entourerons également chaque expression dans une ellipse et numéroterons les expressions à partir de la première à être évaluée afin de voir l'ordre d'envoi des messages.
La figure 4.2 représente deux envois de messages, Color yellow et aMorph color: Color yellow, de telle sorte qu'il y a deux ellipses. L'expression Color yellow est d'abord évaluée en premier, ainsi son ellipse est numérotée à 1. Il y a deux receveurs : aMorph qui reçoit le message color: ... et Color qui reçoit le message yellow (yellow correspond à la couleur jaune en anglais). Chacun des receveurs est souligné.
Un receveur peut être le premier élément d'un message, comme 100 dans l'expression 100 + 200 ou Color (la classe des couleurs) dans l'expression Color yellow. Un objet receveur peut également être le résultat de l'évaluation d'autres messages. Par exemple, dans le message Pen new go: 100, le receveur de ce message go: 100 (littéralement, aller à 100) est l'objet retourné par cette expression Pen new (soit une instance de Pen, la classe crayon). Dans tous les cas, le message est envoyé à un objet appelé le receveur qui a pu être créé par un autre envoi de message.
|
Expression |
Type de messages |
Résultat |
|
Color yellow |
unaire |
Crée une couleur. |
|
aPen |
à mots-clefs |
Le crayon receveur se déplace en avant de 100 pixels. |
|
|
binaire |
Le nombre 100 reçoit le message + avec le paramètre 20. |
|
Browser open |
unaire |
Ouvre un nouveau navigateur de classes. |
|
Pen new |
unaire et à mots-clefs |
Un crayon est créé puis déplacé de 100 pixels. |
|
aPen |
à mots-clefs et binaire |
Le crayon receveur se déplace vers l'avant de 120 pixels. |
La table 4.1 montre différents exemples de messages. Vous devez remarquer que tous les messages n'ont pas obligatoirement d'arguments. Un message unaire comme open (pour ouvrir) ne nécessite pas d'arguments. Les messages à mots-clefs simples ou les messages binaires comme go: 100 et + 20 ont chacun un argument. Il y a aussi des messages simples et des messages composés. Color yellow et 100 + 20 sont simples : un message est envoyé à un objet, tandis que l'expression aPen go: 100 + 20 est composée de deux messages : + 20 est envoyé à 100 et go:est envoyé à aPen avec pour argument le résultat du premier message. Un receveur peut être une expression qui peut retourner un objet. Dans Pen new go: 100, le message go: 100 est envoyé à l'objet qui résulte de l'évaluation de l'expression Pen new.
4-2. Trois sortes de messages▲
Smalltalk utilise quelques règles simples pour déterminer l'ordre dans lequel les messages sont envoyés. Ces règles sont basées sur la distinction établie entre les trois formes d'envoi de messages :
- Les messages unaires sont des messages qui sont envoyés à un objet sans autre information. Par exemple dans
3factorial, factorial (pour factorielle) est un message unaire. - Les messages binaires sont des messages formés avec des opérateurs (souvent arithmétiques). Ils sont binaires car ils ne concernent que deux objets : le receveur et l'objet argument. Par exemple, dans
10+20,+est un message binaire qui est envoyé au receveur10avec l'argument20. - Les messages à mots-clefs sont des messages formés avec plusieurs mots-clefs, chacun d'entre eux se finissant par deux points (
:) et prenant un paramètre. Par exemple, dans anArrayat:1put:10, le mot-clefat:prend un argument1et le mot-clefput:prend l'argument10.
4-2-1. Messages unaires▲
Les messages unaires sont des messages qui ne nécessitent aucun argument. Ils suivent le modèle syntaxique suivant : receveur nomMessage. Le sélecteur est constitué d'une série de caractères ne contenant pas de deux points (:) (par ex., factorial, open, class).
89 sin −→ 0.860069405812453
3 sqrt −→ 1.732050807568877
Float pi −→ 3.141592653589793
'blop' size −→ 4
true not −→ false
Object class −→ Object class "La classe de Object est Object class (!)"Les messages unaires sont des messages qui ne nécessitent pas d'argument. Ils suivent le moule syntaxique : receveur sélecteur.
4-2-2. Messages binaires▲
Les messages binaires sont des messages qui nécessitent exactement un argument et dont le sélecteur consiste en une séquence d’un ou plusieurs caractères de l'ensemble : +, -, *, /, &, =, >, |, <, ∼, et @. Notez que -- n'est pas autorisé.
100@100 −→ 100@100 "crée un objet Point"
3 + 4 −→ 7
10 - 1 −→ 9
4 <= 3 −→ false
(4/3) * 3 = 4 −→ true "l'égalité est juste un message binaire et les fractions sont exactes"
(3/4) == (3/4) −→ false "deux fractions égales ne sont pas le même objet"Les messages binaires sont des messages qui nécessitent exactement un argument et dont le sélecteur consiste en une séquence d’un ou plusieurs caractères de l'ensemble : +, -, *, /, &, =, >, |, <, ∼, et @. Notez que -- n'est pas autorisé.Ils suivent le moule syntaxique : receveur sélecteur argument.
4-2-3. Messages à mots-clefs▲
Les messages à mots-clefs sont des messages qui nécessitent un ou plusieurs arguments et dont le sélecteur consiste en un ou plusieurs mots-clefs se finissant par deux points :. Les messages à mots-clefs suivent le moule syntaxique : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux
Chaque mot-clef utilise un argument. Ainsi r:g:b: est une méthode avec 3 arguments, playFileNamed: et at: sont des méthodes avec un argument, et at:put: est une méthode avec deux arguments. Pour créer une instance de la classe Color on peut utiliser la méthode r:g:b: comme dans Color r: 1 g: 0 b: 0 créant ainsi la couleur rouge. Notez que les deux points ne font pas partie du sélecteur.
En Java ou C++, l'invocation de méthode Smalltalk Color r: 1 g: 0 b: 0 serait écrite Color.rgb(1,0,0).
1 to: 10 −→ (1 to: 10) "création d'un intervalle"
Color r: 1 g: 0 b: 0 −→ Color red "création d'une nouvelle couleur (rouge)"
12 between: 8 and: 15 −→ true
nums := Array newFrom: (1 to: 5).
nums at: 1 put: 6.
nums −→ #(6 2 3 4 5)Les messages basés sur les mots-clefs sont des messages qui nécessitent un ou plusieurs arguments. Leurs sélecteurs consistent en un ou plusieurs mots-clefs chacun se terminant par deux points (:). Ils suivent le moule syntaxique : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux
4-3. Composition de messages▲
Les trois formes d'envoi de messages ont chacune des priorités différentes, ce qui permet de les composer de manière élégante.
- Les messages unaires sont envoyés en premier, puis les messages binaires et enfin les messages à mots-clefs.
- Les messages entre parenthèses sont envoyés avant tout autre type de messages.
- Les messages de même type sont envoyés de gauche à droite.
Ces règles ont un ordre de lecture très naturel. Maintenant si vous voulez être sûr que vos messages sont envoyés dans l'ordre que vous souhaitez, vous pouvez toujours mettre des parenthèses supplémentaires comme dans la figure 4.3. Dans cet exemple, le message yellow est un message unaire et le message color: est un message à mots-clefs ; ainsi l'expression Color yellow est envoyée en premier. Néanmoins, comme les expressions entre parenthèses sont envoyées en premier, mettre des parenthèses (normalement inutiles) autour de Color yellow permet d'accentuer le fait qu'elle doit être envoyée en premier. Le reste de cette section illustre chacun de ces différents points.
4-3-1. Unaire > Binaire > Mots-clefs▲
Les messages unaires sont d'abord envoyés, puis les messages binaires et enfin les messages à mots-clefs. Nous pouvons également dire que les messages unaires ont une priorité plus importante que les autres types de messages.
Règle une. Les messages unaires sont envoyés en premier, puis les messages binaires et finalement les messages à mots-clefs.
Unaire > Binaire > Mots-clefs
Comme ces exemples suivants le montrent, les règles de syntaxe de Smalltalk permettent d'assurer une certaine lisibilité des expressions :
1000 factorial / 999 factorial −→ 1000
2 raisedTo: 1 + 3 factorial −→ 128Malheureusement, les règles sont un peu trop simplistes pour les expressions arithmétiques. Dès lors, des parenthèses doivent être introduites chaque fois que l'on veut imposer un ordre de priorité entre deux opérateurs binaires :
1 + 2 * 3 −→ 9
1 + (2 * 3) −→ 7L'exemple suivant qui est un peu plus complexe ( !) est l'illustration que même des expressions Smalltalk compliquées peuvent être lues de manière assez naturelle :
[:aClass | aClass methodDict keys select: [:aMethod | (aClass>>aMethod) isAbstract ]]
value: Boolean −→ an IdentitySet(#or: #| #and: #& #ifTrue: #ifTrue:ifFalse:
#ifFalse: #not #ifFalse:ifTrue:)Ici nous voulons savoir quelles méthodes de la classe Boolean (classe des booléens) sont abstraites. Nous interrogeons la classe argument aClass pour récupérer les clefs (grâce au message unaire keys) de son dictionnaire de méthodes (grâce au message unaire methodDict), puis nous en sélectionnons (grâce au message à mots-clefs select:) les méthodes de la classe qui sont abstraites. Ensuite nous lions (par value:) l'argument aClass à la valeur concrète Boolean. Nous avons besoin des parenthèses uniquement pour le message binaire >>, qui sélectionne une méthode d'une classe, avant d'envoyer le message unaire isAbstract à cette méthode. Le résultat (sous la forme d'un ensemble de classes IdentifySet) nous montre quelles méthodes doivent être implémentées par les sous-classes concrètes de Boolean : True et False.
Exemple. Dans le message aPen color: Color yellow, il y a un message unaire yellow envoyé à la classe Color et un message à mots-clefs color: envoyé à aPen. Les messages unaires sont d'abord envoyés, de telle sorte que l'expression Color yellow soit d'abord exécutée (1). Celle-ci retourne un objet couleur qui est passé en argument du message aPen color: aColor(2) comme indiqué dans l'exemple 4.1. La figure 4.3 montre graphiquement comment les messages sont envoyés.
aPen color: Color yellow
(1) Color yellow "message unaire envoyé en premier"
−→ aColor
(2) aPen color: aColor "puis le message à mots-clefs"Exemple. Dans le message aPen go: 100 + 20, il y a le message binaire + 20 et un message à mots-clefs go:. Les messages binaires sont d'abord envoyés avant les messages à mots-clefs, ainsi 100 + 20 est envoyé en premier (1) : le message + 20 est envoyé à l'objet 100 et renvoie le nombre 120. Ensuite le message aPen go: 120 est envoyé avec comme argument 120(2). L'exemple 4.2 nous montre comment l'expression est évaluée.
aPen go: 100 + 20
(1) 100 + 20 "le message binaire en premier"
−→ 120
(2) aPen go: 120 "puis le message à mots-clefs"|
|
|
Exemple. Comme exercice, nous vous laissons décomposer l'évaluation du message Pen new go: 100 + 20 qui est composé d'un message unaire, d'un message à mots-clefs et d'un message binaire (voir la figure 4.5).
4-3-2. Les parenthèses en premier▲
Règle deux. Les messages encadrés de parenthèses sont envoyés avant tout autre message.
(Msg) > Unaire > Binaire > Mots-clefs
1.5 tan rounded asString = (((1.5 tan) rounded) asString) −→ true "les parenthèses sont nécessaires ici"
3 + 4 factorial −→ 27 "(et pas 5040)"
(3 + 4) factorial −→ 5040Ici nous avons besoin des parenthèses pour forcer l'envoi de lowMajorScaleOn: avant play.
(FMSound lowMajorScaleOn: FMSound clarinet) play
"(1) envoie le message clarinet à la classe FMSound pour créer le son de clarinette.
(2) envoie le son à FMSound comme argument du message à mots-clefs lowMajorScaleOn:.
(3) joue le son résultant."Exemple. Le message (65@325 extent: 134@100) center renvoie le centre du rectangle dont le point supérieur gauche est (65, 325) et dont la taille est 134×100. L'exemple 4.3 montre comment le message est décomposé et envoyé. Le message entre parenthèses est d'abord envoyé : il contient deux messages binaires 65@325 et 134@100 qui sont d'abord envoyés et qui renvoient des points et un message à mots-clefs extent: qui est ensuite envoyé et qui renvoie un rectangle. Finalement le message unaire center est envoyé au rectangle et le point central est renvoyé.
Évaluer ce message sans parenthèses déclencherait une erreur, car l'objet 100 ne comprend pas le message center.
(65@325 extent: 134@100) center
(1) 65@325 "binaire"
−→ aPoint
(2) 134@100 "binaire"
−→ anotherPoint
(3) aPoint extent: anotherPoint "à mots-clefs"
−→ aRectangle
(4) aRectangle center "unaire"
−→ 132@3754-3-3. De gauche à droite▲
Maintenant, nous savons comment les messages de différentes natures ou priorités sont traités. Il reste une question à aborder : comment les messages de même priorité sont-ils envoyés ? Ils sont envoyés de gauche à droite. Notez que vous avez déjà vu ce comportement dans l'exemple 4.3 dans lequel les deux messages de création de points (@) sont envoyés en premier.
Règle trois. Lorsque les messages sont de même nature, l'ordre d'évaluation est de gauche à droite.
Exemple. Dans l'expression Pen new down, tous les messages sont des messages unaires, donc celui qui est le plus à gauche Pen new est envoyé en premier. Il renvoie un nouveau crayon auquel le deuxième message down (pour poser la pointe du crayon et dessiner) est envoyé comme il est montré dans la figure 4.6.
4-3-4. Incohérences arithmétiques▲
Les règles de composition des messages sont simples, mais peuvent engendrer des incohérences dans l'évaluation des expressions arithmétiques qui sont exprimées sous forme de messages binaires (nous parlons aussi d'irrationalité arithmétique). Voici des situations habituelles où des parenthèses supplémentaires sont nécessaires.
3 + 4 * 5 −→ 35 "(pas 23) les messages binaires sont envoyés de gauche à droite"
3 + (4 * 5) −→ 23
1 + 1/3 −→ (2/3) "et pas 4/3"
1 + (1/3) −→ (4/3)
1/3 + 2/3 −→ (7/9) "et pas 1"
(1/3) + (2/3) −→ 1
Exemple. Dans l'expression 20 + 2 * 5, il y a seulement les messages binaires + et *. En Smalltalk, il n'y a pas de priorité spécifique pour les opérations + et *. Ce ne sont que des messages binaires, ainsi * n'a pas priorité sur +. Ici le message le plus à gauche + est envoyé en premier (1) et ensuite * est envoyé au résultat comme nous le voyons dans l'exemple 4.4.
"Comme il n'y a pas de priorité entre les messages binaires, le message le plus à
gauche, + est évalué en premier même si d'après les règles de l'arithmétique le *
devrait d'abord être envoyé."
20 + 2 * 5
(1) 20 + 2 −→ 22
(2) 22 * 5 −→ 110Comme il est montré dans l'exemple 4.4 le résultat de cette expression n'est pas 30, mais 110. Ce résultat est peut-être inattendu, mais résulte directement des règles utilisées pour envoyer des messages. Ceci est le prix à payer pour la simplicité du modèle de Smalltalk. Afin d'avoir un résultat correct, nous devons utiliser des parenthèses. Lorsque les messages sont entourés par des parenthèses, ils sont évalués en premier. Ainsi l'expression 20 + (2 * 5) restitue le résultat comme nous le voyons dans l'exemple 4.5.
"Les messages entourés de parenthèses sont évalués en premier, ainsi
* est envoyé avant + afin de produire le comportement souhaité."
20 + (2 * 5)
(1) (2 * 5) −→ 10
(2) 20 + 10 −→ 30
 |
 |
En Smalltalk, les opérateurs arithmétiques comme + et * n'ont pas des priorités différentes. + et * ne sont que des messages binaires ; donc * n'a pas priorité sur +. Il faut donc utiliser des parenthèses pour obtenir le résultat désiré.
Notez que la première règle, disant que les messages unaires sont envoyés avant les messages binaires ou à mots-clefs, ne nous force pas à mettre explicitement des parenthèses autour d'eux. La table 4.8 montre des expressions écrites en respectant les règles et les expressions équivalentes si les règles n'existaient pas. Les deux versions engendrent le même effet et renvoient les mêmes valeurs.
|
Priorité implicite |
Équivalent explicite avec parenthèses |
|
aPen color |
aPen color |
|
aPen |
aPen |
|
aPen |
aPen |
|
|
|
4-4. Quelques astuces pour identifier les messages à mots-clefs▲
Souvent, les débutants ont des problèmes pour comprendre quand ils doivent ajouter des parenthèses. Voyons comment les messages à mots-clefs sont reconnus par le compilateur.
4-4-1. Des parenthèses ou pas ?▲
Les caractères [, ], and (, ) délimitent des zones distinctes. Dans ces zones, un message à mots-clefs est la plus longue séquence de mots terminés par (:) qui n'est pas coupée par les caractères (.), ou (;). Lorsque les caractères [, ] et (, ) entourent des mots avec des deux-points, ces mots participent au message à mots-clefs local de la zone définie.
Dans cet exemple, il y a deux mots-clefs distincts : rotatedBy:magnify:smoothing: et at:put:.
aDict
at: (rotatingForm
rotateBy: angle
magnify: 2
smoothing: 1)
put: 3Les caractères [, ] et (, ) délimitent des zones distinctes. Dans ces zones, un message à mots-clefs est la plus longue séquence de mots qui se termine par (:) qui n'est pas coupé par les caractères (.) ou ;. Lorsque les caractères [, ] et (, ) entourent des mots avec des deux-points, ces mots participent au message à mots-clefs local de cette zone.
ASTUCE : si vous avez des problèmes avec ces règles de priorité, vous pouvez commencer simplement en entourant avec des parenthèses chaque fois que vous voulez distinguer deux messages avec la même priorité.
L'expression qui suit ne nécessite pas de parenthèses, car l'expression x isNil est unaire donc envoyée avant le message à mots-clefs ifTrue:.
(x isNil)
ifTrue:[...]L'expression qui suit nécessite des parenthèses, car les messages includes: et ifTrue: sont chacun des messages à mots-clefs.
ord := OrderedCollection new.
(ord includes: $a)
ifTrue:[...]Sans les parenthèses le message inconnu includes:ifTrue: serait envoyé à la collection !
4-4-2. Quand utiliser les [ ] ou les ( ) ?▲
Vous pouvez avoir des difficultés à comprendre quand utiliser des crochets plutôt que des parenthèses. Le principe de base est que vous devez utiliser des [ ] lorsque vous ne savez pas combien de fois une expression peut être évaluée (peut-être même jamais). [ expression] va créer une fermeture lexicale ou bloc (c.-à-d.. un objet) à partir de expression, qui peut être évaluée autant de fois qu'il le faut (voire jamais) en fonction du contexte.
Ainsi les clauses conditionnelles de ifTrue: ou ifTrue:ifFalse: nécessitent des blocs. Suivant le même principe, à la fois le receveur et l'argument du message whileTrue: nécessitent l'utilisation des crochets, car nous ne savons pas combien de fois le receveur ou l'argument seront exécutés.
Les parenthèses quant à elles n'affectent que l'ordre d'envoi des messages. Aucun objet n'est créé, ainsi dans (expression), expression sera toujours évalué exactement une fois (en supposant que le code englobant l'expression soit évalué une fois).
[ x isReady ] whileTrue: [ y doSomething ] "à la fois le receveur et l'argument doivent être des blocs"
4 timesRepeat: [ Beeper beep ] "l'argument est évalué plus d'une fois, donc doit être un bloc"
(x isReady) ifTrue: [ y doSomething ] "le receveur n’est évalué qu'une fois, donc n'est pas un bloc"4-5. Séquences d'expression▲
Les expressions (c.-à-d.. envois de message, affectations…) séparées par des points sont évaluées en séquence. Notez qu'il n'y a pas de point entre la définition d'une variable et l'expression qui suit. La valeur d'une séquence est la valeur de la dernière expression. Les valeurs renvoyées par toutes les expressions excepté la dernière sont ignorées. Notez que le point est un séparateur et non un terminateur d'expression. Le point final est donc optionnel.
| box |
box := 20@30 corner: 60@90.
box containsPoint: 40@50 −→ true4-6. Cascades de messages▲
Smalltalk offre la possibilité d'envoyer plusieurs messages au même receveur en utilisant le point-virgule (;). Dans le jargon Smalltalk, nous parlons de cascade.
Expression Msg1 ; Msg2
|
Sélectionnez |
est équivalent à : |
Sélectionnez |
Notez que l'objet qui reçoit la cascade de messages peut également être le résultat d'un envoi de message. En fait, le receveur de la cascade est le receveur du premier message de la cascade. Dans l'exemple qui suit, le premier message en cascade est setX:setY puisqu'il est suivi du point-virgule. Le receveur du message cascadé setX:setY: est le nouveau point résultant de l'évaluation de Point new et non pas Point. Le message qui suit isZero (pour tester s'il s'agit de zéro) est envoyé au même receveur.
Point new setX: 25 setY: 35; isZero −→ false4-7. Résumé du chapitre▲
- Un message est toujours envoyé à un objet nommé le receveur qui peut être le résultat d'autres envois de messages.
- Les messages unaires sont des messages qui ne nécessitent pas d'arguments. Ils sont de la forme receveur sélecteur.
- Les messages binaires sont des messages qui concernent deux objets, le receveur et un autre objet et dont le sélecteur est composé d’un ou deux caractères de la liste suivante :
+,-,*,/, |, &,=,>,<, ~ et @. Ils sont de la forme : receveur sélecteur argument. - Les messages à mots-clefs sont des messages qui concernent plus d'un objet et qui contiennent au moins un caractère deux-points (
:). Ils sont de la forme : receveur motUnDuSelecteur: argumentUn motDeuxDuSelecteur: argumentDeux. - Règle un. Les messages unaires sont d'abord envoyés, puis les messages binaires et finalement les messages à mots-clefs.
- Règle deux. Les messages entre parenthèses sont envoyés avant tous les autres.
- Règle trois. Lorsque les messages sont de même nature, l'ordre d'évaluation est de gauche à droite.
- En Smalltalk, les opérateurs arithmétiques traditionnels comme
+ou*ont la même priorité.+et*ne sont que des messages binaires ; donc*n'a aucune priorité sur+. Vous devez utiliser les parenthèses pour obtenir un résultat différent.
