Enum ValueSyntax 

pub enum ValueSyntax {
    Eq,
    Paren,
}

Syntax used for providing a value

Variants

Eq

= contents

Paren

(contents)

Implementations

impl ValueSyntax

pub const fn is_eq(self) -> bool

Returns true if the syntax is Eq.

Example

assert!(ValueSyntax::Eq.is_eq());
assert!(!ValueSyntax::Paren.is_eq());

pub const fn is_paren(self) -> bool

Returns true if the syntax is Paren.

Example

assert!(ValueSyntax::Paren.is_paren());
assert!(!ValueSyntax::Eq.is_paren());

pub fn from_stream(parse: &ParseBuffer<'_>) -> Option<ValueSyntax>

Peek the stream without moving the cursor and attempt to construct self based on the next token.

Example

struct Foo {
  peek: Option<ValueSyntax>,
  rest: TokenStream,
}

impl Parse for Foo {
  fn parse(input: ParseStream) -> syn::Result<Self> {
    let peek = ValueSyntax::from_stream(input);
    let rest = input.parse()?;

    Ok(Self { peek, rest })
  }
}

let v: Foo = syn::parse2(quote!(= 123)).unwrap();
assert_eq!(v.peek, Some(ValueSyntax::Eq));
assert_eq!(v.rest.to_string(), "= 123");

let v: Foo = syn::parse2(quote!((456))).unwrap();
assert_eq!(v.peek, Some(ValueSyntax::Paren));
assert_eq!(v.rest.to_string(), "(456)");

let v: Foo = syn::parse2(quote!(none)).unwrap();
assert_eq!(v.peek, None);
assert_eq!(v.rest.to_string(), "none");

pub fn parse_token( self, input: &ParseBuffer<'_>, ) -> Result<Option<ParseBuffer<'_>>, Error>

Parse whatever tokens need to be parsed based on the resolved syntax. Returns a ParseBuffer you should continue parsing if the syntax is Paren.

Example

/// `=` implementation
struct Wrapper1(syn::LitStr);
impl Parse for Wrapper1 {
  fn parse(input: ParseStream) -> syn::Result<Self> {
      let inner = ValueSyntax::Eq.parse_token(input)?;
      assert!(inner.is_none());
      Ok(Self(input.parse()?))
  }
}

/// `(value)` implementation
struct Wrapper2(syn::LitStr);
impl Parse for Wrapper2 {
  fn parse(input: ParseStream) -> syn::Result<Self> {
      let inner = ValueSyntax::Paren.parse_token(input)?.expect("expected inner buffer");
      Ok(Self(inner.parse()?))
  }
}

let v: Wrapper1 = syn::parse2(quote!(= "foo")).unwrap();
assert_eq!(v.0.value(), "foo");

let v: Wrapper2 = syn::parse2(quote!(("bar"))).unwrap();
assert_eq!(v.0.value(), "bar");

pub fn parse<P>(self, input: &ParseBuffer<'_>) -> Result<P, Error>

where P: Parse,

Parse whatever tokens need to be parsed based on the resolved syntax and then parse the referenced value as P.

Example

/// `=` implementation
struct Wrapper1(syn::LitStr);
impl Parse for Wrapper1 {
  fn parse(input: ParseStream) -> syn::Result<Self> {
      Ok(Self(ValueSyntax::Eq.parse(input)?))
  }
}

/// `(value)` implementation
struct Wrapper2(syn::LitStr);
impl Parse for Wrapper2 {
  fn parse(input: ParseStream) -> syn::Result<Self> {
      Ok(Self(ValueSyntax::Paren.parse(input)?))
  }
}

let v: Wrapper1 = syn::parse2(quote!(= "foo")).unwrap();
assert_eq!(v.0.value(), "foo");

let v: Wrapper2 = syn::parse2(quote!(("bar"))).unwrap();
assert_eq!(v.0.value(), "bar");

Trait Implementations

impl Clone for ValueSyntax

fn clone(&self) -> ValueSyntax

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ValueSyntax

impl Debug for ValueSyntax

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

Formats the value using the given formatter.

impl Eq for ValueSyntax

impl PartialEq for ValueSyntax

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ValueSyntax