Boolean 4 state logic wrapped inside package SIMD vectors

Core 4-State Algebra.rs

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum State { Z, X, Zero, One }

impl State {
    #[inline(always)]
    pub fn from_bool(b: Option<bool>) -> Self {
        match b {
            None        => State::X,           // undefined / faulted
            Some(true)  => State::One,
            Some(false) => State::Zero,
        }
    }

    #[inline(always)]
    pub fn and(self, rhs: Self) -> Self {
        use State::*;
        match (self, rhs) {
            (Z, _) | (_, Z)       => Z,
            (X, _) | (_, X)       => X,
            (One, One)            => One,
            (Zero, _) | (_, Zero) => Zero,
        }
    }

    #[inline(always)]
    pub fn or(self, rhs: Self) -> Self {
        use State::*;
        match (self, rhs) {
            (Z, s) | (s, Z) => s,
            (X, _) | (_, X) => X,
            (One, _) | (_, One) => One,
            (Zero, Zero) => Zero,
        }
    }

    #[inline(always)]
    pub fn not(self) -> Self {
        use State::*;
        match self {
            Z => Z,
            X => X,
            One => Zero,
            Zero => One,
        }
    }
}