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

OperatorExampleExplanationOverloadable?
!`ident!(...)`, `ident!{...}`, `ident![...]`Macro expansion
!!exprBitwise or logical complement`Not`
!=`expr != expr`Nonequality comparison`PartialEq`
%`expr % expr`Arithmetic remainder`Rem`
%=`var %= expr`Arithmetic remainder and assignment`RemAssign`
&&expr, &mut exprBorrow
&&type, &mut type, &'a type, &'a mut typeBorrowed 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`
**exprDereference`Deref`
*\*const type, \*mut typeRaw pointer
+`trait + trait`, 'a + traitCompound type constraint
+`expr + expr`Arithmetic addition`Add`
+=`var += expr`Arithmetic addition and assignment`AddAssign`
,`expr, expr`Argument and element separator
\-\- exprArithmetic negation`Neg`
-`expr - expr`Arithmetic subtraction`Sub`
-=`var -= expr`Arithmetic subtraction and assignment`SubAssign`
->`fn(...) -> type`, <code>|...| -> type</code>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`
....exprStruct 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`
<code>|</code><code>pat | pat</code>Pattern alternatives
<code>|</code><code>expr | expr</code>Bitwise OR`BitOr`
<code>|=</code><code>var |= expr</code>Bitwise OR and assignment`BitOrAssign`
<code>||</code><code>expr || expr</code>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

SymbolExplanation
'identNamed 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
<code>|...| expr</code>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

SymbolExplanation
`ident::ident`Namespace path
::pathPath 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`, &lt;type as trait&gt;::identAssociated constants, functions, and types
&lt;type&gt;::...Associated item for a type that cannot be directly named (e.g., &lt;&T&gt;::..., &lt;\[T\]&gt;::..., 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
&lt;type as trait&gt;::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

SymbolExplanation
`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::&lt;i32&gt;())
`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

SymbolExplanation
`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: 'aGeneric 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

SymbolExplanation
#\[meta\]Outer attribute
#!\[meta\]Inner attribute
$identMacro substitution
$ident:kindMacro capture
$(…)…Macro repetition
`ident!(...)`, `ident!{...}`, `ident![...]`Macro invocation

Table B-7 shows symbols that create comments.

Table B-7: Comments

SymbolExplanation
//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

SymbolExplanation
()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 `struct`s and tuple `enum` variants
`expr.0`, `expr.1`, etc.Tuple indexing

Table B-9 shows the contexts in which curly braces are used.

Table B-9: Curly Brackets

ContextExplanation
{...}Block expression
`Type {...}``struct` literal

Table B-10 shows the contexts in which square brackets are used.

Table B-10: Square Brackets

ContextExplanation
\[...\]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”