<h2>Variáveis e Imutabilidade em Rust</h2>
<p>Em Rust, toda variável é <strong>imutável por padrão</strong>. Isso é uma decisão arquitetônica fundamental que torna o código mais previsível e seguro. Quando você declara uma variável com <code>let</code>, ela não pode ser alterada após sua inicialização, a menos que você explicitamente a declare como mutável usando a palavra-chave <code>mut</code>.</p>
<pre><code class="language-rust"></code></pre>
<p>Esse padrão força o desenvolvedor a pensar sobre quais dados realmente precisam mudar durante a execução do programa. A imutabilidade por padrão reduz bugs relacionados a estado compartilhado e facilita o raciocínio sobre o fluxo de dados. Diferente de linguagens como Python ou JavaScript onde tudo é mutável automaticamente, Rust exige que você seja explícito sobre suas intenções.</p>
<h2>Tipos Primitivos em Rust</h2>
<p>Rust oferece um conjunto rico de tipos primitivos divididos em categorias principais. Os <strong>tipos inteiros</strong> incluem <code>i8</code>, <code>i16</code>, <code>i32</code>, <code>i64</code>, <code>i128</code> (assinados) e <code>u8</code>, <code>u16</code>, <code>u32</code>, <code>u64</code>, <code>u128</code> (sem sinal). O tipo padrão é <code>i32</code>. Os <strong>tipos de ponto flutuante</strong> são <code>f32</code> e <code>f64</code>, ambos seguindo o padrão IEEE 754. Já o tipo <code>bool</code> representa valores booleanos (<code>true</code> ou <code>false</code>), e <code>char</code> representa um caractere Unicode de 4 bytes.</p>
<pre><code class="language-rust">fn main() {
// Inteiros
let a: i32 = -42;
let b: u8 = 255;
let c = 100; // Inferido como i32
// Ponto flutuante
let pi: f64 = 3.14159;
let f = 2.5; // Inferido como f64
// Booleano
let ativo = true;
// Caractere (4 bytes, suporta Unicode)
let letra = 'A';
let emoji = '🦀';
println!("Inteiro: {}, Float: {}, Bool: {}, Char: {}", a, pi, ativo, emoji);
}</code></pre>
<p>A <strong>inferência de tipos</strong> em Rust é poderosa: o compilador deduz o tipo baseado no contexto e na operação realizada. Mesmo sem anotações explícitas, o compilador garante type safety em tempo de compilação. Para tipos numéricos, você pode especificar literais com sufixos como <code>42i32</code> ou <code>3.14f32</code> para ser explícito.</p>
<h3>### Operações e Comportamento</h3>
<p>Rust não realiza conversão implícita entre tipos numéricos diferentes. Se você precisa converter <code>i32</code> para <code>i64</code>, deve fazer explicitamente com <code>as</code>. Além disso, operações aritméticas podem causar overflow ou underflow — em modo debug, Rust causa panic; em release, usa aritmética com wrap-around.</p>
<pre><code class="language-rust">fn main() {
let x: i32 = 10;
let y: i64 = x as i64; // Conversão explícita
let resultado = 5 + 3;
let div = 10 / 3; // Divisão inteira = 3
let resto = 10 % 3; // Resto = 1
println!("{}, {}, {}", resultado, div, resto);
}</code></pre>
<h2>Shadowing e Escopo de Variáveis</h2>
<p>O <strong>shadowing</strong> permite redeclarar uma variável com o mesmo nome, "encobrindo" a anterior. Diferente de reatribuição mutável, o shadowing cria uma nova vinculação com potencialmente um tipo diferente. Isso é útil ao transformar dados em etapas sucessivas.</p>
<pre><code class="language-rust">fn main() {
let x = 5; // x é i32
let x = x + 1; // Nova variável x agora é 6
{
let x = x * 2; // Escopo: x = 12
println!("Dentro do escopo: {}", x);
}
println!("Fora do escopo: {}", x); // x = 6
// Mudança de tipo via shadowing
let spaces = " ";
let spaces = spaces.len(); // spaces agora é usize
println!("Espaços: {}", spaces); // Saída: Espaços: 3
}</code></pre>
<p>O escopo em Rust segue regras claras: uma variável existe desde sua declaração até o final do bloco <code>{}</code> contendo-a. Variáveis internas sobrescrevem as externas no mesmo namespace. Essa separação clara de escopos evita bugs sutis de estado global e torna o código mais modular e fácil de raciocinar.</p>
<h2>Tuplas e Arrays como Tipos Compostos</h2>
<p>Para além dos primitivos escalares, Rust oferece <strong>tuplas</strong> e <strong>arrays</strong> como tipos compostos. Uma tupla agrupa valores de tipos potencialmente diferentes em uma estrutura fixa. Arrays, por sua vez, armazenam múltiplos valores do <strong>mesmo tipo</strong> com tamanho fixo em tempo de compilação.</p>
<pre><code class="language-rust">fn main() {
// Tupla heterogênea
let pessoa: (String, i32, bool) = ("Ana".to_string(), 28, true);
println!("Nome: {}, Idade: {}, Ativo: {}", pessoa.0, pessoa.1, pessoa.2);
// Destructuring de tupla
let (nome, idade, _) = pessoa;
println!("Nome: {}, Idade: {}", nome, idade);
// Array homogêneo (tamanho fixo)
let numeros: [i32; 5] = [1, 2, 3, 4, 5];
let primeiro = numeros[0]; // Acesso indexado
// Array com valor repetido
let zeros = [0; 10]; // Dez zeros
println!("Primeiro número: {}, Zeros: {:?}", primeiro, &zeros[0..3]);
}</code></pre>
<p>Tuplas são ideais para retornar múltiplos valores de uma função. Arrays são úteis quando você precisa de coleções de tamanho conhecido em tempo de compilação. O destructuring facilita extrair valores sem acessar índices manualmente, tornando o código mais legível e seguro contra erros de indexação.</p>
<h2>Conclusão</h2>
<p>Três pilares fundamentais definem o modelo de variáveis em Rust: <strong>imutabilidade por padrão</strong> força você a ser explícito sobre mudanças, <strong>type safety em tempo de compilação</strong> previne classes inteiras de bugs, e <strong>tipos primitivos bem-definidos</strong> oferecem controle fino sobre memória e performance. Dominar esses conceitos é essencial para escrever código Rust eficaz e idiomático. A combinação de imutabilidade, tipagem estática e inferência cria um ambiente onde o compilador trabalha <em>com você</em>, não contra você, para produzir software seguro e eficiente.</p>
<h2>Referências</h2>
<ul>
<li><a href="https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html" target="_blank" rel="noopener noreferrer">The Rust Programming Language - Variables and Mutability</a></li>
<li><a href="https://doc.rust-lang.org/rust-by-example/primitives.html" target="_blank" rel="noopener noreferrer">Rust by Example - Primitives</a></li>
<li><a href="https://doc.rust-lang.org/reference/types.html" target="_blank" rel="noopener noreferrer">The Rust Reference - Types</a></li>
<li><a href="https://doc.rust-lang.org/book/ch03-02-data-types.html" target="_blank" rel="noopener noreferrer">Rust Book - Data Types</a></li>
<li><a href="https://github.com/rust-lang/rustlings" target="_blank" rel="noopener noreferrer">Rustlings - Variables Course</a></li>
</ul>