Rust 1.53 is uitgebracht. Google financiert de toevoeging van Rust-ondersteuning aan de Linux-kernel.

De release van de programmeertaal Rust 1.53, oorspronkelijk ontwikkeld door Mozilla en nu verder ontwikkeld onder de vlag van de onafhankelijke non-profit organisatie Rust Foundation, is gepubliceerd. De taal richt zich op veilige geheugenwerking, biedt automatische geheugenbeheer en geeft middelen voor het bereiken van hoge paralleliteit bij de uitvoering van taken, zonder gebruik te maken van een garbage collector en runtime (de runtime is beperkt tot basisinitialisatie en de ondersteuning van de standaardbibliotheek).

Automatisch geheugenbeheer in Rust voorkomt dat ontwikkelaars fouten maken bij het manipuleren van pointers en beschermt tegen problemen die voortkomen uit laag-niveau geheugenwerk, zoals toegang tot geheugen na vrijgave, dereferencen van null pointers, buffer overflow, enz. Voor het verspreiden van bibliotheken, het waarborgen van de opbouw en het beheren van projectafhankelijkheden, wordt de package manager Cargo ontwikkeld. Voor het hosten van bibliotheken wordt de repository crates.io ondersteund.

Belangrijkste vernieuwingen:

• Er is een trait IntoIterator geïmplementeerd voor arrays, waarmee de elementen van een array op waarden kunnen worden doorlopen: for i in [1, 2, 3] { .. }

  Daarnaast is het nu mogelijk om arrays door te geven aan methoden die iterators accepteren, bijvoorbeeld: let set = BTreeSet::from_iter([1, 2, 3]); for (a, b) in some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Eerder was IntoIterator alleen geïmplementeerd voor referenties naar arrays, dat wil zeggen dat het gebruik van referenties nodig was om door waarden te itereren (‘&[1, 2, 3]’) of ‘[1, 2, 3].iter()’. Problemen met compatibiliteit gemaakt door eerder in de compiler toegevoegde conversie van de methode array.into_iter() in (&array).into_iter() verhinderden de implementatie van IntoIterator voor arrays. Deze problemen zijn opgelost met een omweg — de compiler blijft array.into_iter() omzetten naar (&array).into_iter(), alsof de implementatie van IntoIterator niet bestond, maar alleen bij het aanroepen van de methode met de syntaxis ‘.into_iter()’ en niet bij aanroepen in de vorm van ‘in [1, 2, 3]’, ‘iter.zip([1, 2, 3])’, ‘IntoIterator::into_iter([1, 2, 3])’.

• Er is nu de mogelijkheid om de expressies ‘|’ (logische OR-operatie) op elk punt in het patroon aan te geven, bijvoorbeeld in plaats van ‘Some(1) | Some(2)’ kan nu ‘Some(1 | 2)’ worden geschreven: match result { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) => { .. } _ => { .. } }
• Het is toegestaan om niet-ASCII-tekens te gebruiken in identificatoren, inclusief elke nationale symbolen die zijn gedefinieerd in de Unicode-specificatie UAX 31, met uitzondering van emoji-tekens. Bij het gebruik van verschillende, maar op elkaar lijkende symbolen, zal de compiler een waarschuwing weergeven. const BLÅHAJ: &str = «🦈»; struct 人 { 名字: String, } let α = 1; let ｓos = 2; warning: identifier pair considered confusable between ‘ｓ’ and ‘s’
• Een nieuwe reeks API's is toegevoegd aan de stabiele categorie, waaronder zijn gestabiliseerd:
  • array::from_ref
  • array::from_mut
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BufReader::seek_relative
  • cmp::min_by
  • cmp::min_by_key
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • Duration::ZERO
  • Duration::MAX
  • Duration::is_zero
  • Duration::saturating_add
  • Duration::saturating_sub
  • Duration::saturating_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • IntoIterator voor arrays
  • {integer}::BITS
  • io::Error::Unsupported
  • NonZero*::leading_zeros
  • NonZero*::trailing_zeros
  • Option::insert
  • Ordering::is_eq
  • Ordering::is_ne
  • Ordering::is_lt
  • Ordering::is_gt
  • Ordering::is_le
  • Ordering::is_ge
  • OsStr::make_ascii_lowercase
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_lowercase
  • OsStr::to_ascii_uppercase
  • OsStr::is_ascii
  • OsStr::eq_ignore_ascii_case
  • Peekable::peek_mut
  • Rc::increment_strong_count
  • Rc::decrement_strong_count
  • slice::IterMut::as_slice
  • AsRef<[T]> voor slice::IterMut
  • impl SliceIndex voor (Bound<usize>, Bound<usize>)
  • Vec::extend_from_within
• Er is een derde niveau van ondersteuning voor het wasm64-unknown-unknown platform geïmplementeerd. Het derde niveau houdt basisondersteuning in, maar zonder geautomatiseerd testen, het publiceren van officiële builds en verificatie van de bouwbaarheid van de code.
• De pakketbeheerder Cargo is standaard overgeschakeld op het gebruik van de naam 'main' voor de hoofdbranch van de Git-repository (HEAD). Voor afhankelijkheden die zijn gehost in repositories die de naam main gebruiken in plaats van master, is het niet langer nodig om in de instellingen branch = 'main' op te geven.
• In de compiler zijn de eisen voor de minimale versie van LLVM verhoogd naar LLVM 10.

Daarnaast kan worden opgemerkt dat er financiering is verstrekt voor de ontwikkeling van de integratie in de Linux-kernel van tools voor het ontwikkelen van componenten in de Rust-taal. Dit werk zal worden uitgevoerd onder het project Prossimo, onder de auspiciën van de ISRG (Internet Security Research Group), die de oprichter is van het Let's Encrypt-project en het bevorderen van HTTPS en het ontwikkelen van technologieën voor een veiligere internet bevordert. De financiering zal worden verstrekt door Google, die het werk van Miguel Ojeda, de auteur van het Rust-for-Linux-project, zal betalen. Eerder hebben ISRG en Google al de ontwikkeling van een alternatieve HTTP-backend voor de curl-tool en de ontwikkeling van een nieuwe TLS-module voor de http-server van Apache gefinancierd.

Volgens Microsoft en Google wordt ongeveer 70% van de kwetsbaarheden veroorzaakt door onveilige omgang met geheugen. Het gebruik van de programmeertaal Rust voor de ontwikkeling van kerncomponenten, zoals apparaatspecificaties, zou het risico op kwetsbaarheden die door onveilige geheugenhandelingen ontstaan, kunnen verlagen en problemen zoals toegang tot geheugen na bevrijding en bufferoverloop kunnen uitsluiten.

Veilige geheugentoegang wordt in Rust tijdens de compilatie gegarandeerd door middel van referentietests, objecteigenaarschap en het bijhouden van de levensduur van objecten (scope), evenals door het evalueren van de geldigheid van geheugentoegang tijdens het uitvoeren van code. Rust biedt ook middelen om te beschermen tegen gehele getallenoverflows, vereist dat variabelen verplicht worden geïnitialiseerd voordat ze worden gebruikt, behandelt fouten beter in de standaardbibliotheek, past het concept van onveranderlijkheid (immutable) van verwijzingen en variabelen standaard toe en biedt sterke statische typecontrole om logische fouten te minimaliseren.

Bron: opennet.ru