Struct TStr

pub struct TStr<T>(/* private fields */);

Type-level string,used for identifiers in field paths.

This type is always zero sized.

This cannot be converted to a &'static str constant (if you can figure out a cheap way to do that please create an issue/pull request).

Semver concerns

The private __TS type appears as a type argument of TStr in the output of macros from this crate, the __TS type must not be used by name outside of the structural and structural_derive crates.

Direct use of the __TS type will cause compilation errors whenever any other crate uses the “use_const_str” cargo feature, which changes __TS to use const generics to improve error messages.

Also,using the “use_const_str” feature to use the __TS type by name wouldn’t protect from breakage, since other crates can use the “disable_const_str” feature to disable const generics (this feature is useful to work around bugs in const generics).

TStr type

You can get a TStr type (to use as a type argument) with the TS macro, which takes a string literal/ident/integer as input.

TStr construction

TStr<_> can be constructed with:

• the ts macro,which takes a string literal/ident/integer as input.

• the fp macro,when a single string literal/ident/integer in passed, prefer using ts if you want a TStr to always be constructed, since fp can produce other types depending on the arguments.

• the NEW inherent associated constant.

• The <TStr<_> as ConstDefault>::DEFAULT associated constant.

Examples:

• ts!(foo): TStr equivalent of “foo”

• ts!("bar"): TStr equivalent of “bar”

• ts!(1): TStr equivalent of “1”

• ts!(100): TStr equivalent of “100”

• fp!(foo): TStr equivalent of “foo”

• fp!("bar"): TStr equivalent of “bar”

• fp!("@me"): TStr equivalent of “@me”

• fp!(100): TStr equivalent of “100”

• <TS!(0)>::NEW: TStr equivalent of “0”

• <TS!(0)>::DEFAULT: TStr equivalent of “0” (requires importing the ConstDefault trait)

• <TS!("hello")>::NEW: TStr equivalent of “hello”

• <TS!(world)>::NEW: TStr equivalent of “world”

• <TS!(100)>::NEW: TStr equivalent of “100”

Example

For an example of constructing TStr using the ts macro, and constructing other field paths with it, you can look in the docs for the ts macro.

Implementations

impl<T> TStr<T>

pub const NEW: Self

Constructs the TStr.

impl<T> TStr<T>

pub const fn into_path(self) -> NestedFieldPath<(Self,)>

Constructs a NestedFieldPath from this.

pub const fn into_set(self) -> FieldPathSet<(Self,), UniquePaths>

Constructs a FieldPathSet from this.

Trait Implementations

impl<T> Clone for TStr<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> ConstDefault for TStr<T>

const DEFAULT: Self

The default value for Self.

impl<T> Debug for TStr<T>

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

Formats the value using the given formatter.

impl<'a, T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for &'a T

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty> + ?Sized,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<'a, T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for &'a mut T

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty> + ?Sized + 'a,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for Arc<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty> + ?Sized,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for Box<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty> + ?Sized,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for FieldCloner<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for ManuallyDrop<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<P, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for Pin<P>

where P::Target: GetVariantField<TStr<__V>, __F, Ty = __Ty> + Sized, P: Deref,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<P::Target, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for Rc<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty> + ?Sized,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantField<TStr<__V>, __F> for StrucWrapper<T>

where T: GetVariantField<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_( &self, vname: TStr<__V>, fname: __F, ) -> Option<&GetVariantFieldType<T, TStr<__V>, __F>>

Accesses the F field in the V variant by reference.

unsafe fn get_vfield_unchecked(&self, variant: V, field: F) -> &Self::Ty

Accesses the F field in the V variant by reference, without checking that the enum is currently the V variant.

impl<'a, T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for &'a mut T

where &'a mut T: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty> + ?Sized + 'a,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for Box<T>

where Box<T>: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty> + ?Sized,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for FieldCloner<T>

where FieldCloner<T>: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for ManuallyDrop<T>

where ManuallyDrop<T>: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> GetVariantFieldMut<TStr<__V>, __F> for StrucWrapper<T>

where StrucWrapper<T>: Sized, T: GetVariantFieldMut<TStr<__V>, __F, Ty = __Ty>,

fn get_vfield_mut_(&mut self, vname: TStr<__V>, fname: __F) -> Option<&mut __Ty>

Accesses the F field in the V variant by mutable reference.

unsafe fn get_vfield_raw_mut_( this: *mut (), vname: TStr<__V>, fname: __F, ) -> Option<NonNull<__Ty>>

where Self: Sized,

Accesses the F field in the V variant by raw pointer.

fn get_vfield_raw_mut_unchecked_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_unchecked method.

fn get_vfield_raw_mut_fn(&self) -> GetVFieldRawMutFn<TStr<__V>, __F, __Ty>

Gets a function pointer to the get_vfield_raw_mut_ method.

unsafe fn get_vfield_mut_unchecked( &mut self, variant: V, field: F, ) -> &mut Self::Ty

Accesses the F field in the V variant by mutable reference, without checking that the enum is currently the V variant.

unsafe fn get_vfield_raw_mut_unchecked(ptr: *mut (), field: F) -> *mut Self::Ty

where Self: Sized, V: ConstDefault,

Accesses the F field in the V variant by raw pointer, without checking that the enum is currently the V variant.

impl<T, V, F, Ty> IntoVariantField<TStr<V>, F> for Box<T>

where T: ?Sized + IntoVariantField<TStr<V>, F, Ty = Ty>,

fn into_vfield_(self, vname: TStr<V>, fname: F) -> Option<Ty>

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_( &mut self, vname: TStr<V>, fname: F, moved: &mut MovedOutFields, ) -> Option<Ty>

Moves out the F field from the V variant.

unsafe fn into_vfield_unchecked_( self, variant_name: V, field_name: F, ) -> Self::Ty

where Self: Sized,

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_unchecked_( &mut self, variant_name: V, field_name: F, moved_fields: &mut MovedOutFields, ) -> Self::Ty

Converts this into the F field in the V variant by value, without checking that the enum is currently the V variant.

impl<T, V, F> IntoVariantField<TStr<V>, F> for FieldCloner<T>

where T: GetVariantField<TStr<V>, F>, T::Ty: Clone,

fn into_vfield_(self, variant_name: TStr<V>, field_name: F) -> Option<Self::Ty>

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_( &mut self, variant_name: TStr<V>, field_name: F, _: &mut MovedOutFields, ) -> Option<Self::Ty>

Moves out the F field from the V variant.

unsafe fn into_vfield_unchecked_( self, variant_name: V, field_name: F, ) -> Self::Ty

where Self: Sized,

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_unchecked_( &mut self, variant_name: V, field_name: F, moved_fields: &mut MovedOutFields, ) -> Self::Ty

Converts this into the F field in the V variant by value, without checking that the enum is currently the V variant.

impl<T, __V, __F, __Ty> IntoVariantField<TStr<__V>, __F> for StrucWrapper<T>

where T: IntoVariantField<TStr<__V>, __F, Ty = __Ty>,

fn into_vfield_(self, vname: TStr<__V>, fname: __F) -> Option<__Ty>

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_( &mut self, vname: TStr<__V>, fname: __F, moved: &mut MovedOutFields, ) -> Option<__Ty>

Moves out the F field from the V variant.

unsafe fn into_vfield_unchecked_( self, variant_name: V, field_name: F, ) -> Self::Ty

where Self: Sized,

Converts this into the F field in the V variant by value.

unsafe fn move_out_vfield_unchecked_( &mut self, variant_name: V, field_name: F, moved_fields: &mut MovedOutFields, ) -> Self::Ty

Converts this into the F field in the V variant by value, without checking that the enum is currently the V variant.

impl<T> IsMultiFieldPath for TStr<T>

type PathUniqueness = UniquePaths

Whether the paths in the set can contain duplicate paths.

impl<'a, T, __V> IsVariant<TStr<__V>> for &'a T

where T: IsVariant<TStr<__V>> + ?Sized,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<'a, T, __V> IsVariant<TStr<__V>> for &'a mut T

where T: IsVariant<TStr<__V>> + ?Sized + 'a,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for Arc<T>

where T: IsVariant<TStr<__V>> + ?Sized,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for Box<T>

where T: IsVariant<TStr<__V>> + ?Sized,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for FieldCloner<T>

where T: IsVariant<TStr<__V>>,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for ManuallyDrop<T>

where T: IsVariant<TStr<__V>>,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<P, __V> IsVariant<TStr<__V>> for Pin<P>

where P::Target: IsVariant<TStr<__V>> + Sized, P: Deref,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for Rc<T>

where T: IsVariant<TStr<__V>> + ?Sized,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T, __V> IsVariant<TStr<__V>> for StrucWrapper<T>

where T: IsVariant<TStr<__V>>,

fn is_variant_(&self, name: TStr<__V>) -> bool

Checks whether this enum is the variant that V stands for.

impl<T> Ord for TStr<T>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for TStr<T>

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

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

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

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

impl<T> PartialOrd for TStr<T>

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

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

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

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

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

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

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

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

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

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

impl<This, T> RevFieldErr<This> for TStr<T>

where This: ?Sized + FieldType<Self>,

type Err = InfallibleAccess

The error returned by rev_* methods.

impl<This, T> RevFieldType<This> for TStr<T>

where This: ?Sized + FieldType<Self>,

type Ty = <This as FieldType<TStr<T>>>::Ty

The type of the field.

impl<'a, This, T> RevGetFieldImpl<'a, This> for TStr<T>

where This: ?Sized + 'a + GetField<Self>, This::Ty: 'a,

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

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

impl<'a, This, T> RevGetFieldMutImpl<'a, This> for TStr<T>

where This: ?Sized + 'a + GetFieldMut<Self>, This::Ty: 'a,

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

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 This::Ty, InfallibleAccess>

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

impl<'a, This, T> RevGetMultiFieldImpl<'a, This> for TStr<T>

where Self: RevGetFieldImpl<'a, This>, This: 'a + ?Sized, RGFT<Self, This>: 'a, Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields,

type UnnormFields = (Result<&'a <TStr<T> as RevFieldType<This>>::Ty, <TStr<T> as RevFieldErr<This>>::Err>,)

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

fn rev_get_multi_field_impl( self, this: &'a This, ) -> (Result<&'a RGFT<Self, This>, RGFE<Self, This>>,)

Gets references to multiple fields from this.

impl<'a, This, T> RevGetMultiFieldMutImpl<'a, This> for TStr<T>

where Self: RevGetFieldMutImpl<'a, This>, This: 'a + ?Sized, RGFT<Self, This>: 'a, Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,

type UnnormFieldsMut = (Result<&'a mut <TStr<T> as RevFieldType<This>>::Ty, <TStr<T> as RevFieldErr<This>>::Err>,)

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

type UnnormFieldsRawMut = (Result<*mut <TStr<T> as RevFieldType<This>>::Ty, <TStr<T> as RevFieldErr<This>>::Err>,)

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

fn rev_get_multi_field_mut_impl( self, this: &'a mut This, ) -> (Result<&'a mut RGFT<Self, This>, RGFE<Self, 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, ) -> (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

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

impl<This, T> RevIntoFieldImpl<This> for TStr<T>

where This: ?Sized + IntoField<Self>,

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

where This: Sized, Self::Ty: Sized,

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

impl<This, T> RevIntoMultiFieldImpl<This> for TStr<T>

where Self: RevIntoFieldImpl<This>, RGFT<Self, This>: Sized, Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,

type UnnormIntoFields = (Result<<TStr<T> as RevFieldType<This>>::Ty, <TStr<T> as RevFieldErr<This>>::Err>,)

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

fn rev_into_multi_field_impl( self, this: This, ) -> (Result<RGFT<Self, This>, RGFE<Self, This>>,)

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

impl<This, T> RevMoveOutFieldImpl<This> for TStr<T>

where This: ?Sized + IntoField<Self>,

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

where Self::Ty: Sized,

Moves out the field that self represents inside of this.

impl<T> Copy for TStr<T>

impl<T> Eq for TStr<T>

impl<T> IsSingleFieldPath for TStr<T>

impl<T> IsTStr for TStr<T>

impl<T> ShallowFieldPath for TStr<T>