[−][src]Struct structural::StrucWrapper
A wrapper type alternative to StructuralExt
,
with methods for accessing fields in structural types.
Example: Struct
use structural::{StrucWrapper, Structural, fp}; use structural::structural_aliases::Array3; let mut this=Point{x:3, y:5, z:8}; let mut tuple=(13,21,34); rotate_tuple(&mut this); rotate_tuple(&mut tuple); assert_eq!( this, Point{x:8, y:3, z:5} ); assert_eq!( tuple, (34,13,21) ); fn rotate_tuple(tuple: &mut dyn Array3<u32>){ use std::mem::swap; let mut tuple=StrucWrapper(tuple); let (a,b,c)=tuple.muts(fp!(0,1,2)); swap(b,c); swap(a,b); } #[derive(Debug,Structural,PartialEq)] struct Point{ #[struc(rename="0")] pub x: u32, #[struc(rename="1")] pub y: u32, #[struc(rename="2")] pub z: u32, }
Example: Enum
use structural::{StrucWrapper, Structural, fp}; assert_eq!( get_value(States::Initial), 1 ); assert_eq!( get_value(States::Open{how_much: 10}), 160+2 ); assert_eq!( get_value(States::Closed), 3 ); assert_eq!( get_value(UberStates::Initial), 1 ); assert_eq!( get_value(UberStates::Open{how_much: 10, throughput: 14}), 160+2 ); assert_eq!( get_value(UberStates::Open{how_much: 20, throughput: 55}), 320+2 ); assert_eq!( get_value(UberStates::Closed), 3 ); // `States_SI` was declared by the `Structural` derive macro on // the `States` enum,aliasing its accessor trait impls. fn get_value(this: impl States_SI)-> u64 { let this=StrucWrapper(this); if this.is_variant(fp!(Initial)) { 1 }else if let Some(how_much)= this.r(fp!(::Open.how_much)) { 2 + ((*how_much as u64) << 4) }else if this.is_variant(fp!(Closed)) { 3 }else{ 0 } } // This function is equivalent to `get_value` // // `States_SI` was declared by the `Structural` derive macro on // the `States` enum,aliasing its accessor trait impls. fn get_value_switch(this: impl States_SI)-> u64 { structural::switch!{ref this; Initial=>1, Open{&how_much}=>2 + ((how_much as u64) << 4), Closed=>3, _=>0, } } #[derive(Structural)] enum States{ Initial, Open{how_much: u32}, Closed, } #[derive(Structural)] enum UberStates{ Initial, Open{ how_much: u32, throughput: u64, }, Closed, }
Implementations
impl<T> StrucWrapper<T>
[src]
pub fn r<'a, P>(
&'a self,
path: P
) -> NormalizeFieldsOut<Result<&'a P::Ty, P::Err>> where
P: RevGetFieldImpl<'a, T>,
Result<&'a P::Ty, P::Err>: NormalizeFields,
[src]
&'a self,
path: P
) -> NormalizeFieldsOut<Result<&'a P::Ty, P::Err>> where
P: RevGetFieldImpl<'a, T>,
Result<&'a P::Ty, P::Err>: NormalizeFields,
Gets a reference to a single field,determined by path
.
This function is equivalent to StructuralExt::field_
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, fp}; use structural::structural_aliases::Array5; assertions((0,0,13,0,34)); assertions((0,0,13,0,34,"")); assertions((0,0,13,0,34,"",false)); assertions([0,0,13,0,34]); assertions([0,0,13,0,34,0]); assertions([0,0,13,0,34,0,0]); fn assertions(this: impl Array5<u64>){ let mut this=StrucWrapper(this); assert_eq!( this.r(fp!(2)), &13 ); assert_eq!( this.r(fp!(4)), &34 ); }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{ EnumWithNewtype, EnumWithoutNewtype, EnumWithNewtype_SI, RefWrapper, }; assertions(EnumWithNewtype::U32(RefWrapper(0x100, &43370))); assertions(EnumWithoutNewtype::U32(0x100, &43370)); // `EnumWithNewtype_SI` was declared by the `Structural` derive macro on // the `EnumWithNewtype` enum,aliasing its accessor trait impls. fn assertions<'a>(this: impl EnumWithNewtype_SI<'a>){ let mut this=StrucWrapper(this); assert_eq!( this.r(fp!(::U32.0)), Some(&0x100) ); assert_eq!( this.r(fp!(::U32.1)), Some(&&43370) ); assert_eq!( this.r(fp!(::U64.0)), None ); }
pub fn m<'a, P>(
&'a mut self,
path: P
) -> NormalizeFieldsOut<Result<&'a mut P::Ty, P::Err>> where
P: RevGetFieldMutImpl<'a, T>,
Result<&'a mut P::Ty, P::Err>: NormalizeFields,
[src]
&'a mut self,
path: P
) -> NormalizeFieldsOut<Result<&'a mut P::Ty, P::Err>> where
P: RevGetFieldMutImpl<'a, T>,
Result<&'a mut P::Ty, P::Err>: NormalizeFields,
Gets a mutable reference to a single field,determined by path
.
This function is equivalent to StructuralExt::field_mut
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, Structural, fp, make_struct}; assertions(Puck{name:"John", surname:"Chickenbert"}); assertions(make_struct!{ #![derive(Debug,Copy,Clone)] name:"John", surname:"Chickenbert" }); // `Puck_SI` was declared by the `Structural` derive macro on the Puck struct, // aliasing its accessor trait impls. fn assertions(this: impl Puck_SI + Copy){ let mut this=StrucWrapper(this); assert_eq!( this.m(fp!(name)), &mut "John" ); assert_eq!( this.m(fp!(surname)), &mut "Chickenbert" ); } #[derive(Structural,Copy,Clone)] pub struct Puck{ pub name: &'static str, pub surname: &'static str, }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{ EnumWithNewtype, EnumWithoutNewtype, EnumWithNewtype_SI, RefWrapper, }; assertions(EnumWithNewtype::U32(RefWrapper(0x100, &43370))); assertions(EnumWithoutNewtype::U32(0x100, &43370)); // `EnumWithNewtype_SI` was declared by the `Structural` derive macro on // the `EnumWithNewtype` enum,aliasing its accessor trait impls. fn assertions<'a>(this: impl EnumWithNewtype_SI<'a>){ let mut this=StrucWrapper(this); assert_eq!( this.m(fp!(::U32.0)), Some(&mut 0x100) ); assert_eq!( this.m(fp!(::U32.1)), Some(&mut &43370) ); assert_eq!( this.m(fp!(::U64.0)), None ); }
pub fn v<P>(self, path: P) -> NormalizeFieldsOut<Result<P::Ty, P::Err>> where
P: RevIntoFieldImpl<T>,
P::Ty: Sized,
Result<P::Ty, P::Err>: NormalizeFields,
[src]
P: RevIntoFieldImpl<T>,
P::Ty: Sized,
Result<P::Ty, P::Err>: NormalizeFields,
Converts this into a single field by value,determined by path
.
This function is equivalent to StructuralExt::into_field
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, Structural, fp, make_struct}; assertions(Puck{name:"John", surname:"Chickenbert"}); assertions(make_struct!{ #![derive(Debug,Copy,Clone)] name:"John", surname:"Chickenbert" }); // `Puck_SI` was declared by the `Structural` derive macro on the Puck struct, // aliasing its accessor trait impls. fn assertions(this: impl Puck_SI + Copy){ let this=StrucWrapper(this); assert_eq!( this.v(fp!(name)), "John" ); assert_eq!( this.v(fp!(surname)), "Chickenbert" ); } #[derive(Structural,Copy,Clone)] pub struct Puck{ pub name: &'static str, pub surname: &'static str, }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{WithBoom, WithBoom_SI, Bomb}; assertions(WithBoom::Boom{a:"#eh#", b:&[5,8,13]}); assertions( Bomb::Boom{a:"#eh#", b:&[5,8,13]}); // `WithBoom_SI` was declared by the `Structural` derive macro on the `WithBoom` enum, // aliasing its accessor trait impls. fn assertions(this: impl WithBoom_SI + Copy){ let this=StrucWrapper(this); assert_eq!( this.v(fp!(::Boom.a)), Some("#eh#") ); assert_eq!( this.v(fp!(::Boom.b)), Some(&[5,8,13][..]) ); assert!( this.v(fp!(::Nope)).is_none() ); }
pub fn refs<'a, P>(&'a self, path: P) -> RevGetMultiFieldOut<'a, P, T> where
P: RevGetMultiField<'a, T>,
[src]
P: RevGetMultiField<'a, T>,
Gets references to multiple fields,determined by path
.
This function is equivalent to StructuralExt::fields
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, fp, make_struct}; use structural::for_examples::{Struct2, Struct2_SI, Struct3}; assertions(Struct2{foo:Some("&"), bar:(true,false)}); assertions(Struct3{foo:Some("&"), bar:(true,false), baz:&[()]}); assertions(make_struct!{foo:Some("&"), bar:(true,false), boom:()}); // `Struct2_SI` was declared by the `Structural` derive macro on the Struct2 struct, // aliasing its accessor trait impls. fn assertions(this: impl Struct2_SI<&'static str, (bool,bool)>){ let this=StrucWrapper(this); assert_eq!( this.refs(fp!(foo,bar)), (&Some("&"), &(true,false)) ); }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{WithBoom, WithBoom_SI, Bomb}; assertions(WithBoom::Boom{a:"#eh#", b:&[5,8,13]}); assertions( Bomb::Boom{a:"#eh#", b:&[5,8,13]}); // `WithBoom_SI` was declared by the `Structural` derive macro on the `WithBoom` enum, // aliasing its accessor trait impls. fn assertions(this: impl WithBoom_SI){ let this=StrucWrapper(this); assert_eq!( this.refs(fp!(::Boom=>a,b)), Some((&"#eh#", &&[5,8,13][..])) ); assert!( this.refs(fp!(::Nope=>)).is_none() ); }
pub fn clones<'a, P>(
&'a self,
path: P
) -> ClonedOut<RevGetMultiFieldOut<'a, P, T>> where
P: RevGetMultiField<'a, T>,
RevGetMultiFieldOut<'a, P, T>: Cloned,
[src]
&'a self,
path: P
) -> ClonedOut<RevGetMultiFieldOut<'a, P, T>> where
P: RevGetMultiField<'a, T>,
RevGetMultiFieldOut<'a, P, T>: Cloned,
Gets clones of multiple fields,determined by path
.
This function is equivalent to StructuralExt::cloned_fields
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, fp, make_struct}; use structural::for_examples::{Struct2, Struct2_SI, Struct3}; assertions(Struct2{foo:Some("&"), bar:(true,false)}); assertions(Struct3{foo:Some("&"), bar:(true,false), baz:&[()]}); assertions(make_struct!{foo:Some("&"), bar:(true,false), boom:()}); fn assertions(this: impl Struct2_SI<&'static str, (bool,bool)>){ let this=StrucWrapper(this); assert_eq!( this.clones(fp!(foo,bar)), (Some("&"), (true,false)) ); }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{Enum2, Enum2_SI, Enum3, Enum4}; use std::cmp::Ordering; assertions(Enum2::Bar(Ordering::Less, Some(1337))); assertions(Enum3::Bar(Ordering::Less, Some(1337))); assertions(Enum4::Bar(Ordering::Less, Some(1337))); fn assertions(this: impl Enum2_SI){ let this=StrucWrapper(this); assert_eq!( this.clones(fp!(::Bar=>0,1)), Some((Ordering::Less, Some(1337))) ); assert_eq!( this.clones(fp!(::Foo=>0,1)), None ); }
pub fn muts<'a, P>(&'a mut self, path: P) -> RevGetMultiFieldMutOut<'a, P, T> where
P: RevGetMultiFieldMut<'a, T>,
[src]
P: RevGetMultiFieldMut<'a, T>,
Gets mutable references to multiple fields,determined by path
.
This function is equivalent to StructuralExt::fields_mut
,
which has more complete examples.
Example: Struct
use structural::{StrucWrapper, fp}; use structural::structural_aliases::Array5; assertions((0,0,8,0,21)); assertions((0,0,8,0,21,"")); assertions((0,0,8,0,21,"",false)); assertions([0,0,8,0,21]); assertions([0,0,8,0,21,0]); assertions([0,0,8,0,21,0,0]); fn assertions(this: impl Array5<u64>){ let mut this=StrucWrapper(this); assert_eq!( this.muts(fp!(2,4)), (&mut 8, &mut 21) ); }
Example: Enum
use structural::{StrucWrapper, fp}; use structural::for_examples::{Enum2, Enum2_SI, Enum3, Enum4}; assertions(Enum2::Foo(27, 81)); assertions(Enum3::Foo(27, 81)); assertions(Enum4::Foo(27, 81)); fn assertions(this: impl Enum2_SI){ let mut this=StrucWrapper(this); assert_eq!( this.muts(fp!(::Foo=>0,1)), Some((&mut 27, &mut 81)) ); assert_eq!( this.muts(fp!(::Bar=>0)), None ); }
pub fn vals<P>(self, path: P) -> RevIntoMultiFieldOut<P, T> where
P: RevIntoMultiField<T>,
[src]
P: RevIntoMultiField<T>,
Converts this into multiple fields by value, determined by path.
This function is equivalent to StructuralExt::into_fields
,
which has more complete documentation.
Valid Paths
As opposed to the other multiple fields accessor methods, this method only accepts field paths that refer to multiple non-nested fields inside some value (possibly a nested field itself).
For examples of valid and invalid paths to pass as parameter look here.
Example: Struct
use structural::{StrucWrapper, Structural, fp, make_struct}; assert_eq!( into_parts(Bicycle{ frame: Frame("wheeee"), wheels: [Wheel("first"), Wheel("second")], handle_bar: HandleBar("hands on me"), }), (Frame("wheeee"), [Wheel("first"), Wheel("second")], HandleBar("hands on me")) ); assert_eq!( into_parts(make_struct!{ frame: Frame("frame"), wheels: [Wheel("1"), Wheel("4")], handle_bar: HandleBar("9"), }), (Frame("frame"), [Wheel("1"), Wheel("4")], HandleBar("9")) ); // The `Bicycle_SI` was generated for the `Bicycle` struct by the `Structural` derive, // aliasing it's accessor traits fn into_parts(this: impl Bicycle_SI)-> (Frame, [Wheel;2], HandleBar) { let this = StrucWrapper(this); this.vals(fp!(frame, wheels, handle_bar)) } #[derive(Structural,Debug,Copy,Clone,PartialEq)] struct Bicycle{ pub frame: Frame, pub wheels: [Wheel;2], pub handle_bar: HandleBar, }
Example: Enum
use structural::{StrucWrapper, Structural, TS, fp, make_struct}; let human=Human{name: "bob".into(), gold: 600}; assert_eq!( enum_into_human(Entities::Human(human.clone())), Some(human.clone()) ); assert_eq!( enum_into_human(MoreEntities::Human{name: "John".into(), gold: 1234}), Some(Human{name: "John".into(), gold: 1234}) ); // The `Human_VSI` trait was generated for `Human` by the `Structural` derive macro, // to access variants with the same fields as Human. // The `TS!(Human)` argument makes it require the variant to be `Human`. fn enum_into_human(this: impl Human_VSI<TS!(Human)>)-> Option<Human> { let this= StrucWrapper(this); let (name, gold)= this.vals(fp!(::Human=>name,gold))?; Some(Human{name, gold}) } #[derive(Structural, Clone, Debug, PartialEq)] pub struct Human{ pub name: String, pub gold: u64, } #[derive(Structural, Clone, Debug, PartialEq)] pub enum Entities { #[struc(newtype(bounds = "Human_VSI<@variant>"))] Human(Human), Wolf, } #[derive(Structural, Clone, Debug, PartialEq)] pub enum MoreEntities { Human{ name: String, gold: u64, }, Wolf, Cat, Dog, }
pub fn is_variant<P>(&self, _path: P) -> bool where
P: IsTStr,
T: IsVariant<P>,
[src]
P: IsTStr,
T: IsVariant<P>,
Queries whether an enum is a particular variant.
This function is equivalent to StructuralExt::is_variant
.
Example
use structural::{StrucWrapper, Structural, fp}; assertions( EnumOne::Bar, EnumOne::Baz{x:0, y:100}, EnumOne::Qux("hello", "world"), ); assertions(EnumTwo::Bar, EnumTwo::Baz, EnumTwo::Qux); fn assertions<T>(bar: T, baz: T, qux: T) where T: EnumTwo_SI { let bar=StrucWrapper(bar); let baz=StrucWrapper(baz); let qux=StrucWrapper(qux); assert!( bar.is_variant(fp!(Bar)) ); assert!( baz.is_variant(fp!(Baz)) ); assert!( qux.is_variant(fp!(Qux)) ); } #[derive(Structural)] enum EnumOne{ Bar, Baz{ x:u32, y:u32, }, Qux(&'static str, &'static str), } #[derive(Structural)] enum EnumTwo{ Bar, Baz, Qux, }
pub fn into_struc<U>(self) -> U where
T: IntoStructural<U>,
[src]
T: IntoStructural<U>,
Converts this into another structural type,using IntoStructural
.
Struct Example
use structural::{ for_examples::{StructFoo, StructBar}, FP, IntoField, StrucWrapper, make_struct, }; assert_eq!( into_foo(make_struct!{foo: 100}), StructFoo{foo: 100} ); assert_eq!( into_foo(make_struct!{foo: 200}), StructFoo{foo: 200} ); assert_eq!( into_bar(make_struct!{bar: 3}), StructBar{bar: 3} ); assert_eq!( into_bar(make_struct!{bar: 5}), StructBar{bar: 5} ); fn into_foo<T>(this: T)->StructFoo<T::Ty> where T: IntoField<FP!(foo)> { let this=StrucWrapper(this); this.into_struc() } fn into_bar<T>(this: T)->StructBar<T::Ty> where T: IntoField<FP!(bar)> { let this=StrucWrapper(this); this.into_struc() }
Enum Example
use structural::{ convert::{EmptyTryFromError, FromStructural, TryFromError, TryFromStructural}, for_examples::Enum3, Structural, StrucWrapper, make_struct, switch, }; use std::cmp::Ordering; assert_eq!( into_v(Enum3::Foo(3, 8)), NoPayload::Foo ); assert_eq!( into_v(Enum3::Bar(Ordering::Less, None)), NoPayload::Bar ); assert_eq!( into_v(Enum3::Baz{foom: "what"}), NoPayload::Baz ); assert_eq!( into_v(WithPayload::Foo(13)), NoPayload::Foo ); assert_eq!( into_v(WithPayload::Bar(21)), NoPayload::Bar ); assert_eq!( into_v(WithPayload::Baz(34)), NoPayload::Baz ); assert_eq!( into_v(NoPayload::Foo), NoPayload::Foo ); assert_eq!( into_v(NoPayload::Bar), NoPayload::Bar ); assert_eq!( into_v(NoPayload::Baz), NoPayload::Baz ); // `NoPayload_ESI` was generated by the `Structural` derive macro for `NoPayload`, // aliasing its accessor trait impls. fn into_v(this: impl NoPayload_ESI)->NoPayload { let this = StrucWrapper(this); this.into_struc() } #[derive(Debug,Structural,PartialEq)] enum WithPayload<T>{ Foo(T), Bar(T), Baz(T), } #[derive(Debug,Structural,PartialEq)] enum NoPayload{ Foo, Bar, Baz, } // This macro allows enums to only implement the `TryFromStructural` trait, // delegating the `FromStructural` trait to it. structural::z_impl_try_from_structural_for_enum!{ impl[F] TryFromStructural<F> for NoPayload where[ F: NoPayload_SI, ] { type Error = EmptyTryFromError; fn try_from_structural(this){ switch!{this; Foo => Ok(NoPayload::Foo), Bar => Ok(NoPayload::Bar), Baz => Ok(NoPayload::Baz), _ => Err(TryFromError::with_empty_error(this)), } } } FromStructural where[ F: NoPayload_ESI, ] }
pub fn try_into_struc<U>(self) -> Result<U, TryFromError<T, T::Error>> where
T: TryIntoStructural<U>,
[src]
T: TryIntoStructural<U>,
Performs a fallible conversion into another structural type using TryIntoStructural
.
Enum example
use structural::{ convert::{EmptyTryFromError, TryFromError}, for_examples::ResultLike, Structural, StructuralExt, switch, }; assert_eq!( MoreCommand::Open(Door::Green).try_into_struc::<Command>(), Ok(Command::Open(Door::Green)), ); assert_eq!( MoreCommand::Close(Door::Green).try_into_struc::<Command>(), Ok(Command::Close(Door::Green)), ); let lock_cmd = MoreCommand::Lock(Door::Green, Key(12345678)); assert_eq!( lock_cmd.clone().try_into_struc::<Command>(), Err(TryFromError::with_empty_error(lock_cmd)), ); #[derive(Debug,Clone,Structural,PartialEq)] enum Command{ Open(Door), Close(Door), } #[derive(Debug,Clone,Structural,PartialEq)] enum MoreCommand{ Open(Door), Close(Door), Lock(Door, Key), } // This macro implements FromStructural in terms of TryFromStructural, structural::z_impl_try_from_structural_for_enum!{ impl[F] TryFromStructural<F> for Command where[ F: Command_SI, ] { type Error = EmptyTryFromError; fn try_from_structural(this){ switch! {this; Open(door) => Ok(Self::Open(door)), Close(door) => Ok(Self::Close(door)), _ => Err(TryFromError::with_empty_error(this)), } } } // `Command_ESI` was generated by the `Structural` derive for `Command` // aliasing its accessor trait impls, // and requires `F` to only have the `Open`,and `Close` variants. FromStructural where[ F: Command_ESI, ] }
impl<T> StrucWrapper<T>
[src]
pub fn as_ref(&self) -> StrucWrapper<&T>
[src]
Turns a &StrucWrapper<T>
into a StrucWrapper<&T>
.
Example
use structural::{Structural, StrucWrapper, fp, make_struct}; { let this= StrucWrapper(Struct3{foo:Some(13), bar:21, baz:"34"}); with_struct3(this.as_ref()); // Because of the `.as_ref()`,`this` wasn't consumed with_struct3(this.as_ref()); } { let this= StrucWrapper(make_struct!{foo:Some(13), bar:21, baz:"34", quax:false}); with_struct3(this.as_ref()); // Because of the `.as_ref()`,`this` wasn't consumed with_struct3(this.as_ref()); } // The `Struct3_SI` trait was declared for Struct3 by the Structural derive macro, // aliasing its accessor trait impls // // Also, notice how this also requires `Copy`,even though Struct3 doesn't implement it? // The call with Struct3 works because of the `.as_ref()`, // since `&` always implements `Copy`. fn with_struct3(this: StrucWrapper<impl Struct3_SI<u8, u16, &'static str> + Copy>){ assert_eq!( this.r(fp!(foo?)), Some(&13) ); assert_eq!( this.r(fp!(bar)), &21 ); assert_eq!( this.r(fp!(baz)), &"34" ); } #[derive(Structural, Debug)] // With this attribute, you can only access fields by shared reference. #[struc(access="ref")] pub struct Struct3<A, B, C> { pub foo: Option<A>, pub bar: B, pub baz: C, }
pub fn as_mut(&mut self) -> StrucWrapper<&mut T>
[src]
Turns a &mut StrucWrapper<T>
into a StrucWrapper<&mut T>
.
Turns a &StrucWrapper<T>
into a StrucWrapper<&T>
.
Example
use structural::{Structural, StrucWrapper, fp, make_struct}; { let mut this= StrucWrapper(Struct3{foo:Some(13), bar:21, baz:"34"}); with_struct3(this.as_mut()); // Because of the `.as_mut()`,`this` wasn't consumed with_struct3(this.as_mut()); } { let mut this= StrucWrapper(make_struct!{foo:Some(13), bar:21, baz:"34", quax:false}); with_struct3(this.as_mut()); // Because of the `.as_mut()`,`this` wasn't consumed with_struct3(this.as_mut()); } // The `Struct3_SI` trait was declared for Struct3 by the Structural derive macro, // aliasing its accessor trait impls fn with_struct3(mut this: StrucWrapper<impl Struct3_SI<u8, u16, &'static str>>){ assert_eq!( this.r(fp!(foo?)), Some(&13) ); assert_eq!( this.r(fp!(bar)), &21 ); assert_eq!( this.r(fp!(baz)), &"34" ); assert_eq!( this.m(fp!(foo?)), Some(&mut 13) ); assert_eq!( this.m(fp!(bar)), &mut 21 ); assert_eq!( this.m(fp!(baz)), &mut "34" ); } #[derive(Structural, Debug)] // With this attribute, you can only access fields by shared or mutable reference. #[struc(access="mut")] pub struct Struct3<A, B, C> { pub foo: Option<A>, pub bar: B, pub baz: C, }
pub fn map<F, U>(self, f: F) -> StrucWrapper<U> where
F: FnOnce(T) -> U,
[src]
F: FnOnce(T) -> U,
Transforms the wrapped value with the func
function.
pub fn then<F, U>(self, f: F) -> StrucWrapper<U> where
F: FnOnce(Self) -> U,
[src]
F: FnOnce(Self) -> U,
Calls func
with self
,rewrapping its return value in a StrucWrapper<U>
impl<T: Clone, '_> StrucWrapper<&'_ T>
[src]
pub fn cloned(self) -> StrucWrapper<T>
[src]
Maps the wrapped reference into a clone.
impl<T: Clone, '_> StrucWrapper<&'_ mut T>
[src]
pub fn cloned(self) -> StrucWrapper<T>
[src]
Maps the wrapped mutable reference into a clone.
impl<'a, T> StrucWrapper<&'a T>
[src]
pub fn reref(self) -> &'a StrucWrapper<T>
[src]
Turns a StrucWrapper<&T>
into a &StrucWrapper<T>
.
Note that this only works if T: Sized
,
which means that you can't call this method on a StrucWrapper<&dyn Trait>
.
impl<'a, T> StrucWrapper<&'a mut T>
[src]
pub fn remut(self) -> &'a mut StrucWrapper<T>
[src]
Turns a StrucWrapper<&mut T>
into a &mut StrucWrapper<T>
.
Note that this only works if T: Sized
,
which means that you can't call this method on a StrucWrapper<&mut dyn Trait>
.
Trait Implementations
impl<T: Clone> Clone for StrucWrapper<T>
[src]
fn clone(&self) -> StrucWrapper<T>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T> ConstDefault for StrucWrapper<T> where
T: ConstDefault,
[src]
T: ConstDefault,
impl<T: Copy> Copy for StrucWrapper<T>
[src]
impl<T: Debug> Debug for StrucWrapper<T>
[src]
impl<T: Default> Default for StrucWrapper<T>
[src]
fn default() -> StrucWrapper<T>
[src]
impl<T> DropFields for StrucWrapper<T> where
T: DropFields,
[src]
T: DropFields,
fn pre_move(&mut self)
[src]
unsafe fn drop_fields(&mut self, moved: MovedOutFields)
[src]
impl<T: Eq> Eq for StrucWrapper<T>
[src]
impl<T, NP, __Ty> FieldType<NP> for StrucWrapper<T> where
T: FieldType<NP, Ty = __Ty>,
[src]
T: FieldType<NP, Ty = __Ty>,
type Ty = GetFieldType<T, NP>
The type of the FieldPath
field.
impl<T, __From> FromStructural<__From> for StrucWrapper<T> where
T: FromStructural<__From>,
[src]
T: FromStructural<__From>,
fn from_structural(from: __From) -> Self
[src]
impl<T, __F, __Ty> GetField<__F> for StrucWrapper<T> where
T: GetField<__F, Ty = __Ty>,
[src]
T: GetField<__F, Ty = __Ty>,
fn get_field_(&self, fname: __F) -> &__Ty
[src]
impl<T, __F, __Ty> GetFieldMut<__F> for StrucWrapper<T> where
StrucWrapper<T>: Sized,
T: GetFieldMut<__F, Ty = __Ty>,
[src]
StrucWrapper<T>: Sized,
T: GetFieldMut<__F, Ty = __Ty>,
fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty
[src]
unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty where
Self: Sized,
[src]
Self: Sized,
fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>
[src]
impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for StrucWrapper<T> where
T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,
[src]
T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,
fn get_vfield_(
&self,
vname: TStr<__V>,
fname: __F
) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>
[src]
&self,
vname: TStr<__V>,
fname: __F
) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>
unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty
[src]
impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for StrucWrapper<T> where
StrucWrapper<T>: Sized,
T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,
[src]
StrucWrapper<T>: Sized,
T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,
fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>
[src]
unsafe fn get_vfield_raw_mut_(
this: *mut (),
vname: TStr<__V>,
fname: __F
) -> Option<NonNull<__Ty>> where
Self: Sized,
[src]
this: *mut (),
vname: TStr<__V>,
fname: __F
) -> Option<NonNull<__Ty>> where
Self: Sized,
fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>
[src]
fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>
[src]
unsafe fn get_vfield_mut_unchecked(
&mut self,
variant: V,
field: F
) -> &mut Self::Ty
[src]
&mut self,
variant: V,
field: F
) -> &mut Self::Ty
unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty where
Self: Sized,
V: ConstDefault,
[src]
Self: Sized,
V: ConstDefault,
impl<T: Hash> Hash for StrucWrapper<T>
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<F, T> Index<F> for StrucWrapper<T> where
T: GetField<F>,
[src]
T: GetField<F>,
Gets a reference to a non-nested struct field
Example
use structural::{StrucWrapper, fp}; use structural::structural_aliases::Array4; assertions(["hello","world","foo","bar"]); assertions(["hello","world","foo","bar","baz"]); assertions(("hello","world","foo","bar")); assertions(("hello","world","foo","bar","baz")); assertions(("hello","world","foo","bar","baz","qux")); fn assertions(this: impl Array4<&'static str> ){ let this=StrucWrapper(this); assert_eq!( this[fp!(1)], "world" ); assert_eq!( this[fp!(2)], "foo" ); assert_eq!( this[fp!(3)], "bar" ); }
impl<F, T> IndexMut<F> for StrucWrapper<T> where
T: GetFieldMut<F>,
[src]
T: GetFieldMut<F>,
Gets a mutable reference to a non-nested struct field
Example
use structural::{StructuralExt, StrucWrapper, fp, make_struct}; use structural::for_examples::{Struct3, Struct3_SI}; let mut this=Struct3{ foo:Some(33), bar:55, baz:77 }; let mut anon=make_struct!{ foo:Some(0), bar:0, baz:0, extra:"extra" }; fn mutator(this:&mut impl Struct3_SI<u32,u32,u32>){ let mut this=StrucWrapper(this); this[fp!(bar)]+=20; this[fp!(baz)]+=30; } mutator(&mut this); mutator(&mut anon); assert_eq!( this.cloned_fields(fp!(foo, bar, baz)), (Some(33), 75, 107) ); assert_eq!( anon.cloned_fields(fp!(foo, bar, baz, extra)), (Some(0), 20, 30, "extra") );
impl<T, __F, __Ty> IntoField<__F> for StrucWrapper<T> where
T: IntoField<__F, Ty = __Ty>,
[src]
T: IntoField<__F, Ty = __Ty>,
fn into_field_(self, fname: __F) -> __Ty
[src]
unsafe fn move_out_field_(
&mut self,
fname: __F,
moved: &mut MovedOutFields
) -> __Ty
[src]
&mut self,
fname: __F,
moved: &mut MovedOutFields
) -> __Ty
impl<T, __V, __F, __Ty> IntoVariantField<TStr<__V>, __F> for StrucWrapper<T> where
T: IntoVariantField<TStr<__V>, __F, Ty = __Ty>,
[src]
T: IntoVariantField<TStr<__V>, __F, Ty = __Ty>,
fn into_vfield_(self, vname: TStr<__V>, fname: __F) -> Option<__Ty>
[src]
unsafe fn move_out_vfield_(
&mut self,
vname: TStr<__V>,
fname: __F,
moved: &mut MovedOutFields
) -> Option<__Ty>
[src]
&mut self,
vname: TStr<__V>,
fname: __F,
moved: &mut MovedOutFields
) -> Option<__Ty>
unsafe fn into_vfield_unchecked_(
self,
variant_name: V,
field_name: F
) -> Self::Ty where
Self: Sized,
[src]
self,
variant_name: V,
field_name: F
) -> Self::Ty where
Self: Sized,
unsafe fn move_out_vfield_unchecked_(
&mut self,
variant_name: V,
field_name: F,
moved_fields: &mut MovedOutFields
) -> Self::Ty
[src]
&mut self,
variant_name: V,
field_name: F,
moved_fields: &mut MovedOutFields
) -> Self::Ty
impl<T, __V> IsVariant<TStr<__V>> for StrucWrapper<T> where
T: IsVariant<TStr<__V>>,
[src]
T: IsVariant<TStr<__V>>,
fn is_variant_(&self, name: TStr<__V>) -> bool
[src]
impl<T: Ord> Ord for StrucWrapper<T>
[src]
fn cmp(&self, other: &StrucWrapper<T>) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T: PartialEq> PartialEq<StrucWrapper<T>> for StrucWrapper<T>
[src]
fn eq(&self, other: &StrucWrapper<T>) -> bool
[src]
fn ne(&self, other: &StrucWrapper<T>) -> bool
[src]
impl<T: PartialOrd> PartialOrd<StrucWrapper<T>> for StrucWrapper<T>
[src]
fn partial_cmp(&self, other: &StrucWrapper<T>) -> Option<Ordering>
[src]
fn lt(&self, other: &StrucWrapper<T>) -> bool
[src]
fn le(&self, other: &StrucWrapper<T>) -> bool
[src]
fn gt(&self, other: &StrucWrapper<T>) -> bool
[src]
fn ge(&self, other: &StrucWrapper<T>) -> bool
[src]
impl<T> Structural for StrucWrapper<T> where
T: Structural,
[src]
T: Structural,
impl<T> StructuralEq for StrucWrapper<T>
[src]
impl<T> StructuralPartialEq for StrucWrapper<T>
[src]
impl<T, __From, __Err> TryFromStructural<__From> for StrucWrapper<T> where
T: TryFromStructural<__From, Error = __Err>,
[src]
T: TryFromStructural<__From, Error = __Err>,
type Error = __Err
The error parameter of TryFromError
, returned from try_into_structural
on conversion error. Read more
fn try_from_structural(
from: __From
) -> Result<Self, TryFromError<__From, __Err>>
[src]
from: __From
) -> Result<Self, TryFromError<__From, __Err>>
impl<T> VariantCount for StrucWrapper<T> where
T: VariantCount,
[src]
T: VariantCount,
type Count = VariantCountOut<T>
This is a TStr (eg:TS!(3)
) representing the amount of variants of the enum. Read more
Auto Trait Implementations
impl<T> RefUnwindSafe for StrucWrapper<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Send for StrucWrapper<T> where
T: Send,
T: Send,
impl<T> Sync for StrucWrapper<T> where
T: Sync,
T: Sync,
impl<T> Unpin for StrucWrapper<T> where
T: Unpin,
T: Unpin,
impl<T> UnwindSafe for StrucWrapper<T> where
T: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<This, T> Array0<T> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<This, V, T> Array0Variant<T, V> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<This, T> Array1<T> for This where
This: IntoFieldMut<TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
impl<This, T> Array10<T> for This where
This: IntoFieldMut<TStr<__TS<(__8,)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__9,)>>> + Array_0_8<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__8,)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__9,)>>> + Array_0_8<T> + ?Sized,
impl<This, V, T> Array10Variant<T, V> for This where
This: ArrayVariant_0_8<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + ?Sized,
[src]
This: ArrayVariant_0_8<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + ?Sized,
impl<This, T> Array11<T> for This where
This: IntoFieldMut<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + ?Sized,
impl<This, V, T> Array11Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + ?Sized,
impl<This, T> Array12<T> for This where
This: IntoFieldMut<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + ?Sized,
impl<This, V, T> Array12Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + ?Sized,
impl<This, T> Array13<T> for This where
This: Array_0_8<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + ?Sized,
[src]
This: Array_0_8<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + ?Sized,
impl<This, V, T> Array13Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + ?Sized,
impl<This, T> Array14<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + IntoFieldMut<TStr<__TS<(__1, __3)>>> + Array_0_8<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__8,)>>> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + IntoFieldMut<TStr<__TS<(__1, __3)>>> + Array_0_8<T> + ?Sized,
impl<This, V, T> Array14Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __3)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __3)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + ?Sized,
impl<This, T> Array15<T> for This where
This: IntoFieldMut<TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + IntoFieldMut<TStr<__TS<(__1, __3)>>> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __4)>>> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __1)>>> + IntoFieldMut<TStr<__TS<(__1, __2)>>> + IntoFieldMut<TStr<__TS<(__9,)>>> + IntoFieldMut<TStr<__TS<(__1, __3)>>> + Array_0_8<T> + IntoFieldMut<TStr<__TS<(__1, __4)>>> + IntoFieldMut<TStr<__TS<(__1, __0)>>> + ?Sized,
impl<This, V, T> Array15Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __3)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __4)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_0_8<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __2)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __3)>>> + IntoVariantFieldMut<V, TStr<__TS<(__9,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __4)>>> + ?Sized,
impl<This, T> Array16<T> for This where
This: Array_8_16<T> + ?Sized,
[src]
This: Array_8_16<T> + ?Sized,
impl<This, V, T> Array16Variant<T, V> for This where
This: ArrayVariant_8_16<T, V> + ?Sized,
[src]
This: ArrayVariant_8_16<T, V> + ?Sized,
impl<This, T> Array17<T> for This where
This: Array_8_16<T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: Array_8_16<T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, V, T> Array17Variant<T, V> for This where
This: ArrayVariant_8_16<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: ArrayVariant_8_16<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, T> Array18<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + Array_8_16<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + Array_8_16<T> + ?Sized,
impl<This, V, T> Array18Variant<T, V> for This where
This: ArrayVariant_8_16<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + ?Sized,
[src]
This: ArrayVariant_8_16<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + ?Sized,
impl<This, T> Array19<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, V, T> Array19Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + ?Sized,
impl<This, V, T> Array1Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
impl<This, T> Array2<T> for This where
This: IntoFieldMut<TStr<__TS<(__1,)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__0,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1,)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__0,)>>> + ?Sized,
impl<This, T> Array20<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + ?Sized,
impl<This, V, T> Array20Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, T> Array21<T> for This where
This: Array_8_16<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + ?Sized,
[src]
This: Array_8_16<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + ?Sized,
impl<This, V, T> Array21Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + ?Sized,
impl<This, T> Array22<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __1)>>> + Array_8_16<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __6)>>> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __1)>>> + Array_8_16<T> + ?Sized,
impl<This, V, T> Array22Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + ?Sized,
impl<This, T> Array23<T> for This where
This: IntoFieldMut<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __1)>>> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__2, __2)>>> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1, __9)>>> + IntoFieldMut<TStr<__TS<(__2, __0)>>> + IntoFieldMut<TStr<__TS<(__1, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __1)>>> + Array_8_16<T> + IntoFieldMut<TStr<__TS<(__2, __2)>>> + IntoFieldMut<TStr<__TS<(__1, __8)>>> + ?Sized,
impl<This, V, T> Array23Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __2)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_8_16<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__1, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __6)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __2)>>> + ?Sized,
impl<This, T> Array24<T> for This where
This: Array_16_24<T> + ?Sized,
[src]
This: Array_16_24<T> + ?Sized,
impl<This, V, T> Array24Variant<T, V> for This where
This: ArrayVariant_16_24<T, V> + ?Sized,
[src]
This: ArrayVariant_16_24<T, V> + ?Sized,
impl<This, T> Array25<T> for This where
This: Array_16_24<T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: Array_16_24<T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, V, T> Array25Variant<T, V> for This where
This: ArrayVariant_16_24<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: ArrayVariant_16_24<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, T> Array26<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + Array_16_24<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + Array_16_24<T> + ?Sized,
impl<This, V, T> Array26Variant<T, V> for This where
This: ArrayVariant_16_24<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + ?Sized,
[src]
This: ArrayVariant_16_24<T, V, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + ?Sized,
impl<This, T> Array27<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, V, T> Array27Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + ?Sized,
impl<This, T> Array28<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + ?Sized,
impl<This, V, T> Array28Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, T> Array29<T> for This where
This: Array_16_24<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + ?Sized,
[src]
This: Array_16_24<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + ?Sized,
impl<This, V, T> Array29Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + ?Sized,
impl<This, V, T> Array2Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + ?Sized,
impl<This, T> Array3<T> for This where
This: IntoFieldMut<TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + ?Sized,
impl<This, T> Array30<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + ?Sized,
impl<This, V, T> Array30Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + ?Sized,
impl<This, T> Array31<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__3, __0)>>> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __7)>>> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__3, __0)>>> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + ?Sized,
impl<This, V, T> Array31Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __0)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayVariant_16_24<T, V> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __0)>>> + ?Sized,
impl<This, T> Array32<T> for This where
This: IntoFieldMut<TStr<__TS<(__2, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__3, __0)>>> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__3, __1)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2, __8)>>> + IntoFieldMut<TStr<__TS<(__2, __5)>>> + IntoFieldMut<TStr<__TS<(__2, __9)>>> + Array_16_24<T> + IntoFieldMut<TStr<__TS<(__3, __0)>>> + IntoFieldMut<TStr<__TS<(__2, __6)>>> + IntoFieldMut<TStr<__TS<(__3, __1)>>> + IntoFieldMut<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, V, T> Array32Variant<T, V> for This where
This: ArrayVariant_16_24<T, V, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ?Sized,
[src]
This: ArrayVariant_16_24<T, V, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2, __7)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __4)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __8)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __9)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __5)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __0)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3, __1)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2, __6)>>> + ?Sized,
impl<This, V, T> Array3Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + ?Sized,
impl<This, T> Array4<T> for This where
This: IntoFieldMut<TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2,)>>> + IntoFieldMut<TStr<__TS<(__3,)>>> + IntoFieldMut<TStr<__TS<(__1,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__2,)>>> + IntoFieldMut<TStr<__TS<(__3,)>>> + IntoFieldMut<TStr<__TS<(__1,)>>> + ?Sized,
impl<This, V, T> Array4Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + ?Sized,
impl<This, T> Array5<T> for This where
This: IntoFieldMut<TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__3,)>>> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__3,)>>> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + ?Sized,
impl<This, V, T> Array5Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + ?Sized,
impl<This, T> Array6<T> for This where
This: IntoFieldMut<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__5,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__5,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + ?Sized,
impl<This, V, T> Array6Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__5,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__0,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__5,)>>> + ?Sized,
impl<This, T> Array7<T> for This where
This: IntoFieldMut<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__5,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + IntoFieldMut<TStr<__TS<(__6,)>>> + ?Sized,
[src]
This: IntoFieldMut<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__1,)>>> + IntoFieldMut<TStr<__TS<(__4,)>>> + IntoFieldMut<TStr<__TS<(__0,)>>> + IntoFieldMut<TStr<__TS<(__5,)>>> + IntoFieldMut<TStr<__TS<(__2,)>>> + IntoFieldMut<TStr<__TS<(__6,)>>> + ?Sized,
impl<This, V, T> Array7Variant<T, V> for This where
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__5,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__6,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + ?Sized,
[src]
This: IntoVariantFieldMut<V, TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__3,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__4,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__1,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__5,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__6,)>>> + IntoVariantFieldMut<V, TStr<__TS<(__2,)>>> + ?Sized,
impl<This, T> Array8<T> for This where
This: Array_0_8<T> + ?Sized,
[src]
This: Array_0_8<T> + ?Sized,
impl<This, V, T> Array8Variant<T, V> for This where
This: ArrayVariant_0_8<T, V> + ?Sized,
[src]
This: ArrayVariant_0_8<T, V> + ?Sized,
impl<This, T> Array9<T> for This where
This: Array_0_8<T, Ty = T> + IntoFieldMut<TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: Array_0_8<T, Ty = T> + IntoFieldMut<TStr<__TS<(__8,)>>> + ?Sized,
impl<This, V, T> Array9Variant<T, V> for This where
This: ArrayVariant_0_8<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: ArrayVariant_0_8<T, V, Ty = T> + IntoVariantFieldMut<V, TStr<__TS<(__8,)>>> + ?Sized,
impl<This, T> ArrayMove0<T> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<This, T> ArrayMove1<T> for This where
This: IntoField<TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__0,)>>, Ty = T> + ?Sized,
impl<This, T> ArrayMove10<T> for This where
This: IntoField<TStr<__TS<(__8,)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__9,)>>> + ArrayMove_0_8<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__8,)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__9,)>>> + ArrayMove_0_8<T> + ?Sized,
impl<This, T> ArrayMove11<T> for This where
This: IntoField<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + ?Sized,
impl<This, T> ArrayMove12<T> for This where
This: IntoField<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__9,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + ?Sized,
impl<This, T> ArrayMove13<T> for This where
This: ArrayMove_0_8<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + ?Sized,
[src]
This: ArrayMove_0_8<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __0)>>> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + ?Sized,
impl<This, T> ArrayMove14<T> for This where
This: IntoField<TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + IntoField<TStr<__TS<(__1, __3)>>> + ArrayMove_0_8<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __0)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__8,)>>> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + IntoField<TStr<__TS<(__1, __3)>>> + ArrayMove_0_8<T> + ?Sized,
impl<This, T> ArrayMove15<T> for This where
This: IntoField<TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + IntoField<TStr<__TS<(__1, __3)>>> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __4)>>> + IntoField<TStr<__TS<(__1, __0)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__8,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __1)>>> + IntoField<TStr<__TS<(__1, __2)>>> + IntoField<TStr<__TS<(__9,)>>> + IntoField<TStr<__TS<(__1, __3)>>> + ArrayMove_0_8<T> + IntoField<TStr<__TS<(__1, __4)>>> + IntoField<TStr<__TS<(__1, __0)>>> + ?Sized,
impl<This, T> ArrayMove16<T> for This where
This: ArrayMove_8_16<T> + ?Sized,
[src]
This: ArrayMove_8_16<T> + ?Sized,
impl<This, T> ArrayMove17<T> for This where
This: ArrayMove_8_16<T, Ty = T> + IntoField<TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: ArrayMove_8_16<T, Ty = T> + IntoField<TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, T> ArrayMove18<T> for This where
This: IntoField<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __7)>>> + ArrayMove_8_16<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __7)>>> + ArrayMove_8_16<T> + ?Sized,
impl<This, T> ArrayMove19<T> for This where
This: IntoField<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + ?Sized,
impl<This, T> ArrayMove2<T> for This where
This: IntoField<TStr<__TS<(__1,)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__0,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1,)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__0,)>>> + ?Sized,
impl<This, T> ArrayMove20<T> for This where
This: IntoField<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + ?Sized,
impl<This, T> ArrayMove21<T> for This where
This: ArrayMove_8_16<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + ?Sized,
[src]
This: ArrayMove_8_16<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __8)>>> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + ?Sized,
impl<This, T> ArrayMove22<T> for This where
This: IntoField<TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + IntoField<TStr<__TS<(__2, __1)>>> + ArrayMove_8_16<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __8)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __6)>>> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + IntoField<TStr<__TS<(__2, __1)>>> + ArrayMove_8_16<T> + ?Sized,
impl<This, T> ArrayMove23<T> for This where
This: IntoField<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + IntoField<TStr<__TS<(__2, __1)>>> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__2, __2)>>> + IntoField<TStr<__TS<(__1, __8)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1, __9)>>> + IntoField<TStr<__TS<(__2, __0)>>> + IntoField<TStr<__TS<(__1, __7)>>> + IntoField<TStr<__TS<(__2, __1)>>> + ArrayMove_8_16<T> + IntoField<TStr<__TS<(__2, __2)>>> + IntoField<TStr<__TS<(__1, __8)>>> + ?Sized,
impl<This, T> ArrayMove24<T> for This where
This: ArrayMove_16_24<T> + ?Sized,
[src]
This: ArrayMove_16_24<T> + ?Sized,
impl<This, T> ArrayMove25<T> for This where
This: ArrayMove_16_24<T, Ty = T> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: ArrayMove_16_24<T, Ty = T> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, T> ArrayMove26<T> for This where
This: IntoField<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __5)>>> + ArrayMove_16_24<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __5)>>> + ArrayMove_16_24<T> + ?Sized,
impl<This, T> ArrayMove27<T> for This where
This: IntoField<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, T> ArrayMove28<T> for This where
This: IntoField<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __5)>>, Ty = T, Ty = T, Ty = T, Ty = T> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + ?Sized,
impl<This, T> ArrayMove29<T> for This where
This: ArrayMove_16_24<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + ?Sized,
[src]
This: ArrayMove_16_24<T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + ?Sized,
impl<This, T> ArrayMove3<T> for This where
This: IntoField<TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__2,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__1,)>>, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__2,)>>> + ?Sized,
impl<This, T> ArrayMove30<T> for This where
This: IntoField<TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __6)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __4)>>> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + ?Sized,
impl<This, T> ArrayMove31<T> for This where
This: IntoField<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__3, __0)>>> + IntoField<TStr<__TS<(__2, __6)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __4)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __7)>>> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__3, __0)>>> + IntoField<TStr<__TS<(__2, __6)>>> + ?Sized,
impl<This, T> ArrayMove32<T> for This where
This: IntoField<TStr<__TS<(__2, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__3, __0)>>> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__3, __1)>>> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2, __7)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2, __8)>>> + IntoField<TStr<__TS<(__2, __5)>>> + IntoField<TStr<__TS<(__2, __9)>>> + ArrayMove_16_24<T> + IntoField<TStr<__TS<(__3, __0)>>> + IntoField<TStr<__TS<(__2, __6)>>> + IntoField<TStr<__TS<(__3, __1)>>> + IntoField<TStr<__TS<(__2, __4)>>> + ?Sized,
impl<This, T> ArrayMove4<T> for This where
This: IntoField<TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2,)>>> + IntoField<TStr<__TS<(__3,)>>> + IntoField<TStr<__TS<(__1,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__0,)>>, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__2,)>>> + IntoField<TStr<__TS<(__3,)>>> + IntoField<TStr<__TS<(__1,)>>> + ?Sized,
impl<This, T> ArrayMove5<T> for This where
This: IntoField<TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__3,)>>> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__2,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__3,)>>> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + ?Sized,
impl<This, T> ArrayMove6<T> for This where
This: IntoField<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__5,)>>> + IntoField<TStr<__TS<(__2,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__5,)>>> + IntoField<TStr<__TS<(__2,)>>> + ?Sized,
impl<This, T> ArrayMove7<T> for This where
This: IntoField<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__5,)>>> + IntoField<TStr<__TS<(__2,)>>> + IntoField<TStr<__TS<(__6,)>>> + ?Sized,
[src]
This: IntoField<TStr<__TS<(__3,)>>, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T, Ty = T> + IntoField<TStr<__TS<(__1,)>>> + IntoField<TStr<__TS<(__4,)>>> + IntoField<TStr<__TS<(__0,)>>> + IntoField<TStr<__TS<(__5,)>>> + IntoField<TStr<__TS<(__2,)>>> + IntoField<TStr<__TS<(__6,)>>> + ?Sized,
impl<This, T> ArrayMove8<T> for This where
This: ArrayMove_0_8<T> + ?Sized,
[src]
This: ArrayMove_0_8<T> + ?Sized,
impl<This, T> ArrayMove9<T> for This where
This: ArrayMove_0_8<T, Ty = T> + IntoField<TStr<__TS<(__8,)>>> + ?Sized,
[src]
This: ArrayMove_0_8<T, Ty = T> + IntoField<TStr<__TS<(__8,)>>> + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<This, F> IntoFieldMut<F> for This where
This: IntoField<F> + GetFieldMut<F> + ?Sized,
[src]
This: IntoField<F> + GetFieldMut<F> + ?Sized,
impl<This, T> IntoStructural<T> for This where
T: FromStructural<This>,
[src]
T: FromStructural<This>,
fn into_structural(Self) -> T
[src]
impl<This, V, F> IntoVariantFieldMut<V, F> for This where
This: GetVariantFieldMut<V, F> + IntoVariantField<V, F> + ?Sized,
[src]
This: GetVariantFieldMut<V, F> + IntoVariantField<V, F> + ?Sized,
impl<T, __This> OptionMove_ESI<T> for __This where
__This: OptionMove_SI<T> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
[src]
__This: OptionMove_SI<T> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
impl<T, __This> OptionMove_SI<T> for __This where
__This: IsVariant<TStr<__TS<(__S, __o, __m, __e)>>> + IntoVariantField<TStr<__TS<(__S, __o, __m, __e)>>, TStr<__TS<(__0,)>>, Ty = T> + IsVariant<TStr<__TS<(__N, __o, __n, __e)>>> + ?Sized,
[src]
__This: IsVariant<TStr<__TS<(__S, __o, __m, __e)>>> + IntoVariantField<TStr<__TS<(__S, __o, __m, __e)>>, TStr<__TS<(__0,)>>, Ty = T> + IsVariant<TStr<__TS<(__N, __o, __n, __e)>>> + ?Sized,
impl<T, __This> Option_SI<T> for __This where
__This: IsVariant<TStr<__TS<(__S, __o, __m, __e)>>> + IntoVariantFieldMut<TStr<__TS<(__S, __o, __m, __e)>>, TStr<__TS<(__0,)>>, Ty = T> + IsVariant<TStr<__TS<(__N, __o, __n, __e)>>> + ?Sized,
[src]
__This: IsVariant<TStr<__TS<(__S, __o, __m, __e)>>> + IntoVariantFieldMut<TStr<__TS<(__S, __o, __m, __e)>>, TStr<__TS<(__0,)>>, Ty = T> + IsVariant<TStr<__TS<(__N, __o, __n, __e)>>> + ?Sized,
impl<T, __This> RangeFrom_SI<T> for __This where
__This: IntoFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>, Ty = T> + ?Sized,
[src]
__This: IntoFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>, Ty = T> + ?Sized,
impl<T, __This> RangeRef_SI<T> for __This where
__This: GetField<TStr<__TS<(__e, __n, __d)>>, Ty = T, Ty = T> + GetField<TStr<__TS<(__s, __t, __a, __r, __t)>>> + ?Sized,
[src]
__This: GetField<TStr<__TS<(__e, __n, __d)>>, Ty = T, Ty = T> + GetField<TStr<__TS<(__s, __t, __a, __r, __t)>>> + ?Sized,
impl<T, __This> RangeTo_SI<T> for __This where
__This: IntoFieldMut<TStr<__TS<(__e, __n, __d)>>, Ty = T> + ?Sized,
[src]
__This: IntoFieldMut<TStr<__TS<(__e, __n, __d)>>, Ty = T> + ?Sized,
impl<T, __This> Range_SI<T> for __This where
__This: IntoFieldMut<TStr<__TS<(__e, __n, __d)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>> + ?Sized,
[src]
__This: IntoFieldMut<TStr<__TS<(__e, __n, __d)>>, Ty = T, Ty = T> + IntoFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>> + ?Sized,
impl<T, E, __This> ResultMove_ESI<T, E> for __This where
__This: ResultMove_SI<T, E> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
[src]
__This: ResultMove_SI<T, E> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
impl<T, E, __This> ResultMove_SI<T, E> for __This where
__This: IsVariant<TStr<__TS<(__O, __k)>>> + IntoVariantField<TStr<__TS<(__O, __k)>>, TStr<__TS<(__0,)>>, Ty = T, Ty = E> + IsVariant<TStr<__TS<(__E, __r, __r)>>> + IntoVariantField<TStr<__TS<(__E, __r, __r)>>, TStr<__TS<(__0,)>>> + ?Sized,
[src]
__This: IsVariant<TStr<__TS<(__O, __k)>>> + IntoVariantField<TStr<__TS<(__O, __k)>>, TStr<__TS<(__0,)>>, Ty = T, Ty = E> + IsVariant<TStr<__TS<(__E, __r, __r)>>> + IntoVariantField<TStr<__TS<(__E, __r, __r)>>, TStr<__TS<(__0,)>>> + ?Sized,
impl<T, E, __This> Result_ESI<T, E> for __This where
__This: Result_SI<T, E> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
[src]
__This: Result_SI<T, E> + VariantCount<Count = TStr<__TS<(__2,)>>> + ?Sized,
impl<T, E, __This> Result_SI<T, E> for __This where
__This: IsVariant<TStr<__TS<(__O, __k)>>> + IntoVariantFieldMut<TStr<__TS<(__O, __k)>>, TStr<__TS<(__0,)>>, Ty = T, Ty = E> + IsVariant<TStr<__TS<(__E, __r, __r)>>> + IntoVariantFieldMut<TStr<__TS<(__E, __r, __r)>>, TStr<__TS<(__0,)>>> + ?Sized,
[src]
__This: IsVariant<TStr<__TS<(__O, __k)>>> + IntoVariantFieldMut<TStr<__TS<(__O, __k)>>, TStr<__TS<(__0,)>>, Ty = T, Ty = E> + IsVariant<TStr<__TS<(__E, __r, __r)>>> + IntoVariantFieldMut<TStr<__TS<(__E, __r, __r)>>, TStr<__TS<(__0,)>>> + ?Sized,
impl<T> SelfOps for T where
T: ?Sized,
[src]
T: ?Sized,
const T: PhantomData<fn() -> Self>
[src]
const T_D: PhantomData<Self>
[src]
fn assert_ty(self, _other: PhantomData<fn() -> Self>) -> Self
[src]
fn assert_ty_ref(&self, _other: PhantomData<fn() -> Self>) -> &Self
[src]
fn assert_ty_mut(&mut self, _other: PhantomData<fn() -> Self>) -> &mut Self
[src]
fn ty_(&self) -> PhantomData<fn() -> Self>
[src]
fn ty_d(&self) -> PhantomData<Self>
[src]
fn ty_inv(&self) -> PhantomData<fn(Self) -> Self>
[src]
fn ty_inv_ref(&self) -> PhantomData<Cell<&Self>>
[src]
fn eq_id(&self, other: &Self) -> bool
[src]
fn piped<F, U>(self, f: F) -> U where
F: FnOnce(Self) -> U,
[src]
F: FnOnce(Self) -> U,
fn piped_ref<'a, F, U>(&'a self, f: F) -> U where
F: FnOnce(&'a Self) -> U,
[src]
F: FnOnce(&'a Self) -> U,
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U where
F: FnOnce(&'a mut Self) -> U,
[src]
F: FnOnce(&'a mut Self) -> U,
fn mutated<F>(self, f: F) -> Self where
F: FnOnce(&mut Self),
[src]
F: FnOnce(&mut Self),
fn observe<F>(self, f: F) -> Self where
F: FnOnce(&Self),
[src]
F: FnOnce(&Self),
fn into_<T>(self, PhantomData<fn() -> T>) -> T where
Self: Into<T>,
[src]
Self: Into<T>,
fn as_ref_<T>(&self) -> &T where
Self: AsRef<T>,
T: ?Sized,
[src]
Self: AsRef<T>,
T: ?Sized,
fn as_mut_<T>(&mut self) -> &mut T where
Self: AsMut<T>,
T: ?Sized,
[src]
Self: AsMut<T>,
T: ?Sized,
fn drop_(self)
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut 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, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The error type returned when the conversion fails.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<This, T> TryIntoStructural<T> for This where
T: TryFromStructural<This>,
[src]
T: TryFromStructural<This>,
type Error = <T as TryFromStructural<This>>::Error
The error parameter of TryFromError
, returned from try_into_structural
on conversion error. Read more
fn try_into_structural(
Self
) -> Result<T, TryFromError<This, <This as TryIntoStructural<T>>::Error>>
[src]
Self
) -> Result<T, TryFromError<This, <This as TryIntoStructural<T>>::Error>>
impl<T> TypeIdentity for T where
T: ?Sized,
[src]
T: ?Sized,
type Type = T
The same type as Self. Read more
fn into_type_val(self) -> Self::Type where
Self::Type: Sized,
[src]
Self::Type: Sized,
fn into_type_ref(&self) -> &Self::Type
[src]
fn into_type_mut(&mut self) -> &mut Self::Type
[src]
fn into_type_box(self: Box<Self>) -> Box<Self::Type>ⓘImportant traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Important traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>
[src]
fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>
[src]
fn from_type_val(this: Self::Type) -> Self where
Self::Type: Sized,
[src]
Self::Type: Sized,
fn from_type_ref(this: &Self::Type) -> &Self
[src]
fn from_type_mut(this: &mut Self::Type) -> &mut Self
[src]
fn from_type_box(this: Box<Self::Type>) -> Box<Self>ⓘImportant traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;
[src]
Important traits for Box<R>
impl<R> Read for Box<R> where
R: Read + ?Sized, impl<W> Write for Box<W> where
W: Write + ?Sized, impl<F> Future for Box<F> where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<I> Iterator for Box<I> where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;