A Palavra-chave Public

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 9 de 61.

Na lição anterior, você aprendeu como organizar o código em arquivos de módulo separados. No entanto, se você tentasse usar a struct Player a partir de main.rs, você encontraria um erro de compilador. Isso ocorre porque tudo em um módulo Rust é privado por padrão.

Para tornar os itens acessíveis de fora de seu módulo, você deve marcá-los explicitamente com a palavra-chave pub:

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

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

Observe como o pub aparece em vários lugares — na própria struct, em cada campo e no método. Cada item precisa de sua própria declaração de visibilidade.

Sem pub na struct, outros arquivos não podem sequer nomear o tipo. Sem pub nos campos, eles não podem acessar os dados diretamente. Sem pub nos métodos, eles não podem chamá-los.

Agora em main.rs, você pode usar os itens públicos do módulo:

// main.rs
mod player;

use player::Player;

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

A instrução use traz Player para o escopo para que você não precise escrever player::Player todas as vezes. Essa abordagem de privacidade por padrão é intencional — ela incentiva você a pensar cuidadosamente sobre quais partes do seu código devem ser expostas ao mundo exterior.

Desafio

Fácil

Vamos construir um catálogo de produtos simples, organizando seu código em dois arquivos e tornando os itens corretos públicos para que possam ser usados a partir do seu programa principal.

Você criará dois arquivos:

product.rs: Defina uma struct Product com dois campos: name (String) e price (f64). Adicione uma função associada chamada new que recebe um nome e um preço e retorna um novo Product. Lembre-se de marcar a struct, seus campos e o método como públicos para que possam ser acessados de fora do módulo.
main.rs: Declare o módulo product, traga Product para o escopo com uma instrução use, depois crie um produto e imprima seus detalhes.

Pense cuidadosamente sobre onde você precisa da palavra-chave pub—a struct em si precisa estar visível, os campos precisam estar acessíveis para leitura e o método construtor precisa ser chamável a partir do main.rs.

Sua saída deve seguir este formato exato:

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

Por exemplo, se você criar um produto com o nome "Laptop" e o preço 999.99, a saída seria:

Product: Laptop, Price: $999.99

Você receberá duas entradas: o nome do produto e o preço.

Folha de consulta

Em Rust, tudo em um módulo é privado por padrão. Para tornar itens acessíveis de fora de seu módulo, use a palavra-chave pub.

Marque structs, campos e métodos como públicos:

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

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

Cada item precisa de sua própria declaração de visibilidade:

pub na struct torna o tipo visível
pub nos campos permite o acesso direto aos dados
pub nos métodos permite chamá-los

Use a instrução use para trazer itens para o escopo:

// main.rs
mod player;

use player::Player;

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

Experimente você mesmo

// Declara o módulo product
mod product;

// TODO: Trazer Product para o escopo com uma declaração use

fn main() {
    // Ler a 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: Criar um novo Product usando a função Product::new
    
    // TODO: Imprimir os detalhes do produto no formato:
    // Product: {name}, Price: ${price}
}