Discussion :

[bombseb]

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 :

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

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

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

Code :

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

fn fill_vec(mut vec: Vec<i32>)

Ne fonctionne pas :

Code :

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

fn fill_vec(vec: mut Vec<i32>)

[Pyramidev]

Bonjour,

Quand on écrit :

Code :

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

fn function_name(parameter_name: Type)

C'est en fait un cas particulier de :

Code :

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

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 :

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
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 :

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
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:?}");
    }
}

[bombseb]

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 :

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

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

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

Code :

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

fn fill_vec(vec: mut Vec<i32>)

Alors qu'on peut faire ca :

Code :

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

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

[Pyramidev]

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

Code :

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

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 :

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

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 :

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
#[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:?}");
}

Alors qu'on peut faire ca :

Code :

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

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.

[bombseb]

ok merci pour tes explications...

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

Code :

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

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