B - Operators and Symbols

Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

The Rust Programming Language

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 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.identField access .``expr.ident(expr, ...)Method call .``expr.0, expr.1, and so onTuple indexing ..``.., 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 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

SymbolExplanation 'identNamed lifetime or loop label Digits immediately followed by u8, i32, f64, usize, and so onNumeric literal of specific type "..."String literal r"...", r#"..."#, r##"..."##, and so onRaw string literal; escape characters not processed b"..."Byte string literal; constructs an array of bytes instead of a string br"...", br#"..."#, br##"..."##, and so onRaw byte string literal; combination of raw and byte string literal '...'Character literal b'...'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

SymbolExplanation ident::identNamespace path ::pathPath relative to the crate root (that is, an explicitly absolute path) self::pathPath relative to the current module (that is, an explicitly relative path) super::pathPath relative to the parent of the current module type::ident, <type as trait>::identAssociated 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

SymbolExplanation 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<...> typeHigher 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

SymbolExplanation T: 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 metavariable $(...)...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 the contexts in which parentheses are used.

Table B-8: Parentheses

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 structs and tuple enum variants

Table B-9 shows the contexts in which curly brackets 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