De frijlitting fan de systeemprogrammearringstaal Rust 1.51, oprjochte troch it Mozilla-projekt, mar no ûntwikkele ûnder auspysjes fan de ûnôfhinklike non-profit organisaasje Rust Foundation, is publisearre. De taal rjochtet him op ûnthâld feilichheid, jout automatyske ûnthâld behear, en jout de middels te berikken hege taak parallelism sûnder in gebrûk garbage collector of runtime (runtime wurdt redusearre ta basis inisjalisaasje en ûnderhâld fan de standert bibleteek).
It automatyske ûnthâldbehear fan Rust elimineert flaters by it manipulearjen fan oanwizers en beskermet tsjin problemen dy't ûntsteane út manipulaasje fan ûnthâld op leech nivo, lykas tagong krije ta in ûnthâldregio nei't it is befrijd, nul-oanwizers dereferences, bufferoverruns, ensfh. Om bibleteken te fersprieden, assemblage te garandearjen en ôfhinklikens te behearjen, ûntwikkelet it projekt de Cargo-pakketbehearder. It crates.io repository wurdt stipe foar hosting fan bibleteken.
Wichtichste ynnovaasjes:
- De funksjonaliteit dy't ferbûn is mei it brûken fan konstante generika hat de status fan in minimum libbensfetbere produkt (MVP) krigen, wat it griene ljocht jout foar wiidferspraat gebrûk. Const generics kinne typen wurde generalisearre ta konstante wearden, d.w.s. brûke generike arguminten beheind ta in berik fan konstante wearden, net soarten of lifetimes. Dizze funksje lit jo ynteger-parameterisearre typen en abstraksje brûke by it meitsjen fan skaaimerken foar arrays fan elke grutte sûnder in apart type te meitsjen foar elk berik fan jildige wearden om te soargjen dat d'r gjin foarfallen binne bûten grinzen.
Begjinnend mei de hjoeddeistige release, foar arrays mei type "[T; N]" (type T en grutte N) biedt de mooglikheid om type en grutte te abstraheren mei wearden mei elke heule getal, boolean en karaktertypen (struktuer- en enum-typen wurde noch net stipe). Konstante generika ferienfâldigje bibleteekûntwikkeling sterk; bygelyks om in array te brûken dy't net bûn is oan in spesifyk type en grutte, kinne jo opjaan: struct Array { // ^^^^^^^^^^^^^^^^^^^^ definysje fan in konstante generyske list: [T; LENGTH] // ^^^^^^ it gebrûk }
Wannear't eins brûkt wurdt mei dizze definysje fan "Array » de kompilator sil in monomorphyske ferzje fan Array generearje: struct Array { list: [u8; 32] }
- De std :: array :: IntoIter API, basearre op konstante generika, is stabilisearre, wêrmei jo iterators kinne oanmeitsje op wearde foar elke array: fn main() { let array = [1, 2, 3, 4, 5] ; // Earder, om oer in wearde te iterearjen, moasten jo de metoade .iter() neame foar item yn array.iter().copied() { println!("{}", item); } // No kinne jo opjaan foar item yn std::array::IntoIter::new(array) { println!("{}", item); } }
- De ladingpakketbehearder stipet no in nij resolverfjild yn Cargo.toml, dat kin wurde brûkt om de twadde ferzje fan 'e funksje-resolver yn te skeakeljen. De nije ferzje fan de definier foarkomt it kombinearjen fan ôfhinklikensfunksjes neamd yn 'e seksje "[funksjes]" wêr't it net geskikt is, bygelyks as it opnimmen fan in ôfhinklikens dy't wat standertfunksje freget yn buildskripts en makro's, mar by it brûken fan in net-standertfunksje yn it resultearjende útfierbere bestân.
Oant no ta waarden de mooglikheden fan in pakket neamd meardere kearen yn 'e ôfhinklikensgrafyk kombinearre. Bygelyks, as in projekt in ôfhinklikens foo omfettet dy't mooglikheden A en B definiearret, en dit pakket wurdt brûkt yn 'e oare pakketten bar en baz, ek al is bar ôfhinklik fan foo mei funksje A, en baz hinget ôf fan foo mei funksje B, dan it resultaat sil wêze cargo sil kombinearje dizze funksjes en kompilearje foo mei funksjes A en B. Dizze metoade kin resultearje yn in funksje dy't ynskeakele is troch guon ôfhinklikens dy't net ferienichber is mei it doelsysteem wêrfoar de resultearjende bou is makke. Bygelyks, as jo in ferzje fan foo brûke wolle mei "#![no_std]" yn in útfierbere bestannen boud mei "#![no_std]", en tagelyk foo brûke mei "std" tidens de ynbou. rs. By it spesifisearjen fan resolver="2" yn Cargo.toml, sil de pakketbehearder no besykje dit konflikt goed te behanneljen, troch dev-, host- en doelôfhinklikens te skieden.
- Cargo ymplementearret de split-debuginfo-opsje, ynsteld yn 'e seksje "[profyl]", en de korrespondearjende flagge "-Csplit-debuginfo=unpacked" yn rustc, en biedt de ymplemintaasje fan in nije metoade foar it bewarjen fan debug-ynformaasje, dy't de needsaak elimineert rop it dsymutil-hulpprogramma op en fersnelt it bouproses signifikant mei debuggenynformaasje op macOS.
- Stabilisearre makos "ptr::addr_of!" en "ptr::addr_of_mut!", wêrmei jo rauwe oanwizers meitsje kinne foar unalignearre fjilden. brûk std::ptr; #[repr(packed)] struct Packed { f1: u8, f2: u16, } let packed = Packed { f1: 1, f2: 2 }; // & packed.f2 sil meitsje in unaligned pointer dy't liedt ta ûndefiniearre gedrach lit raw_f2 = ptr :: addr_of! (packed.f2); assert_eq!(ûnfeilich {raw_f2.read_unaligned() }, 2);
- In nij diel fan 'e API is oerbrocht nei de stabile kategory, ynklusyf de folgjende metoaden binne stabilisearre:
- Arc :: decrement_strong_count
- Arc :: increment_strong_count
- Once :: call_once_force
- Peekable::next_if_eq
- Peekable :: folgjende_if
- Seek ::stream_position
- array :: IntoIter
- panyk :: panyk_any
- ptr::addr_of!
- ptr::addr_of_mut!
- slice::folje_mei
- slice :: split_inclusive_mut
- slice :: split_inclusive
- slice :: strip_prefix
- slice :: strip_suffix
- str::split_inclusive
- syngronisearje :: OnceState
- taak :: wekker
- It tredde nivo fan stipe is ymplementearre foar de i386-unknown-linux-gnu, i486-unknown-linux-gnu, aarch64_be-unknown-linux-gnu, aarch64-unknown-linux-gnu_ilp32 en aarch64_be-unknown-linux-gnu_ilp32 platfoarms . It tredde nivo omfettet basisstipe, mar sûnder automatisearre testen, publisearjen fan offisjele builds, of kontrolearjen oft de koade boud wurde kin.
Boarne: opennet.ru