Struct IntoIdent 

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

Parses T and concats all its elements to a single identifier by removing all characters that are not valid in identifiers. When T implements Default, such as single string (non group) keywords, operators and Const* literals. Then it can be used to create IntoIdentifier on the fly. Note that construction may still fail when one tries to create a invalid identifier such as one starting with digits for example.

Example

let mut token_iter = "foo 123".to_token_iter();

let parsed = <IntoIdent<Cons<Ident, LiteralInteger>>>::parser(&mut token_iter).unwrap();
assert_tokens_eq!(parsed, "foo123");

keyword!{Foo = "foo"}
let default = <IntoIdent<Cons<Foo, ConstInteger<1234>>>>::default();
assert_tokens_eq!(default, "foo1234");

Implementations

impl<T> IntoIdent<T>

where T: ToTokens,

pub fn from(from: &T) -> Result<IntoIdent<T>, Error>

Creates a IntoIdent from an AST.

Errors

This function returns an error when the provided data cannot be parsed as an identifier.

let mut token_iter = r#" foo "123" "#.to_token_iter();

let parsed = <Cons<Ident, LiteralString>>::parser(&mut token_iter).unwrap();
let ident = IntoIdent::from(&parsed).unwrap();

assert_eq!(ident.as_str(), "foo123");

impl<T> IntoIdent<T>

pub fn as_str(&self) -> &str

Returns the underlying &strwithout its surrounding quotes.

pub fn into_inner(self) -> Cached<Ident>

Destructures IntoIdent<T> to get the inner CachedIdent.

Trait Implementations

impl<T> Debug for IntoIdent<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for IntoIdent<T>

where T: Default + ToTokens,

Available on crate feature proc_macro2 only.

Creates a default constructed IntoIdent<T> from T

Panics

When the concatenation of T does not form a valid Ident.

fn default() -> IntoIdent<T>

Returns the “default value” for a type.

impl<T> From<IntoIdent<T>> for Ident

Available on crate feature proc_macro2 only.

Converts IntoIdent<T> into Ident by consuming the IntoIdent<T>.

fn from(this: IntoIdent<T>) -> Ident

Converts to this type from the input type.

impl<T> Parser for IntoIdent<T>

where T: Parse + ToTokens,

Available on crate feature proc_macro2 only.

fn parser(tokens: &mut TokenIter) -> Result<IntoIdent<T>, Error>

The actual parsing function that must be implemented. This mutates the tokens iterator directly. It should not be called from user code except for implementing parsers itself and then only when the rules below are followed.

impl<T> ToTokens for IntoIdent<T>

where T: ToTokens,

Available on crate feature proc_macro2 only.

fn to_tokens(&self, tokens: &mut TokenStream)

Write &self to the given TokenStream.

fn to_token_iter(&self) -> TokenIter

Convert &self into a TokenIter object.

fn into_token_iter(self) -> TokenIter

where Self: Sized,

Convert self into a TokenIter object.

fn to_token_stream(&self) -> TokenStream

Convert &self into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self into a TokenStream object.

fn tokens_to_string(&self) -> String

Convert &self into a String object. This is mostly used in the test suite to compare the outputs. When the input is a &str then this parses it and returns a normalized String.