Struct B1

pub struct B1;

The type-level bit 1.

Implementations

impl B1

fn new() -> B1

Instantiates a singleton representing this bit.

Trait Implementations

impl Bit for B1

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

impl BitAnd for B1

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

impl BitAnd<B0> for B1

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

impl BitXor for B1

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

impl BitXor<B0> for B1

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

impl Clone for B1

fn clone(&self) -> Self

impl Cmp for B1

type Output = Equal;

impl Cmp<B0> for B1

type Output = Greater;

impl Copy for B1

impl Debug for B1

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

impl Default for B1

fn default() -> Self

impl Eq for B1

impl Hash for B1

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

impl Max for B1

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

impl Max<B0> for B1

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

impl Min for B1

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

impl Min<B0> for B1

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

impl NonZero for B1

impl Not for B1

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

impl Ord for B1

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

impl PartialEq for B1

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

impl PartialOrd for B1

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

impl PowerOfTwo for B1

impl StructuralPartialEq for B1

impl<Rhs: Bit> BitOr<Rhs> for B1

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

Auto Trait Implementations

impl Freeze for B1

impl RefUnwindSafe for B1

impl Send for B1

impl Sync for B1

impl Unpin for B1

impl UnsafeUnpin for B1

impl UnwindSafe for B1

Blanket Implementations

impl<A, B> IsEqual<B> for B1 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 B1 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 B1 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 B1 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 B1 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 B1 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 B1 where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

impl<T> From<T> for B1

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Same for B1

type Output = T;

impl<T, U> Into<U> for B1 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 B1 where U: Into<T>,

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

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

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