Corso Rust

Cheatsheet

Un riferimento veloce — la sintassi essenziale del linguaggio Rust su una pagina sola. Usa Ctrl/Cmd + P per stamparla.

Torna al corso Playground

Variabili e Mutabilità

Dichiarazioni e Shadowing

let x = 5;              // Immutabile di default
let mut y = 10;         // Mutabile (mut)
const MAX: u32 = 100;   // Costante (tipo obbligatorio)
let x = x + 1;          // Shadowing (ri-dichiarazione dello stesso nome)

Le variabili in Rust sono immutabili per impostazione predefinita per garantire sicurezza e concorrenza.

Tipi Primitivi

Tuple e Array

// Tupla (dimensione fissa, tipi eterogenei)
let tuple: (i32, f64, char) = (500, 6.4, 'z');
let first = tuple.0; // Accesso tramite indice

// Array (dimensione fissa, tipo omogeneo)
let array = [1, 2, 3, 4, 5];
let second = array[1]; // Accesso tramite indice

Gli indici degli array partono da 0. Rust controlla l'accesso ai limiti dell'array a runtime, causando il panico se l'indice è fuori limite.

Controllo del Flusso

Condizionali ed Espressioni if

// if/else classico
if number < 5 {
    println!("Piccolo");
} else {
    println!("Grande");
}

// if usato come espressione per assegnare valori
let condition = true;
let number = if condition { 5 } else { 6 };

Cicli (loop, while, for)

// loop (ciclo infinito)
loop {
    break;
}

// while condizionato
while number != 0 {
    number -= 1;
}

// for su un intervallo (range)
for number in 1..4 { // Da 1 a 3
    println!("{}", number);
}

Pattern Matching

match, Option e Result

// Match su valori
match number {
    1 => println!("Uno"),
    2 => println!("Due"),
    _ => println!("Altro"), // Obbligatorio specificare tutti i casi
}

// Match con Option
match x {
    Some(val) => println!("Trovato: {}", val),
    None => println!("Nessun valore"),
}

// Match con Result
match res {
    Ok(val) => println!("Successo: {}", val),
    Err(e) => println!("Errore: {}", e),
}

Ownership e Borrowing

Move e Riferimenti (&)

let s1 = String::from("hello");
let s2 = s1; // La proprieta viene spostata (s1 non e piu utilizzabile!)

let len = calculate_length(&s2); // Passaggio per riferimento immutabile (&)

let mut s3 = String::from("hello");
change(&mut s3); // Passaggio per riferimento mutabile (&mut)

Regole del Borrowing: puoi avere quanti riferimenti immutabili vuoi (&T), OPPURE esattamente un riferimento mutabile (&mut T) alla volta.

Struct e Metodi

Definizione e impl

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Metodo d'istanza (accetta &self)
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Funzione associata (costruttore)
    fn square(size: u32) -> Rectangle {
        Rectangle { width: size, height: size }
    }
}

// Uso
let rect = Rectangle::square(10); // Chiamata funzione associata
let a = rect.area();             // Chiamata metodo