Издадена е Rust 1.53. Google ще финансира добавянето на поддръжка на Rust към ядрото на Linux

Публикувано е изданието на системния програмен език Rust 1.53, основан от проекта Mozilla, но сега разработен под егидата на независимата организация с нестопанска цел Rust Foundation. Езикът се фокусира върху безопасността на паметта, осигурява автоматично управление на паметта и предоставя средствата за постигане на висок паралелизъм на задачите без използване на събирач на отпадъци или време за изпълнение (времето за изпълнение е намалено до основна инициализация и поддръжка на стандартната библиотека).

Автоматичното управление на паметта на Rust елиминира грешките при манипулиране на указатели и предпазва от проблеми, произтичащи от манипулиране на паметта на ниско ниво, като достъп до област на паметта, след като тя е била освободена, дерефериране на нулев указател, препълване на буфер и т.н. За разпространение на библиотеки, осигуряване на сглобяване и управление на зависимости, проектът разработва мениджъра на пакети Cargo. Хранилището crates.io се поддържа за хостване на библиотеки.

Основни иновации:

• За масиви е внедрена характеристиката IntoIterator, която ви позволява да организирате итерацията на елементите на масива по стойности: for i in [1, 2, 3] { .. }

  Също така е възможно да се подадат масиви към методи, които приемат итератори, например: let set = BTreeSet::from_iter([1, 2, 3]); за (a, b) в some_iterator.chain([1]).zip([1, 2, 3]) { .. }

  Преди това IntoIterator беше реализиран само за препратки към масиви, т.е. за итериране на стойности изисква използването на препратки (“&[1, 2, 3]”) или “[1, 2, 3].iter()”. Внедряването на IntoIterator за масиви беше възпрепятствано от проблеми със съвместимостта, причинени от по-ранно преобразуване на компилатора от array.into_iter() в (&array).into_iter(). Тези проблеми бяха решени със заобиколно решение - компилаторът ще продължи да преобразува array.into_iter() в (&array).into_iter(), сякаш не е имало имплементация на чертата IntoIterator, но само когато извиква метода с помощта на ".into_iter( )" синтаксис и без да докосвате извикванията във формата "in [1, 2, 3]", "iter.zip([1, 2, 3])", "IntoIterator::into_iter([1, 2, 3] )".

• Възможно е да се зададат изрази „|“ (логическа операция ИЛИ) във всяка част от шаблона, например вместо „Някои(1) | Some(2)" вече можете да напишете "Some(1 | 2)": резултат от съвпадение { Ok(Some(1 | 2)) => { .. } Err(MyError { kind: FileNotFound | PermissionDenied, .. }) = > { .. } _ => { .. } }
• Използването на не-ASCII знаци в идентификаторите е разрешено, включително всякакви национални знаци, дефинирани в спецификацията Unicode UAX 31, но с изключение на знаци за емотикони. Ако използвате различни, но подобни символи, компилаторът ще издаде предупреждение. const BLÅHAJ: &str = "🦈"; struct 人 { 名字: String, } нека α = 1; letｓos = 2; предупреждение: двойка идентификатори се счита за объркваща между 'ｓ' и 's'
• Нова част от API е прехвърлена в стабилната категория, включително следните стабилизирани:
  • масив::от_реф
  • масив::от_мут
  • AtomicBool::fetch_update
  • AtomicPtr::fetch_update
  • BTreeSet::retain
  • BTreeMap::retain
  • BufReader::seek_relative
  • cmp::min_by
  • cmp::min_по_ключ
  • cmp::max_by
  • cmp::max_by_key
  • DebugStruct::finish_non_exhaustive
  • Продължителност::НУЛА
  • Продължителност::МАКС
  • Продължителност::е_нула
  • Duration::saturating_add
  • Duration::saturating_sub
  • Duration::saturating_mul
  • f32::is_subnormal
  • f64::is_subnormal
  • IntoIterator за масиви
  • {integer}::BITS
  • io::Error::Unsupported
  • Ненула*::водещи_нули
  • NonZero*::trailing_zeros
  • Опция::вмъкване
  • Подреждане::is_eq
  • Подреждане::is_ne
  • Подреждане::is_lt
  • Подреждане::is_gt
  • Подреждане::is_le
  • Подреждане::is_ge
  • OsStr::make_ascii_малки букви
  • OsStr::make_ascii_uppercase
  • OsStr::to_ascii_малки букви
  • OsStr::to_ascii_главен регистър
  • 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]> за slice::IterMut
  • impl SliceIndex за (обвързан , обвързан )
  • Vec::extend_from_within
• Реализирано е третото ниво на поддръжка за платформата wasm64-unknown-unknown. Третото ниво включва основна поддръжка, но без автоматизирано тестване, публикуване на официални компилации или проверка дали кодът може да бъде компилиран.
• Мениджърът на пакети Cargo е преместен да използва името „main“ за главния клон на хранилището на Git (HEAD) по подразбиране. Зависимостите, хоствани в хранилища, които използват името main вместо master, вече не изискват конфигуриране на branch = "main".
• В компилатора изискванията за минималната версия на LLVM са повишени до LLVM 10.

Освен това можем да отбележим предоставянето на финансиране за разработването на интеграция в ядрото на Linux на инструменти за разработване на компоненти на езика Rust. Работата ще се извърши в рамките на проекта Prossimo под егидата на организацията ISRG (Internet Security Research Group), която е основател на проекта Let's Encrypt и насърчава HTTPS и развитието на технологии за повишаване на сигурността на Интернет. Средствата ще бъдат осигурени от Google, която ще плати за работата на Мигел Охеда, автор на проекта Rust-for-Linux. Преди това ISRG и Google вече финансираха създаването на алтернативен HTTP бекенд за помощната програма curl и разработването на нов TLS модул за http сървъра Apache.

Според Microsoft и Google около 70% от уязвимостите са причинени от несигурна работа с паметта. Очаква се, че използването на езика Rust за разработване на компоненти на ядрото, като например драйвери на устройства, ще намали риска от уязвимости, причинени от опасна работа с паметта, и ще елиминира грешки като достъп до област на паметта, след като тя е била освободена и превишаване на границите на буфера.

Безопасното боравене с паметта е осигурено в Rust по време на компилиране чрез проверка на референции, проследяване на собствеността върху обекта и продължителността на живот (обхват) на обекта, както и чрез оценка на коректността на достъпа до паметта по време на изпълнение на кода. Rust също осигурява защита срещу препълване на цели числа, изисква задължителна инициализация на стойностите на променливите преди употреба, обработва грешките по-добре в стандартната библиотека, прилага концепцията за неизменни препратки и променливи по подразбиране, предлага силно статично въвеждане за минимизиране на логическите грешки.

Източник: opennet.ru