È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.78, fondato dal progetto Mozilla, ma ora sviluppato sotto gli auspici dell'organizzazione no-profit indipendente Rust Foundation. Il linguaggio si concentra sulla sicurezza della memoria e fornisce i mezzi per ottenere un elevato parallelismo del lavoro evitando l'uso di un Garbage Collector e del runtime (il runtime è ridotto all'inizializzazione di base e alla manutenzione della libreria standard).
I metodi di gestione della memoria di Rust salvano lo sviluppatore da errori durante la manipolazione dei puntatori e proteggono dai problemi che sorgono a causa della gestione della memoria di basso livello, come l'accesso a un'area di memoria dopo che è stata liberata, la dereferenziazione di puntatori nulli, sovraccarichi del buffer, ecc. Per distribuire le librerie, fornire build e gestire le dipendenze, il progetto sviluppa il gestore di pacchetti Cargo. Il repository crates.io è supportato per l'hosting di librerie.
La sicurezza della memoria viene fornita in Rust in fase di compilazione attraverso il controllo dei riferimenti, tenendo traccia della proprietà dell'oggetto, tenendo traccia della durata dell'oggetto (scopi) e valutando la correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust fornisce anche protezione contro gli overflow di numeri 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, offre una forte tipizzazione statica per ridurre al minimo gli errori logici.
Principali innovazioni:
- È stato proposto un nuovo spazio dei nomi dell'attributo "#[diagnostic]", che fornisce un mezzo per influenzare i messaggi di errore prodotti dal compilatore. Il primo nel nuovo spazio è l'attributo "#[diagnostic::on_unimplemented]", che può essere utilizzato per personalizzare i messaggi di errore generati in una situazione in cui è necessario utilizzare un tratto non implementato per il 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" )] tratto ImportantTrait {} fn use_my_trait(_: impl ImportantTrait ) {} fn main() { use_my_trait(String::new()); } errore[E32]: Il mio messaggio per `ImportantTrait ` non è implementato per `String` —> src/main.rs:0277:32 | 12| use_my_trait(String::new()); | ———— ^^^^^^^^^^^^^ La mia etichetta | | | richiesto da un limite introdotto dal presente bando | = aiuto: il tratto `ImportantTrait ` non è implementato per `String` = nota: Nota 18 = nota: Nota 12
- I controlli pre-asserzione applicati alle funzioni non sicure possono ora essere rinviati fino alla generazione del codice, consentendo di eseguire questi controlli senza la necessità di creare la libreria standard in modalità "#[cfg(debug_assertions)]". Per attivare i controlli è ora sufficiente abilitare gli assert di debug per build di test o debug del proprio codice.
- Il comportamento delle funzioni nella libreria standard che influenzano l'allineamento dei puntatori e delle sezioni è ora prevedibile in fase di esecuzione e dipende dai dati di input. La funzione pointer::align_offset, che calcola l'offset per allineare il puntatore, ora restituisce usize::MAX solo se l'operazione fallisce. Le funzioni slice::align_to e slice::align_to_mut entrambe, che trasformano le fette in una rappresentazione con una fetta centrale allineata e le fette iniziali e finali originali, ora restituiscono sempre la parte centrale più grande.
- Sono stati trasferiti alla categoria stabile:
- impl Leggi per &Stdin
- Consenti l'uso di una durata non statica (non statica) per alcune implementazioni correlate a std::error::Error.
- Implementazione implementata ?Il valore dimensionato è consentito.
- impl Da per io::Errore
- La funzione Barrier::new() è stata stabilizzata per essere utilizzata con l'attributo "const" in qualsiasi contesto invece che con le costanti.
- Per piattaforme di destinazione 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 richiede almeno la versione di Windows 10.
- Il terzo livello di supporto è stato implementato per le piattaforme wasm32-wasip2, arm64ec-pc-windows-msvc, armv8r-none-eabihf e loongarch64-unknown-linux-musl. Il terzo livello prevede il supporto di base, ma senza test automatizzati, pubblicazione di build ufficiali o verifica se il codice può essere creato.
- È stato implementato il secondo livello di supporto per la piattaforma di destinazione Add wasm32-wasip1. Il secondo livello di supporto prevede una garanzia di montaggio.
- La piattaforma wasm32-wasi-preview1-threads è stata rinominata wasm32-wasip1-threads.
- Il compilatore è stato modificato per utilizzare LLVM 18. Quando si utilizza LLVM 18 per architetture x86-32 e x86-64, l'ABI associato ai tipi u128 e i128 è stato modificato.
- Nel Cargo Pact Manager è stata stabilizzata la versione 4 dei file di blocco (lockfile v4).
- Cargo dispone di una cache globale stabilizzata con informazioni sull'ultimo utilizzo dei dati. La cache è ospitata in $CARGO_HOME/.global-cache utilizzando SQLite e viene aggiornata automaticamente per riflettere le ultime modifiche all'indice, al file crate, alla directory del codice, al clone git e al checkout git.
Inoltre, il linguaggio di programmazione Borgo cerca di essere più espressivo del linguaggio Go, ma meno complesso del linguaggio Rust. Borgo combina le migliori caratteristiche di Go e Rust, sopperendo alle carenze di ciascuna lingua. Ad esempio, Go è semplice e diretto, ma non fornisce funzionalità avanzate di sicurezza dei tipi. Il linguaggio Rust fornisce strumenti per una programmazione sicura, ma è eccessivamente complicato. Il progetto è stato sviluppato da Marco Sampellegrini, autore di The Simple Haskell Handbook e sviluppatore del sistema di integrazione continua Quad CI.
Borgo utilizza tipizzazione statica, tipi simili a Go e sintassi simile a Rust. Il punto e virgola è facoltativo alla fine delle righe nel codice Borgo. Il codice Borgo è compilato in una rappresentazione Go completamente compatibile con i pacchetti Go esistenti. Il codice del compilatore è scritto in Rust ed è distribuito sotto la licenza ISC. utilizzare fmt enum NetworkState { Loading, Failed(int), Success(T), } struct Response { titolo: stringa, durata: int, } fn main() { let res = Risposta { titolo: “Hello world”, durata: 0, } let state = NetworkState.Success(res) let msg = match state { NetworkState.Loading => "ancora in caricamento", NetworkState.Failed(code) => fmt.Sprintf("Ricevuto codice errore: %d", codice), NetworkState.Success (res) => res.titolo, } fmt.Println(msg) }
Fonte: opennet.ru
