prototype d'une fonction avec mut

Bonjour,

J'ai cette fonction qui prend un vec en paramètre. J'essaye de bidouiller un petit peu pour comprendre comment ça marche et je me rend compte que le mot clé "mut" des fois on doit le mettre après "vec:" et d'autre fois avant...Je ne comprend pas la logique du truc...

Paramètre en référence mutable :

Code:

---

fn fill_vec(vec: &mut Vec<i32>)

---

Paramètre mutable avec transfert de propriété :

Code:

---

fn fill_vec(mut vec: Vec<i32>)

---

Ne fonctionne pas :

Code:

---

fn fill_vec(vec: mut Vec<i32>)

---

Bonjour,

Quand on écrit :

Code:

---

fn function_name(parameter_name: Type)

---

C'est en fait un cas particulier de :

Code:

---

fn function_name(pattern: Type)

---

Le pattern peut être un simple nom de paramètre, ou bien quelque chose de plus compliqué. Voici un exemple concret avec deux fonctions concat_1 et concat_2 qui font exactement la même chose :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

fn concat_1(x: (Vec<i32>, &[i32])) -> Vec<i32> { let (mut v, s) = x; v.extend_from_slice(s); v }   fn concat_2((mut v, s): (Vec<i32>, &[i32])) -> Vec<i32> { v.extend_from_slice(s); v }   fn main() { for f in [concat_1, concat_2] { let result = f((vec![1, 2, 3], &[4, 5, 6])); println!("Result: {result:?}"); } }

---

concat_1 et concat_2 prennent toutes les deux un couple en paramètre.
Dans concat_1, le paramètre s'appelle x. Ensuite, dans le code, le couple est déstructuré vers deux variables v (un vecteur muable) et s (un slice).
concat_2 fait la même chose d'un coup sans écrire une variable intermédiaire x.

Avec exactement la même logique, les deux fonctions suivantes push_zero_1 et push_zero_2 sont équivalentes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

fn push_zero_1(x: Vec<i32>) -> Vec<i32> { let mut v = x; v.push(0); v }   fn push_zero_2(mut v: Vec<i32>) -> Vec<i32> { v.push(0); v }   fn main() { for f in [push_zero_1, push_zero_2] { let result = f(vec![1, 2, 3]); println!("Result: {result:?}"); } }

---

Ok je ne voyais pas ca comme ca...Je comprend un peu mieux

Déjà je ne savais pas qu'on pouvait faire ca :

Code:

---

fn concat_2((mut v, s): (Vec<i32>, &[i32]))

---

Mais je ne comprend pas qu'on ne puisse pas faire ca :

Code:

---

fn fill_vec(vec: mut Vec<i32>)

---

Alors qu'on peut faire ca :

Code:

---

fn fill_vec(vec: &mut Vec<i32>)

---

Citation:

---

Envoyé par bombseb

Mais je ne comprend pas qu'on ne puisse pas faire ca :

Code:

---

fn fill_vec(vec: mut Vec<i32>)

---

---

Si on écrivait fn fill_vec(vec: mut Vec<i32>) au lieu de fn fill_vec(vec: mut Vec<i32>), alors il faudrait écrire let v: mut Vec<i32> = vec![1, 2, 3]; au lieu de let mut v: Vec<i32> = vec![1, 2, 3];.

Du coup, tu vas me répondre : mais pourquoi justement on écrirait pas let v: mut Vec<i32> = vec![1, 2, 3]; ?

L'avantage d'écrire mut du côté de la variable qui possède directement la donnée est qu'on peut faire ce genre de chose :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#[derive(Debug)] struct Point { x: i32, y: i32, }   fn main() { let point = Point { x: 1, y: 2}; let Point { x: a, y: mut b} = point; b += 40; println!("a: {a:?}"); println!("b: {b:?}"); }

---

Ce code destructure la variable point vers deux variables a et b. Le mut placé juste derrière b lui permet d'être muable.
Au niveau du langage, il n'y a pas besoin de créer un type spécial "point dont x est immuable mais y muable" : on s'empare du contenu du point et on décide après, parmi son contenu, ce qui est muable ou pas.

La même logique s'applique aux patterns des fonctions. On peut par exemple écrire : fn foo(Point { x: a, y: mut b}: Point). Illustration en réécrivant le code ci-dessus d'une autre manière :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#[derive(Debug)] struct Point { x: i32, y: i32, }   fn main() { let point = Point { x: 1, y: 2}; foo(point); }   fn foo(Point { x: a, y: mut b}: Point) { b += 40; println!("a: {a:?}"); println!("b: {b:?}"); }

---

Citation:

---

Envoyé par bombseb

Alors qu'on peut faire ca :

Code:

---

fn fill_vec(vec: &mut Vec<i32>)

---

---

Pour une référence muable, on est effectivement obligé d'écrire mut du côté du type, mais la situation est différente.

Si tu déclares une fonction comme fn foo(v: Vec<i32>) ou fn foo(mut v: Vec<i32>), dans les deux cas, la fonction peut prendre exactement la même chose en paramètre. Le mot clef mut a un impact seulement sur l'intérieur du code de la fonction.

Par contre, entre fn foo(v: &Vec<i32>) et fn foo(v: &mut Vec<i32>), ce ne sera pas pareil du côté de l'appelant. fn foo(v: &mut Vec<i32>) ne pourra pas prendre en paramètre une référence vers un vecteur immuable.

ok merci pour tes explications...

Je ne savais pas du tout qu'on pouvait faire ca :

Code:

---

let Point { x: a, y: mut b} = point;

---

Mais c'est peut être un peu trop avancé pour moi qui suis un simple débutant