Re: Raisons d'essayer Rust

J'ai lu le fil de discussion, et je suis honnêtement un peu dans la même situation que schonfeder à la fin

J'ai lu un peu les pages suivantes : l'exemple de trefis est intéressant et montre une différence plus significative (un seul raise au lieu de trois), au prix d'une formule un peu longue.

Ceci dit la version proposée utilisant les types somme actuels :

match f () with
| Some y ->
 begin match g y with
 | A x ->
 begin match h x with
 | Ok result -> result
 | Error _ -> raise Not_found
 end
 | _ -> raise Not_found
 end
| None -> raise Not_found

ressemblerait beaucoup à la version Go naturelle :

y, err := f()
if err != nil {
 return err
}
switch x := g(y).(type) {
case A:
 result, err := h(x)
 if err != nil {
 return err
 }
 return result 
}
return errors.New("not found")

qui, dans ce cas particulier pourrait être raccourcie (mais c'est pas idiomatique) :

y, err := f()
if err == nil {
 switch x := g(y).(type) {
 case A:
 result, err := h(x)
 if err == nil {
 return result
 }
}
return errors.New("not found")

dans le même style que la solution proposée avec la nouvelle syntaxe qui fonce direct sur la seul cas intéressant :

let foo () =
 match f () with
 | Some y and (g y with A x and (h x with Ok result)) -> result
 | _ -> raise Not_found

Mais, est-ce une situation fréquente que de se retrouver avec seulement un cas qui correspond à un résultat, et tout plein de cas qui correspondent exactement à la même erreur ? Et si on veut ajouter un contexte à l'erreur au lieu d'un simple Not_found (est-ce que c'est h ou g qui n'a pas trouvé de résultat ?), la nouvelle syntaxe proposée n'est plus utilisable.