Module syn::token [] [src]

Tokens representing Rust punctuation, keywords, and delimiters.

The type names in this module can be difficult to keep straight, so we prefer to use the Token! macro instead. This is a type-macro that expands to the token type of the given token.

Example

The ItemStatic syntax tree node is defined like this.

pub struct ItemStatic {
    pub attrs: Vec<Attribute>,
    pub vis: Visibility,
    pub static_token: Token![static],
    pub mutability: Option<Token![mut]>,
    pub ident: Ident,
    pub colon_token: Token![:],
    pub ty: Box<Type>,
    pub eq_token: Token![=],
    pub expr: Box<Expr>,
    pub semi_token: Token![;],
}

Parsing

These tokens can be parsed using the Synom trait and the parser combinator macros punct!, keyword!, parens!, braces!, and brackets!.

#[macro_use]
extern crate syn;

use syn::synom::Synom;
use syn::{Attribute, Visibility, Ident, Type, Expr};

// Parse the ItemStatic struct shown above.
impl Synom for ItemStatic {
    named!(parse -> Self, do_parse!(
        attrs: many0!(Attribute::parse_outer) >>
        vis: syn!(Visibility) >>
        static_token: keyword!(static) >>
        mutability: option!(keyword!(mut)) >>
        ident: syn!(Ident) >>
        colon_token: punct!(:) >>
        ty: syn!(Type) >>
        eq_token: punct!(=) >>
        expr: syn!(Expr) >>
        semi_token: punct!(;) >>
        (ItemStatic {
            attrs, vis, static_token, mutability, ident, colon_token,
            ty: Box::new(ty), eq_token, expr: Box::new(expr), semi_token,
        })
    ));
}

Structs

Add

+

AddEq

+=

And

&

AndAnd

&&

AndEq

&=

Apostrophe

'

As

as

Async

async

At

@

Auto

auto

Bang

!

Box

box

Brace

{...}

Bracket

[...]

Break

break

CapSelf

Self

Caret

^

CaretEq

^=

Catch

catch

Colon

:

Colon2

::

Comma

,

Const

const

Continue

continue

Crate

crate

Default

default

Div

/

DivEq

/=

Do

do

Dollar

$

Dot

.

Dot2

..

Dot3

...

DotDotEq

..=

Dyn

dyn

Else

else

Enum

enum

Eq

=

EqEq

==

Extern

extern

FatArrow

=>

Fn

fn

For

for

Ge

>=

Group

None-delimited group

Gt

>

If

if

Impl

impl

In

in

LArrow

<-

Le

<=

Let

let

Loop

loop

Lt

<

Macro

macro

Match

match

Mod

mod

Move

move

MulEq

*=

Mut

mut

Ne

!=

Or

|

OrEq

|=

OrOr

||

Paren

(...)

Pound

#

Pub

pub

Question

?

RArrow

->

Ref

ref

Rem

%

RemEq

%=

Return

return

Self_

self

Semi

;

Shl

<<

ShlEq

<<=

Shr

>>

ShrEq

>>=

Star

*

Static

static

Struct

struct

Sub

-

SubEq

-=

Super

super

Trait

trait

Type

type

Underscore

_

Union

union

Unsafe

unsafe

Use

use

Where

where

While

while

Yield

yield