[−][src]Struct type_freak::counter::Next

pub struct Next<Count> where
    Count: Counter,  { /* fields omitted */ }

Represents one more step of Counter.

Trait Implementations

impl<Cnt> Counter for Next<Cnt> where
    Cnt: Counter, [src]

impl<Cnt> CountOp for Next<Cnt> where
    Cnt: Counter + CountOp,
    CountOpOutput<Cnt>: Add<U1>,
    Sum<CountOpOutput<Cnt>, U1>: Unsigned, [src]

type Output = Sum<CountOpOutput<Cnt>, U1>

impl<Key, Value, Target, Index, NonTarget, NonTargetValue, Tail> KVInsertAtOp<Key, Value, Target, Next<Index>> for KVCons<NonTarget, NonTargetValue, Tail> where
    Tail: KVList + KVInsertAtOp<Key, Value, Target, Index>,
    Index: Counter, [src]

type Output = KVCons<NonTarget, NonTargetValue, KVInsertAtOpOutput<Tail, Key, Value, Target, Index>>

impl<Target, Index, NonTarget, Value, Tail> KVRemoveAtOp<Target, Next<Index>> for KVCons<NonTarget, Value, Tail> where
    Index: Counter,
    Tail: KVList + KVRemoveAtOp<Target, Index>, [src]

type Output = KVCons<NonTarget, Value, KVRemoveAtOpOutput<Tail, Target, Index>>

impl<Target, Index, NonTarget, Tail> LIndexOfOp<Target, Next<Index>> for LCons<NonTarget, Tail> where
    Index: Counter,
    Tail: TList + LIndexOfOp<Target, Index>,
    LIndexOfOpOutput<Tail, Target, Index>: Add<B1>,
    Add1<LIndexOfOpOutput<Tail, Target, Index>>: Unsigned, [src]

type Output = Add1<LIndexOfOpOutput<Tail, Target, Index>>

impl<Item, Target, Index, NonTarget, Tail> LInsertAtOp<Item, Target, Next<Index>> for LCons<NonTarget, Tail> where
    Tail: TList + LInsertAtOp<Item, Target, Index>,
    Index: Counter, [src]

type Output = LCons<NonTarget, LInsertAtOpOutput<Tail, Item, Target, Index>>

impl<Target, Index, NonTarget, Tail> LSplitOp<Target, Next<Index>> for LCons<NonTarget, Tail> where
    Index: Counter,
    Tail: TList + LSplitOp<Target, Index>, [src]

type FormerOutput = LCons<NonTarget, LSplitOpFormerOutput<Tail, Target, Index>>

type LatterOutput = LSplitOpLatterOutput<Tail, Target, Index>

impl<Target, Index, NonTarget, Tail> LRemoveAtOp<Target, Next<Index>> for LCons<NonTarget, Tail> where
    Index: Counter,
    Tail: TList + LRemoveAtOp<Target, Index>, [src]

type Output = LCons<NonTarget, LRemoveAtOpOutput<Tail, Target, Index>>

Auto Trait Implementations

impl<Count> Send for Next<Count> where
    Count: Send, 

impl<Count> Sync for Next<Count> where
    Count: Sync, 

impl<Count> Unpin for Next<Count> where
    Count: Unpin, 

impl<Count> RefUnwindSafe for Next<Count> where
    Count: RefUnwindSafe, 

impl<Count> UnwindSafe for Next<Count> where
    Count: UnwindSafe, 

Blanket Implementations

impl<Cond, Output> If<Cond> for Output[src]

type Output = <FirstOfFunctor as Functor<(Output, Cond)>>::Output

impl<Same, Output> IfSame<Same, Same> for Output[src]

type Output = Output

impl<Output> IfPredicate<B1> for Output[src]

type Output = Output

impl<Output> IfNotPredicate<B0> for Output[src]

type Output = Output

impl<TrueOutput, FalseOutput> IfElsePredicate<B1, FalseOutput> for TrueOutput[src]

type Output = TrueOutput

impl<TrueOutput, FalseOutput> IfElsePredicate<B0, FalseOutput> for TrueOutput[src]

type Output = FalseOutput

impl<Lhs, Rhs, Output> IfLess<Lhs, Rhs> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfPredicate<<Lhs as IsLess<Rhs>>::Output>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsLess<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseLess<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfLessOrEqual<Lhs, Rhs> for Output where
    Lhs: IsLessOrEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsLessOrEqual<Rhs>>::Output>,
    <Lhs as IsLessOrEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsLessOrEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseLessOrEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfGreater<Lhs, Rhs> for Output where
    Lhs: IsGreater<Rhs>,
    Output: IfPredicate<<Lhs as IsGreater<Rhs>>::Output>,
    <Lhs as IsGreater<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsGreater<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseGreater<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfGreaterOrEqual<Lhs, Rhs> for Output where
    Lhs: IsGreaterOrEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsGreaterOrEqual<Rhs>>::Output>,
    <Lhs as IsGreaterOrEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsGreaterOrEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseGreaterOrEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsLess<Rhs>,
    Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
    <Lhs as IsLess<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>>::Output

impl<Lhs, Rhs, Output> IfEqual<Lhs, Rhs> for Output where
    Lhs: IsEqual<Rhs>,
    Output: IfPredicate<<Lhs as IsEqual<Rhs>>::Output>,
    <Lhs as IsEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfPredicate<<Lhs as IsEqual<Rhs>>::Output>>::Output

impl<Lhs, Rhs, Output, Else> IfElseEqual<Lhs, Rhs, Else> for Output where
    Lhs: IsEqual<Rhs>,
    Output: IfElsePredicate<<Lhs as IsEqual<Rhs>>::Output, Else>,
    <Lhs as IsEqual<Rhs>>::Output: Boolean, [src]

type Output = <Output as IfElsePredicate<<Lhs as IsEqual<Rhs>>::Output, Else>>::Output

impl<Output> IfZero<B0> for Output[src]

type Output = Output

impl<Output> IfZero<Z0> for Output[src]

type Output = Output

impl<Output> IfZero<UTerm> for Output[src]

type Output = Output

impl<Value, Output> IfNonZero<Value> for Output where
    Value: NonZero, [src]

type Output = Output

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self