Variables immuables (débutant)

**Sve@r** · 25/09/2022, 08h42

Bonjour à tous

Vu l'engouement quasi magique pour ce "nouveau" langage qu'est Rust (il peut concurrencer C, aussi simple que Python, aussi rapide que C et surtout plus sécurisé que ces deux langages combinés) et ne voulant pas mourir idiot, j'ai décidé de... je ne vais pas dire "m'y mettre" mais regarder au-moins ce que ça a à offrir.

Donc suivant en cela mes propres principes (être débutant n'empêche pas de lire les tutos, etc), je cherche un tuto, en trouve un qui semble assez bien conçu (il explique les choses progressivement) donc l'ouvre et me met à le lire.
Je fais le classique "Hello World", qui fonctionne (yeah je suis maintenant un rustacé

) et continue.

Et là j'arrive sur un truc qui parle de variables par défaut immuables, nécessitant un "mut" devant pour les rendre modifiables. Ok, pourquoi pas (c'est vrai que pas mal de bugs proviennent de valeurs qui ont changé alors qu'elles n'auraient pas dû... même si cela fait perdre un peu de son sens au vocable "vari-able"). Plus un petit exemple qui le montre parfaitement

Code rust :

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

1
2
3
4
5
6
fn main() {
	let x = 5;
	println!("La valeur de x est : {}", x);
	x = x+1;
	println!("La valeur de x est : {}", x);
}

Voilà, pas de "mut" après "let" donc ça compile pas, normal. Je remplace let x = 5 par let mut x = 5 et là ça compile. Bon, ok.

Puis je continue à lire et là je vois que dans le tuto, on fait du "let" à tire-larigot sur des variables crées sans "mut" et que ça fonctionne.

Je reprends mon exemple et j'écris

Code rust :

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

1
2
3
4
5
6
fn main() {
	let x = 5;
	println!("La valeur de x est : {}", x);
	let x = x+1;
	println!("La valeur de x est : {}", x);
}

Et là aussi ça fonctionne !!!???!!!

Bon ben alors c'est quoi le truc? Pourquoi on dit que les variables sont immuables alors qu'il sufit d'un "let" pour qu'elles ne le soient pas? Pourquoi avoir besoin de "mut" alors que "let" le fait?

Et (tant qu'à faire) je vois aussi qu'on peut créer des constantes qui sont (dixit tuto) comme des variables immuables avec quelques restrictions

une constante est toujours immuable (interdit de mettre un "mut" dessus)
une constante ne peut pas recevoir de calcul issu d'une variable (et effectivement ayant tenté const Y:u16 = x+1 j'ai une belle erreur)

Mais alors, en y réfléchissant, n'ayant finalement que des inconvénients par rapport aux variables immuables (et aucun avantage annexe n'est indiqué par le tuto), je me dis que la constante ne sert pas vraiment à grand chose par rapport à la variable immuable non ? Enfin si elle l'est vraiment (immuable)...

Donc voilà mes deux questions de super grand débutant. Merci de votre indulgence.

**plegat** · 25/09/2022, 12h06

Envoyé par Sve@r

Bonjour à tous

Vu l'engouement quasi magique pour ce "nouveau" langage qu'est Rust (il peut concurrencer C, aussi simple que Python, aussi rapide que C et surtout plus sécurisé que ces deux langages combinés) et ne voulant pas mourir idiot, j'ai décidé de... je ne vais pas dire "m'y mettre" mais regarder au-moins ce que ça a à offrir.

C'est tout à ton honneur... et au moins ça te donnera des billes pour critiquer objectivement!

Envoyé par Sve@r

Bon ben alors c'est quoi le truc? Pourquoi on dit que les variables sont immuables alors qu'il sufit d'un "let" pour qu'elles ne le soient pas? Pourquoi avoir besoin de "mut" alors que "let" le fait?

Bah non... un "let" ne rend pas une variable mutable... c'est juste qu'en faisant:

Code :

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

1
2
 
let x = x+1;

tu "redéfinis" ta variable x, et tu écrases "l'ancienne". C'est ce qu'on appelle du "shadowing" (tu caches l'ancienne variable sous la nouvelle).

Essaye ça et tu vas voir si ça marche... ou pas! (ou plutôt si ça compile... ou pas!)

Code rust :

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

1
2
3
4
5
6
7
8
fn main() {
    let x = 5;
    println!("La valeur de x est : {}", x);
    let x = x+1;
    println!("La valeur de x est : {}", x);
    x = x+1;
println!("La valeur de x est : {}", x);
}

Pour les constantes c'est plus subtil (mais en fait non...)... pourquoi ça existe en Rust alors qu'une variable immuable peut avoir le même effet? Ben pour ce que tu relèves justement.
Une constante, c'est une constante, c'est défini à la compilation, et ça ne bouge et ne bougera pas.
Une variable immuable, elle peut être affectée à l'exécution. Sa valeur peut (et sera généralement) inconnue à la compilation.
(plus des histoires de heap et de stack suivant la nature de la variable, toussa toussa...)

Mais alors, en y réfléchissant, n'ayant finalement que des inconvénients par rapport aux variables immuables

Quels inconvénients?
Pourquoi tu veux modifier une constante???? Pourquoi tu veux lui affecter une valeur que tu ne connais pas à la compilation?
Si tu veux faire ça, tu n'as pas besoin d'une constante.
Une constante, c'est connu, et ça ne change pas. C'est la définition d'une constante...

Et ce qu'il y a de bien, c'est que tu évites les bugs avec des constantes qui évoluent au fil de l'exécution du programme... ils sont toujours sympas à trouver et à expliquer ceux-là...

Tu as tout plein de détails ici: https://doc.rust-lang.org/book/ch03-...utability.html

Plus généralement, si tu veux être un vrai "rustacean", il te faut au moins lire le "book" une fois...

https://doc.rust-lang.org/book/

(il doit être dispo en français quelque part si besoin...)

**Sve@r** · 25/09/2022, 13h19

Envoyé par plegat

C'est tout à ton honneur...

Attention, je ne dis pas que je vais m'y mettre. J'ai besoin d'un langage qui

peut interfacer Postgres
peut interfacer Qt et Qwt (ou son successeur QtGraph)
peut traiter du CSV (et dans toutes ses configurations possibles) sans que j'aie à réinventer la roue
peut calculer les décimaux avec une précision chirurgicale (si je demande 0.2 * 3 je veux avoir 0.6 et non pas 0.6000000000000001)
peut manipuler, calculer et afficher rapidement des données pesant approximativement dans les 1 000 000 de lignes de justement 7 ou 8 décimaux (lignes dans lesquels la colonne C de la ligne L sera calculée avec les autres lignes sur cette même colonne C)
ayant une syntaxe pas trop casse c... (si je dois écrire 30 lignes pour agrandir un tableau...)
donnant un programme utilisable sous Windows et Linux (ou plutôt sous Linux sur lequel je développe et aussi sous Windows)

Pour l'instant, Python répond parfaitement au besoin. Le seule reproche qui m'a été fait pour ce choix c'est qu'on ne peut pas cacher le code source (même en l'obfuscant). Bon le type qui m'a fait ce reproche lui il bosse en javascript donc c'est un peu l'hôpital qui se fout de la charité (en plus on peut maintenant créer des exécutables Python) mais de temps en temps j'essaye quand-même de voir si je peux trouver un autre langage qui réponde aux critères...

Envoyé par plegat

Bah non... un "let" ne rend pas une variable mutable... c'est juste qu'en faisant:

Code :

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

1
2
 
let x = x+1;

tu "redéfinis" ta variable x, et tu écrases "l'ancienne". C'est ce qu'on appelle du "shadowing" (tu caches l'ancienne variable sous la nouvelle).

Ok, j'ai fait une erreur de terminologie mais au final cette opération "shadowing" a comme effet concret de modifier la variable (ok, d'en créer une nouvelle qui remplace l'ancienne mais pour le prog, ça a le même résultat qu'une variable modifiée). Si on dit "ok par devant la variable n'est pas modifiable mais elle l'est par derrière" (ok la porte est fermée mais j'ai laissé les baies vitrées ouvertes !!!) c'est un peu comme les mousticaires belges, avec de petits trous pour les petits moustiques et de gros trous pour les gros moustiques (oups...Dourouc va me tuer

)

Envoyé par plegat

Quels inconvénients?
Pourquoi tu veux modifier une constante???? Pourquoi tu veux lui affecter une valeur que tu ne connais pas à la compilation?
Si tu veux faire ça, tu n'as pas besoin d'une constante.
Une constante, c'est connu, et ça ne change pas. C'est la définition d'une constante...

Ok, je me suis mal exprimé.
Dans mon raisonnement (assez simple j'en suis conscient car probablement il me manque des connaissances), une variable "immuable" c'est une variable qu'on ne peut pas modifier. Donc (je pousse là mon raisonnement) quelque part une variable immuable ressemble tellement à une constante qu'on peut les confondre. De là, si la variable "non modifiable" rend les mêmes services qu'une constante, la constante devient de fait un peu inutile. C'est ce raisonnement que j'ai maladroitement résumé dans le nom "inconvénient"

Envoyé par plegat

Plus généralement, si tu veux être un vrai "rustacean", il te faut au moins lire le "book" une fois...

https://doc.rust-lang.org/book/

(il doit être dispo en français quelque part si besoin...)

Ah ben oui, c'est celui-là que j'ai pris car je le trouvais agréable à lire et expliquant bien les choses (même s'il me manque quelques détails que je viens chercher ici). C'est lui qui donne ce premier exemple de x=5 puis qui fait ensuite du "let" dans tous les sens. Puis il parle ensuite des constantes en disant "c'est comme les variables avec des trucs en moins" => https://jimskapt.github.io/rust-book-fr/.
Et effectivement il indique qu'il est tiré du "book" que tu cites.

**plegat** · 25/09/2022, 14h53

Envoyé par Sve@r

Attention, je ne dis pas que je vais m'y mettre. J'ai besoin d'un langage qui

peut interfacer Qt et Qwt (ou son successeur QtGraph)

Houuuuuuuuuuuuuuuuuu....
Normalement, il y a des choses qui se font, même avec Qt, mais tout ce qui est orienté GUI, c'est un des points un peu... en cours de consolidation, disons... il y a pas mal de "crates" qui font le job (beaucoup orienté webapp ou qui passent par le navigateur, plus ou moins camouflé... d'autres qui commencent à tenir la route...)
Je bataille depuis quelques semaines pour tenter de faire une appli GTK, et ce n'est pas forcément simple (forcément, j'essaie d'y mettre du graphique 3D en prime...)

Pour mon utilisation, c'est un des points à travailler pour Rust...

Envoyé par Sve@r

Pour l'instant, Python répond parfaitement au besoin. Le seule reproche qui m'a été fait pour ce choix c'est qu'on ne peut pas cacher le code source (même en l'obfuscant). Bon le type qui m'a fait ce reproche lui il bosse en javascript donc c'est un peu l'hôpital qui se fout de la charité (en plus on peut maintenant créer des exécutables Python) mais de temps en temps j'essaye quand-même de voir si je peux trouver un autre langage qui réponde aux critères...

Après, ne pas forcément chercher à remplacer un truc qui fonctionne dans un langage par du Rust pour faire "hype"... (j'ai bien compris que ce n'était pas ton cas, mais c'est pour les autres qui liront...)
Il y a quand même de grosse subtilités techniques dans Rust qui ne sont pas forcément simple à appréhender et qui demandent une certaine courbe d'apprentissage (rah le chapitre sur les "smart pointers", que du bonheur...

)

Envoyé par Sve@r

Ok, j'ai fait une erreur de terminologie mais au final cette opération "shadowing" a comme effet concret de modifier la variable (ok, d'en créer une nouvelle qui remplace l'ancienne mais pour le prog, ça a le même résultat qu'une variable modifiée). Si on dit "ok par devant la variable n'est pas modifiable mais elle l'est par derrière" (ok la porte est fermée mais j'ai laissé les baies vitrées ouvertes !!!) c'est un peu comme les mousticaires belges, avec de petits trous pour les petits moustiques et de gros trous pour les gros moustiques (oups...Dourouc va me tuer

)

oui, ça peut être vu comme ça... mais non, beaucoup plus subtil...

Dans le book, tu as l'exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
fn main() {
    let x = 5;
 
    let x = x + 1;
 
    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }
 
    println!("The value of x is: {x}");
}

Ca crache quoi la dernière ligne? Bah non, pas 12... ça sort 6... ce qui veut dire que le "premier" x est bien immutable... donc oui, c'est une moustiquaire belge, mais améliorée!