B - Operators and Symbols

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.


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 complementNot``!=``expr != exprNonequality comparisonPartialEq``%``expr % exprArithmetic remainderRem``%=``var %= exprArithmetic remainder and assignmentRemAssign``&``&expr, &mut exprBorrow&``&type, &mut type, &'a type, &'a mut typeBorrowed pointer type&``expr & exprBitwise ANDBitAnd``&=``var &= exprBitwise AND and assignmentBitAndAssign``&&``expr && exprShort-circuiting logical AND*``expr * exprArithmetic multiplicationMul``*=``var *= exprArithmetic multiplication and assignmentMulAssign``*``*exprDereferenceDeref``*``*const type, *mut typeRaw pointer+``trait + trait, 'a + traitCompound type constraint+``expr + exprArithmetic additionAdd``+=``var += exprArithmetic addition and assignmentAddAssign``,``expr, exprArgument and element separator-``- exprArithmetic negationNeg``-``expr - exprArithmetic subtractionSub``-=``var -= exprArithmetic subtraction and assignmentSubAssign``->``fn(...) -> type, |...| -> typeFunction and closure return type.``expr.identMember access..``.., expr.., ..expr, expr..exprRight-exclusive range literalPartialOrd``..=``..=expr, expr..=exprRight-inclusive range literalPartialOrd``..``..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 / exprArithmetic divisionDiv``/=``var /= exprArithmetic division and assignmentDivAssign``:``pat: type, ident: typeConstraints:``ident: exprStruct field initializer:``'a: loop {...}Loop label;``expr;Statement and item terminator;``[...; len]Part of fixed-size array syntax<<``expr << exprLeft-shiftShl``<<=``var <<= exprLeft-shift and assignmentShlAssign``<``expr < exprLess than comparisonPartialOrd``<=``expr <= exprLess than or equal to comparisonPartialOrd``=``var = expr, ident = typeAssignment/equivalence==``expr == exprEquality comparisonPartialEq``=>``pat => exprPart of match arm syntax>``expr > exprGreater than comparisonPartialOrd``>=``expr >= exprGreater than or equal to comparisonPartialOrd``>>``expr >> exprRight-shiftShr``>>=``var >>= exprRight-shift and assignmentShrAssign``@``ident @ patPattern binding^``expr ^ exprBitwise exclusive ORBitXor``^=``var ^= exprBitwise exclusive OR and assignmentBitXorAssign``|``pat | patPattern alternatives|``expr | exprBitwise ORBitOr``|=``var |= exprBitwise OR and assignmentBitOrAssign``||``expr || exprShort-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 literalr"...", r#"..."#, r##"..."##, etc.Raw string literal, escape characters not processedb"..."Byte string literal; constructs an array of bytes instead of a stringbr"...", br#"..."#, br##"..."##, etc.Raw byte string literal, combination of raw and byte string literal'...'Character literalb'...'ASCII byte literal|...| exprClosure!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

SymbolExplanationident::identNamespace path::pathPath relative to the crate root (i.e., an explicitly absolute path)self::pathPath relative to the current module (i.e., an explicitly relative path).super::pathPath relative to the parent of the current moduletype::ident, <type as trait>::identAssociated 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 ittype::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

SymbolExplanationpath<...>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 functionstruct ident<...> ...Define generic structureenum ident<...> ...Define generic enumerationimpl<...> ...Define generic implementationfor<...> typeHigher-ranked lifetime boundstype<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

SymbolExplanationT: UGeneric parameter T constrained to types that implement U``T: 'aGeneric type T must outlive lifetime 'a (meaning the type cannot transitively contain any references with lifetimes shorter than 'a)T: 'staticGeneric type T contains no borrowed references other than 'static ones'b: 'aGeneric lifetime 'b must outlive lifetime 'a``T: ?SizedAllow generic type parameter to be a dynamically sized type'a + trait, trait + traitCompound 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 repetitionident!(...), 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 typeexpr(expr, ...)Function call expression; also used to initialize tuple struct s and tuple enum variantsexpr.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 expressionType {...}``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”

Previous chapterNext chapter

Previous chapterNext chapter