Il modello di proprietà in Rust

Il principio base del modello di proprietà in Rust consiste essenzialmente nel fatto che ciascuna risorsa può appartenere a uno e un solo “proprietario”. Col termine risorsa si può indicare qualunque cosa, da una porzione di memoria a un socket aperto, fino a qualcosa di più astratto come un mutex lock. Il proprietario della risorsa è il responsabile del suo utilizzo, in alcuni casi pu prestarla ad altri utenti e deve, in ultima istanza, occuparsi della sua rimozione. Tutto ciò avviene automaticamente, grazie all’uso di scope e binding: un binding può possedere o prendere in prestito i valori, e dura fino al termine del proprio scope. Quando un binding esce dallo scope, deve restituire il valore preso in prestito oppure rimuoverlo se ne è il proprietario.

La cosa ancor più interessante è che i controlli per il corretto funzionamento del modello di proprietà sono effettuati e forzati dal compilatore Rust e dallo “strumento di controllo dei prestiti” in fase di compilazione e tutto questo produce una serie di vantaggi aggiuntivi.

Nessuna astrazione

Poiché il corretto funzionamento di un programma viene valutato in fase di compilazione, è possibile considerare il risultato ottenuto dopo la compilazione privo di errori tipici della gestione della memoria e della programmazione concorrente, come ad esempio l’utilizzo di puntatori che fanno riferimento a porzioni di memoria che sono state liberate o problemi di concorrenza (data races). Tutto questo è possibile perché Rust segnala in fase di compilazione eventuali violazioni dei principi sopra esposti, contribuendo in questo modo a mantenere il runtime minimale.
Spostando questi controlli in fase di compilazione non è necessario effettuarli a runtime (il codice compilato è già sicuro), e si possono perciò evitare overhead in fase di runtime. Nel caso della gestione della memoria, questo si traduce nell’inutilità di avere un Garbage Collector a runtime. Tutto questo — avanzato costrutto del linguaggio con pochi o nessun overhead in fase di runtime — è alla base del concetto di “nessuna astrazione”.

Sebbene un’approfondita trattazione del modello di proprietà di Rust esuli dagli obiettivi di questo articolo introduttivo, esistono molte ottime risorse, come il Rust book e articoli che trattano approfonditamente questo argomento. I principi del modello di proprietà e dello strumento di controllo dei prestiti sono due passaggi essenziali per la comprensione di Rust e sono la chiave per comprendere altri aspetti importanti del linguaggio, come la gestione della concorrenza e il parallelismo.

Due piccioni con una fava

Oltre alla gestione sicura della memoria, il parallelismo e la concorrenza rappresentano il secondo paradigma della filosofia di Rust. Può sembrare sorprendente, ma il sistema di proprietà (assieme all’utilizzo di semplici trait) fornisce anche strumenti potenti per il threading, la sincronizzazione e l’accesso simultaneo ai dati.

Iniziando a utilizzare alcune delle primitive integrate per la gestione della concorrenza e approfondendo la conoscenza del linguaggio, potrebbe risultare sorprendente che tali primitive siano fornite dalla libreria standard piuttosto che direttamente dal core del linguaggio stesso. In definitiva, la creazione di nuove metodologie per la programmazione concorrente è lasciata nelle mani degli autori di librerie piuttosto che essere integrata nel core del linguaggio stesso e e suscettibile alle modifiche pianificate per le versioni future del linguaggio.

Prestazioni o leggibilità del codice? Scegli entrambe

Grazie al sistema di tipizzazione statica, caratteristiche scelte con cura, e l’assenza di un Garbage Collector, i binari ottenuti utilizzando il compilatore Rust sono molto veloci e assolutamente prevedibili, al pari di quelli ottenuti utilizzando linguaggi di basso livello tradizionali come C e C++.

Spostando i vari controlli dall’ambiente di runtime ed escludendo la necessità di un Garbage Collector, il codice risultante imita le caratteristiche prestazionali di altri linguaggi di basso livello, anche se il linguaggio continua a rimanere molto più comprensibile. Gli, apparenti, costrutti di alto livello (stringhe, collezioni, funzioni di ordine superiore, ecc.) eliminano quasi completamente i problemi a runtime che di solito si incontrano con gli stessi costrutti in altri linguaggi. Poiché l’output di un programma Rust dopo la compilazione è in una rappresentazione intermedia LVM, il codice macchina finale trarrà vantaggio di tutti i benefici offerti dal compilatore, multipiattaforma, LLVM e di tutte le ottimizzazioni, presenti e future, apportate al compilatore LLVM.

Si potrebbe continuare per ore sottolineando che con Rust non è necessario preoccuparsi di chiudere un socket o di liberare la memoria, spiegando come l’utilizzo dei trait e delle macro garantiscano una grande flessibilità per l’overload degli operatori, oppure descrivendo gli aspetti della programmazione funzionale in Rust (juggling iterator, closure, funzioni di ordine superiore). Ma inutile prolungare troppo questa trattazione. Prima o poi ci si imbatterà comunque in questi aspetti del linguaggio — e si sa che è più divertente scoprire da sé quanto profonda sia la tana del coniglio.

Piuttosto, iniziamo adesso a concentrarci su del vero codice.

Il primo programma in Rust

Senza ulteriori divagazioni, ecco il primo frammento di codice in Rust:

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

Apri questo codice Rust nel playpen online»

Tutto qui? Non è molto scenografico, ma c’è un limite al numero di modi possibili per scrivere un programma “Hello World” in Rust. Di seguito viene mostrato un altro esempio classico spesso utilizzato nei corsi di programmazione.

Giochiamo a Fizzbuzz con Rust

Prendiamo in esame un programma della “vecchia scuola”. Fizzbuzz è un gioco, utilizzato nei paesi anglosassoni per insegnare ai bimbi a contare e a fare le divisioni. Lo scopo del gioco (e dell’algoritmo che andremo a implementare) è quello di contare, teoricamente all’infinito, sostituendo con fizz i numeri che sono divisibili per 3, con buzz i numeri divisibili per 5 e con fizzbuzz i numeri divisibili sia per 3 che per 5 (cioè quelli divisibili per 15).

Per evidenziare meglio la semantica e gli aspetti peculiari di Rust, che sono lo scopo di questo articolo, includiamo i sorgenti dell’algoritmo anche in C e Python.

Versione in C dell’algoritmo Fizzbuzz

#include <stdio.h>

int main(void)
{
    int num;
    for(num=1; num<101; ++num)
    {
        if( num%3 == 0 && num%5 == 0 ) {
            printf("fizzbuzz\n");
        } else if( num%3 == 0) {
            printf("fizz\n");
        } else if( num%5 == 0) {
            printf("buzz\n");
        } else {
            printf("%d\n",num);
        }
    }

    return 0;
}

Versione in Python di Fizzbuzz

for num in xrange(1,101):
    if num%3 == 0 and num%5 == 0:
        print "fizzbuzz"
    elif num%3 == 0:
        print "fizz"
    elif num%5 == 0:
        print "buzz"
    else:
        print num

Versione in Rust di Fizzbuzz

fn main() {
    for num in 1..101 { // Range notation!
        match (num%3, num%5) { // Pattern Matching FTW!
            (0, 0) => println!("fizzbuzz"),
            (0, _) => println!("fizz"),
            (_, 0) => println!("buzz"),
                 _ => println!("{}", num)
        }
    }
}

Apri questo codice Rust nel playpen online»

Anche da queste poche righe di codice si può già iniziare a intravedere i punti di forza di Rust. La differenza più evidente è la scelta di utilizzare il pattern matching, anziché ricorrere alla tradizionale istruzione if. Avremo anche potuto farlo, ma l’utilizzo del metodo match è un importante strumento nel bagaglio di un esperto Rustacean.

L’altra cosa da notare è la notazione mediante l’uso di intervalli del ciclo for, come avviene in Python. Non avremmo però potuto utilizzare, in quanto non previsto dalla filosofia di Rust, un ciclo for classico come nel linguaggio C. I tradizionali cicli for sono considerati fonte di errori e sono perciò stati sostituiti dal concetto più generale di iterazione.

Ora analizziamo più in dettaglio cosa accade nella fase di pattern matching del nostro esempio:

// per il pattern matching creiamo una tupla che contenga
// i resti della divisione intera per 3 e 5
match (num%3, num%5) {
    // quando num è divisibile sia per 3 che 5
    // (entrambi i resti sono 0)
    // -> stampiamo  "fizzbuzz"
    (0, 0) => println!("fizzbuzz"),

    // quando num è divisibile per 3 (il resto è 0)
    // è divisibile per 5? A noi non interessa
    // -> stampiamo "fizz"
    (0, _) => println!("fizz"),

    // quando num è divisibile per 5 (il resto è 0)
    // è divisibile per 3? A noi non interessa
    // -> stampiamo "buzz"
    (_, 0) => println!("buzz"),

    // In qualsiasi altro caso stampiamo il numero
    // Nota, il matching deve essere esaustivo, vale a dire:
    // bisogna considerare tutti i possibili valori, ma questo è forzato
    // dal compiler Rust
         _ => pintln!("{}", num)
}

Questo non è il luogo per trattare approfonditamente il funzionamento del pattern matching, della destrutturazione e per spiegare cosa sono le tuple. È possibile trovare ottimi articoli che trattano questi argomenti in modo approfondito nel libro Rust Book, nel Rust Blog o su Rust By Example, ma pensiamo che accennarli sia un modo per dimostrare le caratteristiche che rendono Rust così potente ed efficace.

Fizzbuzz utilizzando la programmazione funzionale

Per estendere l’ultimo esempio prodotto e per dimostrare la reale versatilità di Rust, nel nostro secondo esempio faremo fare un salto di qualità al codice del nostro Fizzbuzz. Rust definisce se stesso “pluriparadigma”. Possiamo mettere tutto ciò alla prova riscrivendo il programma Fizzbuzz utilizzando la programmazione funzionale. Per avere una migliore prospettiva, mostreremo anche il codice utilizzando le specifiche della versione 6 di JavaScript (EcmaScript 6).

Fizzbuzz, versione JavaScript utilizzando le tecniche della programmazione funzionale della versione 6

Array.from(Array(100).keys()).slice(1)
    .map((num) => {
        if (num%3 === 0 && num%5 === 0) {
            return "fizzbuzz";
        } else if (num%3 === 0) {
            return "fizz";
        } else if (num%5 === 0) {
            return "buzz";
        } else {
            return num;
        }
    })
    .map(output => console.log(output));

Fizzbuzz, versione in Rust utilizzando le tecniche della programmazione funzionale

fn main() {
    (1..101)
        .map(|num| {
            match (num%3, num%5) { // Pattern Matching FTW!
                (0, 0) => "fizzbuzz".to_string(),
                (0, _) => "fizz".to_string(),
                (_, 0) => "buzz".to_string(),
                     _ => format!("{}", num)
            }
        })
        .map(|output| { println!("{}", output); output })
        .collect::<Vec<_>>();
}

Apri questo codice Rust nel playpen online»

Non solo è possibile imitare lo stile di programmazione funzionale di JavaScript mediante l’utilizzo delle closure e le chiamate funzionali ai metodi, ma grazie al potente pattern matching di Rust, è altresì possibile migliorare l’espressività di JavaScript.

Nota: gli iteratori di Rust sono lazy e si rende perciò necessario, per il corretto funzionamento del codice, utilizzare una chiamata al metodo .collect() (che viene denominato un metodo consumer) — dimenticando questa accortezza il codice non funzionerà. Fare riferimento alla sezione consumers del libro Rust Book per ulteriori informazioni su questo argomento.

Scegliere un progetto

A questo punto si dovrebbe essere ansiosi di immergersi in Rust e di iniziare un progetto interessante. Ma che cosa creare? È possibile iniziare sviluppando una piccola applicazione o una piccola libreria e caricarla su crates.io. Molti programmatori hanno già realizzato degli interessanti progetti in Rust: dai piccoli progetti kernel di tipo *nix, a progetti basati su hardware embedded, dai giochi alle strutture lato server, dimostrando che l’unico limite è la propria immaginazione.

Se si vuole iniziare da qualcosa di piccolo, ma collaborando a qualcosa di utile mentre si imparano le parti più complesse della programmazione in Rust, è possibile considerare di collaborare a qualcuno dei progetti presenti su Github o al codice del compiler Rust (anch’esso scritto in Rust).
Oppure, è possibile riscrivere piccole parti delle proprie applicazioni utilizzate nel proprio ambiente produttivo e sperimentare con Rust analizzando i risultati ottenuti. L’interfaccia di Rust per le funzioni esterne, Foreign Function Interface (FFI) è stata realizzata specificatamente per rimpiazzare il codice C. Con un piccolo sforzo è possibile sostituire porzioni di codice dei propri applicativi con del codice Rust. Ma l’interoperabilità non si ferma qui — questi binding per il linguaggio C funzionano anche in modo inverso. Ciò significa che è possibile utilizzare librerie C nel proprio codice Rust — oppure (poiché molti linguaggi di programmazione prevedono un’interfaccia per le librerie standard del linguaggio C) utilizzare chiamate, da e verso, fra Rust e Python, Ruby, o anche Go.

A questo proposito, si guardi il talk di Dan Callahan My Python’s a little Rust-y per imparare a connettere Rust con Python.

Praticamente non esistono linguaggi che non siano in grado di funzionare assieme a Rust. Si desidera compilare il codice Rust in un sorgente JavaScript o utilizzare codice assembly inline nel proprio codice Rust? Si può fare!

E adesso puoi smettere di leggere questo articolo e darti da fare per costruire qualcosa di importante.

E non dimenticare — Rust non è semplicemente un linguaggio di programmazione — è anche una comunità. In caso di problemi è possibile chiedere aiuto nei Forum o su IRC. È anche possibile condividere le proprie impressioni e i propri progetti sul canale Rust Reddit.

Rust è già straordinario — persone come te lo renderanno ancora più grandioso!