This appendix contains a glossary of Rust’s syntax, including operators and other symbols that appear by themselves or in the context of paths, generics, trait bounds, macros, attributes, comments, tuples, and brackets.
Table B-1 contains the operators in Rust, an example of how the operator would appear in context, a short explanation, and whether that operator is overloadable. If an operator is overloadable, the relevant trait to use to overload that operator is listed.
Table B-1: Operators
| Operator | Example | Explanation | Overloadable? |
|---|---|---|---|
! | ident!(...), ident!{...}, ident![...] | Macro expansion | |
! | !expr | Bitwise or logical complement | Not |
!= | expr != expr | Nonequality comparison | PartialEq |
% | expr % expr | Arithmetic remainder | Rem |
%= | var %= expr | Arithmetic remainder and assignment | RemAssign |
& | &expr, &mut expr | Borrow | |
& | &type, &mut type, &'a type, &'a mut type | Borrowed pointer | |
| type | |||
& | expr & expr | Bitwise AND | BitAnd |
&= | var &= expr | Bitwise AND and assignment | BitAndAssign |
&& | expr && expr | Short-circuiting logical AND | |
* | expr * expr | Arithmetic multiplication | Mul |
*= | var *= expr | Arithmetic multiplication and assignment | MulAssign |
| | * | *expr | Dereference | Deref | | * | *const type, *mut type | Raw pointer | | | + | trait + trait, 'a + trait | Compound type constraint | | | + | expr + expr | Arithmetic addition | Add | | += | var += expr | Arithmetic addition and assignment | AddAssign | | , | expr, expr | Argument and element separator | | | - | - expr | Arithmetic negation | Neg | | - | expr - expr | Arithmetic subtraction | Sub | | -= | var -= expr | Arithmetic subtraction and assignment | SubAssign | | -> | fn(...) -> type, |…| -> type | Function and closure return type | | | . | expr.ident| Member access | | |..|.., expr.., ..expr, expr..expr| Right-exclusive range literal |PartialOrd| |..=|..=expr, expr..=expr| Right-inclusive range literal |PartialOrd| |..|..expr| Struct literal update syntax | | |..|variant(x, ..), struct_type { x, .. }| “And the rest” pattern binding | | |...|expr...expr| (Deprecated, use..=instead) In a pattern: inclusive range pattern | | |/|expr / expr| Arithmetic division |Div| |/=|var /= expr| Arithmetic division and assignment |DivAssign| |: | pat: type, ident: type | Constraints | | | : | ident: expr | Struct field initializer | | | : | 'a: loop {...} | Loop label | | | ; | expr; | Statement and item terminator | | | ; | [...; len] | Part of fixed-size array syntax | | | << | expr << expr | Left-shift | Shl | | <<= | var <<= expr | Left-shift and assignment | ShlAssign | | < | expr < expr | Less than comparison | PartialOrd | | <= | expr <= expr | Less than or equal to comparison | PartialOrd | | = | var = expr, ident = type | Assignment/equivalence | | | == | expr == expr | Equality comparison | PartialEq | | => | pat => expr | Part of match arm syntax | | | > | expr > expr | Greater than comparison | PartialOrd | | >= | expr >= expr | Greater than or equal to comparison | PartialOrd | | >> | expr >> expr | Right-shift | Shr | | >>= | var >>= expr | Right-shift and assignment | ShrAssign | | @ | ident @ pat | Pattern binding | | | ^ | expr ^ expr | Bitwise exclusive OR | BitXor | | ^= | var ^= expr | Bitwise exclusive OR and assignment | BitXorAssign | | | | pat | pat | Pattern alternatives | | | | | expr | expr | Bitwise OR | BitOr | | |= | var |= expr | Bitwise OR and assignment | BitOrAssign | | || | expr || expr | Short-circuiting logical OR | | | ? | expr? | Error propagation | |
The following tables contain all symbols that don’t function as operators; that is, they don’t behave like a function or method call.
Table B-2 shows symbols that appear on their own and are valid in a variety of locations.
Table B-2: Stand-Alone Syntax
| Symbol | Explanation |
|---|---|
'ident | Named lifetime or loop label |
...u8, ...i32, ...f64, ...usize, and so on | Numeric literal of |
| specific type | |
"..." | String literal |
r"...", r#"..."#, r##"..."##, and so on | Raw string literal; escape |
| characters not processed | |
b"..." | Byte string literal; constructs an array of bytes instead of a |
| string | |
br"...", br#"..."#, br##"..."##, and so on | Raw byte string literal; |
| combination of raw and byte string literal | |
'...' | Character literal |
b'...' | ASCII byte literal |
| ` | … |
! | Always-empty bottom type for diverging functions |
_ | “Ignored” pattern binding; also used to make integer literals readable |
Table B-3 shows symbols that appear in the context of a path through the module hierarchy to an item.
Table B-3: Path-Related Syntax
| Symbol | Explanation |
|---|---|
ident::ident | Namespace path |
::path | Path relative to the crate root (that is, an explicitly absolute |
| path) | |
self::path | Path relative to the current module (that is, an explicitly |
| relative path) | |
super::path | Path relative to the parent of the current module |
type::ident, <type as trait>::ident | Associated constants, functions, |
| and types | |
<type>::... | Associated item for a type that cannot be directly named (for |
example, <&T>::..., <[T]>::..., and so on) | |
trait::method(...) | Disambiguating a method call by naming the trait that |
| defines it | |
type::method(...) | Disambiguating a method call by naming the type for |
| which it’s defined | |
<type as trait>::method(...) | Disambiguating a method call by naming the |
| trait and type |
Table B-4 shows symbols that appear in the context of using generic type parameters.
Table B-4: Generics
| Symbol | Explanation |
|---|---|
path<...> | Specifies parameters to a generic type in a type (for example, |
Vec<u8>) | |
path::<...>, method::<...> | Specifies parameters to a generic type, |
| function, or method in an expression; often referred to as turbofish (for | |
example, "42".parse::<i32>()) | |
fn ident<...> ... | Define generic function |
struct ident<...> ... | Define generic structure |
enum ident<...> ... | Define generic enumeration |
impl<...> ... | Define generic implementation |
for<...> type | Higher-ranked lifetime bounds |
type<ident=type> | A generic type where one or more associated types have |
specific assignments (for example, Iterator<Item=T>) |
Table B-5 shows symbols that appear in the context of constraining generic type parameters with trait bounds.
Table B-5: Trait Bound Constraints
| Symbol | Explanation |
|---|---|
| T: U` | Generic parameter T constrained to types that implement U |
T: 'a | Generic type T must outlive lifetime 'a (meaning the type |
cannot transitively contain any references with lifetimes shorter than 'a) | |
T: 'static | 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 |
'a + trait, trait + trait | Compound type constraint |
Table B-6 shows symbols that appear in the context of calling or defining macros and specifying attributes on an item.
Table B-6: Macros and Attributes
| Symbol | Explanation |
|---|---|
#[meta] | Outer attribute |
#![meta] | Inner attribute |
$ident | Macro substitution |
$ident:kind | Macro capture |
$(…)… | Macro repetition |
ident!(...), ident!{...}, ident![...] | Macro invocation |
Table B-7 shows symbols that create comments.
Table B-7: Comments
| Symbol | Explanation |
|---|---|
// | Line comment |
//! | Inner line doc comment |
/// | Outer line doc comment |
/*...*/ | Block comment |
/*!...*/ | Inner block doc comment |
/**...*/ | Outer block doc comment |
Table B-8 shows symbols that appear in the context of using tuples.
Table B-8: Tuples
| Symbol | Explanation |
|---|---|
() | Empty tuple (aka unit), both literal and type |
(expr) | Parenthesized expression |
(expr,) | Single-element tuple expression |
(type,) | Single-element tuple type |
(expr, ...) | Tuple expression |
(type, ...) | Tuple type |
expr(expr, ...) | Function call expression; also used to initialize tuple |
structs and tuple enum variants | |
expr.0, expr.1, and so on | Tuple indexing |
Table B-9 shows the contexts in which curly brackets are used.
Table B-9: Curly Brackets
| Context | Explanation |
|---|---|
{...} | Block expression |
Type {...} | struct literal |
Table B-10 shows the contexts in which square brackets are used.
Table B-10: Square Brackets
| Context | Explanation |
|---|---|
[...] | Array literal |
[expr; len] | Array literal containing len copies of expr |
[type; len] | Array type containing len instances of type |
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, or | |
RangeFull as the “index” |