Appendix B: Operators and Symbols
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.
Operators
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 | 
Non-operator Symbols
The following list contains 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, etc. | Numeric literal of specific type | 
| "..." | String literal | 
| r"...",r#"..."#,r##"..."##, etc. | Raw string literal, escape characters not processed | 
| b"..." | Byte string literal; constructs an array of bytes instead of a string | 
| br"...",br#"..."#,br##"..."##, etc. | Raw byte string literal, combination of raw and byte string literal | 
| '...' | Character literal | 
| b'...' | ASCII byte literal | 
| |…| expr | Closure | 
| ! | 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 (i.e., an explicitly absolute path) | 
| self::path | Path relative to the current module (i.e., 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 (e.g., <&T>::...,<[T]>::..., etc.) | 
| 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 generic type in a type (e.g., Vec<u8>) | 
| path::<...>,method::<...> | Specifies parameters to generic type, function, or method in an expression; often referred to as turbofish (e.g., "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 (e.g., 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 Tconstrained to types that implementU | 
| T: 'a | Generic type Tmust outlive lifetime'a(meaning the type cannot transitively contain any references with lifetimes shorter than'a) | 
| T: 'static | Generic type Tcontains no borrowed references other than'staticones | 
| 'b: 'a | Generic lifetime 'bmust 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 tupleenumvariants | 
| expr.0,expr.1, etc. | Tuple indexing | 
Table B-9 shows the contexts in which curly braces are used.
Table B-9: Curly Brackets
| Context | Explanation | 
|---|---|
| {...} | Block expression | 
| Type {...} | structliteral | 
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 lencopies ofexpr | 
| [type; len] | Array type containing leninstances oftype | 
| 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, orRangeFullas the “index” |