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

È stato pubblicato il rilascio del linguaggio di programmazione di uso generale Rust 1.78, originariamente sviluppato da Mozilla, ma attualmente gestito da un'organizzazione no-profit indipendente, la Rust Foundation. Il linguaggio è incentrato sulla gestione sicura della memoria e fornisce strumenti per ottenere un elevato parallelismo nell'esecuzione delle attività, senza utilizzare un garbage collector e un runtime (il runtime si limita alla inizializzazione di base e alla gestione della libreria standard).

I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.

La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori 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 ridurre al minimo gli errori logici.

Novità principali:

• È stato introdotto un nuovo spazio dei nomi per gli attributi «#[diagnostic]», che fornisce strumenti per influenzare i messaggi di errore emessi dal compilatore. Il primo attributo implementato in questo nuovo spazio è «#[diagnostic::on_unimplemented]», che può essere utilizzato per configurare i messaggi di errore emessi quando si richiede di utilizzare un tratto che non è implementato per un tipo. #[diagnostic::on_unimplemented( message = "Il mio messaggio per `ImportantTrait<{A}>` non è implementato per `{Self}`", label = "La mia etichetta", note = "Nota 1", note = "Nota 2" )] trait ImportantTrait<A> {} fn use_my_trait(_: impl ImportantTrait<i32>) {} fn main() { use_my_trait(String::new()); } error[E0277]: Il mio messaggio per `ImportantTrait<i32>` non è implementato per `String` —> src/main.rs:12:18 | 12 | use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ La mia etichetta | | | richiesto da un vincolo introdotto da questa chiamata | = aiuto: il tratto `ImportantTrait<i32>` non è implementato per `String` | = nota: Nota 1 | = nota: Nota 2
• I controlli assert preliminari applicati alle funzioni unsafe possono ora essere posticipati alla fase di generazione del codice, consentendo di eseguire queste verifiche senza la necessità di compilare la libreria standard in modalità "#[cfg(debug_assertions)]". Per attivare i controlli, è sufficiente abilitare gli assert di debug per le build di test o di debug del proprio codice.
• Il comportamento delle funzioni nella libreria standard che influenzano l'allineamento dei puntatori e delle slice è ora prevedibile durante l'esecuzione e dipende dai dati in ingresso. La funzione pointer::align_offset, che calcola l'offset per l'allineamento del puntatore, ora restituisce usize::MAX solo quando non è possibile eseguire l'operazione. Le funzioni slice::align_to e slice::align_to_mut, che trasformano le slice in una rappresentazione con un medio allineato e le slice iniziali e finali originali, restituiscono sempre la parte media più grande.
• Sono stati trasferiti alla categoria stabile:
  • impl Read per &Stdin
  • È stato consentito l'uso di una vita non statica (non ‘static) per alcune implementazioni relative a std::error::Error.
  • Nell'implementazione impl<Fd: AsFd> è consentito l'uso di un valore ?Sized.
  • impl From for io::Error
• La funzione Barrier::new() è stata stabilizzata per l'uso con il flag «const» in qualsiasi contesto invece che con costanti.
• 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 è 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 supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali e verifica della possibilità di compilare codice.
• È stato implementato il secondo livello di supporto per la piattaforma target Add wasm32-wasip1. Il secondo livello di supporto implica garanzia di compilazione.
• La piattaforma wasm32-wasi-preview1-threads è stata rinominata in wasm32-wasip1-threads.
• Il compilatore è stato aggiornato per utilizzare LLVM 18. Utilizzando LLVM 18 per le architetture x86-32 e x86-64, è stato modificato l'ABI relativo ai tipi u128 e i128.
• Nella gestione dei pacchetti Cargo è stata stabilizzata la versione 4 dei file di blocco (lockfile v4).
• In Cargo è stabilito una cache globale contenente informazioni sull'ultima utilizzazione dei dati. La cache è collocata nel file $CARGO_HOME/.global-cache tramite SQLite, si aggiorna automaticamente e riflette le ultime modifiche associate all'indice, al file crate, alla directory del codice, a git clone e a git checkout.

È interessante notare anche il linguaggio di programmazione Borgo, che cerca di essere più espressivo rispetto al linguaggio Go, ma meno complesso rispetto al linguaggio Rust. Borgo combina le migliori caratteristiche di Go e Rust, colmando le lacune di entrambi i linguaggi. Ad esempio, Go è semplice e comprensibile, ma non offre strumenti avanzati per garantire la sicurezza nella gestione dei tipi. Al contrario, Rust fornisce strumenti per una programmazione sicura, ma è eccessivamente complesso. Il progetto è sviluppato da Marco Sampellegrini, autore del libro "The Simple Haskell Handbook" e sviluppatore del sistema di integrazione continua Quad CI.

In Borgo viene utilizzata la tipizzazione statica, con tipi simili a quelli del linguaggio Go e una sintassi simile a Rust. L'indicazione dei punti e virgola alla fine delle righe nel codice di Borgo non è obbligatoria. Il codice scritto in Borgo viene compilato in un'implementazione in Go, completamente compatibile con i pacchetti esistenti per Go. Il codice del compilatore è scritto in Rust e distribuito con 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