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

pub trait RevGetMultiFieldImpl<'a, This: ?Sized + 'a>: IsMultiFieldPath + Sized {
    type UnnormFields: 'a + NormalizeFields;
    fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields;
}

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

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

To get Option<&_> or &_ instead of each of those Results, you can use the RevGetMultiField as a bound instead.

Usage as bound

This trait shouldn't be used as a bound,except in implementations of the same trait.

For a trait that can be used in bounds,you can use RevGetMultiField (it has examples).

Example

This example demonstrates how you can implement RevGetMultiFieldImpl to get a pair of indices.

use structural::field::{FailedAccess, RevGetMultiFieldImpl};
use structural::path::{AliasedPaths, IsMultiFieldPath};
use structural::StructuralExt;

struct Pair(usize,usize);

impl IsMultiFieldPath for Pair{
    type PathUniqueness= AliasedPaths;
}

impl<'a,T:'a> RevGetMultiFieldImpl<'a,[T]> for Pair{
    type UnnormFields=(
        Result<&'a T,FailedAccess>,
        Result<&'a T,FailedAccess>,
    );
     
    fn rev_get_multi_field_impl(self, this: &'a [T]) -> Self::UnnormFields{
        (
            this.get(self.0).ok_or(FailedAccess),
            this.get(self.1).ok_or(FailedAccess),
        )
    }
}

let arr=[2,3,5,8,13,21,34,55,89];

assert_eq!( arr[..].fields(Pair(2,1)), (Some(&5),Some(&3)) );
assert_eq!( arr[..].fields(Pair(0,3)), (Some(&2),Some(&8)) );

Associated Types

type UnnormFields: 'a + NormalizeFields

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

Loading content...

Required methods

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

Gets references to multiple fields from this.

Loading content...

Implementors

impl<'a, F, S, U, This: ?Sized, Mid: ?Sized, OutTy, OutErr> RevGetMultiFieldImpl<'a, This> for NestedFieldPathSet<F, S, U> where
    F: RevGetFieldImpl<'a, This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, U>: RevGetMultiFieldImpl<'a, Mid, UnnormFields = OutTy>,
    OutErr: IsFieldErr,
    This: 'a,
    Mid: 'a,
    OutTy: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutTy, OutErr>: 'a + NormalizeFields, [src]

type UnnormFields = NestedFieldPathSetOutput<OutTy, OutErr>

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

type UnnormFields = ()

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

type UnnormFields = ()

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

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

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

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

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

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

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

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

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

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

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

type UnnormFields = (E0, E1, E2)

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

type UnnormFields = (E0, E1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type UnnormFields = E0

impl<'a, This: ?Sized, T> RevGetMultiFieldImpl<'a, This> for NestedFieldPath<T> where
    Self: RevGetFieldImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields, [src]

type UnnormFields = (Result<&'a RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, T> RevGetMultiFieldImpl<'a, This> for TStr<T> where
    Self: RevGetFieldImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields, [src]

type UnnormFields = (Result<&'a RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, T> RevGetMultiFieldImpl<'a, This> for VariantName<T> where
    Self: RevGetFieldImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields, [src]

type UnnormFields = (Result<&'a RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, V, F> RevGetMultiFieldImpl<'a, This> for VariantField<V, F> where
    Self: RevGetFieldImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields, [src]

type UnnormFields = (Result<&'a RGFT<Self, This>, RGFE<Self, This>>,)

Loading content...