Syntax Index

Keywords

• as: primitive casting, or disambiguating the specific trait containing an item. See Casting Between Types (as), Universal Function Call Syntax (Angle-bracket Form), Associated Types.
• break: break out of loop. See Loops (Ending Iteration Early).
• const: constant items and constant raw pointers. See const and static, Raw Pointers.
• continue: continue to next loop iteration. See Loops (Ending Iteration Early).
• crate: external crate linkage. See Crates and Modules (Importing External Crates).
• else: fallback for if and if let constructs. See if, if let.
• enum: defining enumeration. See Enums.
• extern: external crate, function, and variable linkage. See Crates and Modules (Importing External Crates), Foreign Function Interface.
• false: boolean false literal. See Primitive Types (Booleans).
• fn: function definition and function pointer types. See Functions.
• for: iterator loop, part of trait impl syntax, and higher-ranked lifetime syntax. See Loops (for), Method Syntax.
• if: conditional branching. See if, if let.
• impl: inherent and trait implementation blocks. See Method Syntax.
• in: part of for loop syntax. See Loops (for).
• let: variable binding. See Variable Bindings.
• loop: unconditional, infinite loop. See Loops (loop).
• match: pattern matching. See Match.
• mod: module declaration. See Crates and Modules (Defining Modules).
• move: part of closure syntax. See Closures (move closures).
• mut: denotes mutability in pointer types and pattern bindings. See Mutability.
• pub: denotes public visibility in struct fields, impl blocks, and modules. See Crates and Modules (Exporting a Public Interface).
• ref: by-reference binding. See Patterns (ref and ref mut).
• return: return from function. See Functions (Early Returns).
• Self: implementor type alias. See Traits.
• self: method subject. See Method Syntax (Method Calls).
• static: global variable. See const and static (static).
• struct: structure definition. See Structs.
• trait: trait definition. See Traits.
• true: boolean true literal. See Primitive Types (Booleans).
• type: type alias, and associated type definition. See type Aliases, Associated Types.
• unsafe: denotes unsafe code, functions, traits, and implementations. See Unsafe.
• use: import symbols into scope. See Crates and Modules (Importing Modules with use).
• where: type constraint clauses. See Traits (where clause).
• while: conditional loop. See Loops (while).

Operators and Symbols

• ! (ident!(…), ident!{…}, ident![…]): denotes macro expansion. See Macros.
• ! (!expr): bitwise or logical complement. Overloadable (Not).
• != (var != expr): nonequality comparison. Overloadable (PartialEq).
• % (expr % expr): arithmetic remainder. Overloadable (Rem).
• %= (var %= expr): arithmetic remainder & assignment. Overloadable (RemAssign).
• & (expr & expr): bitwise and. Overloadable (BitAnd).
• & (&expr): borrow. See References and Borrowing.
• & (&type, &mut type, &'a type, &'a mut type): borrowed pointer type. See References and Borrowing.
• &= (var &= expr): bitwise and & assignment. Overloadable (BitAndAssign).
• && (expr && expr): logical and.
• * (expr * expr): arithmetic multiplication. Overloadable (Mul).
• * (*expr): dereference.
• * (*const type, *mut type): raw pointer. See Raw Pointers.
• *= (var *= expr): arithmetic multiplication & assignment. Overloadable (MulAssign).
• + (expr + expr): arithmetic addition. Overloadable (Add).
• + (trait + trait, 'a + trait): compound type constraint. See Traits (Multiple Trait Bounds).
• += (var += expr): arithmetic addition & assignment. Overloadable (AddAssign).
• ,: argument and element separator. See Attributes, Functions, Structs, Generics, Match, Closures, Crates and Modules (Importing Modules with use).
• - (expr - expr): arithmetic subtraction. Overloadable (Sub).
• - (- expr): arithmetic negation. Overloadable (Neg).
• -= (var -= expr): arithmetic subtraction & assignment. Overloadable (SubAssign).
• -> (fn(…) -> type, |…| -> type): function and closure return type. See Functions, Closures.
• -> ! (fn(…) -> !, |…| -> !): diverging function or closure. See Diverging Functions.
• . (expr.ident): member access. See Structs, Method Syntax.
• .. (.., expr.., ..expr, expr..expr): right-exclusive range literal.
• .. (..expr): struct literal update syntax. See Structs (Update syntax).
• .. (variant(x, ..), struct_type { x, .. }): "and the rest" pattern binding. See Patterns (Ignoring bindings).
• ... (...expr, expr...expr) in an expression: inclusive range expression. See Iterators.
• ... (expr...expr) in a pattern: inclusive range pattern. See Patterns (Ranges).
• / (expr / expr): arithmetic division. Overloadable (Div).
• /= (var /= expr): arithmetic division & assignment. Overloadable (DivAssign).
• : (pat: type, ident: type): constraints. See Variable Bindings, Functions, Structs, Traits.
• : (ident: expr): struct field initializer. See Structs.
• : ('a: loop {…}): loop label. See Loops (Loops Labels).
• ;: statement and item terminator.
• ; ([…; len]): part of fixed-size array syntax. See Primitive Types (Arrays).
• << (expr << expr): left-shift. Overloadable (Shl).
• <<= (var <<= expr): left-shift & assignment. Overloadable (ShlAssign).
• < (expr < expr): less-than comparison. Overloadable (PartialOrd).
• <= (var <= expr): less-than or equal-to comparison. Overloadable (PartialOrd).
• = (var = expr, ident = type): assignment/equivalence. See Variable Bindings, type Aliases, generic parameter defaults.
• == (var == expr): equality comparison. Overloadable (PartialEq).
• => (pat => expr): part of match arm syntax. See Match.
• > (expr > expr): greater-than comparison. Overloadable (PartialOrd).
• >= (var >= expr): greater-than or equal-to comparison. Overloadable (PartialOrd).
• >> (expr >> expr): right-shift. Overloadable (Shr).
• >>= (var >>= expr): right-shift & assignment. Overloadable (ShrAssign).
• @ (ident @ pat): pattern binding. See Patterns (Bindings).
• ^ (expr ^ expr): bitwise exclusive or. Overloadable (BitXor).
• ^= (var ^= expr): bitwise exclusive or & assignment. Overloadable (BitXorAssign).
• | (expr | expr): bitwise or. Overloadable (BitOr).
• | (pat | pat): pattern alternatives. See Patterns (Multiple patterns).
• | (|…| expr): closures. See Closures.
• |= (var |= expr): bitwise or & assignment. Overloadable (BitOrAssign).
• || (expr || expr): logical or.
• _: "ignored" pattern binding. See Patterns (Ignoring bindings).

Other Syntax

• 'ident: named lifetime or loop label. See Lifetimes, Loops (Loops Labels).
• …u8, …i32, …f64, …usize, …: numeric literal of specific type.
• "…": string literal. See Strings.
• r"…", r#"…"#, r##"…"##, …: raw string literal, escape characters are not processed. See Reference (Raw String Literals).
• b"…": byte string literal, constructs a [u8] instead of a string. See Reference (Byte String Literals).
• br"…", br#"…"#, br##"…"##, …: raw byte string literal, combination of raw and byte string literal. See Reference (Raw Byte String Literals).
• '…': character literal. See Primitive Types (char).
• b'…': ASCII byte literal.
• |…| expr: closure. See Closures.

• ident::ident: path. See Crates and Modules (Defining Modules).
• ::path: path relative to the crate root (i.e. an explicitly absolute path). See Crates and Modules (Re-exporting with pub use).
• self::path: path relative to the current module (i.e. an explicitly relative path). See Crates and Modules (Re-exporting with pub use).
• super::path: path relative to the parent of the current module. See Crates and Modules (Re-exporting with pub use).
• type::ident, <type as trait>::ident: associated constants, functions, and types. See Associated Types.
• <type>::…: associated item for a type which cannot be directly named (e.g. <&T>::…, <[T]>::…, etc.). See Associated Types.
• trait::method(…): disambiguating a method call by naming the trait which defines it. See Universal Function Call Syntax.
• type::method(…): disambiguating a method call by naming the type for which it's defined. See Universal Function Call Syntax.
• <type as trait>::method(…): disambiguating a method call by naming the trait and type. See Universal Function Call Syntax (Angle-bracket Form).

• path<…> (e.g. Vec<u8>): specifies parameters to generic type in a type. See Generics.
• path::<…>, method::<…> (e.g. "42".parse::<i32>()): specifies parameters to generic type, function, or method in an expression.
• fn ident<…> …: define generic function. See Generics.
• struct ident<…> …: define generic structure. See Generics.
• enum ident<…> …: define generic enumeration. See Generics.
• impl<…> …: define generic implementation.
• for<…> type: higher-ranked lifetime bounds.
• type<ident=type> (e.g. Iterator<Item=T>): a generic type where one or more associated types have specific assignments. See Associated Types.

• T: U: generic parameter T constrained to types that implement U. See Traits.
• T: 'a: generic type T must outlive lifetime 'a. When we say that a type 'outlives' the lifetime, we mean that it cannot transitively contain any references with lifetimes shorter than 'a.
• T : 'static: The generic type T contains no borrowed references other than 'static ones.
• 'b: 'a: generic lifetime 'b must outlive lifetime 'a.
• T: ?Sized: allow generic type parameter to be a dynamically-sized type. See Unsized Types (?Sized).
• 'a + trait, trait + trait: compound type constraint. See Traits (Multiple Trait Bounds).

• #[meta]: outer attribute. See Attributes.
• #![meta]: inner attribute. See Attributes.
• $ident: macro substitution. See Macros.
• $ident:kind: macro capture. See Macros.
• $(…)…: macro repetition. See Macros.

• //: line comment. See Comments.
• //!: inner line doc comment. See Comments.
• ///: outer line doc comment. See Comments.
• /*…*/: block comment. See Comments.
• /*!…*/: inner block doc comment. See Comments.
• /**…*/: outer block doc comment. See Comments.

• (): empty tuple (a.k.a. unit), both literal and type.
• (expr): parenthesized expression.
• (expr,): single-element tuple expression. See Primitive Types (Tuples).
• (type,): single-element tuple type. See Primitive Types (Tuples).
• (expr, …): tuple expression. See Primitive Types (Tuples).
• (type, …): tuple type. See Primitive Types (Tuples).
• expr(expr, …): function call expression. Also used to initialize tuple structs and tuple enum variants. See Functions.
• ident!(…), ident!{…}, ident![…]: macro invocation. See Macros.
• expr.0, expr.1, …: tuple indexing. See Primitive Types (Tuple Indexing).

• {…}: block expression.
• Type {…}: struct literal. See Structs.

• […]: array literal. See Primitive Types (Arrays).
• [expr; len]: array literal containing len copies of expr. See Primitive Types (Arrays).
• [type; len]: array type containing len instances of type. See Primitive Types (Arrays).
• expr[expr]: collection indexing. Overloadable (Index, IndexMut).
• expr[..], expr[a..], expr[..b], expr[a..b]: collection indexing pretending to be collection slicing, using Range, RangeFrom, RangeTo, RangeFull as the "index".