Comment dois-je faire une importation de base/include d'une fonction d'un module à un autre dans la Rouille 2015?

Dans la Rouille, il y a certains mots-clés à traiter avec des modules:

extern crate

extern crate comble le fossé entre la Cargaison et la Rouille. Nous écrire du code dans un .rs fichier, ce fichier peut être compilé avec rustc. La cargaison sera de gérer les dépendances externes et appel rustc. Le extern crate ... ligne indique au compilateur de look pour cet espace de noms, c'est donc sans ambiguïté.

Note de l'éditeur — extern crate n'est pas nécessaire dans de nombreux cas, si vous utilisez la Rouille 2018 édition.

mod

mod a deux usages:

• lorsqu'il est utilisé avec des accolades il déclare un module (espace de noms).
• lorsqu'il est utilisé avec juste un nom, il va chercher le module dans le système de fichiers local.

Modules peuvent être:

• fichiers avec l'extension .rs
• des dossiers avec un seul fichier appelé mod.rs

use

use les importations d'un espace de noms. Nous sommes tenus d'annoncer ce que nous allons utiliser avant de l'utiliser. L'utilisation de la clause est assez strict, si nous avons de l'état use module1::moduleA; aucun autre module de module1 sera disponible mais moduleA. Un astérisque (*) peut être utilisé pour une utilisation tout au sein d'un module: use module1::*;. Les ensembles peuvent être utilisés: use module1::{moduleA, moduleB};

Un exemple:

| main.rs
|- module1
      |- mod.rs
      |- moduleA.rs
      |- moduleB.rs

mod.rs contient:

pub mod moduleA; //declare a child module
pub mod moduleB; //declare a child module

principal.rs contient:

/// ======
//use what Cargo downloaded
extern crate that_one_thing_i_need;

/// ======

mod module1; //declare a child module

//some local stuff I want to scope
mod local {
    pub fn my_function() {}
}

//  ======

//make the symbols locally available:
use module1::moduleA::*;
use module1::moduleB::{functionX, moduleY, typeZ};

//we still need to announce what stuff from the external crate
//we want to use:
//We can do local aliases that will be valid in this one file.
use that_one_thing_i_need::fancy_stuff as fs;

/// ======

fn main() {
    //we can use anything here from the namespaces we are using:
    //     moduleA
    //     functionX
    //     moduleY
    //     typeZ
    //     fs

    //We can access stuff by navigating from the outermost visible
    //module name
    local::my_function();
}

Symboles sont utilisables uniquement dans le module. Si vous voulez traverser cette barrière (même déclarés localement module) nous avons besoin de les rendre publiques, en utilisant le mot-clé pub.