Tutorial Rust: inizia con il linguaggio Rust

Negli ultimi due anni, Rust è passato da una curiosità prodotta nel laboratorio di un dipendente Mozilla a un forte contendente per la scrittura della prossima generazione di app native e soluzioni bare-metal. Ma questi progressi provengono da Rust, che fornisce la propria catena di strumenti e il sistema di gestione dei componenti, insieme alle proprie caratteristiche e stranezze.

Questo articolo illustra le basi per impostare un ambiente di lavoro in Rust, configurare un IDE e sfruttare al meglio il set di strumenti che Rust fornisce per lo sviluppo di app.

Video correlato: Sviluppo di software più sicuro con Rust

Mettiti al passo rapidamente con il nuovo arrivato Rust, progettato per creare software veloce a livello di sistema. Questo spiegatore animato di due minuti mostra come Rust aggira i fastidiosi problemi di programmazione della memoria e della gestione.

Comprendi le versioni notturne, beta e stabili di Rust

La catena di strumenti di Rust consiste principalmente nel compilatore Rust rustc, insieme agli strumenti per la gestione di un'installazione Rust. Poiché Rust è in costante sviluppo, la catena di strumenti Rust è progettata per essere facile da mantenere aggiornata.

I progetti software sono spesso forniti tramite più canali, per separare le versioni stabile e beta del codice. La catena degli strumenti di Rust funziona allo stesso modo, offrendo tre canali per la sua catena degli strumenti:

  • Stabile: principali rilasci minori, che vengono rilasciati ogni sei settimane circa.
  • Beta: candidati per la prossima major point release, che emergono più spesso.
  • Nightly: la build più immediata, con accesso a funzionalità all'avanguardia ma nessuna garanzia sulla loro stabilità.

Come ha sottolineato lo sviluppatore Karol Kuczmarski, è meglio pensare al canale notturno Rust come al proprio linguaggio. Alcune funzionalità di Rust, come la compilazione su WebAssembly, sono disponibili solo nel canale notturno e possono essere attivate solo da speciali direttive del compilatore. In altre parole, non verranno nemmeno compilati sui canali beta o stabili. 

Questo è di progettazione, perché non vi è alcuna garanzia che le funzionalità notturne saranno supportate altrove. Tuttavia, molte di queste funzionalità alla fine passano dal canale notturno alle versioni beta e stabili. (La compilazione in WebAssembly, ad esempio, funziona in stable a partire da Rust 1.30.)

In breve:

  1. Utilizzare stabile per il lavoro di produzione effettivo.
  2. Utilizza la versione beta per testare il software corrente rispetto alle versioni future per vedere se qualcosa potrebbe non funzionare durante l'aggiornamento.
  3. Usa solo nightly per esperimenti in modalità sandbox con le nuove funzionalità di Rust.

Scegli un sistema operativo per lo sviluppo di Rust

Rust supporta tutte e tre le piattaforme principali, Windows, Linux e MacOS, sia nelle versioni a 32 che a 64 bit, con i binari ufficiali per ciascuna. Molte altre piattaforme hanno anche binari ufficiali, ma non hanno lo stesso livello di copertura dei test automatici. Queste piattaforme di seconda classe includono ARMv6 e ARMv7 per iOS, Android e Linux; MIPS Linux e MIPS64 Linux; Edizioni a 32 bit di x86 iOS, Windows e Linux; e WebAssembly. Altre piattaforme, come Windows XP o HaikuOS sperimentale, sono supportate tramite build non ufficiali.

Il team di sviluppo di Rust ha dichiarato che non è una delle missioni di Rust essere il più ampiamente portabile possibile. Ad esempio, sebbene Rust sia disponibile su molte architetture ARM, non è garantito che Rust sarà ufficialmente supportato su piattaforme hardware di fascia bassa.

Detto questo, dovrebbe essere disponibile una build Rust supportata per la stragrande maggioranza dei casi d'uso comuni e tradizionali, ovvero Windows a 32 e 64 bit, Linux e MacOS.

Se hai intenzione di sviluppare in Rust su Windows, tieni a mente le tue catene di strumenti. Rust supporta due catene di strumenti su Windows:

  • L'ABI nativo di Microsoft Visual C (MSVC)
  • L'ABI Gnu utilizzato dal linker GCC.

Poiché quasi tutto il software C / C ++ integrato in Windows utilizza comunque MSVC, ti consigliamo di utilizzare la catena di strumenti MSVC la stragrande maggioranza delle volte. Se mai avrai bisogno di GCC, molto probabilmente sarà per l'interoperabilità con librerie di terze parti costruite in Windows con GCC.

La buona notizia è che il sistema di gestione della catena degli strumenti di Rust ti consente di mantenere installate le catene di strumenti MSVC e GCC e ti consente di passare da una all'altra in base al progetto.

Uno degli obiettivi della compilazione di Rust è WebAssembly, il che significa che puoi scrivere in Rust e distribuire su un browser web. WebAssembly stesso è ancora approssimativo, così come lo è il supporto di Rust. Ma se sei ambizioso e vuoi mettere le mani in disordine, leggi il libro compilato dagli sviluppatori di Rust e WebAssembly che descrive in dettaglio il processo per compilare WebAssembly in Rust. Il libro include un tutorial per un semplice progetto, un'implementazione di Conway's Game of Life, scritto in Rust e distribuito come WebAssembly.

Inizia la configurazione di Rust con rustup

Rust fornisce un programma di installazione all-in-one e un sistema di manutenzione della catena di strumenti chiamato rustup. Scaricalo rustuped eseguilo; otterrà le ultime versioni della catena di strumenti Rust e le installerà per te.

Gli strumenti più critici gestiti da rustupsono:

  • rustupsi. Ogni volta che rustupvengono pubblicate nuove versioni di o altri strumenti, puoi semplicemente eseguire rustup updatee avere tutto aggiornato automaticamente.
  • rustc, il compilatore Rust.
  • Cargo, pacchetto di Rust e gestore dell'area di lavoro.

Per impostazione predefinita, rustupinstalla Rust dal canale stabile. Se vuoi usare le versioni beta o notturne, devi installare quei canali (per esempio,  rustup install nightly) e impostare Rust per usarli di default ( rustup default nightly). Puoi anche specificare manualmente quale canale usare durante la compilazione di un'applicazione Rust, così non devi impostare e ripristinare l'impostazione predefinita ogni volta che ti sposti tra i progetti.

È inoltre possibile utilizzare  rustup per installare e gestire catene di strumenti personalizzate. Questi sono in genere utilizzati da build non ufficiali di terze parti di Rust per piattaforme non supportate, perché in genere richiedono i propri linker o altri strumenti specifici della piattaforma.

Configura il tuo IDE per Rust

Nonostante Rust sia un linguaggio relativamente nuovo, ha già ottenuto un forte supporto da molti IDE comuni. Lo sviluppatore Manuel Hoffman gestisce un progetto per monitorare lo stato di tale supporto sul sito web areweideyet.com.

Far funzionare bene Rust con gli IDE è un obiettivo esplicito del suo team di sviluppo, tramite una funzionalità chiamata Rust Language Server (RLS). RLS fornisce feedback in tempo reale sul codice in questione dal compilatore di Rust, piuttosto che da un parser di terze parti.

Ecco gli IDE che supportano Rust:

  • Visual Studio Code di Microsoft ha un'estensione per il supporto del linguaggio Rust creata dal team di strumenti di sviluppo di Rust. Questo livello di integrazione lo rende uno degli IDE meglio supportati per Rust. 
  • Gli utenti di Eclipse possono scaricare un'edizione preconfezionata di Eclipse per lo sviluppo di Rust o utilizzare il plug-in Corrosion autonomo per Eclipse Photon. (Un pacchetto precedente, RustDT, non è più mantenuto.)
  • Se sei un fan di Emacs o Vim, altri sviluppatori come te hanno scritto componenti aggiuntivi specifici per Rust per entrambi gli editor. Emacs ha una modalità specifica per Rust e Vim ha un plugin per fornire l'evidenziazione e la formattazione della sintassi. Il supporto RLS è disponibile sia per Emacs che per Vim, ma deve essere aggiunto e configurato manualmente.
  • Gli utenti di IntelliJ Idea e Atom possono aggiungere plugin per completare il supporto Rust.
  • Sublime Text ha il supporto della sintassi Rust pronto all'uso ei plugin forniscono un supporto più approfondito per altre funzionalità.
  • Un progetto per creare un semplice IDE specifico per Rust, SolidOak, era in fase di sviluppo per un po 'ma da allora si è bloccato. La soluzione migliore è utilizzare uno degli IDE esistenti che ha già il supporto.

Crea il tuo primo progetto Rust

I progetti Rust sono pensati per avere una struttura di directory coerente, con codice e metadati del progetto memorizzati al loro interno in determinati modi. Il codice è archiviato in una srcsottodirectory e i dettagli sul progetto sono archiviati in due file nella directory principale del progetto,  Cargo.toml(le informazioni di base del progetto) e Cargo.lock(un elenco di dipendenze generato automaticamente). È possibile creare manualmente la struttura della directory e i metadati, ma è più semplice utilizzare gli strumenti di Rust per svolgere il lavoro.

Suggerimento:  la guida in linea Rust By Example per l'apprendimento di Rust fornisce esempi di codice interattivo che possono essere modificati ed eseguiti direttamente nel browser. Tocca quasi tutti i principali concetti di Rust, sebbene alcuni dei concetti chiave, come il prestito e la durata, vengano introdotti relativamente tardi nella discussione.

Lo strumento Cargo di Rust gestisce sia i progetti Rust che le librerie, o "casse", che utilizzano. Per avviare un nuovo progetto Rust denominato my_projectnella sua directory, digita cargo new my_project. (Per gli sviluppatori C # che lavorano con .Net Core, pensa al dotnet newcomando.) Il nuovo progetto appare in una sottodirectory con quel nome, insieme a un manifesto del progetto di base, il Cargo.tomlfile, e uno stub per il codice sorgente del progetto, in una srcsottodirectory.

Quando crei un nuovo progetto, main.rsviene automaticamente creato un  file nella srcdirectory del progetto. Questo file contiene un'app di base "hello world", quindi puoi testare subito la tua toolchain Rust compilandola ed eseguendola.

Il codice sorgente per l'app "hello world":

fn main() {

    println!(“Hello World!”);

}

Per crearlo ed eseguirlo, inserisci la radice della directory del progetto e digita cargo run. Nota che per impostazione predefinita, Cargo crea progetti in modalità di debug. Per eseguire in modalità di rilascio, utilizzare cargo run --release. I binari vengono creati nella sottodirectory target/debugo target/releasedi un progetto, a seconda del profilo di compilazione che stai utilizzando.

Lavora con le casse di ruggine

La gestione dei pacchetti è una parte fondamentale di qualsiasi ambiente di programmazione moderno. A tal fine, Rust fornisce "crates", che sono librerie di terze parti pacchettizzate per la distribuzione con gli strumenti di Rust. Puoi trovare le casse nel registro dei pacchetti ufficiale di Rust, Crates.io.

Se il tuo progetto ha una dipendenza da una particolare cassa, devi specificare quella cassa modificando il Cargo.tomlfile del progetto . Il modo standard per farlo è manualmente, cioè semplicemente modificando Cargo.tomldirettamente con un editor di testo. La prossima volta che il progetto viene ricostruito, Rust ottiene automaticamente tutte le dipendenze necessarie.

Suggerimento: due strumenti cargo-edite cargo-edit-locally, possono aggiornare le dipendenze dalla riga di comando, sebbene siano progetti non ufficiali di terze parti.

Quando crei un progetto Rust che dipende da casse esterne, Cargo cerca quelle casse su Crates.io per impostazione predefinita; non è necessario ottenerli manualmente. Puoi anche fare riferimento alle casse nel tuo progetto tramite l'URL piuttosto che il nome della cassa, nel caso in cui hai bisogno di una cassa che non è ospitata nel registro, come qualcosa da un archivio privato.

Si noti che alcune casse saranno solo installare e costruire sul canale nightly di Rust, perché usano funzioni sperimentali non disponibili in altri canali. Se sei sul canale di rilascio e provi a installare una tale cassa, non riceverai alcun avviso fino a quando la compilazione stessa non fallisce. La documentazione di Crate di solito menziona se richiede o meno il canale notturno, quindi leggi prima di includere, figuriamoci compilare.

Le casse possono essere fornite con i binari inclusi. Alcuni sono strumenti da riga di comando usati nello sviluppo di Rust; altri sono strumenti generici (come  ripgrep). Per installare una di queste casse, digita semplicemente cargo install . Questo non è l' unico modo per distribuire un binario creato con Rust, ma è un modo conveniente per gli sviluppatori Rust di ottenerli come parte di un flusso di lavoro che coinvolge gli strumenti Rust.

Compilare Rust su un'altra piattaforma

Poiché Rust supporta più catene di strumenti, anche nella stessa installazione di Rust, puoi compilare le applicazioni Rust su un sistema operativo e un ambiente di destinazione diversi da quello su cui stai compilando.

Tale cross-compilazione richiede una catena di strumenti sulla piattaforma su cui stai lavorando che corrisponda alla piattaforma di destinazione. A volte, come con la compilazione incrociata su Linux su Windows o viceversa, ciò comporta poco più che avere il linker GCC. Ma altre volte è più complesso. Per la compilazione incrociata su MacOS, ad esempio, sono necessarie le librerie IDE Xcode per completare il lavoro: cctools (l'equivalente Apple di binutils) e MacOS SDK.

Gli strumenti di terze parti offrono alcuni modi per aggirare queste difficoltà:

  • Uno di questi strumenti è Trust, un modello Travis CI e AppVeyor che può pubblicare automaticamente versioni binarie di un progetto Rust. Può essere creato per Linux, Windows e MacOS, anche se richiede l'uso dei servizi Travis CI e AppVeyor e richiede che il tuo progetto sia ospitato su GitHub.
  • Un altro progetto, Cross, viene eseguito direttamente su un host Linux x86 a 64 bit, ma fornisce ciò che il suo creatore descrive come cross-compilazione "a configurazione zero" per un'ampia varietà di obiettivi, inclusi Windows a 64 bit e MIPS.
  • Il progetto crossbuild fornisce un'immagine Docker multi-architettura che può essere utilizzata per il cross-build tra tutte e tre le piattaforme principali.