# Syntax index

This appendix provides an index of tokens and common forms with links to where those elements are defined.

## Keywords

| Keyword       | Use |
|---------------|-----|
| `_`           | [wildcard pattern], [inferred const], [inferred type], [placeholder lifetime], [constant items], [extern crate], [use declarations], [destructuring assignment] |
| `abstract`    | [reserved keyword] |
| `as`          | [extern crate][items.extern-crate.as], [use declarations][items.use.forms.as], [type cast expressions], [qualified paths] |
| `async`       | [async functions], [async blocks], [async closures] |
| `await`       | [await expressions] |
| `become`      | [reserved keyword] |
| `box`         | [reserved keyword] |
| `break`       | [break expressions] |
| `const`       | [const functions], [const items], [const generics], [const blocks], [raw borrow operator], [raw pointer type], [const assembly operands] |
| `continue`    | [continue expressions] |
| `crate`       | [extern crate], [visibility], [paths] |
| `do`          | [reserved keyword] |
| `dyn`         | [trait objects] |
| `else`        | [let statements], [if expressions] |
| `enum`        | [enumerations] |
| `extern`      | [extern crate], [extern function qualifier], [external blocks], [extern function pointer types] |
| `false`       | [boolean type], [boolean expressions], [configuration predicates] |
| `final`       | [reserved keyword] |
| `fn`          | [functions], [function pointer types] |
| `for`         | [trait implementations], [iterator loops], [higher-ranked trait bounds] |
| `gen`         | [reserved keyword] |
| `if`          | [if expressions], [match guards] |
| `impl`        | [inherent impls], [trait impls], [impl trait types], [anonymous type parameters] |
| `in`          | [visibility], [iterator loops], [assembly operands] |
| `let`         | [let statements], [`if let` patterns] |
| `loop`        | [infinite loops] |
| `macro_rules` | [macros by example] |
| `macro`       | [reserved keyword] |
| `match`       | [match expressions] |
| `mod`         | [modules] |
| `move`        | [closure expressions], [async blocks] |
| `mut`         | [borrow expressions], [identifier patterns], [reference patterns], [struct patterns], [reference types], [raw pointer types], [self parameters], [static items] |
| `override`    | [reserved keyword] |
| `priv`        | [reserved keyword] |
| `pub`         | [visibility] |
| `raw`         | [borrow expressions], [raw assembly] |
| `ref`         | [identifier patterns], [struct patterns] |
| `return`      | [return expressions] |
| `safe`        | [external block functions], [external block statics] |
| `self`        | [extern crate][items.extern-crate.self], [self parameters], [visibility], [`self` paths] |
| `Self`        | [`Self` type paths], [use bounds] |
| `static`      | [static items], [`'static` lifetimes] |
| `struct`      | [structs] |
| `super`       | [super paths], [visibility] |
| `trait`       | [trait items] |
| `true`        | [boolean type], [boolean expressions], [configuration predicates] |
| `try`         | [reserved keyword] |
| `type`        | [type aliases] |
| `typeof`      | [reserved keyword] |
| `union`       | [union items] |
| `unsafe`      | [unsafe blocks], [unsafe attributes], [unsafe modules], [unsafe functions], [unsafe external blocks], [unsafe external functions], [unsafe external statics], [unsafe traits], [unsafe trait implementations] |
| `unsized`     | [reserved keyword] |
| `use`         | [use items], [use bounds] |
| `virtual`     | [reserved keyword] |
| `where`       | [where clauses] |
| `while`       | [predicate loops] |
| `yield`       | [reserved keyword] |

## Operators and punctuation

| Symbol | Name        | Use |
|--------|-------------|-----|
| `+`    | Plus        | [addition][arith], [trait bounds], [macro Kleene matcher] |
| `-`    | Minus       | [subtraction][arith], [negation] |
| `*`    | Star        | [multiplication][arith], [dereference], [raw pointers], [macro Kleene matcher], [glob imports] |
| `/`    | Slash       | [division][arith] |
| `%`    | Percent     | [remainder][arith] |
| `^`    | Caret       | [bitwise and logical XOR][arith] |
| `!`    | Not         | [bitwise and logical NOT][negation], [macro calls], [inner attributes][attributes], [never type], [negative impls] |
| `&`    | And         | [bitwise and logical AND][arith], [borrow], [references], [reference patterns] |
| `\|`   | Or | [bitwise and logical OR][arith], [closures], [or patterns], [if let], [while let] |
| `&&`   | AndAnd      | [lazy AND][lazy-bool], [borrow], [references], [reference patterns] |
| `\|\|` | OrOr | [lazy OR][lazy-bool], [closures] |
| `<<`   | Shl         | [shift left][arith], [nested generics][generics] |
| `>>`   | Shr         | [shift right][arith], [nested generics][generics] |
| `+=`   | PlusEq      | [addition assignment][compound] |
| `-=`   | MinusEq     | [subtraction assignment][compound] |
| `*=`   | StarEq      | [multiplication assignment][compound] |
| `/=`   | SlashEq     | [division assignment][compound] |
| `%=`   | PercentEq   | [remainder assignment][compound] |
| `^=`   | CaretEq     | [bitwise XOR assignment][compound] |
| `&=`   | AndEq       | [bitwise AND assignment][compound] |
| `\|=`  | OrEq | [bitwise OR assignment][compound] |
| `<<=`  | ShlEq       | [shift left assignment][compound] |
| `>>=`  | ShrEq       | [shift right assignment][compound], [nested generics][generics] |
| `=`    | Eq          | [assignment], [let statements], [attributes], various type definitions |
| `==`   | EqEq        | [equal][comparison] |
| `!=`   | Ne          | [not equal][comparison] |
| `>`    | Gt          | [greater than][comparison], [generics], [paths], [use bounds] |
| `<`    | Lt          | [less than][comparison], [generics], [paths], [use bounds] |
| `>=`   | Ge          | [greater than or equal to][comparison], [generics] |
| `<=`   | Le          | [less than or equal to][comparison] |
| `@`    | At          | [subpattern binding] |
| `.`    | Dot         | [field access][field], [tuple index] |
| `..`   | DotDot      | [range expressions][expr.range], [struct expressions], [rest pattern], [range patterns], [struct patterns] |
| `...`  | DotDotDot   | [variadic functions], [range patterns] |
| `..=`  | DotDotEq    | [inclusive range expressions][expr.range], [range patterns] |
| `,`    | Comma       | various separators |
| `;`    | Semi        | terminator for various items and statements, [array expressions], [array types] |
| `:`    | Colon       | various separators |
| `::`   | PathSep     | [path separator][paths] |
| `->`   | RArrow      | [functions], [closures], [function pointer type] |
| `=>`   | FatArrow    | [match arms][match], [macros] |
| `<-`   | LArrow      | The left arrow symbol has been unused since before Rust 1.0, but it is still treated as a single token. |
| `#`    | Pound       | [attributes], [raw string literals], [raw byte string literals], [raw C string literals] |
| `$`    | Dollar      | [macros] |
| `?`    | Question    | [try propagation expressions][question], [relaxed trait bounds], [macro Kleene matcher] |
| `~`    | Tilde       | The tilde operator has been unused since before Rust 1.0, but its token may still be used. |

## Comments

| Comment  | Use |
|----------|-----|
| `//`     | [line comment][comments] |
| `//!`    | [inner line comment][comments] |
| `///`    | [outer line doc comment][comments] |
| `/*…*/`  | [block comment][comments] |
| `/*!…*/` | [inner block doc comment][comments] |
| `/**…*/` | [outer block doc comment][comments] |

## Other tokens

| Token        | Use |
|--------------|-----|
| `ident`      | [identifiers] |
| `r#ident`    | [raw identifiers] |
| `'ident`     | [lifetimes and loop labels] |
| `'r#ident`   | [raw lifetimes and loop labels] |
| `…u8`, `…i32`, `…f64`, `…usize`, … | [number literals] |
| `"…"`        | [string literals] |
| `r"…"`, `r#"…"#`, `r##"…"##`, … | [raw string literals] |
| `b"…"`       | [byte string literals] |
| `br"…"`, `br#"…"#`, `br##"…"##`, … | [raw byte string literals] |
| `'…'`        | [character literals] |
| `b'…'`       | [byte literals] |
| `c"…"`       | [C string literals] |
| `cr"…"`, `cr#"…"#`, `cr##"…"##`, … | [raw C string literals] |

## Macros

| Syntax                                     | Use |
|--------------------------------------------|-----|
| `ident!(…)`<br>`ident! {…}`<br>`ident![…]` | [macro invocations] |
| `$ident`                                   | [macro metavariable] |
| `$ident:kind`                              | [macro matcher fragment specifier] |
| `$(…)…`                                    | [macro repetition] |

## Attributes

| Syntax     | Use |
|------------|-----|
| `#[meta]`  | [outer attribute] |
| `#![meta]` | [inner attribute] |

## Expressions

| Expression                | Use |
|---------------------------|-----|
| `\|…\| expr`<br>`\|…\| -> Type { … }` | [closures] |
| `ident::…`                | [paths] |
| `::crate_name::…`         | [explicit crate paths] |
| `crate::…`                | [crate-relative paths] |
| `self::…`                 | [module-relative paths] |
| `super::…`                | [parent module paths] |
| `Type::…`<br>`<Type as Trait>::ident` | [associated items] |
| `<Type>::…`               | [qualified paths] which can be used for types without names such as `<&T>::…`, `<[T]>::…`, etc. |
| `Trait::method(…)`<br>`Type::method(…)`<br>`<Type as Trait>::method(…)` | [disambiguated method calls] |
| `method::<…>(…)`<br>`path::<…>` | [generic arguments], aka turbofish |
| `()`                      | [unit] |
| `(expr)`                  | [parenthesized expressions] |
| `(expr,)`                 | [single-element tuple expressions] |
| `(expr, …)`               | [tuple expressions] |
| `expr(expr, …)`           | [call expressions] |
| `expr.0`, `expr.1`, …     | [tuple indexing expressions] |
| `expr.ident`              | [field access expressions] |
| `{…}`                     | [block expressions] |
| `Type {…}`                | [struct expressions] |
| `Type(…)`                 | [tuple struct constructors] |
| `[…]`                     | [array expressions] |
| `[expr; len]`             | [repeat array expressions] |
| `expr[..]`, `expr[a..]`, `expr[..b]`, `expr[a..b]`, `expr[a..=b]`, `expr[..=b]` | [array and slice indexing expressions] |
| `if expr {…} else {…}`    | [if expressions] |
| `match expr { pattern => {…} }` | [match expressions] |
| `loop {…}`                | [infinite loop expressions] |
| `while expr {…}`          | [predicate loop expressions] |
| `for pattern in expr {…}` | [iterator loops] |
| `&expr`<br>`&mut expr`    | [borrow expressions] |
| `&raw const expr`<br>`&raw mut expr` | [raw borrow expressions] |
| `*expr`                   | [dereference expressions] |
| `expr?`                   | [try propagation expressions] |
| `-expr`                   | [negation expressions] |
| `!expr`                   | [bitwise and logical NOT expressions] |
| `expr as Type`            | [type cast expressions] |

## Items

[Items] are the components of a crate.

| Item                          | Use |
|-------------------------------|-----|
| `mod ident;`<br>`mod ident {…}` | [modules] |
| `use path;`                   | [use declarations] |
| `fn ident(…) {…}`             | [functions] |
| `type Type = Type;`           | [type aliases] |
| `struct ident {…}`            | [structs] |
| `enum ident {…}`              | [enumerations] |
| `union ident {…}`             | [unions] |
| `trait ident {…}`             | [traits] |
| `impl Type {…}`<br>`impl Type for Trait {…}` | [implementations] |
| `const ident = expr;`         | [constant items] |
| `static ident = expr;`        | [static items] |
| `extern "C" {…}`              | [external blocks] |
| `fn ident<…>(…) …`<br>`struct ident<…> {…}`<br>`enum ident<…> {…}`<br>`impl<…> Type<…> {…}` | [generic definitions] |

## Type expressions

[Type expressions] are used to refer to types.

| Type                                  | Use |
|---------------------------------------|-----|
| `bool`, `u8`, `f64`, `str`, …         | [primitive types] |
| `for<…>`                              | [higher-ranked trait bounds] |
| `T: TraitA + TraitB`                  | [trait bounds] |
| `T: 'a + 'b`                          | [lifetime bounds] |
| `T: TraitA + 'a`                      | [trait and lifetime bounds] |
| `T: ?Sized`                           | [relaxed trait bounds] |
| `[Type; len]`                         | [array types] |
| `(Type, …)`                           | [tuple types] |
| `[Type]`                              | [slice types] |
| `(Type)`                              | [parenthesized types] |
| `impl Trait`                          | [impl trait types], [anonymous type parameters] |
| `dyn Trait`                           | [trait object types] |
| `ident`<br>`ident::…`                 | [type paths] (can refer to [structs], [enumerations], [unions], [type aliases], [traits], [generics], etc.) |
| `Type<…>`<br>`Trait<…>`               | [generic arguments] (e.g. `Vec<u8>`) |
| `Trait<ident = Type>`                 | [associated type bindings] (e.g. `Iterator<Item = T>`) |
| `Trait<ident: …>`                     | [associated type bounds] (e.g. `Iterator<Item: Send>`) |
| `&Type`<br>`&mut Type`                | [reference types] |
| `*mut Type`<br>`*const Type`          | [raw pointer types] |
| `fn(…) -> Type`                       | [function pointer types] |
| `_`                                   | [inferred type], [inferred const] |
| `'_`                                  | [placeholder lifetime] |
| `!`                                   | [never type] |

## Patterns

[Patterns] are used to match values.

| Pattern                           | Use |
|-----------------------------------|-----|
| `"foo"`, `'a'`, `123`, `2.4`, …   | [literal patterns] |
| `ident`                           | [identifier patterns] |
| `_`                               | [wildcard pattern] |
| `..`                              | [rest pattern] |
| `a..`, `..b`, `a..b`, `a..=b`, `..=b` | [range patterns] |
| `&pattern`<br>`&mut pattern`      | [reference patterns] |
| `path {…}`                        | [struct patterns] |
| `path(…)`                         | [tuple struct patterns] |
| `(pattern, …)`                    | [tuple patterns] |
| `(pattern)`                       | [grouped patterns] |
| `[pattern, …]`                    | [slice patterns] |
| `CONST`, `Enum::Variant`, …       | [path patterns] |

[`'static` lifetimes]: bound
[`if let` patterns]: expr.if.let
[`self` paths]: paths.qualifiers.mod-self
[`Self` type paths]: paths.qualifiers.type-self
[anonymous type parameters]: type.impl-trait.param
[arith]: expr.arith-logic
[array and slice indexing expressions]: expr.array.index
[array expressions]: expr.array
[array types]: type.array
[assembly operands]: asm.operand-type.supported-operands.in
[assignment]: expr.assign
[associated items]: items.associated
[associated type bindings]: paths.expr
[associated type bounds]: paths.expr
[async blocks]: expr.block.async
[async closures]: expr.closure.async
[async functions]: items.fn.async
[await expressions]: expr.await
[bitwise and logical NOT expressions]: expr.negate
[block expressions]: expr.block
[boolean expressions]: expr.literal
[boolean type]: type.bool
[borrow expressions]: expr.operator.borrow
[borrow]: expr.operator.borrow
[break expressions]: expr.loop.break
[byte literals]: lex.token.byte
[byte string literals]: lex.token.str-byte
[C string literals]: lex.token.str-c
[call expressions]: expr.call
[character literals]: lex.token.literal.char
[closure expressions]: expr.closure
[closures]: expr.closure
[comparison]: expr.cmp
[compound]: expr.compound-assign
[configuration predicates]: cfg
[const assembly operands]: asm.operand-type.supported-operands.const
[const blocks]: expr.block.const
[const functions]: const-eval.const-fn
[const generics]: items.generics.const
[const items]: items.const
[constant items]: items.const
[continue expressions]: expr.loop.continue
[crate-relative paths]: paths.qualifiers.crate
[dereference expressions]: expr.deref
[dereference]: expr.deref
[destructuring assignment]: expr.placeholder
[disambiguated method calls]: expr.call.desugar
[enumerations]: items.enum
[explicit crate paths]: paths.qualifiers.global-root
[extern crate]: items.extern-crate
[extern function pointer types]: type.fn-pointer.qualifiers
[extern function qualifier]: items.fn.extern
[external block functions]: items.extern.fn
[external block statics]: items.extern.static
[external blocks]: items.extern
[field access expressions]: expr.field
[field]: expr.field
[function pointer type]: type.fn-pointer
[function pointer types]: type.fn-pointer
[functions]: items.fn
[generic arguments]: items.generics
[generic definitions]: items.generics
[generics]: items.generics
[glob imports]: items.use.glob
[grouped patterns]: patterns.paren
[higher-ranked trait bounds]: bound.higher-ranked
[identifier patterns]: patterns.ident
[identifiers]: ident
[if expressions]: expr.if
[if let]: expr.if.let
[impl trait types]: type.impl-trait.return
[implementations]: items.impl
[inferred const]: items.generics.const.inferred
[inferred type]: type.inferred
[infinite loop expressions]: expr.loop.infinite
[infinite loops]: expr.loop.infinite
[inherent impls]: items.impl.inherent
[inner attribute]: attributes.inner
[iterator loops]: expr.loop.for
[lazy-bool]: expr.bool-logic
[let statements]: statement.let
[lifetime bounds]: bound.lifetime
[lifetimes and loop labels]: lex.token.life
[literal patterns]: patterns.literal
[macro calls]: macro.invocation
[macro invocations]: macro.invocation
[macro Kleene matcher]: macro.decl.repetition
[macro matcher fragment specifier]: macro.decl.meta.specifier
[macro metavariable]: macro.decl.meta
[macro repetition]: macro.decl.repetition
[macros by example]: macro.decl
[macros]: macro.decl
[match expressions]: expr.match
[match guards]: expr.match.guard
[match]: expr.match
[module-relative paths]: paths.qualifiers.mod-self
[modules]: items.mod
[negation expressions]: expr.negate
[negation]: expr.negate
[negative impls]: items.impl
[never type]: type.never
[number literals]: lex.token.literal.num
[or patterns]: patterns.or
[outer attribute]: attributes.outer
[parent module paths]: paths.qualifiers.super
[parenthesized expressions]: expr.paren
[parenthesized types]: type.name.parenthesized
[path patterns]: patterns.path
[placeholder lifetime]: lifetime-elision.function.explicit-placeholder
[predicate loop expressions]: expr.loop.while
[predicate loops]: expr.loop.while
[primitive types]: type.kinds
[qualified paths]: paths.qualified
[question]: expr.try
[range patterns]: patterns.range
[raw assembly]: asm.options.supported-options.raw
[raw borrow expressions]: expr.borrow.raw
[raw borrow operator]: expr.borrow.raw
[raw byte string literals]: lex.token.str-byte-raw
[raw C string literals]: lex.token.str-c-raw
[raw identifiers]: ident.raw
[raw lifetimes and loop labels]: lex.token.life
[raw pointer type]: type.pointer.raw
[raw pointer types]: type.pointer.raw
[raw pointers]: type.pointer.raw
[raw string literals]: lex.token.literal.str-raw
[reference patterns]: patterns.ref
[reference types]: type.pointer.reference
[references]: type.pointer.reference
[relaxed trait bounds]: bound.sized
[repeat array expressions]: expr.array
[reserved keyword]: lex.keywords.reserved
[rest pattern]: patterns.rest
[return expressions]: expr.return
[self parameters]: items.fn.params.self-pat
[single-element tuple expressions]: expr.tuple
[slice patterns]: patterns.slice
[slice types]: type.slice
[static items]: items.static
[string literals]: lex.token.literal.str
[struct expressions]: expr.struct
[struct patterns]: patterns.struct
[structs]: items.struct
[subpattern binding]: patterns.ident.scrutinized
[super paths]: paths.qualifiers.super
[trait and lifetime bounds]: bound
[trait bounds]: bound
[trait implementations]: items.impl.trait
[trait impls]: items.impl.trait
[trait items]: items.traits
[trait object types]: type.trait-object
[trait objects]: type.trait-object
[traits]: items.traits
[try propagation expressions]: expr.try
[tuple expressions]: expr.tuple
[tuple index]: expr.tuple-index
[tuple indexing expressions]: expr.tuple-index
[tuple patterns]: patterns.tuple
[tuple struct constructors]: items.struct.tuple
[tuple struct patterns]: patterns.tuple-struct
[tuple types]: type.tuple
[type aliases]: items.type
[type cast expressions]: expr.as
[Type expressions]: type.name
[type paths]: type.name.path
[union items]: items.union
[unions]: items.union
[unit]: type.tuple.unit
[unsafe attributes]: attributes.safety
[unsafe blocks]: expr.block.unsafe
[unsafe external blocks]: unsafe.extern
[unsafe external functions]: items.extern.fn.safety
[unsafe external statics]: items.extern.static.safety
[unsafe functions]: unsafe.fn
[unsafe modules]: items.mod.unsafe
[unsafe trait implementations]: items.impl.trait.safety
[unsafe traits]: items.traits.safety
[use bounds]: bound.use
[use declarations]: items.use
[use items]: items.use
[variadic functions]: items.extern.variadic
[visibility]: vis
[where clauses]: items.generics.where
[while let]: expr.loop.while.let
[wildcard pattern]: patterns.wildcard
