Enum parsel::ast::Lit

pub enum Lit {
    Bool(LitBool),
    Byte(LitByte),
    Int(LitInt),
    Uint(LitUint),
    Float(LitFloat),
    Char(LitChar),
    Str(LitStr),
    ByteStr(LitByteStr),
}

Represents any literal value.

The following is a lazy doc-test for ensuring that the Span of literals is preserved when converted between parsel::ast::Lit and syn::Lit.

// This deliberately uses `parse_str()` instead of `parse_quote!{}`
// because the former results in meaningful `Span` values, while
// the latter would cause every token to be spanned to the call site.
let source = r#"
true
   false  6.283
  100000023456         b'\xa3'
      "foo bar baz" - 74819253
   -987766554433221100
    b"This is a byte string! A literal one."
"#;
let parsel: Many<Lit> = parsel::parse_str(source).unwrap();
let syn: Many<syn::Lit> = parsel::parse_str(source).unwrap();

let parsel_strings: Vec<_> = parsel
    .iter()
    .map(Lit::to_string)
    .collect();
let syn_strings: Vec<_> = syn
    .iter()
    .map(|lit| -> String {
        // if we simply used `TokenStream::to_string()` here, then multi-token
        // negative literals would fail the test since their representation
        // sometimes includes a space between the sign and the digits.
        lit.to_token_stream().into_iter().map(|tt| tt.to_string()).collect()
    })
    .collect();

assert_eq!(parsel_strings, syn_strings);

let parsel_spans: Vec<_> = parsel
    .iter()
    .map(Lit::span)
    .map(|span| (span.start(), span.end()))
    .collect();
let syn_spans: Vec<_> = syn
    .iter()
    .map(syn::Lit::span)
    .map(|span| (span.start(), span.end()))
    .collect();

assert_eq!(parsel_spans, syn_spans);

let parsel_converted_spans: Vec<_> = parsel
    .into_iter()
    .map(|lit| syn::Lit::from(lit).span())
    .map(|span| (span.start(), span.end()))
    .collect();
let syn_converted_spans: Vec<_> = syn
    .into_iter()
    .map(|lit| Lit::try_from(lit).unwrap().span())
    .map(|span| (span.start(), span.end()))
    .collect();

assert_eq!(parsel_converted_spans, syn_converted_spans);

Variants

Bool(LitBool)

Byte(LitByte)

Int(LitInt)

Uint(LitUint)

Float(LitFloat)

Char(LitChar)

Str(LitStr)

ByteStr(LitByteStr)

Implementations

impl Lit

pub const fn span(&self) -> Span

pub fn set_span(&mut self, new_span: Span)

Trait Implementations

impl Clone for Lit

fn clone(&self) -> Lit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Lit

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

Formats the value using the given formatter.

impl Display for Lit

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

Formats the value using the given formatter.

impl From<&[u8]> for Lit

fn from(value: &[u8]) -> Self

Converts to this type from the input type.

impl From<&str> for Lit

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<Box<[u8]>> for Lit

fn from(value: Box<[u8]>) -> Self

Converts to this type from the input type.

impl From<Box<str>> for Lit

fn from(value: Box<str>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, [u8]>> for Lit

fn from(value: Cow<'_, [u8]>) -> Self

Converts to this type from the input type.

impl From<Cow<'_, str>> for Lit

fn from(value: Cow<'_, str>) -> Self

Converts to this type from the input type.

impl From<Lit> for Lit

fn from(lit: Lit) -> Self

Converts to this type from the input type.

impl From<LitBool> for Lit

fn from(lit: LitBool) -> Self

Converts to this type from the input type.

impl From<LitByte> for Lit

fn from(lit: LitByte) -> Self

Converts to this type from the input type.

impl From<LitByteStr> for Lit

fn from(lit: LitByteStr) -> Self

Converts to this type from the input type.

impl From<LitChar> for Lit

fn from(lit: LitChar) -> Self

Converts to this type from the input type.

impl From<LitFloat> for Lit

fn from(lit: LitFloat) -> Self

Converts to this type from the input type.

impl From<LitInt> for Lit

fn from(lit: LitInt) -> Self

Converts to this type from the input type.

impl From<LitStr> for Lit

fn from(lit: LitStr) -> Self

Converts to this type from the input type.

impl From<LitUint> for Lit

fn from(lit: LitUint) -> Self

Converts to this type from the input type.

impl From<NotNan<f64>> for Lit

fn from(value: NotNan<f64>) -> Self

Converts to this type from the input type.

impl From<String> for Lit

fn from(value: String) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Lit

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl From<bool> for Lit

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<char> for Lit

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<i64> for Lit

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<u64> for Lit

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Lit

fn from(value: u8) -> Self

Converts to this type from the input type.

impl FromStr for Lit

type Err = Error

The associated error which can be returned from parsing.

fn from_str(string: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Hash for Lit

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parse for Lit

fn parse(input: ParseStream<'_>) -> Result<Self>

impl PartialEq for Lit

fn eq(&self, other: &Lit) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ToTokens for Lit

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

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl TryFrom<Lit> for Lit

type Error = Error

The type returned in the event of a conversion error.

fn try_from(lit: Lit) -> Result<Self>

Performs the conversion.

impl TryFrom<f64> for Lit

type Error = FloatIsNan

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Lit

impl StructuralPartialEq for Lit