You are reading an outdated  edition of TRPL. For more, go here . 
    
         
 
                
                
                
                
                
                
                
                    
                        
as: primitive casting, or disambiguating the specific trait containing an item.  See Casting Between Types (as) , Universal Function Call Syntax (Angle-bracket Form) , Associated Types .break: break out of loop.  See Loops (Ending Iteration Early) .const: constant items and constant raw pointers.  See const and staticRaw Pointers .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 ifif letenum: 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 ifif letimpl: 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 AliasesAssociated 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 
! (ident!(…), ident!{…}, ident![…]): denotes macro expansion.  See Macros .! (!expr): bitwise or logical complement.  Overloadable (Not).!= (var != expr): nonequality comparison.  Overloadable (PartialEq).% (expr % expr): arithmetic remainder.  Overloadable (Rem).%= (var %= expr): arithmetic remainder & assignment. Overloadable (RemAssign).& (expr & expr): bitwise and.  Overloadable (BitAnd).& (&expr, &mut 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. Overloadable (BitAndAssign).&& (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. Overloadable (MulAssign).+ (expr + expr): arithmetic addition.  Overloadable (Add).+ (trait + trait, 'a + trait): compound type constraint.  See Traits (Multiple Trait Bounds) .+= (var += expr): arithmetic addition & assignment. Overloadable (AddAssign).,: 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. Overloadable (SubAssign).-> (fn(…) -> type, |…| -> type): function and closure return type.  See Functions , Closures .. (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...expr) in an expression : inclusive range expression. See Iterators .... (expr...expr) in a pattern : inclusive range pattern.  See Patterns (Ranges) ./ (expr / expr): arithmetic division.  Overloadable (Div)./= (var /= expr): arithmetic division & assignment. Overloadable (DivAssign).: (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. Overloadable (ShlAssign).< (expr < expr): less-than comparison.  Overloadable (PartialOrd).<= (var <= expr): less-than or equal-to comparison.  Overloadable (PartialOrd).= (var = expr, ident = type): assignment/equivalence.  See Variable Bindings , type Aliases== (var == expr): equality comparison.  Overloadable (PartialEq).=> (pat => expr): part of match arm syntax.  See Match .> (expr > expr): greater-than comparison.  Overloadable (PartialOrd).>= (var >= expr): greater-than or equal-to comparison.  Overloadable (PartialOrd).>> (expr >> expr): right-shift.  Overloadable (Shr).>>= (var >>= expr): right-shift & assignment. Overloadable (ShrAssign).@ (ident @ pat): pattern binding.  See Patterns (Bindings) .^ (expr ^ expr): bitwise exclusive or.  Overloadable (BitXor).^= (var ^= expr): bitwise exclusive or & assignment. Overloadable (BitXorAssign).| (expr | expr): bitwise or.  Overloadable (BitOr).| (pat | pat): pattern alternatives.  See Patterns (Multiple patterns) .| (|…| expr): closures.  See Closures .|= (var |= expr): bitwise or & assignment. Overloadable (BitOrAssign).|| (expr || expr): logical or._: "ignored" pattern binding (see Patterns (Ignoring bindings) ). Also used to make integer-literals readable (see Reference (Integer literals) ).? (expr?): Error propagation. Returns early when Err(_) is encountered, unwraps otherwise. Similar to the try! macro 
'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.|…| expr: closure.  See Closures . 
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 .  See Generics § Resolving ambiguities .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. When we say that a type 'outlives' the lifetime, we mean that it cannot transitively contain any references with lifetimes shorter than 'a.T : 'static: The 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.  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) .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, RangeFull as the "index".