Struct Z0

pub struct Z0;

The type-level signed integer 0.

Implementations

impl Z0

fn new() -> Z0

Instantiates a singleton representing the integer 0.

Trait Implementations

impl Abs for Z0

type Output = Z0;

impl Binary for Z0

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

impl Clone for Z0

fn clone(&self) -> Self

impl Cmp for Z0

type Output = Equal;

impl Copy for Z0

impl Debug for Z0

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

impl Default for Z0

fn default() -> Self

impl Eq for Z0

impl Gcd<Z0> for Z0

type Output = Z0;

impl Hash for Z0

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

impl Integer for Z0

const I8: i8 = 0;
const I16: i16 = 0;
const I32: i32 = 0;
const I64: i64 = 0;
const ISIZE: isize = 0;
fn to_i8() -> i8
fn to_i16() -> i16
fn to_i32() -> i32
fn to_i64() -> i64
fn to_isize() -> isize

impl Max for Z0

type Output = Z0;
fn max(self, Z0) -> Self::Output

impl Min for Z0

type Output = Z0;
fn min(self, Z0) -> Self::Output

impl Mul<ATerm> for Z0

type Output = ATerm;
fn mul(self, ATerm) -> Self::Output

impl Neg for Z0

type Output = Z0;
fn neg(self) -> Self::Output

impl Ord for Z0

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

impl PartialEq for Z0

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

impl PartialOrd for Z0

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

impl Pow<Z0> for Z0

type Output = PInt<UInt<UTerm, B1>>;
fn powi(self, Z0) -> Self::Output

impl StructuralPartialEq for Z0

impl Sub for Z0

type Output = Z0;
fn sub(self, Z0) -> Self::Output

impl ToInt<i16> for Z0

fn to_int() -> i16
const INT: i16 = Self::I16;

impl ToInt<i32> for Z0

fn to_int() -> i32
const INT: i32 = Self::I32;

impl ToInt<i64> for Z0

fn to_int() -> i64
const INT: i64 = Self::I64;

impl ToInt<i8> for Z0

fn to_int() -> i8
const INT: i8 = Self::I8;

impl ToInt<isize> for Z0

fn to_int() -> isize
const INT: isize = Self::ISIZE;

impl Zero for Z0

impl<I: Integer + NonZero> Div<I> for Z0

type Output = Z0;
fn div(self, I) -> Self::Output

impl<I: Integer + NonZero> Rem<I> for Z0

type Output = Z0;
fn rem(self, I) -> Self::Output

impl<I: Integer> Add<I> for Z0

type Output = I;
fn add(self, rhs: I) -> Self::Output

impl<I: Integer> Mul<I> for Z0

type Output = Z0;
fn mul(self, I) -> Self::Output

impl<U> Gcd<NInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = PInt<U>;

impl<U> Gcd<PInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = PInt<U>;

impl<U> Max<NInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = Z0;
fn max(self, NInt<U>) -> Self::Output

impl<U> Max<PInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = PInt<U>;
fn max(self, rhs: PInt<U>) -> Self::Output

impl<U> Min<NInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = NInt<U>;
fn min(self, rhs: NInt<U>) -> Self::Output

impl<U> Min<PInt<U>> for Z0 where U: Unsigned + NonZero,

type Output = Z0;
fn min(self, PInt<U>) -> Self::Output

impl<U: Unsigned + NonZero> Cmp<NInt<U>> for Z0

type Output = Greater;

impl<U: Unsigned + NonZero> Cmp<PInt<U>> for Z0

type Output = Less;

impl<U: Unsigned + NonZero> Pow<NInt<U>> for Z0

type Output = Z0;
fn powi(self, NInt<U>) -> Self::Output

impl<U: Unsigned + NonZero> Pow<PInt<U>> for Z0

type Output = Z0;
fn powi(self, PInt<U>) -> Self::Output

impl<U: Unsigned + NonZero> Sub<NInt<U>> for Z0

type Output = PInt<U>;
fn sub(self, NInt<U>) -> Self::Output

impl<U: Unsigned + NonZero> Sub<PInt<U>> for Z0

type Output = NInt<U>;
fn sub(self, PInt<U>) -> Self::Output

impl<V, A> Mul<TArr<V, A>> for Z0 where Z0: Mul<A>,

type Output = TArr<Z0, <Z0 as Mul<A>>::Output>;
fn mul(self, rhs: TArr<V, A>) -> Self::Output

Auto Trait Implementations

impl Freeze for Z0

impl RefUnwindSafe for Z0

impl Send for Z0

impl Sync for Z0

impl Unpin for Z0

impl UnsafeUnpin for Z0

impl UnwindSafe for Z0

Blanket Implementations

impl<A, B> IsEqual<B> for Z0 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 Z0 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 Z0 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 Z0 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 Z0 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 Z0 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<M, N> PartialDiv<N> for Z0 where M: Integer + Div<N> + Rem<N, Output = Z0>,

type Output = <M as Div<N>>::Output;
fn partial_div(self, rhs: N) -> Self::Output

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

impl<T> From<T> for Z0

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Same for Z0

type Output = T;

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

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

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

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