Struct FieldPathSet

pub struct FieldPathSet<T, U> { /* private fields */ }

A list of field paths to access multiple fields, whose uniqueness is determined by the U type parameter.

This is the type that fp!(a, b.c, ::D.e, ::F) constructs.

Construction

You can construct this using (not an exhaustive list):

• fp macro,when you access multiple fields (using => constructs a NestedFieldPathSet instead).

• The one, many, or large constructors.

• The NEW associated constant,if T implements core_extensions::ConstDefault (reexported in structural::reexports::ConstDefault)

Uniqueness

If the U type parameter is a:

• UniquePaths: all the field paths are unique, and this can be passed to StructuralExt::fields_mut and StructuralExt::into_fields.

• AliasedPaths: there might be repeated field paths. This cannot be passed to StructuralExt::fields_mut, because it might borrow the same field mutably twice. This can also not be passed to StructuralExt::into_fields, because a field cannot generally be moved out twice.

Drop Types

To make all the inherent methods in this type const fn this type wraps the T inside a ManuallyDrop, which means that T won’t be dropped inside. If that is a problem don’t construct a FieldPathSet with a T that owns some resource.

Examples

You can look for examples of using this in the multi-field StructuralExt methods, like fields,fields_mut, and into_fields.

Implementations

impl<T> FieldPathSet<(T,), UniquePaths>

pub const fn one(val: T) -> Self

Constructs a FieldPathSet from a single field path.

impl<T> FieldPathSet<T, AliasedPaths>

pub const fn many(paths: T) -> Self

Constructs a FieldPathSet from a tuple of up to 8 field paths.

Note that this doesn’t enforce that its input is in fact a tuple of up to 8 field paths (because const fn can’t have bounds yet).

To be able to access multiple fields mutably/by value at the same time, you must call the unsafe .upgrade() method.

To access more than 8 fields, you must use the large constructor.

impl<T> FieldPathSet<LargePathSet<T>, AliasedPaths>

pub const fn large(paths: T) -> Self

Constructs a FieldPathSet from a tuple of tuples of field paths, for accessing up to 64 fields.

Note that this doesn’t enforce that its input is in fact a tuple of tuples of field paths (because const fn can’t have bounds yet).

To be able to access multiple fields mutably/by value at the same time, you must call the unsafe .upgrade() method.

Example

This example demonstrates calling this function with 8 and 9 field paths, as well as the return value of StructuralExt methods for both path sets.

Accessing over 8 fields returns a tuple of tuples (8 fields each).

You can also destructure the tuple returned by accessor methods by using the field_pat macro, usable from 0 to 64 fields.

use structural::{ FieldPathSet, StructuralExt, path_tuple, ts };

let array = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19];

{
    let path8 = FieldPathSet::large(path_tuple!(
        ts!(0), ts!(1), ts!(2), ts!(3), ts!(4), ts!(5), ts!(6), ts!(7),
    ));
     
    assert_eq!(
        array.cloned_fields(path8),
        (10, 11, 12, 13, 14, 15, 16, 17),
    );
}
{
    let path9 = FieldPathSet::large(path_tuple!(
        ts!(0), ts!(1), ts!(2), ts!(3), ts!(4), ts!(5), ts!(6), ts!(7),
        ts!(8),
    ));
     
    assert_eq!(
        array.cloned_fields(path9),
        (
            (10, 11, 12, 13, 14, 15, 16, 17),
            (18,),
        ),
    );
}

impl<T> FieldPathSet<T, AliasedPaths>

where T: ConstDefault,

pub const NEW: Self = Self::DEFAULT

Constructs a FieldPathSet.

This can also be used to construct a FieldPathSet<T, UniquePaths> in a context where T can be inferred, by doing unsafe{ FieldPathSet::NEW.upgrade_unchecked() } (read the docs for upgrade_unchecked first).

impl<T, U> FieldPathSet<T, U>

where T: ConstDefault,

pub const NEW_ALIASED: FieldPathSet<T, AliasedPaths> = FieldPathSet::NEW

This can be used to construct a FieldPathSet<T, UniquePaths> from a type alias, by doing unsafe{ FOO::NEW_ALIASED.upgrade_unchecked() } (read the docs for upgrade_unchecked first).

impl<T> FieldPathSet<T, UniquePaths>

pub const fn downgrade(self) -> FieldPathSet<T, AliasedPaths>

Converts a FieldPathSet<T,UniquePaths> to a FieldPathSet<T,AliasedPaths>

impl<T> FieldPathSet<T, AliasedPaths>

pub const unsafe fn upgrade_unchecked(self) -> FieldPathSet<T, UniquePaths>

Converts a FieldPathSet<T,AliasedPaths> to a FieldPathSet<T,UniquePaths>

Safety

You must ensure that all the field paths in the T type parameter are unique, there must be no field path that is a prefix of any other field path.

pub const unsafe fn set_uniqueness<U>(self) -> FieldPathSet<T, U>

Converts a FieldPathSet<T,AliasedPaths> to a FieldPathSet<T,U>

Safety

You must ensure that if U==UniquePaths, then all the field paths in the T type parameter are unique, there must be no field path that is a prefix of any other field path.

impl<T, U> FieldPathSet<T, U>

pub const fn into_paths(self) -> T

Gets the tuple of field paths out of this FieldPathSet.

impl<T, U> FieldPathSet<(T,), U>

pub fn into_path(self) -> T

Converts a FieldPathSet containing a single field path into that field path.

impl<T, U> FieldPathSet<T, U>

pub fn push<O, Out>(self, _other: O) -> FieldPathSet<Out, AliasedPaths>

where Self: PushBack<O, Output = FieldPathSet<Out, AliasedPaths>>, FieldPathSet<Out, AliasedPaths>: ConstDefault,

Constructs a new FieldPathSet with _other appended at the end.

Example argumentsfp!(a)/fp!(a.b.c)/fp!(::foo)/fp!(::bar.baz.bam)

pub fn append<T2, U2>( self, _other: FieldPathSet<T2, U2>, ) -> FieldPathSet<AppendOut<T, T2>, AliasedPaths>

where T: Append<T2>, FieldPathSet<AppendOut<T, T2>, AliasedPaths>: ConstDefault,

Constructs a new FieldPathSet with the _other FieldPathSet appended at the end.

Trait Implementations

impl<T, T2, U, U2> Append<FieldPathSet<T2, U2>> for FieldPathSet<T, U>

where T: Append<T2>,

type Output = FieldPathSet<<T as Append<T2>>::Output, AliasedPaths>

The return value of this trait.

impl<T: Clone, U: Clone> Clone for FieldPathSet<T, U>

fn clone(&self) -> FieldPathSet<T, U>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> ConstDefault for FieldPathSet<T, AliasedPaths>

where T: ConstDefault,

const DEFAULT: Self

The default value for Self.

impl<T: Debug, U: Debug> Debug for FieldPathSet<T, U>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for FieldPathSet<T, AliasedPaths>

where T: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<F, U> IntoAliasing for FieldPathSet<F, U>

type Output = FieldPathSet<F, AliasedPaths>

The return value of this trait.

impl<T, U> IsMultiFieldPath for FieldPathSet<T, U>

type PathUniqueness = U

Whether the paths in the set can contain duplicate paths.

impl<T, U> Ord for FieldPathSet<T, U>

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, U> PartialEq for FieldPathSet<T, U>

fn eq(&self, _other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialOrd for FieldPathSet<T, U>

fn partial_cmp(&self, _other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, U, P, U2> PushBack<FieldPathSet<(P,), U2>> for FieldPathSet<T, U>

where T: PushBack<P>,

type Output = FieldPathSet<<T as PushBack<P>>::Output, AliasedPaths>

The return value of this trait.

impl<T, U, P> PushBack<NestedFieldPath<P>> for FieldPathSet<T, U>

where T: PushBack<NestedFieldPath<P>>,

type Output = FieldPathSet<<T as PushBack<NestedFieldPath<P>>>::Output, AliasedPaths>

The return value of this trait.

impl<This, T, U> RevFieldErr<This> for FieldPathSet<(T,), U>

where This: ?Sized, T: RevFieldErr<This>,

type Err = <T as RevFieldErr<This>>::Err

The error returned by rev_* methods.

impl<This, T, U> RevFieldType<This> for FieldPathSet<(T,), U>

where This: ?Sized, T: RevFieldType<This>,

type Ty = <T as RevFieldType<This>>::Ty

The type of the field.

impl<'a, This, T, U> RevGetFieldImpl<'a, This> for FieldPathSet<(T,), U>

where This: ?Sized + 'a, T: RevGetFieldImpl<'a, This>,

fn rev_get_field(self, this: &'a This) -> Result<&'a T::Ty, T::Err>

Accesses the field that self represents inside of this,by reference.

impl<'a, This, T, U> RevGetFieldMutImpl<'a, This> for FieldPathSet<(T,), U>

where This: ?Sized + 'a, T: RevGetFieldMutImpl<'a, This>,

fn rev_get_field_mut(self, this: &'a mut This) -> Result<&'a mut T::Ty, T::Err>

Accesses the field that self represents inside of this,by mutable reference.

unsafe fn rev_get_field_raw_mut( self, this: *mut This, ) -> Result<*mut T::Ty, T::Err>

Accesses the field that self represents inside of this,by raw pointer.

impl<'a, This: ?Sized + 'a, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(), U>

type UnnormFields = ()

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, _this: &'a This)

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0,), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>,)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields, F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>, T3: 'a, E3: IsFieldErr, Result<&'a T3, E3>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields, F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>, T3: 'a, E3: IsFieldErr, Result<&'a T3, E3>: NormalizeFields, F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>, T4: 'a, E4: IsFieldErr, Result<&'a T4, E4>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields, F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>, T3: 'a, E3: IsFieldErr, Result<&'a T3, E3>: NormalizeFields, F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>, T4: 'a, E4: IsFieldErr, Result<&'a T4, E4>: NormalizeFields, F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>, T5: 'a, E5: IsFieldErr, Result<&'a T5, E5>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields, F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>, T3: 'a, E3: IsFieldErr, Result<&'a T3, E3>: NormalizeFields, F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>, T4: 'a, E4: IsFieldErr, Result<&'a T4, E4>: NormalizeFields, F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>, T5: 'a, E5: IsFieldErr, Result<&'a T5, E5>: NormalizeFields, F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>, T6: 'a, E6: IsFieldErr, Result<&'a T6, E6>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), U>

where This: 'a + ?Sized, F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>, T0: 'a, E0: IsFieldErr, Result<&'a T0, E0>: NormalizeFields, F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>, T1: 'a, E1: IsFieldErr, Result<&'a T1, E1>: NormalizeFields, F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>, T2: 'a, E2: IsFieldErr, Result<&'a T2, E2>: NormalizeFields, F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>, T3: 'a, E3: IsFieldErr, Result<&'a T3, E3>: NormalizeFields, F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>, T4: 'a, E4: IsFieldErr, Result<&'a T4, E4>: NormalizeFields, F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>, T5: 'a, E5: IsFieldErr, Result<&'a T5, E5>: NormalizeFields, F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>, T6: 'a, E6: IsFieldErr, Result<&'a T6, E6>: NormalizeFields, F7: RevGetFieldImpl<'a, This, Ty = T7, Err = E7>, T7: 'a, E7: IsFieldErr, Result<&'a T7, E7>: NormalizeFields,

type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>, Result<&'a T7, E7>)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This: ?Sized + 'a, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<()>, U>

type UnnormFields = ()

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, _this: &'a This)

Gets references to multiple fields from this.

impl<'a, This, F0, E0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields,

type UnnormFields = E0

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields,

type UnnormFields = (E0, E1)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>, E3: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2, E3)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>, E3: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>, E4: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2, E3, E4)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>, E3: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>, E4: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>, E5: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2, E3, E4, E5)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>, E3: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>, E4: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>, E5: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>, E6: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2, E3, E4, E5, E6)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, F7, E7, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>, E0: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>, E1: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>, E2: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>, E3: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>, E4: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>, E5: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>, E6: 'a + NormalizeFields, FieldPathSet<SmallPathSet<F7>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E7>, E7: 'a + NormalizeFields,

type UnnormFields = (E0, E1, E2, E3, E4, E5, E6, E7)

A collection of Results<&'a _,_>s referencing fields.

fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields

Gets references to multiple fields from this.

impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(), UniquePaths>

type UnnormFieldsMut = ()

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = ()

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0,), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>,)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>,)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr, F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>, Result<&'a mut T3, E3>: NormalizeFields, Result<*mut T3, E3>: NormalizeFields, T3: 'a, E3: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr, F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>, Result<&'a mut T3, E3>: NormalizeFields, Result<*mut T3, E3>: NormalizeFields, T3: 'a, E3: IsFieldErr, F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>, Result<&'a mut T4, E4>: NormalizeFields, Result<*mut T4, E4>: NormalizeFields, T4: 'a, E4: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr, F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>, Result<&'a mut T3, E3>: NormalizeFields, Result<*mut T3, E3>: NormalizeFields, T3: 'a, E3: IsFieldErr, F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>, Result<&'a mut T4, E4>: NormalizeFields, Result<*mut T4, E4>: NormalizeFields, T4: 'a, E4: IsFieldErr, F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>, Result<&'a mut T5, E5>: NormalizeFields, Result<*mut T5, E5>: NormalizeFields, T5: 'a, E5: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr, F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>, Result<&'a mut T3, E3>: NormalizeFields, Result<*mut T3, E3>: NormalizeFields, T3: 'a, E3: IsFieldErr, F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>, Result<&'a mut T4, E4>: NormalizeFields, Result<*mut T4, E4>: NormalizeFields, T4: 'a, E4: IsFieldErr, F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>, Result<&'a mut T5, E5>: NormalizeFields, Result<*mut T5, E5>: NormalizeFields, T5: 'a, E5: IsFieldErr, F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>, Result<&'a mut T6, E6>: NormalizeFields, Result<*mut T6, E6>: NormalizeFields, T6: 'a, E6: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths>

where This: 'a + ?Sized, F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>, Result<&'a mut T0, E0>: NormalizeFields, Result<*mut T0, E0>: NormalizeFields, T0: 'a, E0: IsFieldErr, F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>, Result<&'a mut T1, E1>: NormalizeFields, Result<*mut T1, E1>: NormalizeFields, T1: 'a, E1: IsFieldErr, F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>, Result<&'a mut T2, E2>: NormalizeFields, Result<*mut T2, E2>: NormalizeFields, T2: 'a, E2: IsFieldErr, F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>, Result<&'a mut T3, E3>: NormalizeFields, Result<*mut T3, E3>: NormalizeFields, T3: 'a, E3: IsFieldErr, F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>, Result<&'a mut T4, E4>: NormalizeFields, Result<*mut T4, E4>: NormalizeFields, T4: 'a, E4: IsFieldErr, F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>, Result<&'a mut T5, E5>: NormalizeFields, Result<*mut T5, E5>: NormalizeFields, T5: 'a, E5: IsFieldErr, F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>, Result<&'a mut T6, E6>: NormalizeFields, Result<*mut T6, E6>: NormalizeFields, T6: 'a, E6: IsFieldErr, F7: RevGetFieldMutImpl<'a, This, Ty = T7, Err = E7>, Result<&'a mut T7, E7>: NormalizeFields, Result<*mut T7, E7>: NormalizeFields, T7: 'a, E7: IsFieldErr,

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>, Result<&'a mut T7, E7>)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>, Result<*mut T7, E7>)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<()>, UniquePaths>

type UnnormFieldsMut = ()

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = ()

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,

type UnnormFieldsMut = E0

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = T0

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,

type UnnormFieldsMut = (E0, E1)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,

type UnnormFieldsMut = (E0, E1, E2)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>, E3: 'a + NormalizeFields, T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>,

type UnnormFieldsMut = (E0, E1, E2, E3)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2, T3)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>, E3: 'a + NormalizeFields, T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>, E4: 'a + NormalizeFields, T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>,

type UnnormFieldsMut = (E0, E1, E2, E3, E4)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>, E3: 'a + NormalizeFields, T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>, E4: 'a + NormalizeFields, T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>, E5: 'a + NormalizeFields, T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>,

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>, E3: 'a + NormalizeFields, T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>, E4: 'a + NormalizeFields, T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>, E5: 'a + NormalizeFields, T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>, FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E6, UnnormFieldsRawMut = T6>, E6: 'a + NormalizeFields, T6: 'a + NormalizeFields + DerefNested<'a, Dereffed = E6>,

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5, E6)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths>

where This: 'a + ?Sized, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>, E0: 'a + NormalizeFields, T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>, E1: 'a + NormalizeFields, T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>, E2: 'a + NormalizeFields, T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>, E3: 'a + NormalizeFields, T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>, E4: 'a + NormalizeFields, T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>, E5: 'a + NormalizeFields, T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>, FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E6, UnnormFieldsRawMut = T6>, E6: 'a + NormalizeFields, T6: 'a + NormalizeFields + DerefNested<'a, Dereffed = E6>, FieldPathSet<SmallPathSet<F7>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E7, UnnormFieldsRawMut = T7>, E7: 'a + NormalizeFields, T7: 'a + NormalizeFields + DerefNested<'a, Dereffed = E7>,

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5, E6, E7)

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6, T7)

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl( self, this: *mut This, ) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

impl<This, T, U> RevIntoFieldImpl<This> for FieldPathSet<(T,), U>

where This: ?Sized, T: RevIntoFieldImpl<This>,

fn rev_into_field(self, this: This) -> Result<T::Ty, T::Err>

where This: Sized, T::Ty: Sized,

Accesses the field that self represents inside of this,by value.

impl<'a, This> RevIntoMultiFieldImpl<This> for FieldPathSet<(), UniquePaths>

type UnnormIntoFields = ()

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, _this: This)

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0,), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>,)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr, F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>, Result<T6, E6>: NormalizeFields, E6: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr, F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>, Result<T6, E6>: NormalizeFields, E6: IsFieldErr, F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>, Result<T7, E7>: NormalizeFields, E7: IsFieldErr,

type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>, Result<T7, E7>)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<()>, UniquePaths>

type UnnormIntoFields = ()

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, _this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0,)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields,

type UnnormIntoFields = E0

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields,

type UnnormIntoFields = (E0, E1)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>, E3: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2, E3)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>, E3: NormalizeFields, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>, E4: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2, E3, E4)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>, E3: NormalizeFields, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>, E4: NormalizeFields, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>, E5: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2, E3, E4, E5)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>, E3: NormalizeFields, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>, E4: NormalizeFields, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>, E5: NormalizeFields, FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>, E6: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2, E3, E4, E5, E6)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, F7, E7> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths>

where This: DropFields, FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>, E0: NormalizeFields, FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>, E1: NormalizeFields, FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>, E2: NormalizeFields, FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>, E3: NormalizeFields, FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>, E4: NormalizeFields, FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>, E5: NormalizeFields, FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>, E6: NormalizeFields, FieldPathSet<SmallPathSet<F7>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E7>, E7: NormalizeFields,

type UnnormIntoFields = (E0, E1, E2, E3, E4, E5, E6, E7)

This is usually a tuple of Result<_, E: IsFieldErr>s.

fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<This, T, U> RevMoveOutFieldImpl<This> for FieldPathSet<(T,), U>

where This: ?Sized, T: RevMoveOutFieldImpl<This>,

unsafe fn rev_move_out_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Result<Self::Ty, Self::Err>

where T::Ty: Sized,

Moves out the field that self represents inside of this.

impl<'a, This> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(), UniquePaths>

unsafe fn rev_move_out_multi_field( self, _this: &mut This, _moved: &mut MovedOutFields, )

Moves out multiple fields from this

impl<'a, This, F0, E0, T0> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0,), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr, F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>, Result<T6, E6>: NormalizeFields, E6: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths>

where This: DropFields, F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>, Result<T0, E0>: NormalizeFields, E0: IsFieldErr, F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>, Result<T1, E1>: NormalizeFields, E1: IsFieldErr, F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>, Result<T2, E2>: NormalizeFields, E2: IsFieldErr, F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>, Result<T3, E3>: NormalizeFields, E3: IsFieldErr, F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>, Result<T4, E4>: NormalizeFields, E4: IsFieldErr, F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>, Result<T5, E5>: NormalizeFields, E5: IsFieldErr, F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>, Result<T6, E6>: NormalizeFields, E6: IsFieldErr, F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>, Result<T7, E7>: NormalizeFields, E7: IsFieldErr,

unsafe fn rev_move_out_multi_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Self::UnnormIntoFields

Moves out multiple fields from this

impl<T: Copy, U: Copy> Copy for FieldPathSet<T, U>

impl<T, U> Eq for FieldPathSet<T, U>

impl<T, U> IsSingleFieldPath for FieldPathSet<(T,), U>

impl<U> ShallowFieldPath for FieldPathSet<(), U>

impl<F0, U> ShallowFieldPath for FieldPathSet<(F0,), U>

where F0: ShallowFieldPath,

impl<F0, F1, U> ShallowFieldPath for FieldPathSet<(F0, F1), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath,

impl<F0, F1, F2, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath,

impl<F0, F1, F2, F3, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath, F3: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath, F3: ShallowFieldPath, F4: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath, F3: ShallowFieldPath, F4: ShallowFieldPath, F5: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, F6, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath, F3: ShallowFieldPath, F4: ShallowFieldPath, F5: ShallowFieldPath, F6: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), U>

where F0: ShallowFieldPath, F1: ShallowFieldPath, F2: ShallowFieldPath, F3: ShallowFieldPath, F4: ShallowFieldPath, F5: ShallowFieldPath, F6: ShallowFieldPath, F7: ShallowFieldPath,

impl<U> ShallowFieldPath for FieldPathSet<LargePathSet<()>, U>

impl<F0, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0,)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,

impl<F0, F1, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,

impl<F0, F1, F2, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,

impl<F0, F1, F2, F3, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, F6, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath,

impl<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U>

where FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath, FieldPathSet<SmallPathSet<F7>, U>: ShallowFieldPath,