Rust:Operators and Symbols

电玩女神 2023-01-22 05:52 2阅读 0赞

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

<table> 
 <thead> 
  <tr> 
   <th>Operator</th> 
   <th>Example</th> 
   <th>Explanation</th> 
   <th>Overloadable?</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>!</code></td> 
   <td><code>ident!(...)</code>,&nbsp;<code>ident!{...}</code>,&nbsp;<code>ident![...]</code></td> 
   <td>Macro expansion</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>!</code></td> 
   <td><code>!expr</code></td> 
   <td>Bitwise or logical complement</td> 
   <td><code>Not</code></td> 
  </tr> 
  <tr> 
   <td><code>!=</code></td> 
   <td><code>var != expr</code></td> 
   <td>Nonequality comparison</td> 
   <td><code>PartialEq</code></td> 
  </tr> 
  <tr> 
   <td><code>%</code></td> 
   <td><code>expr % expr</code></td> 
   <td>Arithmetic remainder</td> 
   <td><code>Rem</code></td> 
  </tr> 
  <tr> 
   <td><code>%=</code></td> 
   <td><code>var %= expr</code></td> 
   <td>Arithmetic remainder and assignment</td> 
   <td><code>RemAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>&amp;</code></td> 
   <td><code>&amp;expr</code>,&nbsp;<code>&amp;mut expr</code></td> 
   <td>Borrow</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>&amp;</code></td> 
   <td><code>&amp;type</code>,&nbsp;<code>&amp;mut type</code>,&nbsp;<code>&amp;'a type</code>,&nbsp;<code>&amp;'a mut type</code></td> 
   <td>Borrowed pointer type</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>&amp;</code></td> 
   <td><code>expr &amp; expr</code></td> 
   <td>Bitwise AND</td> 
   <td><code>BitAnd</code></td> 
  </tr> 
  <tr> 
   <td><code>&amp;=</code></td> 
   <td><code>var &amp;= expr</code></td> 
   <td>Bitwise AND and assignment</td> 
   <td><code>BitAndAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>&amp;&amp;</code></td> 
   <td><code>expr &amp;&amp; expr</code></td> 
   <td>Short-circuiting logical AND</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td><code>expr * expr</code></td> 
   <td>Arithmetic multiplication</td> 
   <td><code>Mul</code></td> 
  </tr> 
  <tr> 
   <td><code>*=</code></td> 
   <td><code>var *= expr</code></td> 
   <td>Arithmetic multiplication and assignment</td> 
   <td><code>MulAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td><code>*expr</code></td> 
   <td>Dereference</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>*</code></td> 
   <td><code>*const type</code>,&nbsp;<code>*mut type</code></td> 
   <td>Raw pointer</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>+</code></td> 
   <td><code>trait + trait</code>,&nbsp;<code>'a + trait</code></td> 
   <td>Compound type constraint</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>+</code></td> 
   <td><code>expr + expr</code></td> 
   <td>Arithmetic addition</td> 
   <td><code>Add</code></td> 
  </tr> 
  <tr> 
   <td><code>+=</code></td> 
   <td><code>var += expr</code></td> 
   <td>Arithmetic addition and assignment</td> 
   <td><code>AddAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>,</code></td> 
   <td><code>expr, expr</code></td> 
   <td>Argument and element separator</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>-</code></td> 
   <td><code>- expr</code></td> 
   <td>Arithmetic negation</td> 
   <td><code>Neg</code></td> 
  </tr> 
  <tr> 
   <td><code>-</code></td> 
   <td><code>expr - expr</code></td> 
   <td>Arithmetic subtraction</td> 
   <td><code>Sub</code></td> 
  </tr> 
  <tr> 
   <td><code>-=</code></td> 
   <td><code>var -= expr</code></td> 
   <td>Arithmetic subtraction and assignment</td> 
   <td><code>SubAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>-&gt;</code></td> 
   <td><code>fn(...) -&gt; type</code>,&nbsp;<code>|...| -&gt; type</code></td> 
   <td>Function and closure return type</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>.</code></td> 
   <td><code>expr.ident</code></td> 
   <td>Member access</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>..</code></td> 
   <td><code>..</code>,&nbsp;<code>expr..</code>,&nbsp;<code>..expr</code>,&nbsp;<code>expr..expr</code></td> 
   <td>Right-exclusive range literal</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>..=</code></td> 
   <td><code>..=expr</code>,&nbsp;<code>expr..=expr</code></td> 
   <td>Right-inclusive range literal</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>..</code></td> 
   <td><code>..expr</code></td> 
   <td>Struct literal update syntax</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>..</code></td> 
   <td><code>variant(x, ..)</code>,&nbsp;<code>struct_type { x, .. }</code></td> 
   <td>“And the rest” pattern binding</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>...</code></td> 
   <td><code>expr...expr</code></td> 
   <td>In a pattern: inclusive range pattern</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>/</code></td> 
   <td><code>expr / expr</code></td> 
   <td>Arithmetic division</td> 
   <td><code>Div</code></td> 
  </tr> 
  <tr> 
   <td><code>/=</code></td> 
   <td><code>var /= expr</code></td> 
   <td>Arithmetic division and assignment</td> 
   <td><code>DivAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>:</code></td> 
   <td><code>pat: type</code>,&nbsp;<code>ident: type</code></td> 
   <td>Constraints</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>:</code></td> 
   <td><code>ident: expr</code></td> 
   <td>Struct field initializer</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>:</code></td> 
   <td><code>'a: loop {...}</code></td> 
   <td>Loop label</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>;</code></td> 
   <td><code>expr;</code></td> 
   <td>Statement and item terminator</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>;</code></td> 
   <td><code>[...; len]</code></td> 
   <td>Part of fixed-size array syntax</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>&lt;&lt;</code></td> 
   <td><code>expr &lt;&lt; expr</code></td> 
   <td>Left-shift</td> 
   <td><code>Shl</code></td> 
  </tr> 
  <tr> 
   <td><code>&lt;&lt;=</code></td> 
   <td><code>var &lt;&lt;= expr</code></td> 
   <td>Left-shift and assignment</td> 
   <td><code>ShlAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>&lt;</code></td> 
   <td><code>expr &lt; expr</code></td> 
   <td>Less than comparison</td> 
   <td><code>PartialOrd</code></td> 
  </tr> 
  <tr> 
   <td><code>&lt;=</code></td> 
   <td><code>expr &lt;= expr</code></td> 
   <td>Less than or equal to comparison</td> 
   <td><code>PartialOrd</code></td> 
  </tr> 
  <tr> 
   <td><code>=</code></td> 
   <td><code>var = expr</code>,&nbsp;<code>ident = type</code></td> 
   <td>Assignment/equivalence</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>==</code></td> 
   <td><code>expr == expr</code></td> 
   <td>Equality comparison</td> 
   <td><code>PartialEq</code></td> 
  </tr> 
  <tr> 
   <td><code>=&gt;</code></td> 
   <td><code>pat =&gt; expr</code></td> 
   <td>Part of match arm syntax</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>&gt;</code></td> 
   <td><code>expr &gt; expr</code></td> 
   <td>Greater than comparison</td> 
   <td><code>PartialOrd</code></td> 
  </tr> 
  <tr> 
   <td><code>&gt;=</code></td> 
   <td><code>expr &gt;= expr</code></td> 
   <td>Greater than or equal to comparison</td> 
   <td><code>PartialOrd</code></td> 
  </tr> 
  <tr> 
   <td><code>&gt;&gt;</code></td> 
   <td><code>expr &gt;&gt; expr</code></td> 
   <td>Right-shift</td> 
   <td><code>Shr</code></td> 
  </tr> 
  <tr> 
   <td><code>&gt;&gt;=</code></td> 
   <td><code>var &gt;&gt;= expr</code></td> 
   <td>Right-shift and assignment</td> 
   <td><code>ShrAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>@</code></td> 
   <td><code>ident @ pat</code></td> 
   <td>Pattern binding</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>^</code></td> 
   <td><code>expr ^ expr</code></td> 
   <td>Bitwise exclusive OR</td> 
   <td><code>BitXor</code></td> 
  </tr> 
  <tr> 
   <td><code>^=</code></td> 
   <td><code>var ^= expr</code></td> 
   <td>Bitwise exclusive OR and assignment</td> 
   <td><code>BitXorAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td><code>pat | pat</code></td> 
   <td>Pattern alternatives</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td><code>expr | expr</code></td> 
   <td>Bitwise OR</td> 
   <td><code>BitOr</code></td> 
  </tr> 
  <tr> 
   <td><code>|=</code></td> 
   <td><code>var |= expr</code></td> 
   <td>Bitwise OR and assignment</td> 
   <td><code>BitOrAssign</code></td> 
  </tr> 
  <tr> 
   <td><code>||</code></td> 
   <td><code>expr || expr</code></td> 
   <td>Short-circuiting logical OR</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td><code>?</code></td> 
   <td><code>expr?</code></td> 
   <td>Error propagation</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

### [Non-operator Symbols][] ###

The following list contains all non-letters 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

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>'ident</code></td> 
   <td>Named lifetime or loop label</td> 
  </tr> 
  <tr> 
   <td><code>...u8</code>,&nbsp;<code>...i32</code>,&nbsp;<code>...f64</code>,&nbsp;<code>...usize</code>, etc.</td> 
   <td>Numeric literal of specific type</td> 
  </tr> 
  <tr> 
   <td><code>"..."</code></td> 
   <td>String literal</td> 
  </tr> 
  <tr> 
   <td><code>r"..."</code>,&nbsp;<code>r#"..."#</code>,&nbsp;<code>r##"..."##</code>, etc.</td> 
   <td>Raw string literal, escape characters not processed</td> 
  </tr> 
  <tr> 
   <td><code>b"..."</code></td> 
   <td>Byte string literal; constructs a&nbsp;<code>[u8]</code>&nbsp;instead of a string</td> 
  </tr> 
  <tr> 
   <td><code>br"..."</code>,&nbsp;<code>br#"..."#</code>,&nbsp;<code>br##"..."##</code>, etc.</td> 
   <td>Raw byte string literal, combination of raw and byte string literal</td> 
  </tr> 
  <tr> 
   <td><code>'...'</code></td> 
   <td>Character literal</td> 
  </tr> 
  <tr> 
   <td><code>b'...'</code></td> 
   <td>ASCII byte literal</td> 
  </tr> 
  <tr> 
   <td><code>|...| expr</code></td> 
   <td>Closure</td> 
  </tr> 
  <tr> 
   <td><code>!</code></td> 
   <td>Always empty bottom type for diverging functions</td> 
  </tr> 
  <tr> 
   <td><code>_</code></td> 
   <td>“Ignored” pattern binding; also used to make integer literals readable</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>ident::ident</code></td> 
   <td>Namespace path</td> 
  </tr> 
  <tr> 
   <td><code>::path</code></td> 
   <td>Path relative to the crate root (i.e., an explicitly absolute path)</td> 
  </tr> 
  <tr> 
   <td><code>self::path</code></td> 
   <td>Path relative to the current module (i.e., an explicitly relative path).</td> 
  </tr> 
  <tr> 
   <td><code>super::path</code></td> 
   <td>Path relative to the parent of the current module</td> 
  </tr> 
  <tr> 
   <td><code>type::ident</code>,&nbsp;<code>&lt;type as trait&gt;::ident</code></td> 
   <td>Associated constants, functions, and types</td> 
  </tr> 
  <tr> 
   <td><code>&lt;type&gt;::...</code></td> 
   <td>Associated item for a type that cannot be directly named (e.g.,&nbsp;<code>&lt;&amp;T&gt;::...</code>,&nbsp;<code>&lt;[T]&gt;::...</code>, etc.)</td> 
  </tr> 
  <tr> 
   <td><code>trait::method(...)</code></td> 
   <td>Disambiguating a method call by naming the trait that defines it</td> 
  </tr> 
  <tr> 
   <td><code>type::method(...)</code></td> 
   <td>Disambiguating a method call by naming the type for which it’s defined</td> 
  </tr> 
  <tr> 
   <td><code>&lt;type as trait&gt;::method(...)</code></td> 
   <td>Disambiguating a method call by naming the trait and type</td> 
  </tr> 
 </tbody> 
</table>

Table B-4 shows symbols that appear in the context of using generic type parameters.

Table B-4: Generics

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>path&lt;...&gt;</code></td> 
   <td>Specifies parameters to generic type in a type (e.g.,&nbsp;<code>Vec&lt;u8&gt;</code>)</td> 
  </tr> 
  <tr> 
   <td><code>path::&lt;...&gt;</code>,&nbsp;<code>method::&lt;...&gt;</code></td> 
   <td>Specifies parameters to generic type, function, or method in an expression; often referred to as turbofish (e.g.,&nbsp;<code>"42".parse::&lt;i32&gt;()</code>)</td> 
  </tr> 
  <tr> 
   <td><code>fn ident&lt;...&gt; ...</code></td> 
   <td>Define generic function</td> 
  </tr> 
  <tr> 
   <td><code>struct ident&lt;...&gt; ...</code></td> 
   <td>Define generic structure</td> 
  </tr> 
  <tr> 
   <td><code>enum ident&lt;...&gt; ...</code></td> 
   <td>Define generic enumeration</td> 
  </tr> 
  <tr> 
   <td><code>impl&lt;...&gt; ...</code></td> 
   <td>Define generic implementation</td> 
  </tr> 
  <tr> 
   <td><code>for&lt;...&gt; type</code></td> 
   <td>Higher-ranked lifetime bounds</td> 
  </tr> 
  <tr> 
   <td><code>type&lt;ident=type&gt;</code></td> 
   <td>A generic type where one or more associated types have specific assignments (e.g.,&nbsp;<code>Iterator&lt;Item=T&gt;</code>)</td> 
  </tr> 
 </tbody> 
</table>

Table B-5 shows symbols that appear in the context of constraining generic type parameters with trait bounds.

Table B-5: Trait Bound Constraints

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>T: U</code></td> 
   <td>Generic parameter&nbsp;<code>T</code>&nbsp;constrained to types that implement&nbsp;<code>U</code></td> 
  </tr> 
  <tr> 
   <td><code>T: 'a</code></td> 
   <td>Generic type&nbsp;<code>T</code>&nbsp;must outlive lifetime&nbsp;<code>'a</code>&nbsp;(meaning the type cannot transitively contain any references with lifetimes shorter than&nbsp;<code>'a</code>)</td> 
  </tr> 
  <tr> 
   <td><code>T : 'static</code></td> 
   <td>Generic type&nbsp;<code>T</code>&nbsp;contains no borrowed references other than&nbsp;<code>'static</code>&nbsp;ones</td> 
  </tr> 
  <tr> 
   <td><code>'b: 'a</code></td> 
   <td>Generic lifetime&nbsp;<code>'b</code>&nbsp;must outlive lifetime&nbsp;<code>'a</code></td> 
  </tr> 
  <tr> 
   <td><code>T: ?Sized</code></td> 
   <td>Allow generic type parameter to be a dynamically sized type</td> 
  </tr> 
  <tr> 
   <td><code>'a + trait</code>,&nbsp;<code>trait + trait</code></td> 
   <td>Compound type constraint</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>#[meta]</code></td> 
   <td>Outer attribute</td> 
  </tr> 
  <tr> 
   <td><code>#![meta]</code></td> 
   <td>Inner attribute</td> 
  </tr> 
  <tr> 
   <td><code>$ident</code></td> 
   <td>Macro substitution</td> 
  </tr> 
  <tr> 
   <td><code>$ident:kind</code></td> 
   <td>Macro capture</td> 
  </tr> 
  <tr> 
   <td><code>$(…)…</code></td> 
   <td>Macro repetition</td> 
  </tr> 
  <tr> 
   <td><code>ident!(...)</code>,&nbsp;<code>ident!{...}</code>,&nbsp;<code>ident![...]</code></td> 
   <td>Macro invocation</td> 
  </tr> 
 </tbody> 
</table>

Table B-7 shows symbols that create comments.

Table B-7: Comments

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>//</code></td> 
   <td>Line comment</td> 
  </tr> 
  <tr> 
   <td><code>//!</code></td> 
   <td>Inner line doc comment</td> 
  </tr> 
  <tr> 
   <td><code>///</code></td> 
   <td>Outer line doc comment</td> 
  </tr> 
  <tr> 
   <td><code>/*...*/</code></td> 
   <td>Block comment</td> 
  </tr> 
  <tr> 
   <td><code>/*!...*/</code></td> 
   <td>Inner block doc comment</td> 
  </tr> 
  <tr> 
   <td><code>/**...*/</code></td> 
   <td>Outer block doc comment</td> 
  </tr> 
 </tbody> 
</table>

Table B-8 shows symbols that appear in the context of using tuples.

Table B-8: Tuples

<table> 
 <thead> 
  <tr> 
   <th>Symbol</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>()</code></td> 
   <td>Empty tuple (aka unit), both literal and type</td> 
  </tr> 
  <tr> 
   <td><code>(expr)</code></td> 
   <td>Parenthesized expression</td> 
  </tr> 
  <tr> 
   <td><code>(expr,)</code></td> 
   <td>Single-element tuple expression</td> 
  </tr> 
  <tr> 
   <td><code>(type,)</code></td> 
   <td>Single-element tuple type</td> 
  </tr> 
  <tr> 
   <td><code>(expr, ...)</code></td> 
   <td>Tuple expression</td> 
  </tr> 
  <tr> 
   <td><code>(type, ...)</code></td> 
   <td>Tuple type</td> 
  </tr> 
  <tr> 
   <td><code>expr(expr, ...)</code></td> 
   <td>Function call expression; also used to initialize tuple&nbsp;<code>struct</code>s and tuple&nbsp;<code>enum</code>&nbsp;variants</td> 
  </tr> 
  <tr> 
   <td><code>expr.0</code>,&nbsp;<code>expr.1</code>, etc.</td> 
   <td>Tuple indexing</td> 
  </tr> 
 </tbody> 
</table>

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

Table B-9: Curly Brackets

<table> 
 <thead> 
  <tr> 
   <th>Context</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>{...}</code></td> 
   <td>Block expression</td> 
  </tr> 
  <tr> 
   <td><code>Type {...}</code></td> 
   <td><code>struct</code>&nbsp;literal</td> 
  </tr> 
 </tbody> 
</table>

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

Table B-10: Square Brackets

<table> 
 <thead> 
  <tr> 
   <th>Context</th> 
   <th>Explanation</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>[...]</code></td> 
   <td>Array literal</td> 
  </tr> 
  <tr> 
   <td><code>[expr; len]</code></td> 
   <td>Array literal containing&nbsp;<code>len</code>&nbsp;copies of&nbsp;<code>expr</code></td> 
  </tr> 
  <tr> 
   <td><code>[type; len]</code></td> 
   <td>Array type containing&nbsp;<code>len</code>&nbsp;instances of&nbsp;<code>type</code></td> 
  </tr> 
  <tr> 
   <td><code>expr[expr]</code></td> 
   <td>Collection indexing. Overloadable (<code>Index</code>,&nbsp;<code>IndexMut</code>)</td> 
  </tr> 
  <tr> 
   <td><code>expr[..]</code>,&nbsp;<code>expr[a..]</code>,&nbsp;<code>expr[..b]</code>,&nbsp;<code>expr[a..b]</code></td> 
   <td>Collection indexing pretending to be collection slicing, using&nbsp;<code>Range</code>,&nbsp;<code>RangeFrom</code>,&nbsp;<code>RangeTo</code>, or&nbsp;<code>RangeFull</code>&nbsp;as the “index”</td> 
  </tr> 
 </tbody> 
</table>

[Operators]: https://doc.rust-lang.org/book/appendix-02-operators.html#operators
[Non-operator Symbols]: https://doc.rust-lang.org/book/appendix-02-operators.html#non-operator-symbols