Como passar em uma entrevista sobre Rust: principais perguntas de A a Z

Introdução: Por que Rust é um desafio para o entrevistador

Rust é uma linguagem que exige do desenvolvedor um profundo entendimento de gerenciamento de memória, sistema de tipos e modelo de concorrência. Uma entrevista sobre Rust não é uma verificação de sintaxe, mas um teste de compreensão da filosofia da linguagem. Neste artigo, analisaremos as principais perguntas que podem ser feitas em uma entrevista — desde os fundamentos de ownership até tópicos avançados como assincronicidade. Você descobrirá quais respostas o entrevistador espera e como evitar erros comuns.

1. Ownership, borrowing e lifetimes

1.1. O que é ownership e como funciona?

Este é o fundamento do Rust. Cada valor tem exatamente um dono. Quando o dono sai de escopo, o valor é removido. Isso evita a necessidade de um garbage collector e garante segurança de memória em tempo de compilação.

fn main() {    let s1 = String::from("olá");    let s2 = s1; // s1 é movido para s2    // println!("{}", s1); // Erro! s1 não é mais válido    println!("{}", s2); // Funciona}

Dica: Explique a diferença entre movimentação (move) e cópia (copy). Para tipos que implementam a trait Copy (por exemplo, números inteiros), a movimentação não ocorre — os dados são copiados.

1.2. Regras de borrowing

Borrowing permite usar uma referência aos dados sem transferir a propriedade. Existem dois tipos de referências:

• Imutáveis (&T): pode haver quantas quiser, os dados não podem ser alterados.
• Mutáveis (&mut T): apenas uma referência aos dados no escopo atual.

fn main() {    let mut s = String::from("hello");    let r1 = &s; // referência imutável    let r2 = &s; // outra referência imutável — ok    // let r3 = &mut s; // Erro! Não é possível ter referências imutáveis e mutáveis simultaneamente    println!("{} {}", r1, r2);}

Pergunta capciosa: "Por que o Rust proíbe referências mutáveis e imutáveis ao mesmo tempo?" Resposta: para prevenir condições de corrida (data races) em tempo de compilação.

1.3. Lifetimes — como explicar em termos simples

Lifetimes são anotações que informam ao compilador por quanto tempo as referências serão válidas. Na maioria das vezes, o compilador as infere sozinho, mas em funções complexas é necessário especificá-las explicitamente.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {    if x.len() > y.len() { x } else { y }}

Ideia chave: 'a significa que a referência retornada não viverá mais do que ambas as referências de entrada. Isso garante que a referência não se torne pendente (dangling).

2. Enums, pattern matching e traits

2.1. Enum em Rust — por que é mais poderoso do que em outras linguagens

Em Rust, enums podem armazenar dados de qualquer tipo — strings, números, structs e até mesmo outros enums. Isso permite criar tipos de dados algébricos (ADT).

enum Message {    Quit,    Move { x: i32, y: i32 },    Write(String),    ChangeColor(i32, i32, i32),}

Pergunta típica: "Como funciona Option<T> e por que Rust não tem null?" Resposta: Option é um enum que pode ser Some(T) ou None. O compilador obriga a tratar ambas as variantes, o que elimina erros com ponteiros nulos.

2.2. Pattern matching

A construção match é o coração do Rust. Ela deve ser exaustiva (exhaustive).

fn describe_point(point: (i32, i32)) -> &'static str {    match point {        (0, 0) => "origem",        (0, _) => "no eixo X",        (_, 0) => "no eixo Y",        _ => "em algum lugar no plano",    }}

Dica para a entrevista: Use if let para