Rust par l'exemple

// Un module nommé `my`.
mod my {
    // Les items se trouvant dans le module sont privés, par défaut.
    fn private_function() {
        println!("called `my::private_function()`");
    }

    // Utilisez le mot-clé `pub` pour modifier la visibilité par défaut.
    pub fn function() {
        println!("called `my::function()`");
    }

    // Des items se trouvant dans le même module peuvent se solliciter
    // entre-eux, même lorsqu'ils sont privés.
    pub fn indirect_access() {
        print!("called `my::indirect_access()`, that\n> ");
        private_function();
    }

    // Les modules peuvent également être imbriqués.
    pub mod nested {
        pub fn function() {
            println!("called `my::nested::function()`");
        }

        #[allow(dead_code)]
        fn private_function() {
            println!("called `my::nested::private_function()`");
        }
    }
    // Les modules imbriqués suivent les mêmes règles vis-à-vis de la 
    // visibilité.
    mod private_nested {
        #[allow(dead_code)]
        pub fn function() {
            println!("called `my::private_nested::function()`");
        }
    }
}

fn function() {
    println!("called `function()`");
}

fn main() {
    // Les noms des modules rattachés à une ressource peuvent être explicités 
    // pour supprimer toute ambiguïté entre deux ressources possédant le même
    // nom.
    function();
    my::function();

    // Les items publics, y compris ceux qui se trouvent dans les modules 
    // imbriqués, peuvent être sollicités en dehors du module parent.
    my::indirect_access();
    my::nested::function();


    // Les items privés d'un module ne peuvent pas être directement sollicités,
    // même si ils sont imbriqués dans un module public:

    // Erreur! `private_function` est privée.
    // my::private_function();
    // TODO ^ Essayez de décommenter cette ligne.

    // Erreur! `private_function` est privée.
    // my::nested::private_function();
    // TODO ^ Essayez de décommenter cette ligne.

    // Erreur! `private_nested` est un module privé.
    // my::private_nested::function();
    // TODO ^ Essayez de décommenter cette ligne.
}

mod my {
    // Une structure publique avec un champ public générique de type `T`.
    pub struct WhiteBox<T> {
        pub contents: T,
    }

    // Une structure publique avec un champ privé générique de type `T`.
    #[allow(dead_code)]
    pub struct BlackBox<T> {
        contents: T,
    }

    impl<T> BlackBox<T> {
        // Constructeur public.
        pub fn new(contents: T) -> BlackBox<T> {
            BlackBox {
                contents: contents,
            }
        }
    }
}

fn main() {
    // Les structures publiques possédant des champs publics 
    // peuvent être instanciées avec les séparateurs `{}`.
    let white_box = my::WhiteBox { contents: "public information" };

    // et leurs champs peuvent être sollicités normalement.
    println!("The white box contains: {}", white_box.contents);

    // Les structures publiques composées de champs privés ne peuvent pas être 
    // instanciées de manière "classique" (i.e. en précisant le nom des champs).
    // Erreur! `BlackBox` possèdent des champs privés.
    // let black_box = my::BlackBox { contents: "classified information" };
    // TODO ^ Essayez de décommenter cette ligne.

    // En revanche, elles peuvent être créées avec un constructeur public.
    let _black_box = my::BlackBox::new("classified information");

    // Les champs privés d'une structure publique ne peuvent pas être 
    // sollicités directement.
    // Erreur! Le champ `contents` est privé.
    // println!("The black box contains: {}", _black_box.contents);
    // TODO ^ Essayez de décommenter cette ligne.
}

// Assigne le chemin `deeply::nested::function` à l'identificateur 
// `other_function`.
use deeply::nested::function as other_function;

fn function() {
    println!("called `function()`");
}

mod deeply {
    pub mod nested {
        pub fn function() {
            println!("called `deeply::nested::function()`")
        }
    }
}

fn main() {
    // Accès moins verbeux à `deeply::nested::function`.
    other_function();

    println!("Entering block");
    {
        // Ceci est équivalent à `use deeply::nested::function as function`.
        // La nouvelle assignation `function()` prendra le pas 
        // sur `deeply::nested::function()`.
        use deeply::nested::function;
        function();

        // Les assignations `use` ne sont disponibles que dans le contexte 
        // où elles ont vu le jour. Dans ce cas, où `function()` occulte 
        // le chemin de base, ce "shadowing" n'est effectif que dans ce bloc.
        println!("Leaving block");
    }

    function();
}

fn function() {
    println!("called `function()`");
}

mod cool {
    pub fn function() {
        println!("called `cool::function()`");
    }
}

mod my {
    fn function() {
        println!("called `my::function()`");
    }

    mod cool {
        pub fn function() {
            println!("called `my::cool::function()`");
        }
    }

    pub fn indirect_call() {
        // Appelons toutes les fonctions nommées `fonction` depuis ce 
        // contexte!
        print!("called `my::indirect_call()`, that\n> ");

        // Le mot-clé `self` fait référence au module courant (en l'occurrence 
        // `my`). Appeler `self::function()` ou `function()` revient exactement 
        // au même, puisqu'ils font tous deux référence à la même fonction.
        self::function();
        function();

        // Vous pouvez également utiliser `self` pour accéder à un autre module 
        // imbriqué dans `my`.
        self::cool::function();

        // Le mot-clé `super` fait référence au contexte parent (en-dehors du 
        // module `my`, pour cet exemple).
        super::function();

        // Si vous ne spécifiez aucun des deux mot-clés, le compilateur 
        // comprendra que vous essayez d'utiliser une ressource se trouvant 
        // dans le contexte de la crate.
        // On va donc assigner un nouvel identificateur à `cool::function()` se 
        // trouvant dans le contexte de la crate.
        // Le contexte de la crate représente tout ce qui se trouve en-dehors des modules.
        {
            use cool::function as root_function;
            root_function();
        }
    }
}

fn main() {
    my::indirect_call();
}

$ tree .
.
|-- my
|   |-- inaccessible.rs
|   |-- mod.rs
|   `-- nested.rs
`-- split.rs

// Dans le fichier my/mod.rs
// De la même manière `mod inaccessible` et `mod nested` vont essayer de localiser 
// les fichiers `nested.rs` et `inaccessible.rs` pour récupérer et ajouter leur contenu 
// dans leur module respectif.
mod inaccessible;
pub mod nested;

pub fn function() {
    println!("called `my::function()`");
}

fn private_function() {
    println!("called `my::private_function()`");
}

pub fn indirect_access() {
    print!("called `my::indirect_access()`, that\n> ");

    private_function();
}

// Dans le fichier my/nested.rs
pub fn function() {
    println!("called `my::nested::function()`");
}

#[allow(dead_code)]
fn private_function() {
    println!("called `my::nested::private_function()`");
}

// Dans le fichier my/inaccessible.rs
#[allow(dead_code)]
pub fn public_function() {
    println!("called `my::inaccessible::public_function()`");
}

$ rustc split.rs && ./split
called `my::function()`
called `function()`
called `my::indirect_access()`, that
> called `my::private_function()`
called `my::nested::function()`