Trait structural::field::rev_get_field::RevIntoFieldImpl

pub trait RevIntoFieldImpl<This: ?Sized>: RevFieldErr<This> {
    fn rev_into_field(self, this: This) -> Result<Self::Ty, Self::Err>
    where
        This: Sized,
        Self::Ty: Sized;
}

Like Into*Field::into_*field_,except that the parameters are reversed,

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

This is used by the StructuralExt::into_field and StructuralExt::box_into_field method.

Use as bound

For examples of using RevIntoFieldImpl as a bound look at example for:

• RevIntoField: For infallible field access,generalerally struct fields,not inside of a nested enum.

• OptRevIntoField: Fallible field access,generally for getting a field in a (potentially nested) enum.

Example

This example demonstrates implementing RevIntoFieldImpl.

The transmute in this example is only sound because of the #[repr(transparent)] attribute on the Wrapper struct, and the reference to T is converted into a reference to Wrapper<T>.
Transmutes like that are not sound in the more general case, like transmuting from an arbitrary Foo<T> to Foo<Newtype<T>> using std::mem::transmute, since the layout of Foo is allowed to change.

use structural::{
    field::{FailedAccess, RevFieldErr, RevFieldType, RevGetFieldImpl, RevIntoFieldImpl},
    path::IsSingleFieldPath,
    StructuralExt, fp,
};

use core::mem;

let mut tup=(3,5,8,13);

assert_eq!( tup.into_field(Wrapped(fp!(0))), Newtype(3) );
assert_eq!( tup.into_field(Wrapped(fp!(1))), Newtype(5) );
assert_eq!( tup.into_field(Wrapped(fp!(2))), Newtype(8) );
assert_eq!( tup.into_field(Wrapped(fp!(3))), Newtype(13) );


#[derive(Debug,Copy,Clone,PartialEq)]
struct Wrapped<P>(P);

#[repr(transparent)]
#[derive(Debug,Copy,Clone,PartialEq)]
pub struct Newtype<T:?Sized>(T);

impl<P> IsSingleFieldPath for Wrapped<P>{}

impl<P,T> RevFieldType<T> for Wrapped<P>
where
    P: RevFieldType<T>,
{
    type Ty = Newtype<P::Ty>;
}

impl<P,T> RevFieldErr<T> for Wrapped<P>
where
    P: RevFieldErr<T>,
{
    type Err = P::Err;
}

impl<P,T> RevIntoFieldImpl<T> for Wrapped<P>
where
    P: RevIntoFieldImpl<T>,
    P::Ty: Sized,
{
    fn rev_into_field(self, this: T) -> Result<Self::Ty, Self::Err>
    where
        Self::Ty: Sized
    {
        self.0.rev_into_field(this)
            .map(Newtype)
    }
}

Required methods

fn rev_into_field(self, this: This) -> Result<Self::Ty, Self::Err> where
    This: Sized,
    Self::Ty: Sized, 

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

Loading content...

Implementors

impl<F0, T0, E0, F1, T1, E1, F2, T2, E2, F3, T3, E3, F4, T4, E4, F5, T5, E5, F6, T6, E6, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, F2, F3, F4, F5, F6, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    F2: RevIntoFieldImpl<T1, Ty = T2, Err = E2>,
    F3: RevIntoFieldImpl<T2, Ty = T3, Err = E3>,
    F4: RevIntoFieldImpl<T3, Ty = T4, Err = E4>,
    F5: RevIntoFieldImpl<T4, Ty = T5, Err = E5>,
    F6: RevIntoFieldImpl<T5, Ty = T6, Err = E6>,
    FL: RevIntoFieldImpl<T6, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    E2: IntoFieldErr<CombErr>,
    E3: IntoFieldErr<CombErr>,
    E4: IntoFieldErr<CombErr>,
    E5: IntoFieldErr<CombErr>,
    E6: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, F1, T1, E1, F2, T2, E2, F3, T3, E3, F4, T4, E4, F5, T5, E5, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, F2, F3, F4, F5, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    F2: RevIntoFieldImpl<T1, Ty = T2, Err = E2>,
    F3: RevIntoFieldImpl<T2, Ty = T3, Err = E3>,
    F4: RevIntoFieldImpl<T3, Ty = T4, Err = E4>,
    F5: RevIntoFieldImpl<T4, Ty = T5, Err = E5>,
    FL: RevIntoFieldImpl<T5, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    E2: IntoFieldErr<CombErr>,
    E3: IntoFieldErr<CombErr>,
    E4: IntoFieldErr<CombErr>,
    E5: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, F1, T1, E1, F2, T2, E2, F3, T3, E3, F4, T4, E4, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, F2, F3, F4, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    F2: RevIntoFieldImpl<T1, Ty = T2, Err = E2>,
    F3: RevIntoFieldImpl<T2, Ty = T3, Err = E3>,
    F4: RevIntoFieldImpl<T3, Ty = T4, Err = E4>,
    FL: RevIntoFieldImpl<T4, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    E2: IntoFieldErr<CombErr>,
    E3: IntoFieldErr<CombErr>,
    E4: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, F1, T1, E1, F2, T2, E2, F3, T3, E3, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, F2, F3, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    F2: RevIntoFieldImpl<T1, Ty = T2, Err = E2>,
    F3: RevIntoFieldImpl<T2, Ty = T3, Err = E3>,
    FL: RevIntoFieldImpl<T3, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    E2: IntoFieldErr<CombErr>,
    E3: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, F1, T1, E1, F2, T2, E2, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, F2, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    F2: RevIntoFieldImpl<T1, Ty = T2, Err = E2>,
    FL: RevIntoFieldImpl<T2, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    E2: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, F1, T1, E1, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, F1, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    F1: RevIntoFieldImpl<T0, Ty = T1, Err = E1>,
    FL: RevIntoFieldImpl<T1, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    E1: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<F0, T0, E0, FL, TL, EL, This, CombErr> RevIntoFieldImpl<This> for NestedFieldPath<(F0, FL)> where
    Self: RevFieldErr<This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    This: ?Sized,
    F0: RevIntoFieldImpl<This, Ty = T0, Err = E0>,
    FL: RevIntoFieldImpl<T0, Ty = TL, Err = EL>,
    E0: IntoFieldErr<CombErr>,
    EL: IntoFieldErr<CombErr>, 

fn rev_into_field(self, field: This) -> Result<TL, CombErr> where
    This: Sized, 

impl<This> RevIntoFieldImpl<This> for NestedFieldPath<()>

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

impl<This, A, B, U> RevIntoFieldImpl<This> for NestedFieldPathSet<A, (B,), U> where
    This: ?Sized,
    A: RevIntoFieldImpl<This>,
    B: RevIntoFieldImpl<A::Ty>,
    A::Ty: Sized,
    Self: RevFieldErr<This, Ty = B::Ty>,
    A::Err: IntoFieldErr<Self::Err>,
    B::Err: IntoFieldErr<Self::Err>, 

fn rev_into_field(self, this: This) -> Result<B::Ty, Self::Err> where
    This: Sized,
    B::Ty: Sized, 

impl<This, F0> RevIntoFieldImpl<This> for NestedFieldPath<(F0,)> where
    This: ?Sized,
    F0: RevIntoFieldImpl<This>, 

fn rev_into_field(self, this: This) -> Result<F0::Ty, F0::Err> where
    This: Sized,
    F0::Ty: Sized, 

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, 

impl<This: ?Sized, S> RevIntoFieldImpl<This> for VariantName<TStr<S>> where
    This: IsVariant<TStr<S>>,
    S: 'static, 

fn rev_into_field(
    self,
    this: This
) -> Result<VariantProxy<This, TStr<S>>, FailedAccess> where
    This: Sized, 

impl<This: ?Sized, T> RevIntoFieldImpl<This> for TStr<T> where
    This: IntoField<Self>, 

fn rev_into_field(self, this: This) -> Result<This::Ty, InfallibleAccess> where
    This: Sized,
    Self::Ty: Sized, 

impl<This: ?Sized, _V, _F> RevIntoFieldImpl<This> for VariantField<_V, _F> where
    This: IntoVariantField<_V, _F>, 

fn rev_into_field(self, this: This) -> Result<This::Ty, FailedAccess> where
    This: Sized, 

Loading content...