Panoramica del linguaggio Rust

Edizione Rust 2024 — linguaggio di sistema | sicurezza della memoria senza GC | concorrenza senza paura | astrazioni a costo zero

Paradigma

Multi-paradigma: imperativo, funzionale, orientato agli oggetti (tratti), orientato ai dati. Tipizzazione statica con inferenza completa, sistema di tipi nominali, tipi di dati algebrici. Compilazione tramite LLVM. Il controllo del prestito impone la sicurezza della memoria in fase di compilazione.

Tipi

Dichiarazioni

Proprietà e prestiti

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).

Regole di prestito

• Uno &mut T XOR molti &T in qualsiasi momento
• I riferimenti sono sempre validi (nessun puntatore penzolante)
• Durata elisa se non ambigua ('a, 'static)

Flusso di controllo

Modelli di corrispondenza

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

Operatori

Sistema dei tratti

Tratti standard (selezionati)

impl Trait / dyn Trait

• impl Trait — tipo di reso opaco (invio statico)
• dyn Trait — oggetto tratto (invio dinamico)
• where clausole per limiti complessi: fn f<T>() where T: Clone + Debug

Generici

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 { ... } }

Modello di memoria

Assegnazione

• Stack: variabili locali, array a dimensione fissa
• Mucchio: Box<T>, Vec<T>, String, Rc<T>, Arc<T>
• alloc / Layout per assegnazione manuale (in std::alloc)

Puntatori intelligenti

• Box<T> — allocazione dell'heap di proprietà, unico proprietario
• Rc<T> — con conteggio dei riferimenti (non thread-safe)
• Arc<T> — con conteggio atomico dei riferimenti (threadsafe)
• Cell<T> — mutabilità interiore per Copy tipi
• RefCell<T> — controllo del prestito in fase di esecuzione
• Mutex<T> / RwLock<T> — mutabilità interna thread-safe
• UnsafeCell<T> — cruda mutabilità interiore

Concorrenza

Libreria standard (moduli selezionati)

Gestione degli errori

// 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 non sicuro

unsafe { ... } i blocchi abilitano:

• Dereferenziazione del puntatore grezzo
• Chiamare funzioni non sicure (FFI)
• Access/modify statica mutevole
• Implementa tratti non sicuri
• Accesso al campo dell'Unione

Il controllo del prestito è ancora valido all'interno di unsafe.

Test

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

Attributi di prova

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

Catena di strumenti

Edizioni

Compilazione

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

Obiettivi

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 (oltre 100 target)

Interoperabilità 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