Rust: il primo programma

Un corso di programmazione non può non iniziare con un classico Hello world!. Un semplice script che si limita a stampare una frase di buon auspicio ma che, nel contempo, aiuta a verificare l'operatività dell'ambiente di esecuzione e a scoprire gli elementi fondamentali che la tecnologia in questione ci propone.

Il nostro primo programma in Rust

Ecco il nostro Hello world! in linguaggio Rust:

// Questo è il nostro Hello world!
/*
Con questo esempio impariamo a:
- creare una funzione
- stampare una stringa
- inserire commenti nel codice
*/
fn main() {
    println!("Hello world!"); // Questa riga stampa un messaggio su console
}

Abbiamo scritto una funzione con la keyword fn intitolata main che, come in molti altri linguaggi, rappresenta l'entry point dell'esecuzione di un programma
ovvero la parte di codice che, al lancio del software, verrà eseguita per prima.

I commenti in Rust

Abbiamo riempito il nostro esempio di commenti, altri elementi fondamentali per un corretto approccio al lavoro. I commenti sono frasi in linguaggio naturale inserite in un programma e totalmente ignorate dal compilatore. Il loro scopo è inserire osservazioni, documentazione, annotazioni o altro
ancora affinché il progetto sia ben comprensibile per noi, in primis, e per i nostri colleghi/collaboratori.

I commenti tipicamente possono essere scritti su una riga sola con l'annotazione // o su più righe con /* ... */ sebbene spesso i programmatori Rust tendano per abitudine
a scrivere anche commenti multiriga su più linee ognuna iniziante con //. In questo caso, abbiamo mostrato tre modi per inserire commenti: uno a riga singola indipendente, un blocco su
più righe ed un altro a riga singola inserito alla fine di un'istruzione.

Formattazione e macro

Per quanto riguarda i principali simboli di formattazione del codice vediamo che Rust ha un aspetto piuttosto C-like con le parentesi graffe per delimitare blocchi di codice come quello che delimita il corpo del main ed il punto e virgola per porre termine alle istruzioni.

L'unico elemento davvero operativo di tutto l'esempio è println!("Hello world!") un'istruzione incaricata di stampare a video la frase "Hello world!". Di sicuro stupisce quel punto
esclamativo posto tra println e la parentesi tonda aperta. Ci dice che si tratta non di una funzione ma di una macro, un elemento sintattico che sarà nostra cura esplorare
attentamente nel seguito della guida e che ha lo scopo di permettere il riutilizzo di codice venendo sostituita, a tempo di compilazione, con le vere istruzioni da eseguire, Per accontentiamoci di sapere questo.

Eseguiamo il programma d'esempio

Come già accennato, Rust è un linguaggio compilato quindi non va interpretato "al volo" ma deve prima essere trasformato in un eseguibile. Se state utilizzando strumenti come Replit o il Rust Playground potreste farci poco caso ma se avete scritto questo esempio in un normale file di testo (che noi qui chiamiamo main.rs) avrete bisogno di compilarlo utilizzando l'apposito tool rustc. Anche in questo caso facciamo una piccola digressione. Nel seguito della guida studieremo lo strumento leader per la gestione dei progetti in Rust, cargo, che probabilmente vedrete apparire altrove sin dallo studio di esempi basilari. Qui preferiamo procedere passo passo e per questo accenneremo soltanto a cargo riservandoci di approfondirlo più avanti.

Iniziamo a compilare il nostro programma:

$ rustc main.rs

A seguito di questo comando (che non deve restituire output), troveremo nel nostro spazio di lavoro due file: main.rs e main. Mentre il primo è lo script che già conosciamo,
il secondo è l'eseguibile che ci è stato preparato dal compilatore. Per eseguirlo, basta invocarlo:

$ ./main
Hello world!

Ecco fatto: il nostro primo programma ha funzionato correttamente.

Testiamo cargo

In attesa di studiarlo nel dettaglio possiamo testare cargo affidando a lui il nostro primo programma. Questo tool lavora per progetti pertanto anche per un esercizio semplice come il nostro dovremo crearne uno. La fortuna è che un nuovo progetto cargo produce già di suo un Hello world.

Per creare un nuovo progetto, utilizziamo cargo new seguito dal nome del nostro progetto:

$ cargo new helloworld
Created binary (application) `helloworld` package
Il comando avrà creato una stuttura che possiamo riepilogare così:

helloworld
├── Cargo.toml
└── src
    └── main.rs

In pratica, il progetto consiste in una cartella, di nome helloworld che contiene il file Cargo.toml (ci servirà più avanti per gestire dipendenze e altro) ed una
cartella di nome src con all'interno un file main.rs con un "Hello world" standard, leggermente diverso dal nostro.

A questo punto potremo, dall'interno della cartella helloworld, eseguire il build ed il run, rispettivamente, per compilare ed eseguire il nostro programma:

$ cd helloworld/
$ cargo build
   Compiling helloworld v0.1.0
    Finished dev [unoptimized + debuginfo] target(s) in 1.22s
$ cargo run
     Running `target/debug/helloworld`
Hello, world!

Come vediamo, al termine delle righe precedenti troviamo la stampa del messaggio "Hello, world" e, per esercizio, potremo provare anche a modificare a piacimento il programma che l'ha generato.