Em Rust, variáveis são imutáveis por padrão, o que é uma das características que garantem segurança e concorrência sem surpresas. Isso significa que, uma vez que um valor é atribuído a uma variável, ele não pode ser alterado. Essa imutabilidade padrão incentiva um estilo de programação que evita efeitos colaterais indesejados. No entanto, Rust também oferece maneiras de tornar variáveis mutáveis quando necessário, além de recursos como shadowing e constantes que ampliam as opções de gerenciamento de dados.

Nesta aula, exploraremos a fundo esses conceitos: a declaração de variáveis com let e let mut, o shadowing (que permite reutilizar nomes de variáveis), as constantes (const) e as convenções de nomenclatura adotadas pela comunidade Rust. Cada tópico será acompanhado de exemplos práticos para solidificar o aprendizado.

let e let mut

Em Rust, a forma mais básica de declarar uma variável é usando a palavra-chave let. Por padrão, a variável é imutável, ou seja, seu valor não pode ser alterado após a atribuição. Isso é uma escolha de design que promove código mais seguro e previsível. Tentar modificar uma variável imutável resulta em erro de compilação.

Para permitir a mutabilidade, usamos let mut. A palavra-chave mut torna a variável mutável, permitindo que seu valor seja alterado posteriormente. É importante usar mutabilidade apenas quando necessário, pois isso facilita o raciocínio sobre o código.

fn main() {
    // Variável imutável
    let x = 5;
    // x = 6; // Erro! Não é possível atribuir duas vezes a uma variável imutável

    // Variável mutável
    let mut y = 10;
    println!("y = {}", y);
    y = 15; // Ok, y é mutável
    println!("y agora = {}", y);
}

No exemplo acima, x é imutável e não pode ser alterado. Já y é mutável e pode receber um novo valor. Observe que o compilador nos ajuda a evitar erros: se tentarmos modificar x, o código não compila. Isso é uma vantagem em relação a linguagens onde todas as variáveis são mutáveis por padrão.

Shadowing

Shadowing é um recurso que permite declarar uma nova variável com o mesmo nome de uma variável anterior, efetivamente "sombreando" a anterior. A nova variável pode ter um tipo diferente ou ser mutável, enquanto a anterior permanece inacessível a partir daquele ponto. Isso é diferente de mutabilidade, pois estamos criando uma nova variável, não alterando a existente.

Shadowing é útil quando você quer transformar um valor em outro tipo ou reutilizar um nome de variável sem precisar criar um nome diferente. O shadowing é feito simplesmente usando let novamente com o mesmo nome.

fn main() {
    let x = 5;
    let x = x + 1; // shadowing, x agora é 6
    {
        let x = x * 2; // shadowing dentro de um escopo interno
        println!("x interno = {}", x); // 12
    }
    println!("x externo = {}", x); // 6
}

Note que o shadowing dentro do bloco interno não afeta a variável externa. Após o bloco, o valor de x volta a ser 6. Shadowing também permite mudar o tipo da variável, o que não seria possível com mutabilidade.

fn main() {
    let spaces = "   ";
    let spaces = spaces.len(); // spaces agora é um número (usize)
    println!("Número de espaços: {}", spaces);
}

Sem shadowing, seria necessário usar dois nomes diferentes, como spaces_str e spaces_num. Shadowing torna o código mais conciso.

Constantes

Constantes são valores nomeados que são imutáveis e, diferentemente de variáveis, são sempre imutáveis. Elas são declaradas com a palavra-chave const e devem ter o tipo explicitamente anotado. Constantes podem ser declaradas em qualquer escopo, inclusive no escopo global (fora de funções). Elas são úteis para valores que não mudam e são conhecidos em tempo de compilação.

Constantes não podem ser sombreadas (shadowed) nem declaradas com mut. O valor de uma constante é substituído diretamente no código durante a compilação (inlining), o que pode trazer benefícios de desempenho. Por convenção, nomes de constantes usam letras maiúsculas com underscores (SCREAMING_CASE).

const MAX_POINTS: u32 = 100_000;

fn main() {
    println!("O valor máximo é {}", MAX_POINTS);
    // MAX_POINTS = 200_000; // Erro! Constantes são imutáveis
}

Note que usamos u32 como tipo, e o valor pode incluir underscores para melhor legibilidade. Constantes são avaliadas em tempo de compilação, então podem ser usadas em expressões constantes, como tamanhos de arrays.

Convenções de nomes

Rust tem convenções de nomenclatura bem definidas que ajudam a manter o código consistente e legível. Para variáveis e funções, usa-se snake_case (todas as letras minúsculas com underscores separando palavras). Para constantes, usa-se SCREAMING_CASE (letras maiúsculas com underscores). Para tipos (structs, enums, traits), usa-se PascalCase (primeira letra de cada palavra maiúscula, sem underscores).

Seguir essas convenções é importante para que outros programadores Rust possam entender seu código facilmente. O compilador não impõe essas regras (exceto para nomes de constantes, que geram um warning se não estiverem em SCREAMING_CASE), mas a comunidade as adota fortemente.

// snake_case para variáveis e funções
let minha_variavel = 42;
fn minha_funcao() {}

// SCREAMING_CASE para constantes
const MEU_VALOR_MAXIMO: i32 = 100;

// PascalCase para tipos
struct MeuTipo {}
enum MinhaEnum {}

Além disso, é recomendado usar nomes descritivos e evitar abreviações desnecessárias. Nomes curtos como x, y são aceitáveis em contextos simples (como coordenadas), mas em geral prefira nomes que indiquem o propósito da variável.

Boas práticas e observações finais

Ao trabalhar com variáveis em Rust, lembre-se: prefira imutabilidade por padrão e torne variáveis mutáveis apenas quando necessário. Use shadowing para transformações de tipos ou para reutilizar nomes de forma segura. Constantes são ótimas para valores fixos que são conhecidos em tempo de compilação. E siga as convenções de nomenclatura para manter seu código alinhado com a comunidade.

Outra dica: evite shadowing excessivo, pois pode tornar o código confuso. Use com moderação, especialmente em escopos aninhados. Lembre-se também de que constantes são inseridas inline, então se você precisa de um valor que pode ser computado em tempo de execução, use uma variável imutável (let).

Referências

Exercícios

  1. Declare uma variável imutável chamada nome com o valor "Rust" e tente alterá-la para "Python". O que acontece? Corrija o código para que funcione.

    ✓ Resposta: O código original com variável imutável causa erro de compilação. Para corrigir, torne a variável mutável com let mut nome = "Rust"; e então atribua nome = "Python";. Exemplo:
    fn main() {
    let mut nome = "Rust";
    nome = "Python";
    println!("{}", nome);
}

  2. Use shadowing para transformar uma variável numero de tipo inteiro (i32) para uma string que represente o número em texto (ex.: 42 -> "42").

    ✓ Resposta:
    fn main() {
    let numero = 42;
    let numero = numero.to_string(); // shadowing, numero agora é String
    println!("{}", numero);
}

  3. Declare uma constante chamada TAXA_JUROS com valor 0.05 (f64). Tente declarar a mesma constante novamente com let (shadowing) dentro da função main. Isso é permitido? Explique.

    ✓ Resposta: Sim, é permitido. Constantes e variáveis vivem em namespaces diferentes? Na verdade, shadowing de uma constante por uma variável é permitido, pois a constante é um item e a variável é um binding. O código a seguir compila:
    const TAXA_JUROS: f64 = 0.05;
fn main() {
    let TAXA_JUROS = 0.10; // shadowing, mas isso é uma nova variável
    println!("{}", TAXA_JUROS); // imprime 0.10
}
    No entanto, isso pode ser confuso e não é recomendado como boa prática. A constante original ainda existe, mas a variável local a sombreia.

  4. Corrija o código a seguir para seguir as convenções de nomenclatura Rust: let meu_valor_maximo = 100; e const MINHA_CONSTANTE: i32 = 50;.

    ✓ Resposta: A variável deve usar snake_case: let meu_valor_maximo = 100; (já está correto). A constante deve usar SCREAMING_CASE: const MINHA_CONSTANTE: i32 = 50; está incorreta; o correto é const MINHA_CONSTANTE: i32 = 50;? Na verdade, o nome da constante deve ser todo maiúsculo: MINHA_CONSTANTE não segue SCREAMING_CASE porque "MINHA" e "CONSTANTE" estão separados por underscore, mas cada palavra deve ser maiúscula. O correto seria MINHA_CONSTANTE? Sim, isso é SCREAMING_CASE. O código original está correto? Não, porque a constante está com letras minúsculas? O exemplo original: const MINHA_CONSTANTE: i32 = 50; - está em maiúsculas? "MINHA_CONSTANTE" está em maiúsculas? Sim, está em SCREAMING_CASE (todas maiúsculas). Então está correto. Se o exemplo original fosse const minha_constante: i32 = 50;, aí estaria errado. Portanto, a resposta deve considerar que a constante já está correta. Ajuste: a variável está correta, a constante também. O exercício pode ter sido mal formulado. Vou assumir que o código original tem erros: let MeuValorMaximo = 100; e const minha_constante: i32 = 50;. A resposta seria: corrigir para let meu_valor_maximo = 100; e const MINHA_CONSTANTE: i32 = 50;.

  5. Escreva um programa que declare uma variável mutável contador com valor 0, depois use um loop (while ou loop) para incrementá-la até 10, imprimindo cada valor. Use shadowing para reiniciar o contador para 0 após o loop, sem usar mutabilidade.

    ✓ Resposta:
    fn main() {
    let mut contador = 0;
    while contador <= 10 {
        println!("{}", contador);
        contador += 1;
    }
    // Shadowing para reiniciar
    let contador = 0; // nova variável imutável
    println!("Contador reiniciado: {}", contador);
}