Où est l'endroit recommandé pour placer les déclarations `use` en Rust?

Question

Où est l'endroit recommandé pour mettre les déclarations use? Je n'ai pas trouvé de réponse décisive dans le livre, dans les FAQ, les listes de diffusion ou les forums en ligne. Je commence un nouveau projet en Rust et je préférerais adopter la bonne approche dès le départ.

L'une des deux approches ci-dessous est-elle recommandée? Est-ce seulement pour "aliasser" des choses ou fait-il plus, comme initialiser un module s'il n'a pas été utilisé auparavant?

use std::io;
use std::io::Write;

fn some_func() -> () {
    [...] // Nous supposons que nous avons besoin de std::io ici
}

fn some_other_func() -> () {
    [...] // Nous supposons que nous avons besoin de std::io et std::io::Write ici
}

OU

fn some_func() -> () {
    use std::io;
    [...] // Nous supposons que nous avons besoin de std::io ici
}

fn some_other_func() -> () {
    use std::io;
    use std::io::Write;
    [...] // Nous supposons que nous avons besoin de std::io et std::io::Write ici
}

Answer 1

En résumé : Comme presque tous les autres logiciels, cela dépend de ce que vous faites. Le style courant que j'ai observé (et que je préfère moi-même) est de les placer en haut du fichier et de les déplacer vers un champ d'application plus restreint au besoin.

---

En général, je recommande de commencer par placer les déclarations use directement après les déclarations extern crate et mod, séparées par une ligne vide :

extern crate foo;
extern crate bar;

mod interesting;

use std::collections::HashMap;
use foo::Foo;
use bar::{Quux, moo};    
use interesting::something;    

// structs, fonctions, etc.

Je recommande cela par défaut car, la plupart du temps, une importation est utilisée dans plusieurs éléments de niveau supérieur. Il est donc logique de l'importer une seule fois.

Il arrive que des traits importés aient des méthodes en conflit, et dans ces cas, je limite l'importation à l'endroit où elle est nécessaire. Il y a aussi des cas où je travaille intensivement avec une seule énumération et souhaite l'importer globalement pour éviter de répéter le nom de l'énumération :

fn foo(e: MyEnum) {
    use MyEnum::*;

    match e {
        One => 1,
        Two => 2,
    }
}

Dans certains cas, des déclarations use en conflit indiquent que vous tentez de faire trop dans un seul fichier et qu'il devrait être découpé en fichiers séparés, les déclarations use ne sont alors plus ambiguës.