# Module syn::token

source · [−]
Expand description

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

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};

    // Parse the ItemStatic struct shown above.
    impl Parse for ItemStatic {
        fn parse(input: ParseStream) -> Result<Self> {
            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()?,
            })
        }
    }

## Other operations

Every keyword and punctuation token supports the following operations.

- Peeking — `input.peek(Token![...])`

- Parsing — `input.parse::<Token![...]>()?`

- Printing — `quote!( ... #the_token ... )`

- Construction from a `Span` — `let the_token = Token![...](sp)`

- Field access to its span — `let sp = the_token.span`

## Structs

Abstract

`abstract`

Add

`+`

AddEq

`+=`

And

`&`

AndAnd

`&&`

AndEq

`&=`

As

`as`

Async

`async`

At

`@`

Auto

`auto`

Await

`await`

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

`==`

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.