Visão geral da linguagem Rust

Edição Rust 2024 — linguagem de sistemas | segurança de memória sem GC | simultaneidade destemida | abstrações de custo zero

Paradigma

Multiparadigma: imperativo, funcional, orientado a objetos (traços), orientado a dados. Tipagem estática com inferência completa, sistema de tipos nominais, tipos de dados algébricos. Compilação via LLVM. O verificador de empréstimo reforça a segurança da memória em tempo de compilação.

Tipos

Declarações

Propriedade e empréstimo

Each value has exactly one owner.
Ownership can be moved (assignment, function call).
References (&T) borrow without taking ownership.
Mutable references (&mut T) are exclusive — only one at a time.
References must never outlive their referent (lifetimes).

Regras de empréstimo

• Um &mut T XOR muitos &T a qualquer momento
• As referências são sempre válidas (sem ponteiros pendentes)
• Tempos de vida omitidos quando inequívocos ('a, 'static)

Fluxo de controle

Padrões de correspondência

Pattern        := Literal | Identifier | _ | ref | mut | @ binding
                 | Tuple(x, y) | Struct { field } | Enum::Variant(x)
                 | x | y (OR) | x @ y (bind) | .. (rest)
                 | ... (inclusive range) | ..= (inclusive range)
Guards         := Pattern if condition => body

Operadores

Sistema de características

Características padrão (selecionadas)

impl Trait / dyn Trait

• impl Trait — tipo de retorno opaco (despacho estático)
• dyn Trait — objeto de característica (despacho dinâmico)
• where cláusulas para limites complexos: fn f<T>() where T: Clone + Debug

Genéricos

fn id<T: Display>(x: T) -> T { x }
struct Pair<T, U> { first: T, second: U }
enum Option<T> { Some(T), None }
impl<T: Clone> Pair<T, T> { fn duplicate(&self) -> Self { ... } }

Modelo de memória

Alocação

• Pilha: variáveis locais, matrizes de tamanho fixo
• Pilha: Box<T>, Vec<T>, String, Rc<T>, Arc<T>
• alloc / Layout para alocação manual (em std::alloc)

Ponteiros inteligentes

• Box<T> — alocação de heap de propriedade, proprietário único
• Rc<T> — contagem de referência (não threadsafe)
• Arc<T> — contado atomicamente por referência (threadsafe)
• Cell<T> — mutabilidade interior para Copy tipos
• RefCell<T> — verificação de empréstimo em tempo de execução
• Mutex<T> / RwLock<T> — mutabilidade interna segura para thread
• UnsafeCell<T> — mutabilidade interna bruta

Simultaneidade

Biblioteca Padrão (módulos selecionados)

Tratamento de erros

// Recoverable: Result<T, E>
fn div(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 { Err("division by zero".into()) }
    else { Ok(a / b) }
}
let r = div(10, 2)?;  // early return on Err

// Unrecoverable: panic!
panic!("something went wrong");

// Expected/unexpected split
// Result for recoverable, panic for programmer errors

Rust inseguro

unsafe { ... } blocos permitem:

• Desreferência de ponteiro bruto
• Chame funções inseguras (FFI)
• Access/modify estática mutável
• Implementar características inseguras
• Acesso ao campo da união

O verificador de empréstimo ainda se aplica dentro de unsafe.

Teste

#[test]
fn test_addition() {
    assert_eq!(2 + 2, 4);
    assert!(true);
    assert_ne!(1, 2);
}

Atributos de teste

#[test] #[should_panic] #[ignore] #[cfg(test)] #[bench]

Conjunto de ferramentas

Edições

Compilação

rustc file.rs                    # compile
cargo new project                # new project
cargo build                      # debug build
cargo build --release            # release build
cargo run                        # build + run
cargo test                       # run tests
cargo doc --open                 # generate docs
cargo check                      # type-check without codegen

Alvos

x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu x86_64-pc-windows-msvc x86_64-apple-darwin wasm32-unknown-unknown wasm32-wasi thumbv7em-none-eabihf (mais de 100 alvos)

Interoperabilidade C

// FFI declaration
extern "C" {
    fn printf(fmt: *const u8, ...) -> i32;
}

// Linking
#[link(name = "m")]
extern "C" { fn sqrt(x: f64) -> f64; }

// ABI types
// i32 → c_int, u64 → c_ulonglong, *const T → *const c_void