Organização Modular de Arquivos em Rust

Introdução

Neste laboratório, a hierarquia de arquivos dos módulos no exemplo de código pode ser representada da seguinte forma: existe um diretório chamado "my" que contém dois arquivos, "inaccessible.rs" e "nested.rs". Além disso, existe um arquivo chamado "my.rs" e um arquivo chamado "split.rs". O arquivo "split.rs" inclui o módulo "my", que é definido no arquivo "my.rs", e o arquivo "my.rs" inclui os módulos "inaccessible" e "nested", que são definidos nos arquivos "inaccessible.rs" e "nested.rs", respectivamente.

Nota: Se o laboratório não especificar um nome de arquivo, você pode usar qualquer nome de arquivo que desejar. Por exemplo, você pode usar main.rs, compilar e executar com rustc main.rs && ./main.

Hierarquia de Arquivos

Módulos podem ser mapeados para uma hierarquia de arquivos/diretórios. Vamos decompor o exemplo de visibilidade em arquivos:

$ tree .
.
├── my
│   ├── inaccessible.rs
│   └── nested.rs
├── my.rs
└── split.rs

Em split.rs:

// Esta declaração procurará um arquivo chamado `my.rs` e
// inserirá seu conteúdo dentro de um módulo chamado `my` sob este escopo
mod my;

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

fn main() {
    my::function();

    function();

    my::indirect_access();

    my::nested::function();
}

Em my.rs:

// Similarmente, `mod inaccessible` e `mod nested` localizarão os arquivos
// `nested.rs` e `inaccessible.rs` e os inserirão aqui sob seus respectivos
// módulos
mod inaccessible;
pub mod nested;

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

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

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

    private_function();
}

Em my/nested.rs:

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

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

Em my/inaccessible.rs:

#[allow(dead_code)]
pub fn public_function() {
    println!("chamada `my::inaccessible::public_function()`");
}

Vamos verificar se as coisas ainda funcionam como antes:

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

Resumo

Parabéns! Você concluiu o laboratório de Hierarquia de Arquivos. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.