Trait bevy::reflect::Tuple[−]

pub trait Tuple: Reflect {
    fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>;
    fn field_mut(
        &mut self, 
        index: usize
    ) -> Option<&mut (dyn Reflect + 'static)>;
    fn field_len(&self) -> usize;
    fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>
impl<'a> Iterator for TupleFieldIter<'a>    type Item = &'a (dyn Reflect + 'static);;
    fn clone_dynamic(&self) -> DynamicTuple;
}

Required methods

fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

fn field_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

fn field_len(&self) -> usize

fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

fn clone_dynamic(&self) -> DynamicTuple

Trait Implementations

impl GetTupleField for dyn Tuple + 'static

pub fn get_field<T>(&self, index: usize) -> Option<&T> where
T: Reflect,

pub fn get_field_mut<T>(&mut self, index: usize) -> Option<&mut T> where
T: Reflect,

Implementations on Foreign Types

impl Tuple for ()

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E> Tuple for (A, B, C, D, E) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J> Tuple for (A, B, C, D, E, F, G, H, I, J) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B> Tuple for (A, B) where
A: Reflect,
B: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J, K, L> Tuple for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect,
    K: Reflect,
    L: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I> Tuple for (A, B, C, D, E, F, G, H, I) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A> Tuple for (A,) where
A: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J, K> Tuple for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,
    I: Reflect,
    J: Reflect,
    K: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H> Tuple for (A, B, C, D, E, F, G, H) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,
    H: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D> Tuple for (A, B, C, D) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G> Tuple for (A, B, C, D, E, F, G) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,
    G: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F> Tuple for (A, B, C, D, E, F) where
    A: Reflect,
    B: Reflect,
    C: Reflect,
    D: Reflect,
    E: Reflect,
    F: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C> Tuple for (A, B, C) where
    A: Reflect,
    B: Reflect,
    C: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn clone_dynamic(&self) -> DynamicTuple

Implementors

impl Tuple for DynamicTuple

Trait bevy::reflect::Tuple[−]

Required methods

fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

fn field_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

fn field_len(&self) -> usize

fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

fn clone_dynamic(&self) -> DynamicTuple

Trait Implementations

impl GetTupleField for dyn Tuple + 'static

pub fn get_field<T>(&self, index: usize) -> Option<&T> where T: Reflect,

pub fn get_field_mut<T>(&mut self, index: usize) -> Option<&mut T> where T: Reflect,

Implementations on Foreign Types

impl Tuple for ()

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E> Tuple for (A, B, C, D, E) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J> Tuple for (A, B, C, D, E, F, G, H, I, J) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect, H: Reflect, I: Reflect, J: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B> Tuple for (A, B) where A: Reflect, B: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J, K, L> Tuple for (A, B, C, D, E, F, G, H, I, J, K, L) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect, H: Reflect, I: Reflect, J: Reflect, K: Reflect, L: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I> Tuple for (A, B, C, D, E, F, G, H, I) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect, H: Reflect, I: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A> Tuple for (A,) where A: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H, I, J, K> Tuple for (A, B, C, D, E, F, G, H, I, J, K) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect, H: Reflect, I: Reflect, J: Reflect, K: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G, H> Tuple for (A, B, C, D, E, F, G, H) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect, H: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D> Tuple for (A, B, C, D) where A: Reflect, B: Reflect, C: Reflect, D: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F, G> Tuple for (A, B, C, D, E, F, G) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect, G: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut( &mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘNotable traits for TupleFieldIter<'a>impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);

pub fn clone_dynamic(&self) -> DynamicTuple

impl<A, B, C, D, E, F> Tuple for (A, B, C, D, E, F) where A: Reflect, B: Reflect, C: Reflect, D: Reflect, E: Reflect, F: Reflect,

pub fn field(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

pub fn get_field<T>(&self, index: usize) -> Option<&T> where
T: Reflect,

pub fn get_field_mut<T>(&mut self, index: usize) -> Option<&mut T> where
T: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E> Tuple for (A, B, C, D, E) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G, H, I, J> Tuple for (A, B, C, D, E, F, G, H, I, J) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,
H: Reflect,
I: Reflect,
J: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B> Tuple for (A, B) where
A: Reflect,
B: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G, H, I, J, K, L> Tuple for (A, B, C, D, E, F, G, H, I, J, K, L) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,
H: Reflect,
I: Reflect,
J: Reflect,
K: Reflect,
L: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G, H, I> Tuple for (A, B, C, D, E, F, G, H, I) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,
H: Reflect,
I: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A> Tuple for (A,) where
A: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G, H, I, J, K> Tuple for (A, B, C, D, E, F, G, H, I, J, K) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,
H: Reflect,
I: Reflect,
J: Reflect,
K: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G, H> Tuple for (A, B, C, D, E, F, G, H) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,
H: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D> Tuple for (A, B, C, D) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F, G> Tuple for (A, B, C, D, E, F, G) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,
G: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C, D, E, F> Tuple for (A, B, C, D, E, F) where
A: Reflect,
B: Reflect,
C: Reflect,
D: Reflect,
E: Reflect,
F: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`

impl<A, B, C> Tuple for (A, B, C) where
A: Reflect,
B: Reflect,
C: Reflect,

pub fn field_mut(
&mut self,
index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn iter_fields(&self) -> TupleFieldIter<'_>ⓘ
Notable traits for TupleFieldIter<'a>
`impl<'a> Iterator for TupleFieldIter<'a> type Item = &'a (dyn Reflect + 'static);`