rust/syntax-index.md at b1c5c26c6885588a14b39250a729fe7a7356db6c

Steve Klabnik 024aa9a345 src/doc/trpl -> src/doc/book

The book was located under 'src/doc/trpl' because originally, it was
going to be hosted under that URL. Late in the game, before 1.0, we
decided that /book was a better one, so we changed the output, but
not the input. This causes confusion for no good reason. So we'll change
the source directory to look like the output directory, like for every
other thing in src/doc.

2015-11-19 11:30:18 -05:00

13 KiB

Raw Blame History

% Syntax Index

Keywords

as: primitive casting. See Casting Between Types (as).
break: break out of loop. See Loops (Ending Iteration Early).
const: constant items. See const and static.
continue: continue to next loop iteration. See Loops (Ending Iteration Early).
crate: external crate linkage. See Crates and Modules (Importing External Crates).
else: fallback for if and if let constructs. See if, if let.
enum: defining enumeration. See Enums.
extern: external crate, function, and variable linkage. See Crates and Modules (Importing External Crates), Foreign Function Interface.
false: boolean false literal. See Primitive Types (Booleans).
fn: function definition and function pointer types. See Functions.
for: iterator loop, part of trait impl syntax, and higher-ranked lifetime syntax. See Loops (for), Method Syntax.
if: conditional branching. See if, if let.
impl: inherent and trait implementation blocks. See Method Syntax.
in: part of for loop syntax. See Loops (for).
let: variable binding. See Variable Bindings.
loop: unconditional, infinite loop. See Loops (loop).
match: pattern matching. See Match.
mod: module declaration. See Crates and Modules (Defining Modules).
move: part of closure syntax. See Closures (move closures).
mut: denotes mutability in pointer types and pattern bindings. See Mutability.
pub: denotes public visibility in struct fields, impl blocks, and modules. See Crates and Modules (Exporting a Public Interface).
ref: by-reference binding. See Patterns (ref and ref mut).
return: return from function. See Functions (Early Returns).
Self: implementor type alias. See Traits.
self: method subject. See Method Syntax (Method Calls).
static: global variable. See const and static (static).
struct: structure definition. See Structs.
trait: trait definition. See Traits.
true: boolean true literal. See Primitive Types (Booleans).
type: type alias, and associated type definition. See type Aliases, Associated Types.
unsafe: denotes unsafe code, functions, traits, and implementations. See Unsafe.
use: import symbols into scope. See Crates and Modules (Importing Modules with use).
where: type constraint clauses. See Traits (where clause).
while: conditional loop. See Loops (while).

Operators and Symbols

! (expr!(…), expr!{…}, expr![…]): denotes macro expansion. See Macros.
! (!expr): bitwise or logical complement. Overloadable (Not).
% (expr % expr): arithmetic remainder. Overloadable (Rem).
%= (var %= expr): arithmetic remainder & assignment.
& (expr & expr): bitwise and. Overloadable (BitAnd).
& (&expr): borrow. See References and Borrowing.
& (&type, &mut type, &'a type, &'a mut type): borrowed pointer type. See References and Borrowing.
&= (var &= expr): bitwise and & assignment.
&& (expr && expr): logical and.
* (expr * expr): arithmetic multiplication. Overloadable (Mul).
* (*expr): dereference.
* (*const type, *mut type): raw pointer. See Raw Pointers.
*= (var *= expr): arithmetic multiplication & assignment.
+ (expr + expr): arithmetic addition. Overloadable (Add).
+ (trait + trait, 'a + trait): compound type constraint. See Traits (Multiple Trait Bounds).
+= (var += expr): arithmetic addition & assignment.
,: argument and element separator. See Attributes, Functions, Structs, Generics, Match, Closures, Crates and Modules (Importing Modules with use).
- (expr - expr): arithmetic subtraction. Overloadable (Sub).
- (- expr): arithmetic negation. Overloadable (Neg).
-= (var -= expr): arithmetic subtraction & assignment.
-> (fn(…) -> type, |…| -> type): function and closure return type. See Functions, Closures.
-> ! (fn(…) -> !, |…| -> !): diverging function or closure. See Diverging Functions.
. (expr.ident): member access. See Structs, Method Syntax.
.. (.., expr.., ..expr, expr..expr): right-exclusive range literal.
.. (..expr): struct literal update syntax. See Structs (Update syntax).
.. (variant(x, ..), struct_type { x, .. }): "and the rest" pattern binding. See Patterns (Ignoring bindings).
... (expr ... expr): inclusive range pattern. See Patterns (Ranges).
/ (expr / expr): arithmetic division. Overloadable (Div).
/= (var /= expr): arithmetic division & assignment.
: (pat: type, ident: type): constraints. See Variable Bindings, Functions, Structs, Traits.
: (ident: expr): struct field initializer. See Structs.
: ('a: loop {…}): loop label. See Loops (Loops Labels).
;: statement and item terminator.
; ([…; len]): part of fixed-size array syntax. See Primitive Types (Arrays).
<< (expr << expr): left-shift. Overloadable (Shl).
<<= (var <<= expr): left-shift & assignment.
< (expr < expr): less-than comparison. Overloadable (Cmp, PartialCmp).
<= (var <= expr): less-than or equal-to comparison. Overloadable (Cmp, PartialCmp).
= (var = expr, ident = type): assignment/equivalence. See Variable Bindings, type Aliases, generic parameter defaults.
== (var == expr): comparison. Overloadable (Eq, PartialEq).
=> (pat => expr): part of match arm syntax. See Match.
> (expr > expr): greater-than comparison. Overloadable (Cmp, PartialCmp).
>= (var >= expr): greater-than or equal-to comparison. Overloadable (Cmp, PartialCmp).
>> (expr >> expr): right-shift. Overloadable (Shr).
>>= (var >>= expr): right-shift & assignment.
@ (ident @ pat): pattern binding. See Patterns (Bindings).
^ (expr ^ expr): bitwise exclusive or. Overloadable (BitXor).
^= (var ^= expr): bitwise exclusive or & assignment.
| (expr | expr): bitwise or. Overloadable (BitOr).
| (pat | pat): pattern alternatives. See Patterns (Multiple patterns).
|= (var |= expr): bitwise or & assignment.
|| (expr || expr): logical or.
_: "ignored" pattern binding. See Patterns (Ignoring bindings).

Other Syntax

'ident: named lifetime or loop label. See Lifetimes, Loops (Loops Labels).
…u8, …i32, …f64, …usize, …: numeric literal of specific type.
"…": string literal. See Strings.
r"…", r#"…"#, r##"…"##, …: raw string literal, escape characters are not processed. See Reference (Raw String Literals).
b"…": byte string literal, constructs a [u8] instead of a string. See Reference (Byte String Literals).
br"…", br#"…"#, br##"…"##, …: raw byte string literal, combination of raw and byte string literal. See Reference (Raw Byte String Literals).
'…': character literal. See Primitive Types (char).
b'…': ASCII byte literal.

ident::ident: path. See Crates and Modules (Defining Modules).
::path: path relative to the crate root (i.e. an explicitly absolute path). See Crates and Modules (Re-exporting with pub use).
self::path: path relative to the current module (i.e. an explicitly relative path). See Crates and Modules (Re-exporting with pub use).
super::path: path relative to the parent of the current module. See Crates and Modules (Re-exporting with pub use).
type::ident: associated constants, functions, and types. See Associated Types.
<type>::…: associated item for a type which cannot be directly named (e.g. <&T>::…, <[T]>::…, etc.). See Associated Types.

path<…> (e.g. Vec<u8>): specifies parameters to generic type in a type. See Generics.
path::<…>, method::<…> (e.g. "42".parse::<i32>()): specifies parameters to generic type, function, or method in an expression.
fn ident<…> …: define generic function. See Generics.
struct ident<…> …: define generic structure. See Generics.
enum ident<…> …: define generic enumeration. See Generics.
impl<…> …: define generic implementation.
for<…> type: higher-ranked lifetime bounds.
type<ident=type> (e.g. Iterator<Item=T>): a generic type where one or more associated types have specific assignments. See Associated Types.

T: U: generic parameter T constrained to types that implement U. See Traits.
T: 'a: generic type T must outlive lifetime 'a.
'b: 'a: generic lifetime 'b must outlive lifetime 'a.
T: ?Sized: allow generic type parameter to be a dynamically-sized type. See Unsized Types (?Sized).
'a + trait, trait + trait: compound type constraint. See Traits (Multiple Trait Bounds).

#[meta]: outer attribute. See Attributes.
#![meta]: inner attribute. See Attributes.
$ident: macro substitution. See Macros.
$ident:kind: macro capture. See Macros.
$(…)…: macro repetition. See Macros.

//: line comment. See Comments.
//!: inner line doc comment. See Comments.
///: outer line doc comment. See Comments.
/*…*/: block comment. See Comments.
/*!…*/: inner block doc comment. See Comments.
/**…*/: outer block doc comment. See Comments.

(): empty tuple (a.k.a. unit), both literal and type.
(expr): parenthesized expression.
(expr,): single-element tuple expression. See Primitive Types (Tuples).
(type,): single-element tuple type. See Primitive Types (Tuples).
(expr, …): tuple expression. See Primitive Types (Tuples).
(type, …): tuple type. See Primitive Types (Tuples).
expr(expr, …): function call expression. Also used to initialize tuple structs and tuple enum variants. See Functions.
ident!(…), ident!{…}, ident![…]: macro invocation. See Macros.
expr.0, expr.1, …: tuple indexing. See Primitive Types (Tuple Indexing).

{…}: block expression.
Type {…}: struct literal. See Structs.

[…]: array literal. See Primitive Types (Arrays).
[expr; len]: array literal containing len copies of expr. See Primitive Types (Arrays).
[type; len]: array type containing len instances of type. See Primitive Types (Arrays).

13 KiB Raw Blame History

Keywords

Operators and Symbols

Other Syntax

13 KiB

Raw Blame History