Struct SameLayout

pub struct SameLayout<A, B>(/* private fields */);

A proof type, showing two types A and B have the same layout.

Implementations

impl<A, B> SameLayout<A, B>

pub const fn new() -> Option<Self>

pub fn forget_vec(self, vec: Vec<A>) -> Vec<B>

‘Transmute’ a vector by reusing its buffer. NOTE: This will forget all elements. You must clear the vector first if they are important, or set_len on the result if you can guarantee that old elements are valid initializers for the new type. This affords more flexibility for the caller as they might want to use As as an initializer for Bs which would be invalid if we dropped them. Manually drain the vector if this is not desirable.

pub fn deinit_box(self, boxed: Box<A>) -> (A, Box<MaybeUninit<B>>)

‘Transmute’ a box by reusing its buffer. NOTE: for the same flexibility as Vec, forget about the returned A.

impl<A, B> SameLayout<A, B>

pub const fn array<const N: usize>(self) -> SameLayout<[A; N], [B; N]>

pub const fn chain<C>(self, _: SameLayout<B, C>) -> SameLayout<A, C>

Apply a transitive argument to construct a new relation proof.

pub const fn transpose(self) -> SameLayout<B, A>

Use commutativity of equality.

Trait Implementations

impl<A, B> Clone for SameLayout<A, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for SameLayout<A, B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: Hash, B: Hash> Hash for SameLayout<A, B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: PartialEq, B: PartialEq> PartialEq for SameLayout<A, B>

fn eq(&self, other: &SameLayout<A, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, B> Copy for SameLayout<A, B>

impl<A: Eq, B: Eq> Eq for SameLayout<A, B>

impl<A, B> StructuralPartialEq for SameLayout<A, B>