Software-update: Rust 1.83.0

Rust is een programmeertaal bedacht door Graydon Hoare en oorspronkelijk ontwikkeld door Mozilla. Het is deels geïnspireerd op de programmeertaal C, maar kent syntactische en semantische verschillen. Het focust op veiligheid en moet moderne computersystemen efficiënter te benutten. Het wordt ingezet door onder andere Cloudflare, OVH, Mozilla, Deliveroo, Coursera, AppSignal en Threema. Versie 1.83 is uitgebracht en de releasenotes voor die uitgave kunnen hieronder worden gevonden.

New const capabilities

This release includes several large extensions to what code running in const contexts can do. This refers to all code that the compiler has to evaluate at compile-time: the initial value of const and static items, array lengths, enum discriminant values, const generic arguments, and functions callable from such contexts (const fn).

References to statics. So far, const contexts except for the initializer expression of a static item were forbidden from referencing static items. This limitation has now been lifted:

References to statics.

Note, however, that reading the value of a mutable or interior mutable static is still not permitted in const contexts. Furthermore, the final value of a constant may not reference any mutable or interior mutable statics:

These limitations ensure that constants are still "constant": the value they evaluate to, and their meaning as a pattern (which can involve dereferencing references), will be the same throughout the entire program execution.

That said, a constant is permitted to evaluate to a raw pointer that points to a mutable or interior mutable static:

Mutable references and pointers. It is now possible to use mutable references in const contexts:

Mutable references and pointers.

Mutable raw pointers and interior mutability are also supported:

However, mutable references and pointers can only be used inside the computation of a constant, they cannot become a part of the final value of the constant:

This release also ships with a whole bag of new functions that are now stable in const contexts (see the end of the "Stabilized APIs" section).

These new capabilities and stabilized APIs unblock an entire new category of code to be executed inside const contexts, and we are excited to see how the Rust ecosystem will make use of this!

Stabilized APIs

BufRead::skip_untilControlFlow::break_valueControlFlow::continue_valueControlFlow::map_breakControlFlow::map_continueDebugList::finish_non_exhaustiveDebugMap::finish_non_exhaustiveDebugSet::finish_non_exhaustiveDebugTuple::finish_non_exhaustiveErrorKind::ArgumentListTooLongErrorKind::DeadlockErrorKind::DirectoryNotEmptyErrorKind::ExecutableFileBusyErrorKind::FileTooLargeErrorKind::HostUnreachableErrorKind::IsADirectoryErrorKind::NetworkDownErrorKind::NetworkUnreachableErrorKind::NotADirectoryErrorKind::NotSeekableErrorKind::ReadOnlyFilesystemErrorKind::ResourceBusyErrorKind::StaleNetworkFileHandleErrorKind::StorageFullErrorKind::TooManyLinksOption::get_or_insert_defaultWaker::dataWaker::newWaker::vtablechar::MINhash_map::Entry::insert_entryhash_map::VacantEntry::insert_entry

BufRead::skip_until

ControlFlow::break_value

ControlFlow::continue_value

ControlFlow::map_break

ControlFlow::map_continue

DebugList::finish_non_exhaustive

DebugMap::finish_non_exhaustive

DebugSet::finish_non_exhaustive

DebugTuple::finish_non_exhaustive

ErrorKind::ArgumentListTooLong

ErrorKind::Deadlock

ErrorKind::DirectoryNotEmpty

ErrorKind::ExecutableFileBusy

ErrorKind::FileTooLarge

ErrorKind::HostUnreachable

ErrorKind::IsADirectory

ErrorKind::NetworkDown

ErrorKind::NetworkUnreachable

ErrorKind::NotADirectory

ErrorKind::NotSeekable

ErrorKind::ReadOnlyFilesystem

ErrorKind::ResourceBusy

ErrorKind::StaleNetworkFileHandle

ErrorKind::StorageFull

ErrorKind::TooManyLinks

Option::get_or_insert_default

Waker::data

Waker::new

Waker::vtable

char::MIN

hash_map::Entry::insert_entry

hash_map::VacantEntry::insert_entry

These APIs are now stable in const contexts:

Cell::into_innerDuration::as_secs_f32Duration::as_secs_f64Duration::div_duration_f32Duration::div_duration_f64MaybeUninit::as_mut_ptrNonNull::as_mutNonNull::copy_fromNonNull::copy_from_nonoverlappingNonNull::copy_toNonNull::copy_to_nonoverlappingNonNull::slice_from_raw_partsNonNull::writeNonNull::write_bytesNonNull::write_unalignedOnceCell::into_innerOption::as_mutOption::expectOption::replaceOption::takeOption::unwrapOption::unwrap_uncheckedOption::<&_>::copiedOption::<&mut _>::copiedOption::<Option<_>>::flattenOption::<Result<_, _>>::transposeRefCell::into_innerResult::as_mutResult::<&_, _>::copiedResult::<&mut _, _>::copiedResult::<Option<_>, _>::transposeUnsafeCell::get_mutUnsafeCell::into_innerarray::from_mutchar::encode_utf8{float}::classify{float}::is_finite{float}::is_infinite{float}::is_nan{float}::is_normal{float}::is_sign_negative{float}::is_sign_positive{float}::is_subnormal{float}::from_bits{float}::from_be_bytes{float}::from_le_bytes{float}::from_ne_bytes{float}::to_bits{float}::to_be_bytes{float}::to_le_bytes{float}::to_ne_bytesmem::replaceptr::replaceptr::slice_from_raw_parts_mutptr::writeptr::write_unaligned<*const _>::copy_to<*const _>::copy_to_nonoverlapping<*mut _>::copy_from<*mut _>::copy_from_nonoverlapping<*mut _>::copy_to<*mut _>::copy_to_nonoverlapping<*mut _>::write<*mut _>::write_bytes<*mut _>::write_unalignedslice::from_mutslice::from_raw_parts_mut<[_]>::first_mut<[_]>::last_mut<[_]>::first_chunk_mut<[_]>::last_chunk_mut<[_]>::split_at_mut<[_]>::split_at_mut_checked<[_]>::split_at_mut_unchecked<[_]>::split_first_mut<[_]>::split_last_mut<[_]>::split_first_chunk_mut<[_]>::split_last_chunk_mutstr::as_bytes_mutstr::as_mut_ptrstr::from_utf8_unchecked_mut

Cell::into_inner

Duration::as_secs_f32

Duration::as_secs_f64

Duration::div_duration_f32

Duration::div_duration_f64

MaybeUninit::as_mut_ptr

NonNull::as_mut

NonNull::copy_from

NonNull::copy_from_nonoverlapping

NonNull::copy_to

NonNull::copy_to_nonoverlapping

NonNull::slice_from_raw_parts

NonNull::write

NonNull::write_bytes

NonNull::write_unaligned

OnceCell::into_inner

Option::as_mut

Option::expect

Option::replace

Option::take

Option::unwrap

Option::unwrap_unchecked

Option::<&_>::copied

Option::<&mut _>::copied

Option::<Option<_>>::flatten

Option::<Result<_, _>>::transpose

RefCell::into_inner

Result::as_mut

Result::<&_, _>::copied

Result::<&mut _, _>::copied

Result::<Option<_>, _>::transpose

UnsafeCell::get_mut

UnsafeCell::into_inner

array::from_mut

char::encode_utf8

{float}::classify

{float}::is_finite

{float}::is_infinite

{float}::is_nan

{float}::is_normal

{float}::is_sign_negative

{float}::is_sign_positive

{float}::is_subnormal

{float}::from_bits

{float}::from_be_bytes

{float}::from_le_bytes

{float}::from_ne_bytes

{float}::to_bits

{float}::to_be_bytes

{float}::to_le_bytes

{float}::to_ne_bytes

mem::replace

ptr::replace

ptr::slice_from_raw_parts_mut

ptr::write

ptr::write_unaligned

<*const _>::copy_to

<*const _>::copy_to_nonoverlapping

<*mut _>::copy_from

<*mut _>::copy_from_nonoverlapping

<*mut _>::copy_to

<*mut _>::copy_to_nonoverlapping

<*mut _>::write

<*mut _>::write_bytes

<*mut _>::write_unaligned

slice::from_mut

slice::from_raw_parts_mut

<[_]>::first_mut

<[_]>::last_mut

<[_]>::first_chunk_mut

<[_]>::last_chunk_mut

<[_]>::split_at_mut

<[_]>::split_at_mut_checked

<[_]>::split_at_mut_unchecked

<[_]>::split_first_mut

<[_]>::split_last_mut

<[_]>::split_first_chunk_mut

<[_]>::split_last_chunk_mut

str::as_bytes_mut

str::as_mut_ptr

str::from_utf8_unchecked_mut

Other changes

Check out everything that changed in Rust, Cargo, and Clippy.

Source: Tweakers.net