[−][src]Macro structural::TS
For getting the type of a TStr<_>
(type-level string).
You can also use tstr_aliases
to declare one or more aliases for type-level strings.
Inputs
This has the same syntax as the ts
macro,
a single identifier,string literal, or integer.
Small Example:
use structural::TS; type Foo=TS!("foo"); type Bar=TS!(foo); // Equivalent to `TS!("foo")` type Baz=TS!(100); // Equivalent to `TS!("100")`
Example
This example demonstrates how TStr
can be used to manually bound a
type parameter with the *VariantField*
traits,to access a variant field.
use structural::{StructuralExt,FP,Structural,TS,ts}; use structural::{GetFieldType, GetVariantFieldType, IntoVariantFieldMut, VariantField}; // `GetFieldType<This,FP!(::Ok.0)>` can also be written as // `GetVariantFieldType<This,TS!(Ok),TS!(0)>`. // // `GetVariantFieldType` is useful in generic contexts where // the name of the variant is taken separately from the name of the field. fn into_ok<This>(this: This)->Option<GetFieldType<This,FP!(::Ok.0)>> where This: IntoVariantFieldMut<TS!(Ok),TS!(0)> { // Equivalent to: `this.into_field(fp!(::Ok.0))` this.into_field(VariantField::new(ts!("Ok"), ts!("0"))) } #[derive(Structural)] enum ResultLike<T,E>{ Ok(T), Err(E), } assert_eq!( into_ok(ResultLike::<_,()>::Ok(99)), Some(99)); assert_eq!( into_ok(ResultLike::<(),_>::Err(99)), None); assert_eq!( into_ok(Result::<_,()>::Ok(99)), Some(99)); assert_eq!( into_ok(Result::<(),_>::Err(99)), None);
Example
This example uses the TS
macro to access a single non-nested field,
instead of the FP
or fp
macros.
use structural::{GetField,StructuralExt,Structural,FP,TS}; fn main(){ let phone=CellPhone{ memory: Bytes{ bytes:64_000_000_000 }, charge: Charge{ percent:50 }, }; assert_eq!( get_charge(&phone).percent, 50 ); let battery=Battery{ charge: Charge{ percent:70 }, }; assert_eq!( get_charge(&battery).percent, 70 ); } type charge_TStr=TS!(charge); // An `FP!(identifier)` is the same type as `TS!(identifier)`, // but because it's more flexible it's used for field paths by default. // Eg:You can write `GetFieldType<FooEnum, FP!(::Foo.bar)>` with `FP` but not with `TS`. // // `TS` always produces the `TStr` type, // while FP produces different types depending on the input. fn get_charge( this:&dyn GetField<FP!(charge), Ty=Charge> )-> Charge { this.field_(charge_TStr::NEW).clone() } #[derive(Structural)] struct CellPhone{ pub memory: Bytes, pub charge: Charge, } #[derive(Structural)] struct Battery{ pub charge: Charge, } #[derive(Debug,Copy,Clone)] struct Bytes{ bytes: u64, } #[derive(Debug,Copy,Clone)] struct Charge{ percent: u8, }