Discussion :

[unoomad]

Bonjour/bonsoir je suis en apprentissage du langage Ruse mais j'ai du mal dans la gestion des erreurs exemple :

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
18
19
20
21
22
23
24
25
 
type MathResult = Result<f64, MathError>;
 
fn div(x: f64, y: f64) -> MathResult {
        if y == 0.0 {
            // This operation would `fail`, instead let's return the reason of
            // the failure wrapped in `Err`
            Err(MathError::DivisionByZero)
        } else {
            // This operation is valid, return the result wrapped in `Ok`
            Ok(x / y)
        }
}
 
enum MathError {
        DivisionByZero,
        NegativeLogarithm,
        NegativeSquareRoot,
    }
 
fn main(){
 
div(10.0,20.0);
 
}

Si je comprends bien Ok et Err renvoient un objet de type Result mais je me suis demandé d'ou venais ces fonctions.

Sur la documentation j'ai vu que le type Result<T, E> était un enum je ne sais pas complètement ce que c'est mais j'ai vu ça :

Code :

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

1
2
3
4
5
 
enum Result<T, E> {
   Ok(T),
   Err(E)
}

Je voudrais savoir en détail comment utiliser ces enum et la gestion des erreur que je ne comprends pas trop si je n'ai pas trop précisé certaine choses vous pouvez me demander en commentaire.

Merci cordialement unoomad.

[imperio]

La gestion des erreurs se fait effectivement via des enums, notamment Result. Ton code est bon dans l'ensemble. Pour vérifier si ta fonction a bien fonctionné, on fera ça :

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
18
19
20
21
22
23
24
25
#[derive(Debug)]
enum MathError {
    DivisionByZero
}
 
type MathResult = Result<f64, MathError>;
 
fn div(x: f64, y: f64) -> MathResult {
    if y == 0.0 {
        // This operation would `fail`, instead let's return the reason of
        // the failure wrapped in `Err`
        Err(MathError::DivisionByZero)
    } else {
        // This operation is valid, return the result wrapped in `Ok`
        Ok(x / y)
    }
}
 
fn main() {
    println!("{:?}", div(1f64, 2f64)); // -> affiche Ok(0.5)
    match div(1f64, 0f64) {
        Ok(value) => println!("Ça s'est bien passé : {}", value),
        Err(err) => println!("Une erreur est arrivée : {:?}", err)
    };
}

On obtient la valeur contenue dans l'enum en matchant dessus. Comme je l'ai dit dans le cours, tu peux aussi utiliser la méthode unwrap :

Code :

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

1
2
3
4
fn main() {
    println!("{}", div(1f64, 2f64).unwrap()); // -> affiche 0.5
    println!("{}", div(1f64, 0f64).unwrap()); // -> va planter
}

Mais c'est à tes risques et périls. J'espère avoir répondu à tes questions.

[unoomad]

Donc si j'ai bien compris pour la gestion d'erreur d'un coté on doit "emballer" grace a la fonction Ok ou Err et verifier grâce au pattern maching si le résultat est bon ou si il y a une erreur c'est ça ? Ce que je ne comprends pas c'est que ces deux fonctions font 2 choses differente on dirait l'utilisation de Ok dans la fonction div n'est pas la même que dans le pattern matching dans le main c'est ça qui me bloque un peu ...

Code :

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

1
2
3
4
5
 
match div(1f64, 0f64) {
        Ok(value) => println!("Ça s'est bien passé : {}", value),
        Err(err) => println!("Une erreur est arrivée : {:?}", err)
    };

Ce que je me demande ici c'est comment il sais si c'est dans Ok ou Err qu'il doit aller, c'est grace a l'objet du type Result<f64, MathError> ?
Quand c'est Ok la fonction div renvoie un truc du genre Result<0.5, ()> et si c'est Err ça renvoie ça Result<(), DivisionByZero> ?

[imperio]

Ah ça y est, j'ai compris ton problème ! Ok et Err sont des enums, mais un peu particulières : ce sont des structures tuples. En gros ce sont des éléments d'enums qui contiennent une valeur. Je reprends mon exemple du cours :

Code :

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

1
2
3
4
5
6
struct Distance(isize);
 
let distance = Distance(23);
 
let Distance(longueur) = distance;
println!("La distance est {}", longueur);

On pourrait faire un truc avec un Result dans ce genre :

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
struct Distance(i32);
 
fn get_distance(dist: i32) -> Result<Distance, String> {
    if dist < 0 {
        Err("Distance invalide".to_owned())
    } else {
        Ok(Distance(dist))
    }
}
 
// et maintenant on match dessus pour récupérer la valeur :
match get_distance(23) {
    Ok(Distance(d)) => println!("La distance est {}", d),
    Err(e) => println!("erreur : {}", e)
};

On aurait aussi pu faire comme ça pour récupérer la valeur :

Code :

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

1
2
3
4
5
6
let distance = get_distance(23).unwrap();
// ici on a donc distance qui vaut Distance(23)
// Pour récupérer la valeur :
match distance {
    Distance(d) => println!("La distance est {}", d)
};

Tu comprends un peu mieux comment ça fonctionne ?

[unoomad]

Ahh c'est bon j'ai compris je pensais que c'était quelque chose différent des structs mais dernière chose si c'est des enum on est pas sensé les utilisés comme ça ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#[derive(Debug)]
enum MathError {
    DivisionByZero(i8)
}
fn main(){
 
    let division = MathError::DivisionByZero(8);
    let MathError::DivisionByZero(val) = MathError::DivisionByZero(8);
    println!("{}", val);
 
}

Pourquoi Ok et Err n'ont pas de préfixe ?

[imperio]

Parce qu'ils sont déjà importés "par défaut". Dans ton cas tu peux faire :

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)]
enum MathError {
    DivisionByZero(i8)
}
 
use MathError::DivisionByZero;
 
fn main(){
 
    let division = DivisionByZero(8);
    let DivisionByZero(val) = DivisionByZero(8);
    println!("{}", val);
}

Cependant je préfère avec les préfixes.

[unoomad]

Ah je vois tout est clair maintenant je résous ce post, la je travaille sur les références et variable avant de poser d'autre question dessus ... Merci a toi.