Rilascio di Rust 1.78. Linguaggio Borgo, che combina i punti di forza di Go e Rust

È stata pubblicata la versione del linguaggio di programmazione generale Rust 1.78, originariamente sviluppata da Mozilla e ora mantenuta sotto l'egida della Rust Foundation, un'organizzazione non profit indipendente. Il linguaggio è focalizzato sulla gestione sicura della memoria e offre strumenti per raggiungere un alto livello di parallelismo nell'esecuzione dei compiti, evitando l'uso di un garbage collector e un runtime (il runtime si limita all'inizializzazione di base e al supporto della libreria standard).

I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori di manipolazione dei puntatori e li proteggono da problemi derivanti da operazioni a basso livello con la memoria, come l'accesso a aree di memoria dopo il loro rilascio, la dereferenziazione di puntatori nulli, l'uscita dai limiti del buffer, ecc. Per la distribuzione delle librerie, l'assicurazione della compilazione e la gestione delle dipendenze, il progetto promuove il gestore di pacchetti Cargo. È supportato un repository per l'hosting delle librerie su crates.io.

La gestione sicura della memoria in Rust è garantita durante la compilazione attraverso il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la considerazione del tempo di vita degli oggetti (ambiti di visibilità) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per minimizzare gli errori logici.

Novità principali:

• È stato proposto un nuovo spazio dei nomi per gli attributi «#[diagnostic]», che fornisce strumenti per influenzare i messaggi di errore restituiti dal compilatore. Primo nel nuovo spazio è stato implementato l'attributo «#[diagnostic::on_unimplemented]», che può essere utilizzato per configurare i messaggi di errore emessi quando è necessario utilizzare un tratto che non è stato implementato per un tipo. #[diagnostic::on_unimplemented( message = «My Message for `ImportantTrait<{A}>` is not implemented for `{Self}`», label = «My Label», note = «Note 1», note = «Note 2» )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); } error[E0277]: My Message for `ImportantTrait<i32>` is not implemented for `String` —> src\/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ My Label | | | required by a bound introduced by this call | = help: the trait `ImportantTrait<i32>` is not implemented for `String` = note: Note 1 = note: Note 2
• I controlli assert preliminari applicati a funzioni unsafe possono ora essere posticipati alla fase di generazione del codice, permettendo di eseguire tali controlli senza la necessità di compilare la libreria standard in modalità «#[cfg(debug_assertions)]». Per far scattare i controlli ora è sufficiente abilitare gli assert di debug per le versioni di test o di debug del proprio codice.
• Il comportamento delle funzioni nella libreria standard che influiscono sull'allineamento dei puntatori e degli slice è ora prevedibile durante l'esecuzione e dipende dai dati in ingresso. La funzione pointer::align_offset, che calcola l'offset per l'allineamento di un puntatore, ora restituisce usize::MAX solo in caso di impossibilità di eseguire l'operazione. Le funzioni slice::align_to e slice::align_to_mut, che trasformano gli slice in una rappresentazione allineata con il centro e gli slice iniziali e finali, ora restituiscono sempre la parte centrale più grande.
• Sono stati introdotti nel ramo stabile:
  • impl Read for &Stdin
  • È consentito l'uso di tempi di vita non statici (non 'static) per alcune implementazioni relative a std::error::Error.
  • Nell'implementazione impl è consentito l'uso del valore ?Sized.
  • impl From per io::Error
• La funzione Barrier::new() è stata stabilizzata per l'uso con il modificatore 'const' in qualsiasi contesto invece che come costante.
• Per le piattaforme target x86_64-pc-windows-msvc, i686-pc-windows-msvc, x86_64-pc-windows-gnu, i686-pc-windows-gnu, x86_64-pc-windows-gnullvm e i686-pc-windows-gnullvm ora è richiesta almeno la versione Windows 10.
• È stato implementato il terzo livello di supporto per le piattaforme wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf e loongarch64-unknown-linux-musl. Il terzo livello implica un supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali o verifica della possibilità di compilarne il codice.
• È stato implementato il secondo livello di supporto per la piattaforma target Add wasm32-wasip1. Il secondo livello di supporto implica la garanzia di compilazione.
• La piattaforma wasm32-wasi-preview1-threads è stata rinominata in wasm32-wasip1-threads.
• Il compilatore è stato aggiornato per utilizzare LLVM 18. Con l'uso di LLVM 18 per le architetture x86-32 e x86-64 è stata modificata l'ABI relativa ai tipi u128 e i128.
• Nel gestore di pacchetti Cargo è stata stabilizzata la versione 4 dei file lock (lockfile v4).
• In Cargo è stato stabilizzato la cache globale con informazioni sull'ultima volta che i dati sono stati utilizzati. La cache è memorizzata nel file $CARGO_HOME/.global-cache tramite SQLite, aggiornato automaticamente e riflette le ultime modifiche relative all'indice, al file crate, alla directory del codice, a git clone e git checkout.

In aggiunta, si può notare il linguaggio di programmazione Borgo, che cerca di essere più espressivo del linguaggio Go, ma meno complesso del linguaggio Rust. Borgo combina le migliori caratteristiche di Go e Rust, colmando le lacune di ciascuno dei linguaggi. Ad esempio, il linguaggio Go è semplice e chiaro, ma non offre strumenti avanzati per garantire la sicurezza nella gestione dei tipi. Il linguaggio Rust offre strumenti per una programmazione sicura, ma è eccessivamente complicato. Il progetto è sviluppato da Marco Sampellegrini, autore del libro 'The Simple Haskell Handbook' e sviluppatore del sistema di integrazione continua Quad CI.

In Borgo si utilizza una tipizzazione statica, con tipi simili a quelli del linguaggio Go e una sintassi che ricorda Rust. Non è obbligatorio specificare i punti e virgola alla fine delle righe nel codice di Borgo. Il codice scritto in Borgo viene compilato in un formato compatibile con il linguaggio Go, completamente interoperabile con i pacchetti esistenti per Go. Il codice del compilatore è scritto in Rust e rilasciato sotto licenza ISC. use fmt enum NetworkState { Loading, Failed(int), Success(T), } struct Response { title: string, duration: int, } fn main() { let res = Response { title: "Hello world", duration: 0, } let state = NetworkState.Success(res) let msg = match state { NetworkState.Loading => "still loading", NetworkState.Failed(code) => fmt.Sprintf("Got error code: %d", code), NetworkState.Success(res) => res.title, } fmt.Println(msg) }

Fonte: opennet.ru