Struct type_level_logic::types::balanced::Minus

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

Trait Implementations

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

fn default() -> Minus<X>

Returns the "default value" for a type.

impl<X: Int> Int for Minus<X>

fn reify() -> isize

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

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

impl<N: Int> IntPred for Minus<N> where
    N: IntPred, 

type Output = Plus<<N as IntPred>::Output>

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

type Output = Zero<Minus<N>>

impl<N: Int> Unique for Minus<N>

type Output = Minus<N>

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

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

impl<N: Int> IntAdd<Term> for Minus<N>

type Output = Minus<N>

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

type Output = Undefined

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

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

impl<M: Int, N: Int> IntAdd<Plus<N>> for Minus<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<Minus<N>> for Minus<M> where
    <M as IntAdd<N>>::Output: IntAdd<Minus>,
    M: IntAdd<N>, 

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

impl<N: Int> IntSub<Term> for Minus<N>

type Output = Minus<N>

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

type Output = Undefined

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

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

impl<M: Int, N: Int> IntSub<Plus<N>> for Minus<M> where
    <M as IntSub<N>>::Output: IntSub<Plus>,
    M: IntSub<N>, 

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

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

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

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

type Output = Term

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

type Output = Undefined

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

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

impl<M: Int, N: Int> IntMul<Plus<N>> for Minus<M> where
    <M as IntMul<Zero<Plus<N>>>>::Output: IntSub<Plus<N>>,
    M: IntMul<Zero<Plus<N>>>, 

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

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

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

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

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

impl<M: Int, N: Int, L: Int, E: Int, G: Int> IntCmp<Zero<N>, L, E, G> for Minus<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<Plus<N>, L, E, G> for Minus<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 Minus<M> where
    M: IntCmp<N, L, E, G>, 

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

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

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

impl<M: Int, N: Int, L: IntPair, E: IntPair, G: IntPair> IntCmp2<Zero<N>, L, E, G> for Minus<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<Plus<N>, L, E, G> for Minus<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 Minus<M> where
    M: IntCmp2<N, L, E, G>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Output = <<<Minus<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 Minus<N> where
    N: IntDivInternal<D, <Minus<R> as IntAbsMinThreeCmp<<Minus<R> as IntSub<D>>::Output, <Minus<R> as IntAdd<D>>::Output, <Q as IntTriple>::Output, Plus<Q>, Minus<Q>>>::Output>,
    Minus<R>: IntAbsMinThreeCmp<<Minus<R> as IntSub<D>>::Output, <Minus<R> as IntAdd<D>>::Output, <Q as IntTriple>::Output, Plus<Q>, Minus<Q>>,
    Minus<R>: IntSub<D>,
    Minus<R>: IntAdd<D>,
    Q: IntTriple, 

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