5 * `as`: primitive casting. See [Casting Between Types (`as`)].
6 * `break`: break out of loop. See [Loops (Ending Iteration Early)].
7 * `const`: constant items and constant raw pointers. See [`const` and `static`], [Raw Pointers].
8 * `continue`: continue to next loop iteration. See [Loops (Ending Iteration Early)].
9 * `crate`: external crate linkage. See [Crates and Modules (Importing External Crates)].
10 * `else`: fallback for `if` and `if let` constructs. See [`if`], [`if let`].
11 * `enum`: defining enumeration. See [Enums].
12 * `extern`: external crate, function, and variable linkage. See [Crates and Modules (Importing External Crates)], [Foreign Function Interface].
13 * `false`: boolean false literal. See [Primitive Types (Booleans)].
14 * `fn`: function definition and function pointer types. See [Functions].
15 * `for`: iterator loop, part of trait `impl` syntax, and higher-ranked lifetime syntax. See [Loops (`for`)], [Method Syntax].
16 * `if`: conditional branching. See [`if`], [`if let`].
17 * `impl`: inherent and trait implementation blocks. See [Method Syntax].
18 * `in`: part of `for` loop syntax. See [Loops (`for`)].
19 * `let`: variable binding. See [Variable Bindings].
20 * `loop`: unconditional, infinite loop. See [Loops (`loop`)].
21 * `match`: pattern matching. See [Match].
22 * `mod`: module declaration. See [Crates and Modules (Defining Modules)].
23 * `move`: part of closure syntax. See [Closures (`move` closures)].
24 * `mut`: denotes mutability in pointer types and pattern bindings. See [Mutability].
25 * `pub`: denotes public visibility in `struct` fields, `impl` blocks, and modules. See [Crates and Modules (Exporting a Public Interface)].
26 * `ref`: by-reference binding. See [Patterns (`ref` and `ref mut`)].
27 * `return`: return from function. See [Functions (Early Returns)].
28 * `Self`: implementor type alias. See [Traits].
29 * `self`: method subject. See [Method Syntax (Method Calls)].
30 * `static`: global variable. See [`const` and `static` (`static`)].
31 * `struct`: structure definition. See [Structs].
32 * `trait`: trait definition. See [Traits].
33 * `true`: boolean true literal. See [Primitive Types (Booleans)].
34 * `type`: type alias, and associated type definition. See [`type` Aliases], [Associated Types].
35 * `unsafe`: denotes unsafe code, functions, traits, and implementations. See [Unsafe].
36 * `use`: import symbols into scope. See [Crates and Modules (Importing Modules with `use`)].
37 * `where`: type constraint clauses. See [Traits (`where` clause)].
38 * `while`: conditional loop. See [Loops (`while`)].
40 ## Operators and Symbols
42 * `!` (`ident!(…)`, `ident!{…}`, `ident![…]`): denotes macro expansion. See [Macros].
43 * `!` (`!expr`): bitwise or logical complement. Overloadable (`Not`).
44 * `!=` (`var != expr`): nonequality comparison. Overloadable (`PartialEq`).
45 * `%` (`expr % expr`): arithmetic remainder. Overloadable (`Rem`).
46 * `%=` (`var %= expr`): arithmetic remainder & assignment.
47 * `&` (`expr & expr`): bitwise and. Overloadable (`BitAnd`).
48 * `&` (`&expr`): borrow. See [References and Borrowing].
49 * `&` (`&type`, `&mut type`, `&'a type`, `&'a mut type`): borrowed pointer type. See [References and Borrowing].
50 * `&=` (`var &= expr`): bitwise and & assignment.
51 * `&&` (`expr && expr`): logical and.
52 * `*` (`expr * expr`): arithmetic multiplication. Overloadable (`Mul`).
53 * `*` (`*expr`): dereference.
54 * `*` (`*const type`, `*mut type`): raw pointer. See [Raw Pointers].
55 * `*=` (`var *= expr`): arithmetic multiplication & assignment.
56 * `+` (`expr + expr`): arithmetic addition. Overloadable (`Add`).
57 * `+` (`trait + trait`, `'a + trait`): compound type constraint. See [Traits (Multiple Trait Bounds)].
58 * `+=` (`var += expr`): arithmetic addition & assignment.
59 * `,`: argument and element separator. See [Attributes], [Functions], [Structs], [Generics], [Match], [Closures], [Crates and Modules (Importing Modules with `use`)].
60 * `-` (`expr - expr`): arithmetic subtraction. Overloadable (`Sub`).
61 * `-` (`- expr`): arithmetic negation. Overloadable (`Neg`).
62 * `-=` (`var -= expr`): arithmetic subtraction & assignment.
63 * `->` (`fn(…) -> type`, `|…| -> type`): function and closure return type. See [Functions], [Closures].
64 * `-> !` (`fn(…) -> !`, `|…| -> !`): diverging function or closure. See [Diverging Functions].
65 * `.` (`expr.ident`): member access. See [Structs], [Method Syntax].
66 * `..` (`..`, `expr..`, `..expr`, `expr..expr`): right-exclusive range literal.
67 * `..` (`..expr`): struct literal update syntax. See [Structs (Update syntax)].
68 * `..` (`variant(x, ..)`, `struct_type { x, .. }`): "and the rest" pattern binding. See [Patterns (Ignoring bindings)].
69 * `...` (`expr ... expr`): inclusive range pattern. See [Patterns (Ranges)].
70 * `/` (`expr / expr`): arithmetic division. Overloadable (`Div`).
71 * `/=` (`var /= expr`): arithmetic division & assignment.
72 * `:` (`pat: type`, `ident: type`): constraints. See [Variable Bindings], [Functions], [Structs], [Traits].
73 * `:` (`ident: expr`): struct field initializer. See [Structs].
74 * `:` (`'a: loop {…}`): loop label. See [Loops (Loops Labels)].
75 * `;`: statement and item terminator.
76 * `;` (`[…; len]`): part of fixed-size array syntax. See [Primitive Types (Arrays)].
77 * `<<` (`expr << expr`): left-shift. Overloadable (`Shl`).
78 * `<<=` (`var <<= expr`): left-shift & assignment.
79 * `<` (`expr < expr`): less-than comparison. Overloadable (`PartialOrd`).
80 * `<=` (`var <= expr`): less-than or equal-to comparison. Overloadable (`PartialOrd`).
81 * `=` (`var = expr`, `ident = type`): assignment/equivalence. See [Variable Bindings], [`type` Aliases], generic parameter defaults.
82 * `==` (`var == expr`): equality comparison. Overloadable (`PartialEq`).
83 * `=>` (`pat => expr`): part of match arm syntax. See [Match].
84 * `>` (`expr > expr`): greater-than comparison. Overloadable (`PartialOrd`).
85 * `>=` (`var >= expr`): greater-than or equal-to comparison. Overloadable (`PartialOrd`).
86 * `>>` (`expr >> expr`): right-shift. Overloadable (`Shr`).
87 * `>>=` (`var >>= expr`): right-shift & assignment.
88 * `@` (`ident @ pat`): pattern binding. See [Patterns (Bindings)].
89 * `^` (`expr ^ expr`): bitwise exclusive or. Overloadable (`BitXor`).
90 * `^=` (`var ^= expr`): bitwise exclusive or & assignment.
91 * `|` (`expr | expr`): bitwise or. Overloadable (`BitOr`).
92 * `|` (`pat | pat`): pattern alternatives. See [Patterns (Multiple patterns)].
93 * `|` (`|…| expr`): closures. See [Closures].
94 * `|=` (`var |= expr`): bitwise or & assignment.
95 * `||` (`expr || expr`): logical or.
96 * `_`: "ignored" pattern binding. See [Patterns (Ignoring bindings)].
100 <!-- Various bits of standalone stuff. -->
102 * `'ident`: named lifetime or loop label. See [Lifetimes], [Loops (Loops Labels)].
103 * `…u8`, `…i32`, `…f64`, `…usize`, …: numeric literal of specific type.
104 * `"…"`: string literal. See [Strings].
105 * `r"…"`, `r#"…"#`, `r##"…"##`, …: raw string literal, escape characters are not processed. See [Reference (Raw String Literals)].
106 * `b"…"`: byte string literal, constructs a `[u8]` instead of a string. See [Reference (Byte String Literals)].
107 * `br"…"`, `br#"…"#`, `br##"…"##`, …: raw byte string literal, combination of raw and byte string literal. See [Reference (Raw Byte String Literals)].
108 * `'…'`: character literal. See [Primitive Types (`char`)].
109 * `b'…'`: ASCII byte literal.
110 * `|…| expr`: closure. See [Closures].
112 <!-- Path-related syntax -->
114 * `ident::ident`: path. See [Crates and Modules (Defining Modules)].
115 * `::path`: path relative to the crate root (*i.e.* an explicitly absolute path). See [Crates and Modules (Re-exporting with `pub use`)].
116 * `self::path`: path relative to the current module (*i.e.* an explicitly relative path). See [Crates and Modules (Re-exporting with `pub use`)].
117 * `super::path`: path relative to the parent of the current module. See [Crates and Modules (Re-exporting with `pub use`)].
118 * `type::ident`: associated constants, functions, and types. See [Associated Types].
119 * `<type>::…`: associated item for a type which cannot be directly named (*e.g.* `<&T>::…`, `<[T]>::…`, *etc.*). See [Associated Types].
123 * `path<…>` (*e.g.* `Vec<u8>`): specifies parameters to generic type *in a type*. See [Generics].
124 * `path::<…>`, `method::<…>` (*e.g.* `"42".parse::<i32>()`): specifies parameters to generic type, function, or method *in an expression*.
125 * `fn ident<…> …`: define generic function. See [Generics].
126 * `struct ident<…> …`: define generic structure. See [Generics].
127 * `enum ident<…> …`: define generic enumeration. See [Generics].
128 * `impl<…> …`: define generic implementation.
129 * `for<…> type`: higher-ranked lifetime bounds.
130 * `type<ident=type>` (*e.g.* `Iterator<Item=T>`): a generic type where one or more associated types have specific assignments. See [Associated Types].
134 * `T: U`: generic parameter `T` constrained to types that implement `U`. See [Traits].
135 * `T: 'a`: generic type `T` must outlive lifetime `'a`.
136 * `'b: 'a`: generic lifetime `'b` must outlive lifetime `'a`.
137 * `T: ?Sized`: allow generic type parameter to be a dynamically-sized type. See [Unsized Types (`?Sized`)].
138 * `'a + trait`, `trait + trait`: compound type constraint. See [Traits (Multiple Trait Bounds)].
140 <!-- Macros and attributes -->
142 * `#[meta]`: outer attribute. See [Attributes].
143 * `#![meta]`: inner attribute. See [Attributes].
144 * `$ident`: macro substitution. See [Macros].
145 * `$ident:kind`: macro capture. See [Macros].
146 * `$(…)…`: macro repetition. See [Macros].
150 * `//`: line comment. See [Comments].
151 * `//!`: inner line doc comment. See [Comments].
152 * `///`: outer line doc comment. See [Comments].
153 * `/*…*/`: block comment. See [Comments].
154 * `/*!…*/`: inner block doc comment. See [Comments].
155 * `/**…*/`: outer block doc comment. See [Comments].
157 <!-- Various things involving parens and tuples -->
159 * `()`: empty tuple (*a.k.a.* unit), both literal and type.
160 * `(expr)`: parenthesized expression.
161 * `(expr,)`: single-element tuple expression. See [Primitive Types (Tuples)].
162 * `(type,)`: single-element tuple type. See [Primitive Types (Tuples)].
163 * `(expr, …)`: tuple expression. See [Primitive Types (Tuples)].
164 * `(type, …)`: tuple type. See [Primitive Types (Tuples)].
165 * `expr(expr, …)`: function call expression. Also used to initialize tuple `struct`s and tuple `enum` variants. See [Functions].
166 * `ident!(…)`, `ident!{…}`, `ident![…]`: macro invocation. See [Macros].
167 * `expr.0`, `expr.1`, …: tuple indexing. See [Primitive Types (Tuple Indexing)].
169 <!-- Bracey things -->
171 * `{…}`: block expression.
172 * `Type {…}`: `struct` literal. See [Structs].
174 <!-- Brackety things -->
176 * `[…]`: array literal. See [Primitive Types (Arrays)].
177 * `[expr; len]`: array literal containing `len` copies of `expr`. See [Primitive Types (Arrays)].
178 * `[type; len]`: array type containing `len` instances of `type`. See [Primitive Types (Arrays)].
179 * `expr[expr]`: collection indexing. Overloadable (`Index`, `IndexMut`).
180 * `expr[..]`, `expr[a..]`, `expr[..b]`, `expr[a..b]`: collection indexing pretending to be collection slicing, using `Range`, `RangeFrom`, `RangeTo`, `RangeFull` as the "index".
182 [`const` and `static` (`static`)]: const-and-static.html#static
183 [`const` and `static`]: const-and-static.html
184 [`if let`]: if-let.html
186 [`type` Aliases]: type-aliases.html
187 [Associated Types]: associated-types.html
188 [Attributes]: attributes.html
189 [Casting Between Types (`as`)]: casting-between-types.html#as
190 [Closures (`move` closures)]: closures.html#move-closures
191 [Closures]: closures.html
192 [Comments]: comments.html
193 [Crates and Modules (Defining Modules)]: crates-and-modules.html#defining-modules
194 [Crates and Modules (Exporting a Public Interface)]: crates-and-modules.html#exporting-a-public-interface
195 [Crates and Modules (Importing External Crates)]: crates-and-modules.html#importing-external-crates
196 [Crates and Modules (Importing Modules with `use`)]: crates-and-modules.html#importing-modules-with-use
197 [Crates and Modules (Re-exporting with `pub use`)]: crates-and-modules.html#re-exporting-with-pub-use
198 [Diverging Functions]: functions.html#diverging-functions
200 [Foreign Function Interface]: ffi.html
201 [Functions (Early Returns)]: functions.html#early-returns
202 [Functions]: functions.html
203 [Generics]: generics.html
204 [Lifetimes]: lifetimes.html
205 [Loops (`for`)]: loops.html#for
206 [Loops (`loop`)]: loops.html#loop
207 [Loops (`while`)]: loops.html#while
208 [Loops (Ending Iteration Early)]: loops.html#ending-iteration-early
209 [Loops (Loops Labels)]: loops.html#loop-labels
210 [Macros]: macros.html
212 [Method Syntax (Method Calls)]: method-syntax.html#method-calls
213 [Method Syntax]: method-syntax.html
214 [Mutability]: mutability.html
215 [Operators and Overloading]: operators-and-overloading.html
216 [Patterns (`ref` and `ref mut`)]: patterns.html#ref-and-ref-mut
217 [Patterns (Bindings)]: patterns.html#bindings
218 [Patterns (Ignoring bindings)]: patterns.html#ignoring-bindings
219 [Patterns (Multiple patterns)]: patterns.html#multiple-patterns
220 [Patterns (Ranges)]: patterns.html#ranges
221 [Primitive Types (`char`)]: primitive-types.html#char
222 [Primitive Types (Arrays)]: primitive-types.html#arrays
223 [Primitive Types (Booleans)]: primitive-types.html#booleans
224 [Primitive Types (Tuple Indexing)]: primitive-types.html#tuple-indexing
225 [Primitive Types (Tuples)]: primitive-types.html#tuples
226 [Raw Pointers]: raw-pointers.html
227 [Reference (Byte String Literals)]: ../reference.html#byte-string-literals
228 [Reference (Raw Byte String Literals)]: ../reference.html#raw-byte-string-literals
229 [Reference (Raw String Literals)]: ../reference.html#raw-string-literals
230 [References and Borrowing]: references-and-borrowing.html
231 [Strings]: strings.html
232 [Structs (Update syntax)]: structs.html#update-syntax
233 [Structs]: structs.html
234 [Traits (`where` clause)]: traits.html#where-clause
235 [Traits (Multiple Trait Bounds)]: traits.html#multiple-trait-bounds
236 [Traits]: traits.html
237 [Unsafe]: unsafe.html
238 [Unsized Types (`?Sized`)]: unsized-types.html#sized
239 [Variable Bindings]: variable-bindings.html