Struct rfc::core::convert::transmute::options::NeglectValidity

pub struct NeglectValidity;

Partially neglect the static validity check.

By default, TransmuteFrom and TransmuteInto's methods require that all instantiations of the source type are guaranteed to be valid instantiations of the destination type. This precludes transmutations which might be valid depending on the source value:

#[derive(PromiseTransmutableFrom, PromiseTransmutableInto)]
#[repr(u8)]
enum Bool {
    True = 1,
    False = 0,
}
 
/* ⚠️ This example intentionally does not compile. */
let _ : Bool  = some_u8_value.transmute_into(); // Compile Error!

The NeglectValidity option disables this check.

By using the NeglectValidity option, you are committing to ensure dynamically source value is a valid instance of the destination type. For instance:

#[derive(PromiseTransmutableFrom, PromiseTransmutableInto)]
#[repr(u8)]
enum Bool {
    True = 1,
    False = 0,
}
 
pub trait TryIntoBool
{
    fn try_into_bool(self) -> Option<Bool>;
}
 
impl<T> TryIntoBool for T
where
    T: TransmuteInto<u8>,
    u8: TransmuteInto<Bool, NeglectValidity>
{
    fn try_into_bool(self) -> Option<Bool> {
        let val: u8 = self.transmute_into();
 
        if val > 1 {
            None
        } else {
            // Safe, because we've first verified that
            // `val` is a bit-valid instance of a boolean.
            Some(unsafe {val.unsafe_transmute_into()})
        }
    }
}

Even with NeglectValidity, the compiler will still statically reject transmutations that cannot possibly be valid:

#[derive(PromiseTransmutableInto)]
#[repr(C)] enum Foo { A = 24 }
 
#[derive(PromiseTransmutableFrom)]
#[repr(C)] enum Bar { Z = 42 }
 
let _ = <Bar as TransmuteFrom<Foo, NeglectValidity>::unsafe_transmute_from(Foo::N) // Compile error!

Trait Implementations

impl TransmuteOptions for NeglectValidity