Enum Literal

pub enum Literal<B: Buffer> {
    Bool(BoolLit),
    Integer(IntegerLit<B>),
    Float(FloatLit<B>),
    Char(CharLit<B>),
    String(StringLit<B>),
    Byte(ByteLit<B>),
    ByteString(ByteStringLit<B>),
}

A literal. This is the main type of this library.

This type is generic over the underlying buffer B, which can be &str or String.

To create this type, you have to either call Literal::parse with an input string or use the From<_> impls of this type. The impls are only available of the corresponding crate features are enabled (they are enabled by default).

Variants

Bool(BoolLit)

Integer(IntegerLit<B>)

Float(FloatLit<B>)

Char(CharLit<B>)

String(StringLit<B>)

Byte(ByteLit<B>)

ByteString(ByteStringLit<B>)

Implementations

impl<B: Buffer> Literal<B>

pub fn parse(input: B) -> Result<Self, ParseError>

Parses the given input as a Rust literal.

pub fn suffix(&self) -> &str

Returns the suffix of this literal or "" if it doesn’t have one.

Rust token grammar actually allows suffixes for all kinds of tokens. Most Rust programmer only know the type suffixes for integer and floats, e.g. 0u32. And in normal Rust code, everything else causes an error. But it is possible to pass literals with arbitrary suffixes to proc macros, for example:

some_macro!(3.14f33  16px  '🦊'good_boy  "toph"beifong);

Boolean literals, not actually being literals, but idents, cannot have suffixes and this method always returns "" for those.

There are some edge cases to be aware of:

• Integer suffixes must not start with e or E as that conflicts with the exponent grammar for floats. 0e1 is a float; 0eel is also parsed as a float and results in an error.
• Hexadecimal integers eagerly parse digits, so 0x5abcdefgh has a suffix von gh.
• Suffixes can contain and start with _, but for integer and number literals, _ is eagerly parsed as part of the number, so 1_x has the suffix x.
• The input 55f32 is regarded as integer literal with suffix f32.

Example

use litrs::Literal;

assert_eq!(Literal::parse(r##"3.14f33"##).unwrap().suffix(), "f33");
assert_eq!(Literal::parse(r##"123hackerman"##).unwrap().suffix(), "hackerman");
assert_eq!(Literal::parse(r##"0x0fuck"##).unwrap().suffix(), "uck");
assert_eq!(Literal::parse(r##"'🦊'good_boy"##).unwrap().suffix(), "good_boy");
assert_eq!(Literal::parse(r##""toph"beifong"##).unwrap().suffix(), "beifong");

impl Literal<&str>

pub fn into_owned(self) -> Literal<String>

Makes a copy of the underlying buffer and returns the owned version of Self.

Trait Implementations

impl<B: Clone + Buffer> Clone for Literal<B>

fn clone(&self) -> Literal<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Buffer> Debug for Literal<B>

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

Formats the value using the given formatter.

impl<B: Buffer> Display for Literal<B>

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

Formats the value using the given formatter.

impl From<&Literal> for Literal<String>

fn from(src: &Literal) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<BoolLit> for Literal<B>

fn from(src: BoolLit) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<ByteLit<B>> for Literal<B>

fn from(src: ByteLit<B>) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<ByteStringLit<B>> for Literal<B>

fn from(src: ByteStringLit<B>) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<CharLit<B>> for Literal<B>

fn from(src: CharLit<B>) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<FloatLit<B>> for Literal<B>

fn from(src: FloatLit<B>) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<IntegerLit<B>> for Literal<B>

fn from(src: IntegerLit<B>) -> Self

Converts to this type from the input type.

impl From<Literal> for Literal<String>

fn from(src: Literal) -> Self

Converts to this type from the input type.

impl<B: Buffer> From<StringLit<B>> for Literal<B>

fn from(src: StringLit<B>) -> Self

Converts to this type from the input type.

impl<B: PartialEq + Buffer> PartialEq for Literal<B>

fn eq(&self, other: &Literal<B>) -> 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 TryFrom<&TokenTree> for Literal<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(tt: &TokenTree) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TokenTree> for Literal<String>

type Error = InvalidToken

The type returned in the event of a conversion error.

fn try_from(tt: TokenTree) -> Result<Self, Self::Error>

Performs the conversion.

impl<B: Eq + Buffer> Eq for Literal<B>

impl<B: Buffer> StructuralPartialEq for Literal<B>