[][src]Module syn::token

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.

# use syn::{Attribute, Expr, Ident, Token, Type, Visibility};
#
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

Keywords and punctuation can be parsed through the ParseStream::parse method. Delimiter tokens are parsed using the parenthesized!, bracketed! and braced! macros.

use syn::{Attribute, Result};
use syn::parse::{Parse, ParseStream};
#
# enum ItemStatic {}

// Parse the ItemStatic struct shown above.
impl Parse for ItemStatic {
    fn parse(input: ParseStream) -> Result<Self> {
        # use syn::ItemStatic;
        # fn parse(input: ParseStream) -> Result<ItemStatic> {
        Ok(ItemStatic {
            attrs: input.call(Attribute::parse_outer)?,
            vis: input.parse()?,
            static_token: input.parse()?,
            mutability: input.parse()?,
            ident: input.parse()?,
            colon_token: input.parse()?,
            ty: input.parse()?,
            eq_token: input.parse()?,
            expr: input.parse()?,
            semi_token: input.parse()?,
        })
        # }
        # unimplemented!()
    }
}

Other operations

Every keyword and punctuation token supports the following operations.

Structs

Abstract

abstract

Add

+

AddEq

+=

And

&

AndAnd

&&

AndEq

&=

As

as

Async

async

At

@

Auto

auto

Bang

!

Become

become

Box

box

Brace

{...}

Bracket

[...]

Break

break

Caret

^

CaretEq

^=

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

==

Existential

existential

Extern

extern

FatArrow

=>

Final

final

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

||

Override

override

Paren

(...)

Pound

#

Priv

priv

Pub

pub

Question

?

RArrow

->

Ref

ref

Rem

%

RemEq

%=

Return

return

SelfType

Self

SelfValue

self

Semi

;

Shl

<<

ShlEq

<<=

Shr

>>

ShrEq

>>=

Star

*

Static

static

Struct

struct

Sub

-

SubEq

-=

Super

super

Tilde

~

Trait

trait

Try

try

Type

type

Typeof

typeof

Underscore

_

Union

union

Unsafe

unsafe

Unsized

unsized

Use

use

Virtual

virtual

Where

where

While

while

Yield

yield

Traits

Token

Marker trait for types that represent single tokens.