# [−] [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.

    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.