Trait IntSub

pub trait IntSub<B: Int>: Int {
    type Output: Int;
}

Integer subtraction. Used as Sub<X, Y> or <X as IntSub<Y>>::Output.

Required Associated Types

type Output: Int

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl IntSub<Term> for Term

type Output = Term

impl IntSub<Term> for Undefined

type Output = Undefined

impl IntSub<Undefined> for Term

type Output = Undefined

impl IntSub<Undefined> for Undefined

type Output = Undefined

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

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

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

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

where <M as IntSub<N>>::Output: IntSub<Minus>, M: IntSub<N> + Int,

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

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

where M: IntSub<N> + Int,

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

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

where <M as IntSub<N>>::Output: IntSub<Plus>, M: IntSub<N> + Int,

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

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

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

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

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

where M: IntSub<N> + Int,

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

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

where M: IntSub<N> + Int,

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

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

where M: IntSub<N> + Int,

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

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

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

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

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

where N: IntNeg + Int,

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

impl<N> IntSub<Plus<N>> for Term

where N: IntNeg + Int,

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

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

type Output = Undefined

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

type Output = Undefined

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

type Output = Minus<N>

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

type Output = Plus<N>

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 Minus<N>

type Output = Undefined

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

type Output = Undefined

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

type Output = Undefined

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

where Zero<N>: IntNeg,

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

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

type Output = Undefined