La palabra clave Public

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 9 de 61.

En la lección anterior, aprendiste a organizar el código en archivos de módulo separados. Sin embargo, si intentaras usar la estructura Player desde main.rs, encontrarías un error del compilador. Esto se debe a que todo en un módulo de Rust es privado de forma predeterminada.

Para hacer que los elementos sean accesibles desde fuera de su módulo, debes marcarlos explícitamente con la palabra clave pub:

// player.rs
pub struct Player {
    pub name: String,
    pub score: u32,
}

impl Player {
    pub fn new(name: String) -> Player {
        Player { name, score: 0 }
    }
}

Observa cómo pub aparece en varios lugares: en la propia estructura, en cada campo y en el método. Cada elemento necesita su propia declaración de visibilidad.

Sin pub en la estructura, otros archivos ni siquiera pueden nombrar el tipo. Sin pub en los campos, no pueden acceder a los datos directamente. Sin pub en los métodos, no pueden llamarlos.

Ahora en main.rs, puedes usar los elementos públicos del módulo:

// main.rs
mod player;

use player::Player;

fn main() {
    let p = Player::new(String::from("Alice"));
    println!("{}", p.name);
}

La instrucción use incorpora Player al ámbito, así que no tienes que escribir player::Player cada vez. Este enfoque de privacidad predeterminada es intencional. Te anima a pensar detenidamente qué partes de tu código deberían exponerse al mundo exterior.

Desafío

Fácil

Construyamos un catálogo de productos sencillo organizando tu código en dos archivos y haciendo públicos los elementos adecuados para que puedan usarse desde tu programa principal.

Crearás dos archivos:

product.rs: Define una estructura Product con dos campos: name (String) y price (f64). Añade una función asociada llamada new que tome un nombre y un precio, y devuelva un nuevo Product. Recuerda marcar la estructura, sus campos y el método como públicos para que se pueda acceder a ellos desde fuera del módulo.
main.rs: Declara el módulo de productos, introduce Product en el ámbito con una instrucción use, después crea un producto e imprime sus detalles.

Piensa detenidamente dónde necesitas la palabra clave pub: la estructura en sí debe ser visible, los campos deben ser accesibles para su lectura y el método constructor debe poder llamarse desde main.rs.

Tu salida debe seguir este formato exacto:

Product: {name}, Price: ${price}

Por ejemplo, si creas un producto con el nombre "Laptop" y el precio 999.99, la salida sería:

Product: Laptop, Price: $999.99

Recibirás dos entradas: el nombre del producto y el precio.

Pruébalo tú mismo

// Declara el módulo product
mod product;

// TODO: Trae Product al ámbito con una sentencia use

fn main() {
    // Lee la entrada
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    let mut price_input = String::new();
    std::io::stdin().read_line(&mut price_input).expect("Failed to read line");
    let price: f64 = price_input.trim().parse().expect("Failed to parse price");
    
    // TODO: Crea un nuevo Product usando la función Product::new
    
    // TODO: Imprime los detalles del producto en el formato:
    // Product: {name}, Price: ${price}
}