push_unique.rs

trait PushUnique {
    type Item;
    fn push_unique(&mut self, item: Self::Item) -> Result<(), Self::Item>;
}

impl<T> PushUnique for Vec<T>
where
    T: PartialEq,
{
    type Item = T;

    fn push_unique(&mut self, item: Self::Item) -> Result<(), Self::Item> {
        if self.contains(&item) {
            Err(item)
        } else {
            self.push(item);
            Ok(())
        }
    }
}

#[cfg(test)]
mod test {
    use super::PushUnique;

    #[test]
    fn can_push_single() {
        let mut v = Vec::new();
        v.push_unique(0).unwrap();
    }

    #[test]
    fn cant_push_multiple() {
        let v = Vec::new();
        let mut v: Vec<_> = v.into();
        assert!(v.push_unique(0).is_ok());
        assert!(v.push_unique(0).is_err());
    }
}

scrutinize.rs

use std::slice;

pub fn scrutinize<T>(_x: T) {
    let p = &_x;
    let s = unsafe {
        let p = p as *const T as *mut u8;
        slice::from_raw_parts(p, std::mem::size_of::<T>())
    };
    dbg!(s);
}

#[cfg(test)]
mod test {
    use crate::scrutinize::scrutinize;
    use std::mem::MaybeUninit;

    #[test]
    fn zeroize() {
        let a = &() as *const ();
        let b = &() as *const ();
        println!("{:?}", a.cmp(&b));
    }

    #[test]
    fn arghhhh() {
        let bytes = MaybeUninit::<bool>::uninit();
        dbg!(&bytes);
        scrutinize(bytes);
    }
}