Struct yoke::kinda_sorta_dangling::KindaSortaDangling

#[repr(transparent)]
pub(crate) struct KindaSortaDangling<T: 'static> {
    dangle: MaybeUninit<T>,
}

This type is intended to be similar to the type MaybeDangling<T> proposed in RFC 3336.

The effect of this is that in Rust’s safety model, types inside here are not expected to have any memory dependent validity properties (dereferenceable, noalias).

See #3696 for a testcase where Yoke fails under miri’s field-retagging mode if not using KindaSortaDangling.

This has T: 'static since we don’t need anything else and we don’t want to have to think (more) about variance over lifetimes or dropck.

After RFC 3336 lands we can use MaybeDangling instead.

Note that a version of this type also exists publicly as the [maybe_dangling] crate; which also exports a patched ManuallyDrop with similar semantics and does not require T: 'static. Consider using this if you need something more general and are okay with adding dependencies.

maybe_dangling

Fields

dangle: MaybeUninit<T>

Safety invariant: This is always an initialized T, never uninit or other invalid bit patterns. Its drop glue will execute during Drop::drop rather than during the drop glue for KindaSortaDangling, which means that we have to be careful about not touching the values as initialized during drop after that, but that’s a short period of time.

Implementations

impl<T: 'static> KindaSortaDangling<T>

pub(crate) const fn new(dangle: T) -> Self

pub(crate) fn into_inner(self) -> T

Trait Implementations

impl<T: 'static> Deref for KindaSortaDangling<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: 'static> DerefMut for KindaSortaDangling<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: 'static> Drop for KindaSortaDangling<T>

fn drop(&mut self)

Executes the destructor for this type.