Rust 1.45 programspråk release

publiceras version 1.45 av systemets programmeringsspråk Rustgrundades av Mozilla-projektet. Språket fokuserar på säker minneshantering, ger automatisk minneshantering och ger möjlighet att uppnå hög jobbparallellism samtidigt som man undviker användningen av en sophämtare och runtime.

Rusts automatiska minneshantering räddar utvecklaren från fel vid manipulering av pekare och skyddar mot problem som uppstår på grund av minnesmanipulation på låg nivå, som att komma åt ett minnesområde efter det att det har frigjorts, avläsning av nollpekare, buffertöverskridningar, etc. För att distribuera bibliotek, säkerställa montering och hantera beroenden utvecklar projektet en pakethanterare Laddning, vilket gör att du kan få de bibliotek du behöver för programmet med ett klick. Ett arkiv stöds för värdbibliotek lådor.io.

Den huvudsakliga innovationer:

• Eliminerad långvarig defekt när du utför omvandlingar mellan heltal och flyttal. Eftersom Rust-kompilatorn använder LLVM som backend, utfördes typkonverteringsoperationer genom LLVM-mellankodinstruktioner som t.ex. fptoui, som har en betydande egenskap - odefinierat beteende om det resulterande värdet inte passar in i måltypen. Till exempel, vid konvertering av flytvärdet 300 med typ f32 till heltalstyp u8 är resultatet oförutsägbart och kan variera på olika system. Problemet är att den här funktionen visas i kod som inte är markerad som "osäker".

  Från och med Rust 1.45 är beteendet för överflöde av typstorlek strikt reglerat, och konverteringsoperationen "som" kontrollerar efter spill och tvingar värdet att konverteras till max- eller minimivärdet för måltypen (för exemplet ovan, ett värde på 300 skulle konverteras till 255). För att inaktivera sådana kontroller tillhandahålls ytterligare API-anrop "{f64, f32}::to_int_unchecked", som fungerar i osäkert läge.

  fn cast(x: f32) -> u8 {
  x som u8
  }

  fn main() {
  låt too_big = 300.0;
  låt too_small = -100.0;
  låt nan = f32::NAN;

  låt x: f32 = 1.0;
  låt y: u8 = osäker { x.to_int_unchecked() };

  println!("för_big_casted = {}", cast(too_big)); // utgång 255
  println!("för_small_casted = {}", cast(too_small)); // utgång 0
  println!("not_a_number_casted = {}", cast(nan)); // utgång 0
  }

• Använd stabiliserad procedurmakronfunktionsliknande uttryck, mallar och uttalanden. Tidigare kunde sådana makron inte anropas överallt, utan bara i vissa delar av koden (som ett separat anrop, inte sammanflätat med annan kod). Att utöka hur makron kan kallas, liknande funktioner, var ett av kraven för att få webbramverket att fungera Raket i stabila utgåvor av Rust. Tidigare krävde att uppnå ytterligare flexibilitet när det gäller att definiera hanterare i Rocket att man aktiverade en experimentell funktion som heter "proc_macro_hygiene", som inte är tillgänglig i stabila versioner av Rust. Denna funktionalitet är nu inbyggd i stabila versioner av språket.
• Tillåtet att använda intervall med typen "char" för att iterera över intervallvärden (ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo}):

  för ch in 'a'..='z' {
  print!("{}", ch);
  }
  println!(); // Kommer att skriva ut "abcdefghijklmnopqrstuvwxyz"

• En ny del av API har överförts till kategorin stabil, inklusive stabiliserad
  Arc::as_ptr,
  BTreeMap::remove_entry,
  Rc::as_ptr,
  rc::Svag::as_ptr,
  rc::Weak::from_raw,
  rc::Weak::into_raw,
  str::strip_prefix,
  str::strip_suffix,
  sync::Svag::as_ptr,
  sync::Weak::from_raw,
  sync::Weak::into_raw,
  char::UNICODE_VERSION,
  Span::resolved_at,
  Span::located_at,
  Span::mixed_site,
  unix::process::CommandExt::arg0.

• Rustc-kompilatorn har lagt till stöd för att åsidosätta olika målplattformsfunktioner med flaggan "target-feature", till exempel "-C target-feature=+avx2,+fma". Nya flaggor har också lagts till:
  "force-unwind-tables" för att generera unwind-anropstabeller, oavsett kraschhanteringsstrategi; "embed-bitcode" för att kontrollera om LLVM-bitkod ingår i genererade rlibs. Flaggan "embed-bitcode" är aktiverad som standard i Cargo för att optimera byggtid och diskutrymmesförbrukning.

• En tredje nivå av stöd har tillhandahållits för plattformarna mipsel-sony-psp och thumbv7a-uwp-windows-msvc. Den tredje nivån innebär grundläggande support, men utan automatiserad testning och publicering av officiella builds.

Dessutom kan det noteras berättelsen om att skapa det enklaste appar på Rust-språket, börjar använda systemets starthanterare och är redo att laddas helt i stället för operativsystemet.
Artikeln är den första i en serie dedikerad till att demonstrera tekniker som efterfrågas inom lågnivåprogrammering och OS-utveckling.

Källa: opennet.ru