You are reading an outdated edition of TRPL. For more, go here.

Syntax Index

Keywords

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, generic parameter defaults.
  • == (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.

Other Syntax

  • 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.
  • {…}: 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".