Struct type_level_logic::types::balanced::Zero

pub struct Zero<X: Int = Term>(_);

Trait Implementations

impl<X: Default + Int> Default for Zero<X>

fn default() -> Zero<X>

Returns the "default value" for a type.

impl<X: Int> Int for Zero<X>

fn reify() -> isize

impl<N: Int> IntSucc for Zero<N>

type Output = Plus<N>

impl<N: Int> IntPred for Zero<N>

type Output = Minus<N>

impl<N: Int> IntTriple for Zero<N>

type Output = Zero<Zero<N>>

impl Unique for Zero<Term>

type Output = Term

impl<N: Int> Unique for Zero<Zero<N>> where
    Zero<N>: Unique, 

type Output = Zero<<Zero<N> as Unique>::Output>

impl<N: Int> Unique for Zero<Plus<N>> where
    N: Unique, 

type Output = Zero<Plus<<N as Unique>::Output>>

impl<N: Int> Unique for Zero<Minus<N>> where
    N: Unique, 

type Output = Zero<Minus<<N as Unique>::Output>>

impl IntNeg for Zero<Term>

type Output = Term

impl<N: Int> IntNeg for Zero<Zero<N>> where
    Zero<N>: IntNeg, 

type Output = Zero<<Zero<N> as IntNeg>::Output>

impl<N: Int> IntNeg for Zero<Plus<N>> where
    N: IntNeg, 

type Output = Zero<Minus<<N as IntNeg>::Output>>

impl<N: Int> IntNeg for Zero<Minus<N>> where
    N: IntNeg, 

type Output = Zero<Plus<<N as IntNeg>::Output>>

impl<N: Int> IntAdd<Term> for Zero<N> where
    Zero<N>: Unique, 

type Output = <Zero<N> as Unique>::Output

impl<N: Int> IntAdd<Undefined> for Zero<N>

type Output = Undefined

impl<M: Int, N: Int> IntAdd<Zero<N>> for Zero<M> where
    Zero<<M as IntAdd<N>>::Output>: Unique,
    M: IntAdd<N>, 

type Output = <Zero<<M as IntAdd<N>>::Output> as Unique>::Output

impl<M: Int, N: Int> IntAdd<Plus<N>> for Zero<M> where
    M: IntAdd<N>, 

type Output = Plus<<M as IntAdd<N>>::Output>

impl<M: Int, N: Int> IntAdd<Minus<N>> for Zero<M> where
    M: IntAdd<N>, 

type Output = Minus<<M as IntAdd<N>>::Output>

impl<N: Int> IntSub<Term> for Zero<N> where
    Zero<N>: Unique, 

type Output = <Zero<N> as Unique>::Output

impl<N: Int> IntSub<Undefined> for Zero<N>

type Output = Undefined

impl<M: Int, N: Int> IntSub<Zero<N>> for Zero<M> where
    Zero<<M as IntSub<N>>::Output>: Unique,
    M: IntSub<N>, 

type Output = <Zero<<M as IntSub<N>>::Output> as Unique>::Output

impl<M: Int, N: Int> IntSub<Plus<N>> for Zero<M> where
    M: IntSub<N>, 

type Output = Minus<<M as IntSub<N>>::Output>

impl<M: Int, N: Int> IntSub<Minus<N>> for Zero<M> where
    M: IntSub<N>, 

type Output = Plus<<M as IntSub<N>>::Output>

impl<N: Int> IntMul<Term> for Zero<N>

type Output = Term

impl<N: Int> IntMul<Undefined> for Zero<N>

type Output = Undefined

impl<M: Int, N: Int> IntMul<Zero<N>> for Zero<M> where
    M: IntMul<Zero<Zero<N>>>, 

type Output = <M as IntMul<Zero<Zero<N>>>>::Output

impl<M: Int, N: Int> IntMul<Plus<N>> for Zero<M> where
    M: IntMul<Zero<Plus<M>>>, 

type Output = <M as IntMul<Zero<Plus<M>>>>::Output

impl<M: Int, N: Int> IntMul<Minus<N>> for Zero<M> where
    M: IntMul<Zero<Minus<N>>>, 

type Output = <M as IntMul<Zero<Minus<N>>>>::Output

impl<N: Int, L: Int, E: Int, G: Int> IntCmp<Term, L, E, G> for Zero<N> where
    N: IntCmp<Term, L, E, G>, 

type Output = <N as IntCmp<Term, L, E, G>>::Output

impl<M: Int, N: Int, L: Int, E: Int, G: Int> IntCmp<Zero<N>, L, E, G> for Zero<M> where
    M: IntCmp<N, L, E, G>, 

type Output = <M as IntCmp<N, L, E, G>>::Output

impl<M: Int, N: Int, L: Int, E: Int, G: Int> IntCmp<Plus<N>, L, E, G> for Zero<M> where
    M: IntCmp<N, L, L, G>, 

type Output = <M as IntCmp<N, L, L, G>>::Output

impl<M: Int, N: Int, L: Int, E: Int, G: Int> IntCmp<Minus<N>, L, E, G> for Zero<M> where
    M: IntCmp<N, L, G, G>, 

type Output = <M as IntCmp<N, L, G, G>>::Output

impl<N: Int, L: IntPair, E: IntPair, G: IntPair> IntCmp2<Term, L, E, G> for Zero<N> where
    N: IntCmp2<Term, L, E, G>, 

type Output = <N as IntCmp2<Term, L, E, G>>::Output

impl<M: Int, N: Int, L: IntPair, E: IntPair, G: IntPair> IntCmp2<Zero<N>, L, E, G> for Zero<M> where
    M: IntCmp2<N, L, E, G>, 

type Output = <M as IntCmp2<N, L, E, G>>::Output

impl<M: Int, N: Int, L: IntPair, E: IntPair, G: IntPair> IntCmp2<Plus<N>, L, E, G> for Zero<M> where
    M: IntCmp2<N, L, L, G>, 

type Output = <M as IntCmp2<N, L, L, G>>::Output

impl<M: Int, N: Int, L: IntPair, E: IntPair, G: IntPair> IntCmp2<Minus<N>, L, E, G> for Zero<M> where
    M: IntCmp2<N, L, G, G>, 

type Output = <M as IntCmp2<N, L, G, G>>::Output

impl<X: Int> IntAbs for Zero<X> where
    Term: IntLteCmp<Zero<X>, Zero<X>, <Zero<X> as IntNeg>::Output>,
    Zero<X>: IntNeg, 

type Output = <Term as IntLteCmp<Zero<X>, Zero<X>, <Zero<X> as IntNeg>::Output>>::Output

impl<M: Int, N: Int> IntRevInternal<N> for Zero<M> where
    M: IntRevInternal<Zero<N>>, 

type Output = <M as IntRevInternal<Zero<N>>>::Output

impl<N: Int, D: Int> IntDiv<Zero<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Zero<D>, Int2<Term, Term>>>::Output: Int2P2,
    <Zero<N> as IntRev>::Output: IntDivInternal<Zero<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Zero<D>, Int2<Term, Term>>>::Output as Int2P2>::Output

impl<N: Int, D: Int> IntDiv<Plus<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Plus<D>, Int2<Term, Term>>>::Output: Int2P2,
    <Zero<N> as IntRev>::Output: IntDivInternal<Plus<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Plus<D>, Int2<Term, Term>>>::Output as Int2P2>::Output

impl<N: Int, D: Int> IntDiv<Minus<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Minus<D>, Int2<Term, Term>>>::Output: Int2P2,
    <Zero<N> as IntRev>::Output: IntDivInternal<Minus<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Minus<D>, Int2<Term, Term>>>::Output as Int2P2>::Output

impl<N: Int, D: Int> IntRem<Zero<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Zero<D>, Int2<Term, Term>>>::Output: Int2P1,
    <Zero<N> as IntRev>::Output: IntDivInternal<Zero<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Zero<D>, Int2<Term, Term>>>::Output as Int2P1>::Output

impl<N: Int, D: Int> IntRem<Plus<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Plus<D>, Int2<Term, Term>>>::Output: Int2P1,
    <Zero<N> as IntRev>::Output: IntDivInternal<Plus<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Plus<D>, Int2<Term, Term>>>::Output as Int2P1>::Output

impl<N: Int, D: Int> IntRem<Minus<D>> for Zero<N> where
    <<Zero<N> as IntRev>::Output as IntDivInternal<Minus<D>, Int2<Term, Term>>>::Output: Int2P1,
    <Zero<N> as IntRev>::Output: IntDivInternal<Minus<D>, Int2<Term, Term>>,
    Zero<N>: IntRev, 

type Output = <<<Zero<N> as IntRev>::Output as IntDivInternal<Minus<D>, Int2<Term, Term>>>::Output as Int2P1>::Output

impl<N: Int, D: Int, R: Int, Q: Int> IntDivInternal<D, Int2<R, Q>> for Zero<N> where
    N: IntDivInternal<D, <<R as IntTriple>::Output as IntAbsMinThreeCmp<<<R as IntTriple>::Output as IntSub<D>>::Output, <<R as IntTriple>::Output as IntAdd<D>>::Output, <Q as IntTriple>::Output, Plus<Q>, Minus<Q>>>::Output>,
    <R as IntTriple>::Output: IntAbsMinThreeCmp<<<R as IntTriple>::Output as IntSub<D>>::Output, <<R as IntTriple>::Output as IntAdd<D>>::Output, <Q as IntTriple>::Output, Plus<Q>, Minus<Q>>,
    R: IntTriple,
    <R as IntTriple>::Output: IntSub<D>,
    R: IntTriple,
    <R as IntTriple>::Output: IntAdd<D>,
    R: IntTriple,
    Q: IntTriple, 

type Output = <N as IntDivInternal<D, <<R as IntTriple>::Output as IntAbsMinThreeCmp<<<R as IntTriple>::Output as IntSub<D>>::Output, <<R as IntTriple>::Output as IntAdd<D>>::Output, <Q as IntTriple>::Output, Plus<Q>, Minus<Q>>>::Output>>::Output