[−][src]Struct type_freak::list::LCons
Represents an intermediate node.
Methods
impl<Head, Tail> LCons<Head, Tail> where
Tail: TList, [src]
Tail: TList,
Trait Implementations
impl<Target, Value, Tail> Functor<LCons<(Target, Value), Tail>> for KVKeyValueAtFunctor<Target, Current> where
Tail: KVList, [src]
Tail: KVList,
impl<NonTarget, Value, Tail, Target, Index> Functor<LCons<(NonTarget, Value), Tail>> for KVKeyValueAtFunctor<Target, Next<Index>> where
Tail: KVList,
Index: Counter,
KVKeyValueAtFunctor<Target, Index>: Functor<Tail>, [src]
Tail: KVList,
Index: Counter,
KVKeyValueAtFunctor<Target, Index>: Functor<Tail>,
type Output = KVKeyValueAt<Tail, Target, Index>
impl<Func, Head, Tail> Functor<LCons<Head, Tail>> for FMapFunctor<Func> where
Tail: TList,
LCons<Head, Tail>: LMapOp<Func>, [src]
Tail: TList,
LCons<Head, Tail>: LMapOp<Func>,
type Output = LMapOpOutput<LCons<Head, Tail>, Func>
impl<LHead, LTail> Functor<LCons<LHead, LTail>> for ApplicativeFunctor<LNil> where
LTail: TList, [src]
LTail: TList,
impl<LHead, LTail, RHead, RTail> Functor<LCons<LHead, LTail>> for ApplicativeFunctor<LCons<RHead, RTail>> where
LTail: TList,
RTail: TList,
LCons<LHead, LTail>: LMapOp<ApplyToTListFunctor<LCons<RHead, RTail>>>,
LMapOpOutput<LCons<LHead, LTail>, ApplyToTListFunctor<LCons<RHead, RTail>>>: LFoldOp<LNil, LConcatComposeFunctor>, [src]
LTail: TList,
RTail: TList,
LCons<LHead, LTail>: LMapOp<ApplyToTListFunctor<LCons<RHead, RTail>>>,
LMapOpOutput<LCons<LHead, LTail>, ApplyToTListFunctor<LCons<RHead, RTail>>>: LFoldOp<LNil, LConcatComposeFunctor>,
type Output = LFoldOpOutput<LMapOpOutput<LCons<LHead, LTail>, ApplyToTListFunctor<LCons<RHead, RTail>>>, LNil, LConcatComposeFunctor>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceMaxComposeFunctor where
Tail: TList + LFoldOp<Head, MaxComposeFunctor>, [src]
Tail: TList + LFoldOp<Head, MaxComposeFunctor>,
type Output = LFoldOpOutput<Tail, Head, MaxComposeFunctor>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceMinComposeFunctor where
Tail: TList + LFoldOp<Head, MinComposeFunctor>, [src]
Tail: TList + LFoldOp<Head, MinComposeFunctor>,
type Output = LFoldOpOutput<Tail, Head, MinComposeFunctor>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceSumComposeFunctor where
Tail: TList + LFoldOp<Head, SumComposeFunctor>, [src]
Tail: TList + LFoldOp<Head, SumComposeFunctor>,
type Output = LFoldOpOutput<Tail, Head, SumComposeFunctor>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceProdComposeFunctor where
Tail: TList + LFoldOp<Head, ProdComposeFunctor>, [src]
Tail: TList + LFoldOp<Head, ProdComposeFunctor>,
type Output = LFoldOpOutput<Tail, Head, ProdComposeFunctor>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceAllFunctor where
Tail: TList + LFoldOp<Head, AndComposePredicate>,
LFoldOpOutput<Tail, Head, AndComposePredicate>: Boolean, [src]
Tail: TList + LFoldOp<Head, AndComposePredicate>,
LFoldOpOutput<Tail, Head, AndComposePredicate>: Boolean,
type Output = LFoldOpOutput<Tail, Head, AndComposePredicate>
impl<Head, Tail> Functor<LCons<Head, Tail>> for LReduceAnyFunctor where
Tail: TList + LFoldOp<Head, OrComposePredicate>,
LFoldOpOutput<Tail, Head, OrComposePredicate>: Boolean, [src]
Tail: TList + LFoldOp<Head, OrComposePredicate>,
LFoldOpOutput<Tail, Head, OrComposePredicate>: Boolean,
type Output = LFoldOpOutput<Tail, Head, OrComposePredicate>
impl<Index, IRemain, Target, TRemain, Key, Value, Tail> KVRemoveManyOp<LCons<Target, TRemain>, LCons<Index, IRemain>> for KVCons<Key, Value, Tail> where
Index: Counter,
IRemain: TList,
TRemain: TList,
Tail: KVList,
Self: KVRemoveAtOp<Target, Index>,
KVRemoveAtOpOutput<Self, Target, Index>: KVRemoveManyOp<TRemain, IRemain>, [src]
Index: Counter,
IRemain: TList,
TRemain: TList,
Tail: KVList,
Self: KVRemoveAtOp<Target, Index>,
KVRemoveAtOpOutput<Self, Target, Index>: KVRemoveManyOp<TRemain, IRemain>,
type Output = KVRemoveManyOpOutput<KVRemoveAtOpOutput<Self, Target, Index>, TRemain, IRemain>
impl<Func, Head, Tail> LMapOp<Func> for LCons<Head, Tail> where
Func: Functor<Head>,
Tail: TList + LMapOp<Func>, [src]
Func: Functor<Head>,
Tail: TList + LMapOp<Func>,
type Output = LCons<ApplyFunctor<Func, Head>, LMapOpOutput<Tail, Func>>
impl<Init, Func, Head, Tail> LFoldOp<Init, Func> for LCons<Head, Tail> where
Func: Functor<(Init, Head)>,
Tail: TList + LFoldOp<ApplyFunctor<Func, (Init, Head)>, Func>, [src]
Func: Functor<(Init, Head)>,
Tail: TList + LFoldOp<ApplyFunctor<Func, (Init, Head)>, Func>,
type Output = LFoldOpOutput<Tail, ApplyFunctor<Func, (Init, Head)>, Func>
impl<Func, Head, Tail> LFilterOp<Func> for LCons<Head, Tail> where
Func: Functor<Head>,
Tail: TList + LFilterOp<Func>,
Func::Output: Maybe,
MaybeMapFunctor<LPrependToFunctor<LFilterOpOutput<Tail, Func>>>: Functor<ApplyFunctor<Func, Head>>,
UnwrapOrFunctor<LFilterOpOutput<Tail, Func>>: Functor<MaybeMap<ApplyFunctor<Func, Head>, LPrependToFunctor<LFilterOpOutput<Tail, Func>>>>,
UnwrapOr<MaybeMap<ApplyFunctor<Func, Head>, LPrependToFunctor<LFilterOpOutput<Tail, Func>>>, LFilterOpOutput<Tail, Func>>: TList, [src]
Func: Functor<Head>,
Tail: TList + LFilterOp<Func>,
Func::Output: Maybe,
MaybeMapFunctor<LPrependToFunctor<LFilterOpOutput<Tail, Func>>>: Functor<ApplyFunctor<Func, Head>>,
UnwrapOrFunctor<LFilterOpOutput<Tail, Func>>: Functor<MaybeMap<ApplyFunctor<Func, Head>, LPrependToFunctor<LFilterOpOutput<Tail, Func>>>>,
UnwrapOr<MaybeMap<ApplyFunctor<Func, Head>, LPrependToFunctor<LFilterOpOutput<Tail, Func>>>, LFilterOpOutput<Tail, Func>>: TList,
type Output = UnwrapOr<MaybeMap<ApplyFunctor<Func, Head>, LPrependToFunctor<LFilterOpOutput<Tail, Func>>>, LFilterOpOutput<Tail, Func>>
impl<State, Func, Head, Tail> LScanOp<State, Func> for LCons<Head, Tail> where
Func: Functor<(State, Head)>,
Tail: TList + LScanOp<SecondOf<ApplyFunctor<Func, (State, Head)>>, Func>,
FirstOfFunctor: Functor<ApplyFunctor<Func, (State, Head)>>,
SecondOfFunctor: Functor<ApplyFunctor<Func, (State, Head)>>,
ApplyFunctor<Func, (State, Head)>: Pair, [src]
Func: Functor<(State, Head)>,
Tail: TList + LScanOp<SecondOf<ApplyFunctor<Func, (State, Head)>>, Func>,
FirstOfFunctor: Functor<ApplyFunctor<Func, (State, Head)>>,
SecondOfFunctor: Functor<ApplyFunctor<Func, (State, Head)>>,
ApplyFunctor<Func, (State, Head)>: Pair,
type Output = LCons<FirstOf<ApplyFunctor<Func, (State, Head)>>, LScanOpOutput<Tail, Self::State, Func>>
type State = SecondOf<ApplyFunctor<Func, (State, Head)>>
impl<Target, Tail> LIndexOfOp<Target, Current> for LCons<Target, Tail> where
Tail: TList, [src]
Tail: TList,
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]
Index: Counter,
Tail: TList + LIndexOfOp<Target, Index>,
LIndexOfOpOutput<Tail, Target, Index>: Add<B1>,
Add1<LIndexOfOpOutput<Tail, Target, Index>>: Unsigned,
type Output = Add1<LIndexOfOpOutput<Tail, Target, Index>>
impl<List, Index, IRemain, Target, TRemain> LIndexOfManyOp<LCons<Target, TRemain>, LCons<Index, IRemain>> for List where
List: NonEmptyTList,
Index: Counter,
IRemain: TList,
TRemain: TList,
Self: LIndexOfManyOp<TRemain, IRemain> + LIndexOfOp<Target, Index>, [src]
List: NonEmptyTList,
Index: Counter,
IRemain: TList,
TRemain: TList,
Self: LIndexOfManyOp<TRemain, IRemain> + LIndexOfOp<Target, Index>,
type Output = LCons<LIndexOfOpOutput<Self, Target, Index>, LIndexOfManyOpOutput<Self, TRemain, IRemain>>
impl<Item, Head, Tail> LAppendOp<Item> for LCons<Head, Tail> where
Tail: TList + LAppendOp<Item>, [src]
Tail: TList + LAppendOp<Item>,
type Output = LCons<Head, LAppendOpOutput<Tail, Item>>
impl<Target, Item, Tail> LInsertAtOp<Item, Target, Current> for LCons<Target, Tail> where
Tail: TList, [src]
Tail: TList,
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]
Tail: TList + LInsertAtOp<Item, Target, Index>,
Index: Counter,
type Output = LCons<NonTarget, LInsertAtOpOutput<Tail, Item, Target, Index>>
impl<Head, Tail> NonEmptyTList for LCons<Head, Tail> where
Tail: TList, [src]
Tail: TList,
impl<Head, Tail> LLengthOp for LCons<Head, Tail> where
Tail: TList + LLengthOp,
LLengthOpOutput<Tail>: Add<U1>,
Sum<LLengthOpOutput<Tail>, U1>: Unsigned, [src]
Tail: TList + LLengthOp,
LLengthOpOutput<Tail>: Add<U1>,
Sum<LLengthOpOutput<Tail>, U1>: Unsigned,
type Output = Sum<LLengthOpOutput<Tail>, U1>
impl<LHead, LTail, RHead, RTail, Index, IRemain> LSetEqualOp<LCons<RHead, RTail>, LCons<Index, IRemain>> for LCons<LHead, LTail> where
Index: Counter,
IRemain: TList,
LTail: TList,
RTail: TList,
Self: LRemoveAtOp<RHead, Index>,
LRemoveAtOpOutput<Self, RHead, Index>: LSetEqualOp<RTail, IRemain>, [src]
Index: Counter,
IRemain: TList,
LTail: TList,
RTail: TList,
Self: LRemoveAtOp<RHead, Index>,
LRemoveAtOpOutput<Self, RHead, Index>: LSetEqualOp<RTail, IRemain>,
type Output = LSetEqualOpOutput<LRemoveAtOpOutput<Self, RHead, Index>, RTail, IRemain>
impl<Rhs, Head, Tail> LConcatOp<Rhs> for LCons<Head, Tail> where
Rhs: TList,
Tail: TList + LConcatOp<Rhs>, [src]
Rhs: TList,
Tail: TList + LConcatOp<Rhs>,
type Output = LCons<Head, LConcatOpOutput<Tail, Rhs>>
impl<Target, Tail> LSplitOp<Target, Current> for LCons<Target, Tail> where
Tail: TList, [src]
Tail: TList,
type FormerOutput = LNil
type LatterOutput = Self
impl<Target, Index, NonTarget, Tail> LSplitOp<Target, Next<Index>> for LCons<NonTarget, Tail> where
Index: Counter,
Tail: TList + LSplitOp<Target, Index>, [src]
Index: Counter,
Tail: TList + LSplitOp<Target, Index>,
type FormerOutput = LCons<NonTarget, LSplitOpFormerOutput<Tail, Target, Index>>
type LatterOutput = LSplitOpLatterOutput<Tail, Target, Index>
impl<Value, Tail> LToUsizeVec for LCons<Value, Tail> where
Value: Unsigned,
Tail: TList + LToUsizeVec, [src]
Value: Unsigned,
Tail: TList + LToUsizeVec,
fn to_usize_vec() -> Vec<usize>[src]
fn append_usize_vec(values: &mut Vec<usize>)[src]
impl<Target, Tail> LRemoveAtOp<Target, Current> for LCons<Target, Tail> where
Tail: TList, [src]
Tail: TList,
type Output = Tail
impl<Target, Index, NonTarget, Tail> LRemoveAtOp<Target, Next<Index>> for LCons<NonTarget, Tail> where
Index: Counter,
Tail: TList + LRemoveAtOp<Target, Index>, [src]
Index: Counter,
Tail: TList + LRemoveAtOp<Target, Index>,
type Output = LCons<NonTarget, LRemoveAtOpOutput<Tail, Target, Index>>
impl<Index, IRemain, Target, TRemain, Head, Tail> LRemoveManyOp<LCons<Target, TRemain>, LCons<Index, IRemain>> for LCons<Head, Tail> where
Index: Counter,
IRemain: TList,
TRemain: TList,
Tail: TList,
Self: LRemoveAtOp<Target, Index>,
LRemoveAtOpOutput<Self, Target, Index>: LRemoveManyOp<TRemain, IRemain>, [src]
Index: Counter,
IRemain: TList,
TRemain: TList,
Tail: TList,
Self: LRemoveAtOp<Target, Index>,
LRemoveAtOpOutput<Self, Target, Index>: LRemoveManyOp<TRemain, IRemain>,
type Output = LRemoveManyOpOutput<LRemoveAtOpOutput<Self, Target, Index>, TRemain, IRemain>
impl<LHead, LTail, RHead, RTail> LZipOp<LCons<RHead, RTail>> for LCons<LHead, LTail> where
LTail: TList + LZipOp<RTail>,
RTail: TList, [src]
LTail: TList + LZipOp<RTail>,
RTail: TList,
type Output = LCons<(LHead, RHead), LZipOpOutput<LTail, RTail>>
impl<Head, Tail> LZipOp<LNil> for LCons<Head, Tail> where
Tail: TList, [src]
Tail: TList,
impl<Head, Tail> LZipOp<LCons<Head, Tail>> for LNil where
Tail: TList, [src]
Tail: TList,
impl<LHead, RHead, Tail> LUnzipOp for LCons<(LHead, RHead), Tail> where
Tail: TList + LUnzipOp, [src]
Tail: TList + LUnzipOp,
type FormerOutput = LCons<LHead, LUnzipOpFormerOutput<Tail>>
type LatterOutput = LCons<RHead, LUnzipOpLatterOutput<Tail>>
impl<Head, Tail> TList for LCons<Head, Tail> where
Tail: TList, [src]
Tail: TList,
Auto Trait Implementations
impl<Head, Tail> Send for LCons<Head, Tail> where
Head: Send,
Tail: Send,
Head: Send,
Tail: Send,
impl<Head, Tail> Unpin for LCons<Head, Tail> where
Head: Unpin,
Tail: Unpin,
Head: Unpin,
Tail: Unpin,
impl<Head, Tail> Sync for LCons<Head, Tail> where
Head: Sync,
Tail: Sync,
Head: Sync,
Tail: Sync,
impl<Head, Tail> UnwindSafe for LCons<Head, Tail> where
Head: UnwindSafe,
Tail: UnwindSafe,
Head: UnwindSafe,
Tail: UnwindSafe,
impl<Head, Tail> RefUnwindSafe for LCons<Head, Tail> where
Head: RefUnwindSafe,
Tail: RefUnwindSafe,
Head: RefUnwindSafe,
Tail: RefUnwindSafe,
Blanket Implementations
impl<Cond, Output> If<Cond> for Output[src]
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]
Lhs: IsLess<Rhs>,
Output: IfPredicate<<Lhs as IsLess<Rhs>>::Output>,
<Lhs as IsLess<Rhs>>::Output: Boolean,
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]
Lhs: IsLess<Rhs>,
Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
<Lhs as IsLess<Rhs>>::Output: Boolean,
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]
Lhs: IsLessOrEqual<Rhs>,
Output: IfPredicate<<Lhs as IsLessOrEqual<Rhs>>::Output>,
<Lhs as IsLessOrEqual<Rhs>>::Output: Boolean,
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]
Lhs: IsLess<Rhs>,
Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
<Lhs as IsLess<Rhs>>::Output: Boolean,
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]
Lhs: IsGreater<Rhs>,
Output: IfPredicate<<Lhs as IsGreater<Rhs>>::Output>,
<Lhs as IsGreater<Rhs>>::Output: Boolean,
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]
Lhs: IsLess<Rhs>,
Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
<Lhs as IsLess<Rhs>>::Output: Boolean,
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]
Lhs: IsGreaterOrEqual<Rhs>,
Output: IfPredicate<<Lhs as IsGreaterOrEqual<Rhs>>::Output>,
<Lhs as IsGreaterOrEqual<Rhs>>::Output: Boolean,
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]
Lhs: IsLess<Rhs>,
Output: IfElsePredicate<<Lhs as IsLess<Rhs>>::Output, Else>,
<Lhs as IsLess<Rhs>>::Output: Boolean,
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]
Lhs: IsEqual<Rhs>,
Output: IfPredicate<<Lhs as IsEqual<Rhs>>::Output>,
<Lhs as IsEqual<Rhs>>::Output: Boolean,
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]
Lhs: IsEqual<Rhs>,
Output: IfElsePredicate<<Lhs as IsEqual<Rhs>>::Output, Else>,
<Lhs as IsEqual<Rhs>>::Output: Boolean,
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]
Value: NonZero,
type Output = Output
impl<List> KVRemoveManyOp<LNil, LNil> for List where
List: KVList, [src]
List: KVList,
type Output = List
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> From<T> for T[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Same<T> for T[src]
type Output = T
Should always be Self