Organización de archivos modular en Rust

Introducción

En este laboratorio, la jerarquía de archivos de los módulos en el ejemplo de código puede representarse de la siguiente manera: Existe un directorio llamado "my" que contiene dos archivos, "inaccessible.rs" y "nested.rs". Además, existe un archivo llamado "my.rs" y un archivo llamado "split.rs". El archivo "split.rs" incluye el módulo "my" que está definido en el archivo "my.rs", y el archivo "my.rs" incluye los módulos "inaccessible" y "nested" que están definidos en los archivos "inaccessible.rs" y "nested.rs" respectivamente.

Nota: Si el laboratorio no especifica un nombre de archivo, puede usar cualquier nombre de archivo que desee. Por ejemplo, puede usar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.

Jerarquía de archivos

Los módulos se pueden mapear a una jerarquía de archivos/directorios. Analicemos el ejemplo de visibilidad en archivos:

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

En split.rs:

// Esta declaración buscará un archivo llamado `my.rs` y
// insertará su contenido dentro de un módulo llamado `my` en este ámbito
mod my;

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

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

    function();

    my::indirect_access();

    my::nested::function();
}

En my.rs:

// Del mismo modo, `mod inaccessible` y `mod nested` localizarán los archivos `nested.rs`
// y `inaccessible.rs` e insertarán aquí bajo sus respectivos
// módulos
mod inaccessible;
pub mod nested;

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

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

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

    private_function();
}

En my/nested.rs:

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

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

En my/inaccessible.rs:

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

Veamos si las cosas siguen funcionando como antes:

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

Resumen

¡Felicitaciones! Has completado el laboratorio de Jerarquía de archivos. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.