Struct B0

pub struct B0;

The type-level bit 0.

Implementations

impl B0

fn new() -> B0

Instantiates a singleton representing this bit.

Trait Implementations

impl Bit for B0

const U8: u8 = 0;
const BOOL: bool = false;
fn new() -> Self
fn to_u8() -> u8
fn to_bool() -> bool

impl BitOr for B0

type Output = B0;
fn bitor(self, B0) -> Self::Output

impl BitOr<B1> for B0

type Output = B1;
fn bitor(self, B1) -> Self::Output

impl BitXor for B0

type Output = B0;
fn bitxor(self, B0) -> Self::Output

impl BitXor<B1> for B0

type Output = B1;
fn bitxor(self, B1) -> Self::Output

impl Clone for B0

fn clone(&self) -> Self

impl Cmp for B0

type Output = Equal;

impl Cmp<B1> for B0

type Output = Less;

impl Copy for B0

impl Debug for B0

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

impl Default for B0

fn default() -> Self

impl Eq for B0

impl Hash for B0

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

impl Max for B0

type Output = B0;
fn max(self, B0) -> B0

impl Max<B1> for B0

type Output = B1;
fn max(self, rhs: B1) -> B1

impl Min for B0

type Output = B0;
fn min(self, B0) -> B0

impl Min<B1> for B0

type Output = B0;
fn min(self, B1) -> B0

impl Not for B0

type Output = B1;
fn not(self) -> Self::Output

impl Ord for B0

fn cmp(&self, other: &Self) -> Ordering

impl PartialEq for B0

fn eq(&self, other: &Self) -> bool

impl PartialOrd for B0

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

impl StructuralPartialEq for B0

impl Zero for B0

impl<Rhs: Bit> BitAnd<Rhs> for B0

type Output = B0;
fn bitand(self, Rhs) -> Self::Output

Auto Trait Implementations

impl Freeze for B0

impl RefUnwindSafe for B0

impl Send for B0

impl Sync for B0

impl Unpin for B0

impl UnsafeUnpin for B0

impl UnwindSafe for B0

Blanket Implementations

impl<A, B> IsEqual<B> for B0 where A: Cmp<B> + IsEqualPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_equal(self, rhs: B) -> <A as IsEqual<B>>::Output

impl<A, B> IsGreater<B> for B0 where A: Cmp<B> + IsGreaterPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsGreaterPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_greater(self, rhs: B) -> <A as IsGreater<B>>::Output

impl<A, B> IsGreaterOrEqual<B> for B0 where A: Cmp<B> + IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_greater_or_equal(self, rhs: B) -> <A as IsGreaterOrEqual<B>>::Output

impl<A, B> IsLess<B> for B0 where A: Cmp<B> + IsLessPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsLessPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_less(self, rhs: B) -> <A as IsLess<B>>::Output

impl<A, B> IsLessOrEqual<B> for B0 where A: Cmp<B> + IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_less_or_equal(self, rhs: B) -> <A as IsLessOrEqual<B>>::Output

impl<A, B> IsNotEqual<B> for B0 where A: Cmp<B> + IsNotEqualPrivate<B, <A as Cmp<B>>::Output>,

type Output = <A as IsNotEqualPrivate<B, <A as Cmp<B>>::Output>>::Output;
fn is_not_equal(self, rhs: B) -> <A as IsNotEqual<B>>::Output

impl<T> Any for B0 where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for B0 where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for B0 where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for B0 where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for B0

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Same for B0

type Output = T;

impl<T, U> Into<U> for B0 where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for B0 where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for B0 where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>