Struct structural::FieldPathSet

#[repr(transparent)]pub struct FieldPathSet<T, U> { /* fields omitted */ }

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

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>

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<AppendOut<T, T2>, 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: Copy, U: Copy> Copy for FieldPathSet<T, U>

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<T, U> Eq for FieldPathSet<T, U>

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> IsSingleFieldPath for FieldPathSet<(T,), U>

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

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, U> PartialOrd<FieldPathSet<T, U>> 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.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method 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<PushBackOut<T, P>, 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<PushBackOut<T, NestedFieldPath<P>>, 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::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::Ty

The type of the field.

impl<'a, This: ?Sized, T, U> RevGetFieldImpl<'a, This> for FieldPathSet<(T,), U> where
    This: '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: ?Sized, T, U> RevGetFieldMutImpl<'a, This> for FieldPathSet<(T,), U> where
    This: '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, F0, E0, T0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0,), U> where
    This: 'a,
    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: ?Sized, F0, E0, T0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0,)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, 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<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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, 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<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U> where
    This: 'a,
    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<(), 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: ?Sized, F0, E0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, U> where
    This: 'a,
    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: ?Sized, F0, E0, F1, E1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, U> where
    This: 'a,
    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: ?Sized, F0, E0, F1, E1, F2, E2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, U> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1), U> where
    This: 'a,
    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: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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, 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: ?Sized, F0, E0, T0, F1, E1, T1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1)>, U> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2), U> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, U> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, U> where
    This: 'a,
    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: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0,), UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0,)>, UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, 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<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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, 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<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
    This: 'a,
    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<(), 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: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1), UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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: ?Sized, 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,
    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<'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: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1)>, UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2), UniquePaths> where
    This: 'a,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, UniquePaths> where
    This: 'a,
    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: ?Sized, 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,
    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: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
    This: 'a,
    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<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, 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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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, 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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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, 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<SmallPathSet<(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<(), 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> 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, 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, 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<'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, T0, F1, E1, T1> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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<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, 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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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, 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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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<'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<SmallPathSet<(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<'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, 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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(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<F0, U> ShallowFieldPath for FieldPathSet<(F0,), U> where
    F0: ShallowFieldPath, 

impl<F0, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0,)>, U> where
    F0: 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, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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<(), 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, U> ShallowFieldPath for FieldPathSet<(F0, F1), U> where
    F0: ShallowFieldPath,
    F1: 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, 

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

impl<F0, F1, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(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, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, U> where
    F0: ShallowFieldPath,
    F1: ShallowFieldPath,
    F2: ShallowFieldPath,
    F3: ShallowFieldPath,
    F4: ShallowFieldPath,