Installazione di Rust

Per iniziare a programmare in Rust, è necessario installare il compilatore e gli strumenti di sviluppo. Rust utilizza rustup come strumento ufficiale per gestire le installazioni e gli aggiornamenti del linguaggio. In questa guida vedremo come installare Rust su tutti i principali sistemi operativi e come creare il primo progetto.

Rustup: Il Gestore delle Installazioni

rustup è lo strumento ufficiale per installare e gestire le versioni di Rust. Permette di:

• Installare e aggiornare il compilatore Rust (rustc)
• Gestire diverse versioni (stable, beta, nightly)
• Installare componenti aggiuntivi (clippy, rustfmt, rust-analyzer)
• Gestire i target di compilazione per cross-compilation

Installazione su Linux e macOS

Su Linux e macOS, apri il terminale ed esegui il seguente comando:

// Esegui nel terminale (non è codice Rust):
// curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Lo script scaricherà e installerà rustup, che a sua volta installerà l’ultima versione stabile di Rust. Durante l’installazione, ti verrà chiesto di scegliere tra le opzioni di installazione: nella maggior parte dei casi, l’opzione predefinita (1) è quella consigliata.

Dopo l’installazione, riavvia il terminale o esegui:

// Esegui nel terminale:
// source $HOME/.cargo/env

Installazione su Windows

Su Windows hai due opzioni principali:

1. Tramite il sito ufficiale: Scarica e avvia rustup-init.exe dal sito rustup.rs. L’installer ti guiderà attraverso il processo.

2. Tramite winget: Se usi Windows Package Manager, puoi installare Rust con:

// Esegui nel terminale:
// winget install Rustlang.Rustup

Su Windows, Rust richiede i Microsoft C++ Build Tools. L’installer di rustup ti guiderà nell’installazione se non sono già presenti nel sistema.

Verifica dell’Installazione

Dopo l’installazione, verifica che tutto funzioni correttamente aprendo un nuovo terminale:

// Esegui nel terminale:
// rustc --version
// Output esempio: rustc 1.84.0 (9fc6b4312 2025-01-07)

Puoi anche verificare la versione di Cargo:

// Esegui nel terminale:
// cargo --version
// Output esempio: cargo 1.84.0 (fb7c98348 2024-12-18)

Cargo: Il Package Manager di Rust

Cargo è il package manager e build system ufficiale di Rust. Viene installato automaticamente insieme a rustup e si occupa di:

• Creare nuovi progetti
• Compilare il codice
• Gestire le dipendenze (chiamate crate)
• Eseguire i test
• Generare la documentazione
• Pubblicare librerie su crates.io

Il Primo Programma: Hello World

Creiamo il nostro primo progetto Rust utilizzando Cargo:

// Esegui nel terminale:
// cargo new hello_world
// cd hello_world

Cargo crea una struttura di directory come questa:

// hello_world/
// ├── Cargo.toml    (file di configurazione del progetto)
// └── src/
//     └── main.rs   (file sorgente principale)

Il file Cargo.toml contiene le informazioni sul progetto:

// Contenuto di Cargo.toml:
// [package]
// name = "hello_world"
// version = "0.1.0"
// edition = "2024"
//
// [dependencies]

Il file src/main.rs contiene già un programma Hello World:

fn main() {
    println!("Hello, world!");
}

La funzione main è il punto di ingresso di ogni programma Rust. La macro println! stampa il testo a schermo seguito da un ritorno a capo.

Comandi Essenziali di Cargo

Eseguire il Programma

// Esegui nel terminale:
// cargo run
// Output:
//    Compiling hello_world v0.1.0
//     Finished dev [unoptimized + debuginfo] target(s)
//      Running `target/debug/hello_world`
// Hello, world!

cargo run compila il progetto in modalità debug e lo esegue immediatamente.

Compilare senza Eseguire

// Esegui nel terminale:
// cargo build

cargo build compila il progetto e genera l’eseguibile nella cartella target/debug/.

Compilare in Modalità Release

// Esegui nel terminale:
// cargo build --release

cargo build --release compila con le ottimizzazioni attivate. L’eseguibile viene generato in target/release/ ed è significativamente più veloce rispetto alla versione debug, ma la compilazione richiede più tempo.

Controllare il Codice senza Compilare

// Esegui nel terminale:
// cargo check

cargo check verifica che il codice compili correttamente senza generare l’eseguibile. È molto più veloce di cargo build ed è utile durante lo sviluppo.

Aggiornare Rust

Per aggiornare Rust all’ultima versione stabile:

// Esegui nel terminale:
// rustup update

Questo comando aggiorna il compilatore, Cargo e tutti i componenti installati all’ultima versione disponibile.

Per vedere quali toolchain sono installate:

// Esegui nel terminale:
// rustup show

Strumenti Aggiuntivi Consigliati

Dopo l’installazione di base, è consigliato installare alcuni strumenti utili:

// Esegui nel terminale:
// rustup component add clippy      // Linter per codice Rust
// rustup component add rustfmt     // Formattatore automatico del codice
// rustup component add rust-analyzer  // Language server per gli IDE

• Clippy: Analizza il codice e suggerisce miglioramenti e best practice.
• Rustfmt: Formatta automaticamente il codice secondo lo stile standard di Rust.
• Rust Analyzer: Fornisce completamento del codice, navigazione e diagnostica negli editor.

Conclusione

L’installazione di Rust è un processo semplice grazie a rustup, che gestisce automaticamente il compilatore, Cargo e tutti gli strumenti necessari. Cargo semplifica enormemente la gestione dei progetti, dalla creazione alla compilazione, dall’esecuzione dei test alla gestione delle dipendenze. Con l’ambiente configurato, sei pronto per iniziare a scrivere codice Rust sicuro e performante.