È stato pubblicato il rilascio del linguaggio di programmazione general-purpose Rust 1.61, 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:
- È possibile definire i propri codici di ritorno dalla funzione principale. Originariamente, la funzione principale di Rust poteva restituire solo il tipo "()" (unità), che indicava sempre uno stato di uscita riuscito a meno che lo sviluppatore non chiamasse esplicitamente la funzione "process::exit(code)". In Rust 1.26, utilizzando il tratto unstable Termination nella funzione main, era possibile restituire i valori “Ok” ed “Err”, corrispondenti ai codici EXIT_SUCCESS e EXIT_FAILURE nei programmi C. In Rust 1.61, il tratto Termination è stato reso stabile ed è stato proposto un tipo ExitCode separato per rappresentare un codice di ritorno specifico, che astrae i tipi di ritorno specifici della piattaforma fornendo sia le costanti predefinite SUCCESS e FAILURE, sia il metodo From per restituire un codice di ritorno personalizzato. utilizzare std::process::ExitCode; fn main() -> ExitCode { if !check_foo() { return ExitCode::from(8); } CodiceUscita::SUCCESSO }
- Sono state stabilizzate ulteriori funzionalità delle funzioni definite utilizzando l'espressione "const fn", che possono essere chiamate non solo come funzioni regolari, ma anche utilizzate in qualsiasi contesto al posto delle costanti. Queste funzioni vengono calcolate in fase di compilazione, non in fase di esecuzione, quindi sono soggette ad alcune restrizioni, come la possibilità di leggere solo dalle costanti. Nella nuova versione, le operazioni di base con i puntatori a funzione sono consentite all'interno delle funzioni const (è consentito creare, passare e lanciare puntatori, ma non chiamare una funzione tramite puntatore); limiti dei tratti per parametri generici di funzioni const come T: Copia; tratti dispacciabili dinamicamente (dyn Trait); impl Tipi di tratti per argomenti di funzione e valori restituiti.
- Lo stream gestisce Stdin, Stdout e Stderr in std::io ora hanno una durata statica ("'static") quando bloccati, consentendo costrutti come "let out = std::io::stdout().lock();" con l'acquisizione di un handle e l'impostazione di un blocco in un'espressione.
- Una nuova porzione dell'API è stata spostata nella categoria stabile, inclusi i metodi e le implementazioni dei tratti sono stati stabilizzati:
- Pin::static_mut
- Pin::rif._statico
- Vec::retain_mut
- VecDeque::retain_mut
- Scrivi per Cursore<[u8; N]>
- std::os::unix::net::SocketAddr::from_pathname
- std::process::ExitCode
- std::process::Terminazione
- std::thread::JoinHandle::is_finished
- L'attributo "const", che determina la possibilità di utilizzarlo in qualsiasi contesto al posto delle costanti, viene utilizzato nelle funzioni:
- <*const T>::offset e <*mut T>::offset
- <*const T>::wrapping_offset e <*mut T>::wrapping_offset
- <*const T>::add e <*mut T>::add
- <*const T>::sub e <*mut T>::sub
- <*const T>::wrapping_add e <*mut T>::wrapping_add
- <*const T>::wrapping_sub e <*mut T>::wrapping_sub
- <[T]>::as_mut_ptr
- <[T]>::as_ptr_range
- <[T]>::as_mut_ptr_range
Inoltre, puoi notare l'articolo "Rust: A Critical Retrospective" con un riassunto delle impressioni del linguaggio Rust dopo aver scritto 100mila righe di codice al suo interno durante lo sviluppo del sistema operativo microkernel Xous utilizzato nel firmware. Gli svantaggi includono sintassi difficile da comprendere, incompletezza e sviluppo continuo del linguaggio, mancanza di build ripetibili, problemi tipici con la fiducia nelle dipendenze in Crates.io e la necessità di mantenere una certa disciplina per scrivere codice sicuro. Le funzionalità che hanno superato le aspettative includono strumenti per il refactoring del codice e la rielaborazione degli "hack" aggiunti durante la prototipazione rapida.
Fonte: opennet.ru