[−][src]Trait structural::field::multi_fields::RevIntoMultiFieldImpl

pub trait RevIntoMultiFieldImpl<This>: IsMultiFieldPath<PathUniqueness = UniquePaths> + Sized {
    type UnnormIntoFields: NormalizeFields;
    fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields;
}

Converts This into multiple fields by value, usually returning a tuple of Result<T, E: IsFieldErr>s,

This is the type we are accessing,and Self is a field path.

To get Option<T>s and Ts instead of each of those Results, you can use the RevIntoMultiField as a bound instead.

Example: implementation

This example demonstrates how you can implement this trait by delegating to implementations of RevMoveOutFieldImpl known not to alias.

use structural::{FP, make_struct};
use structural::for_examples::{Struct2, Struct3};
use structural::path::{IsMultiFieldPath, UniquePaths};
use structural::field::{
    ownership::IntoFieldsWrapper,
    DropFields, IsFieldErr, NormalizeFields,
    RevIntoMultiFieldImpl, RevIntoMultiFieldOut, RevIntoMultiField, RevMoveOutFieldImpl
};

let value_0=Struct2{foo: Some(5), bar: 8};
assert_eq!(into_foo_bar(value_0), (Some(5), 8));

let value_1=Struct3{foo: Some(13), bar: 21, baz: 34};
assert_eq!(into_foo_bar(value_1), (Some(13), 21));

fn into_foo_bar<T>(this: T)->RevIntoMultiFieldOut<FooBarPair, T>
where
    FooBarPair: RevIntoMultiField<T>,
{
    FooBarPair.rev_into_multi_field(this)
}


struct FooBarPair;

type Foo_P=FP!(foo);
type Bar_P=FP!(bar);

impl IsMultiFieldPath for FooBarPair{
    type PathUniqueness = UniquePaths;
}

impl<T0,T1,E0,E1,This> RevIntoMultiFieldImpl<This> for FooBarPair
where
    This: DropFields,
    Foo_P: RevMoveOutFieldImpl<This, Ty=T0, Err=E0>,
    Bar_P: RevMoveOutFieldImpl<This, Ty=T1, Err=E1>,
    E0: IsFieldErr,
    E1: IsFieldErr,
    (
        Result<T0, E0>,
        Result<T1, E1>,
    ): NormalizeFields
{
    type UnnormIntoFields=(
        Result<T0, E0>,
        Result<T1, E1>,
    );

    fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields{
        // This is unsafe because:
        //
        // - The `moved: &mut MovedOutFields` passed to `rev_move_out_field` must only
        // be mutated inside of `rev_move_out_field`
        //
        // - `rev_move_out_field` must be called only once for any given field,
        // since calling it twice would move a field twice.
        unsafe{
            let mut this=IntoFieldsWrapper::new(this);

            let (this, moved)=this.inner_and_moved_mut();
            (
                <Foo_P>::NEW.rev_move_out_field(this, moved),
                <Bar_P>::NEW.rev_move_out_field(this, moved),
            )
        }
    }
}

Associated Types

type UnnormIntoFields: NormalizeFields

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

Loading content...

Required methods

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.

Loading content...

Implementors

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

type UnnormIntoFields = ()

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

type UnnormIntoFields = ()

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, [src]

type UnnormIntoFields = E0

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, [src]

type UnnormIntoFields = (E0, E1)

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, [src]

type UnnormIntoFields = (E0, E1, E2)

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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

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, [src]

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>)

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, [src]

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>)

impl<F, S, This, Mid, OutTy, OutErr> RevIntoMultiFieldImpl<This> for NestedFieldPathSet<F, S, UniquePaths> where
    F: RevIntoFieldImpl<This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, UniquePaths>: RevIntoMultiFieldImpl<Mid, UnnormIntoFields = OutTy>,
    OutTy: NormalizeFields,
    OutErr: IsFieldErr,
    NestedFieldPathSetOutput<OutTy, OutErr>: NormalizeFields, [src]

type UnnormIntoFields = NestedFieldPathSetOutput<OutTy, OutErr>

impl<This, T> RevIntoMultiFieldImpl<This> for NestedFieldPath<T> where
    Self: RevIntoFieldImpl<This>,
    RGFT<Self, This>: Sized,
    Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, [src]

type UnnormIntoFields = (Result<RGFT<Self, This>, RGFE<Self, This>>,)

impl<This, T> RevIntoMultiFieldImpl<This> for TStr<T> where
    Self: RevIntoFieldImpl<This>,
    RGFT<Self, This>: Sized,
    Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, [src]

type UnnormIntoFields = (Result<RGFT<Self, This>, RGFE<Self, This>>,)

impl<This, T> RevIntoMultiFieldImpl<This> for VariantName<T> where
    Self: RevIntoFieldImpl<This>,
    RGFT<Self, This>: Sized,
    Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, [src]

type UnnormIntoFields = (Result<RGFT<Self, This>, RGFE<Self, This>>,)

impl<This, V, F> RevIntoMultiFieldImpl<This> for VariantField<V, F> where
    Self: RevIntoFieldImpl<This>,
    RGFT<Self, This>: Sized,
    Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, [src]

type UnnormIntoFields = (Result<RGFT<Self, This>, RGFE<Self, This>>,)

Loading content...