Rust - Hello, world!

Iniziamo quindi il nostro percorso con il classico, beneaugurante, saluto da parte del linguaggio e già potremo fare parecchie considerazioni interessanti:

Esempio 2-1

fn main() {
  print!("Ciao, Mondo!");
}

La prima riga ci presenta la keyword fn che introduce una funzione. Il concetto di funzioni è fondamentale in questo linguaggio ma per il momento non approfondiamo il discorso riguardo ad esso, discorso che riprenderemo ovviamente più avanti. In questo caso la funzione ha nome main e costituisce l'entry point del programma. Tale funzione è necessaria, senza la sua presenza il compilatore si lamenta e non compila. La coppia di parentesi dopo la parola main indica, non essendovi nulla al suo interno, che non stiamo passando alcun parametro alla funzione stessa. Impareremo che i parametri sono dei veri e propri input per le funzioni. Rust è un linguaggio case sensitive, ovvero, per quei pochi che non lo sapessero, fa distinzione tra maiuscole e minuscole, per cui scrivere Main è diverso da main (corretto) o mAin. Sempre alla riga 1 notiamo il simbolo di parentesi graffa aperta. In Rust, come in molti altri linguaggi, le sequenze di istruzioni sono contenute all'interno di una coppia di graffe, aperta e chiusa, la corrispondente la trovate alla riga 3. Per chi ad esempio programma in C, C++, Java o C# questo è un concetto ben noto.
La seconda riga ci presenta un sistema per stampare una stringa a video (quel print! che avrete senza dubbio notato) ma questo sistema non è la classica funzione o metodo di altri linguaggi ma una macro, come indicato da quel punto esclamativo che segue il comando print. La scelta di usare una macro anzichè una normale funzione di stampa masce da alcune considerazioni, la più importante credo che dipenda dal fatto che Rust non accetta, se non in casi piuttosto complessi, le funzioni variadiche, ovvero che accettano un numero variabile di parametri cosa che in una funzione di stampa è praticamente necessario garantire. Per inciso esiste anche println! che scrive e va a capo mentre print! a capo non ci va. Queste istruzioni di scrittura saranno oggetto di apposito paragrafo. Sempre alla seconda riga abbiamo una stringa, ovvero una sequenza di caratteri compresa all'interno di una coppia di doppi apici. Sulle sequenze di caratteri però il discorso è molto complesso, come vedremo, e legato a concetti profondi per il linguaggio. Ancora, molto importante, notiamo il ; con cui terminano le istruzioni, anche qui in stile C/C++ e altri. In realtà in questo esempio il ; potrebbe essere omesso trattandosi dell'ultima (e in questo caso unica) istruzione, il programma funziona anche senza di esso. Ma direi che è buona abitudine metterlo sempre.
La terza riga si limita a chiudere il programma non essendoci altre istruzioni seguenti.


Commenti.
I commenti al codice in Rust possono essere inseriti su singola riga o su più righe. Una prima forma è costituita da un doppio backslash // che dovrà essere inserito per ogni singola riga di commento. In dettaglio:

// questo è un commento su riga singola

// questo invece è un commento su più righe
// che si fa in pratica come insieme di righe singole

Un'altra forma di commento è quella che prevede la coppia composta da /* e */ tale sequenza è interessante perchè può essere messa sia all'interno di una riga di istruzioni sia esteso su più righe.

Esempio 2.2

fn main(){
  let x1 =/* definisco un intero*/ 1;
/* commento su più
righe
e più lungo */
  println!("{}", x1); 
}

La riga 2 è vista dal compilatore come fosse:
let x1 = 1;
Esiste anche una forma di commento introdotta da 3 backslash: ///. Questa forma è forse anche più comune della precedente e risulta molto utile per creare documentazione del vostro codice grazie all'eccellente tool rustdoc il cui uso, non proprio semplicissimo di primo acchito, non è oggetto di questo paragrafo.

Quanto esposto in questa sezione serve solo per prendere confidenza con il compilatore e con qualche concetto di base. Dal prossimo di farà sul serio.