mirror of https://github.com/rust-lang/book
242 lines
9.5 KiB
Markdown
242 lines
9.5 KiB
Markdown
<!-- DO NOT EDIT THIS FILE.
|
||
|
||
This file is periodically generated from the content in the `/src/`
|
||
directory, so all fixes need to be made in `/src/`.
|
||
-->
|
||
|
||
[TOC]
|
||
|
||
## 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 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 |
|
||
| `|…| 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 (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
|
||
`struct`s 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” |
|
||
|