====== La méthode yourself ======

Dans cette séquence nous allons découvrir la méthode **yourself**, qui a priori ne sert à rien et qui est pourtant extrêmement utile.

On commence par un exercice avec cette expression:

<code smalltalk>
" Un ensemble contenant la valeur 2"
Set new add: 2

">>> 2"
</code>

On aimerait récupérer un ensemble contenant la valeur 2, cependant l'exécution de l' expression ci-dessus ne nous retourne que la valeur 2. Alors pourquoi est-ce qu'on obtient la valeur 2 plutôt qu'un ensemble qui contient 2 ?

Si on regarde le code de la méthode "add:" implémentée dans la classe "Set", on voit que cette méthode retourne son paramètre. 

Dans l'expression "Set new add 2":
  * La classe "Set" est le receveur du message new.
  * Quand on envoie "new" à la classe "Set", on obtient une nouvealle instance de "Set" donc un nouvel ensemble auquel on envoie le message "add: 2"
  * La méthode add:2 retourne son paramètre, c'est-à-dire 2. 

Avec l'expression précédente on a perdu notre ensemble. Une façon de corriger ce problème-là est de découper ces expressions étape par étape:

<code smalltalk>
|s|
s := Set new.
s add:2.
s

">>> a Set(2)"
</code>

On peut créer une variable temporaire, donc là on déclare la variable "s". On assigne dans "s" notre nouvel ensemble, on ajoute 2 dans "s". Et "s" maintenant a comme contenu un ensemble qui contient la valeur 2. C'est bien ce que l'on souhaitait.

Mais on peut simplifier cette expression-là en utilisant la méthode "yourself". Alors si on regarde la méthode "yourself", son contenu, la seule chose qu'il y a à l'intérieur de "yourself" c'est "^ self". On a dit que "Return self" était optionnel donc a priori cette méthode pourrait aussi bien être vide, et ne faire rien du tout que retourner son receveur.

Cette méthode, a priori, ne fait rien d'autre que retourner son receveur et elle est quand même parfaitement utile dans ce genre de cas-là.

Grâce à l'opérateur cascade ';', après avoir ajouté 2, on va explicitement exécuter la méthode "yourself" qui va nous retourner le receveur, de façon à ce que l'expression complète soit le receveur, c'est-à-dire le nouvel ensemble.

<code smalltalk>
|s|
s := Set new
  add:2;
  yourself.

s
">>> a Set(2)"
</code>

Donc si je prends "Set new", retourne un nouvel objet "Set", "Add 2" appliqué à "Set new" ça retourne 2, mais **grâce à l'opérateur cascade suivi de "Yourself"** l'ensemble de l'expression va retourner le nouveau "Set".

Alors pourquoi la cascade retourne systématiquement la valeur retournée par sa dernière expression? La cascade, dans ce cas-là retourne la valeur retournée par "yourself".

On se sert très fréquemment de **yourself et de la cascade dans les méthodes d'instanciation**. Ce sont des méthodes qu'on va mettre côté classe, ce sont des méthodes de classe, des messages qu'on va envoyer à des classes et qui retournent de nouvelles instances.

là, pour créer un nouveau "Set" qui contient un objet par défaut, je peux envoyer le message "With" avec cet objet par défaut dans "Set", et ce code-là va être exécuté pour créer un nouveau "Set", le mettre dans la variable "Instance", ajouter à Instance le nouvel objet, le paramètre et retourner instance. Mais l'ensemble de ces expressions, je peux le réécrire en utilisant Yourself de façon un tout petit peu plus concise et plus idiomatique. Donc typiquement, on retrouvera ce genre de code-là dans l'ensemble de l'image Pharo donc il est important de bien maîtriser le point-virgule, donc la cascade et yourself.

En résumé, certaines méthodes, même si elles sont extrêmement simples, peuvent être très puissantes et très utilisées. Et la cascade, donc le point-virgule et la méthode yourself sont très souvent utilisés ensemble, pour s'assurer qu'une expression complète retourne bien une valeur, la valeur qu'on a souhaitée.