A Palavra-chave Public

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 9 de 61.

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

Para tornar os itens acessíveis de fora do 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 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 estrutura, outros arquivos nem podem 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 criar um catálogo de produtos simples organizando seu código em dois arquivos e tornando públicos os itens certos para que possam ser usados no 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 de produto, coloque Product no escopo com uma instrução use e, em seguida, crie um produto e imprima seus detalhes.

Pense com cuidado sobre onde você precisa da palavra-chave pub: a própria struct precisa estar visível, os campos precisam estar acessíveis para leitura e o método construtor precisa poder ser chamado de 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 será:

Product: Laptop, Price: $999.99

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

Experimente você mesmo

// Declare o módulo product
mod product;

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

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