/// `value` must have been created by `Self::into_raw`.

/// This function must not be called twice for the same `value`.

/// The type `T` must be the one given to `Self::into_raw`.

unsafe fn from_raw<T: ?Sized + 'a>(

value: MaybeUninit<[u8; INDIRECT_SIZE]>,

) -> Self::ForT<T>;

/// # Safety

/// The type `T` must be the same one used in `Self::new`.

pub unsafe fn into_inner<T: ?Sized>(self) -> I::ForT<T> {

// SAFETY: indirect was created with this I's into_raw in Self::new.

// This function cannot be called twice because we take ownership of self and

impl<'a> Sealed<'a> for Ref {

fn into_raw<T: ?Sized + 'a>(value: Self::ForT<T>) -> MaybeUninit<[u8; INDIRECT_SIZE]> {

// SAFETY: A possibly fat borrow can be stores in a 2 usize wide maybe uninit array.

unsafe { transmute::<&'a T, MaybeUninit<[u8; INDIRECT_SIZE]>>(value) }

}

unsafe fn from_raw<T: ?Sized + 'a>(any: MaybeUninit<[u8; INDIRECT_SIZE]>) -> Self::ForT<T> {

// SAFETY: We know the value is from Self::into_raw because of the caller invariants.

unsafe { transmute::<MaybeUninit<[u8; INDIRECT_SIZE]>, &'a T>(any) }

impl<'a> Sealed<'a> for Mut {

fn into_raw<T: ?Sized + 'a>(value: Self::ForT<T>) -> MaybeUninit<[u8; INDIRECT_SIZE]> {

// SAFETY: A possibly fat borrow can be stores in a 2 usize wide maybe uninit array.

unsafe { transmute::<&'a mut T, MaybeUninit<[u8; INDIRECT_SIZE]>>(value) }

}

unsafe fn from_raw<T: ?Sized + 'a>(any: MaybeUninit<[u8; INDIRECT_SIZE]>) -> Self::ForT<T> {

// SAFETY: We know the value is from Self::into_raw because of the caller invariants.

unsafe { transmute::<MaybeUninit<[u8; INDIRECT_SIZE]>, &'a mut T>(any) }

/// # Safety

/// Same rules as [`core::mem::transmute()`].

unsafe fn transmute<T, U>(value: T) -> U {

// Create union type that can store a `T` or a `U`.

// We can then use this to convert between them.

let z = RawIndirect::<Ref>::new(y);

// SAFETY: Same type as y which we made it from.

let w: &i32 = unsafe { z.into_inner() };

assert_eq!(w, y);

let z = RawIndirect::<Ref>::new(y);

// SAFETY: Same type as y which we made it from.

let w: &i32 = unsafe { z.into_inner() };

assert_eq!(w.as_int(), x);

let z = RawIndirect::<Mut>::new(y);

// SAFETY: Same type as y which we made it from.

let w: &mut i32 = unsafe { z.into_inner() };

*w += 1;

let z = RawIndirect::<Mut>::new(y);

// SAFETY: Same type as y which we made it from.

let w: &mut dyn AddOne = unsafe { z.into_inner() };

w.add_one();