Operator expressions grammar

Author: brauliobz

src/expressions/operator-expr.md

@@ -1,5 +1,18 @@
 # Operator expressions
 
+> **<sup>Syntax</sup>**  
+> _OperatorExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; [_BorrowExpression_]  
+> &nbsp;&nbsp; | [_DereferenceExpression_]  
+> &nbsp;&nbsp; | [_ErrorPropagationExpression_]  
+> &nbsp;&nbsp; | [_NegationExpression_]  
+> &nbsp;&nbsp; | [_ArithmeticOrLogicalExpression_]  
+> &nbsp;&nbsp; | [_ComparisonExpression_]  
+> &nbsp;&nbsp; | [_LazyBooleanExpression_]  
+> &nbsp;&nbsp; | [_TypeCastExpression_]  
+> &nbsp;&nbsp; | [_AssignmentExpression_]  
+> &nbsp;&nbsp; | [_CompoundAssignmentExpression_]  
+
 Operators are defined for built in types by the Rust language. Many of the
 following operators can also be overloaded using traits in `std::ops` or
 `std::cmp`.
@@ -21,6 +34,10 @@ overflow:
 
 ## Grouped expressions
 
+> **<sup>Syntax</sup>**  
+> _GroupedExpression_ :  
+> &nbsp;&nbsp; `(` [_Expression_] `)`
+
 An expression enclosed in parentheses evaluates to the result of the enclosed
 expression. Parentheses can be used to explicitly specify evaluation order
 within an expression.
@@ -36,6 +53,11 @@ assert_eq!(y, 20);
 
 ## Borrow operators
 
+> **<sup>Syntax</sup>**  
+> _BorrowExpression_ :   
+> &nbsp;&nbsp; &nbsp;&nbsp; (`&`|`&&`) [_Expression_]  
+> &nbsp;&nbsp; | (`&`|`&&`) `mut` [_Expression_]  
+
 The `&` (shared borrow) and `&mut` (mutable borrow) operators are unary prefix
 operators. When applied to an lvalue produce a reference (pointer) to the
 location that the value refers to. The lvalue is also placed into a borrowed
@@ -62,6 +84,10 @@ let mut array = [-2, 3, 9];
 
 ## The dereference operator
 
+> **<sup>Syntax</sup>**  
+> _DereferenceExpression_ :  
+> &nbsp;&nbsp; `*` [_Expression_]
+
 The `*` (dereference) operator is also a unary prefix operator. When applied to
 a [pointer](types.html#pointer-types) it denotes the pointed-to location. If
 the expression is of type `&mut T` and `*mut T`, and is either a local
@@ -81,7 +107,11 @@ let y = &mut 9;
 assert_eq!(*y, 11);
 ```
 
-## The `?` operator.
+## The `?` operator
+
+> **<sup>Syntax</sup>**  
+> _ErrorPropagationExpression_ :  
+> &nbsp;&nbsp; [_Expression_] `?`  
 
 The `?` ("question mark") operator can be applied to values of the `Result<T,
 E>` type to propagate errors. If applied to `Err(e)` it will return
@@ -104,6 +134,11 @@ println!("{:?}", res);
 
 ## Negation operators
 
+> **<sup>Syntax</sup>**  
+> _NegationExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; `-` [_Expression_]  
+> &nbsp;&nbsp; | `!` [_Expression_]  
+
 These are the last two unary operators. This table summarizes the behavior of
 them on primitive types and which traits are used to overload these operators
 for other types. Remember that signed integers are always represented using
@@ -128,6 +163,19 @@ assert_eq!(true, !false);
 
 ## Arithmetic and Logical Binary Operators
 
+> **<sup>Syntax</sup>**  
+> _ArithmeticOrLogicalExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_] `+` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `-` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `*` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `/` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `%` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `&` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `|` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `^` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `<<` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `>>` [_Expression_]  
+
 Binary operators expressions are all written with infix notation. This table
 summarizes the behavior of arithmetic and logical binary operators on
 primitive types and which traits are used to overload these operators for other
@@ -168,6 +216,15 @@ assert_eq!(-10 >> 2, -3);
 
 ## Comparison Operators
 
+> **<sup>Syntax</sup>**  
+> _ComparisonExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_] `==` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `!=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `>` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `<` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `>=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `<=` [_Expression_]  
+
 Comparison operators are also defined both for primitive types and many type in
 the standard library. Parentheses are required when chaining comparison
 operators. For example, the expression `a == b == c` is invalid and may be
@@ -212,6 +269,11 @@ assert!("World" >= "Hello");
 
 ## Lazy boolean operators
 
+> **<sup>Syntax</sup>**  
+> _LazyBooleanExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_] `||` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `&&` [_Expression_]
+
 The operators `||` and `&&` may be applied to operands of boolean type. The
 `||` operator denotes logical 'or', and the `&&` operator denotes logical
 'and'. They differ from `|` and `&` in that the right-hand operand is only
@@ -227,6 +289,10 @@ let y = false && panic!(); // false, doesn't evaluate `panic!()`
 
 ## Type cast expressions
 
+> **<sup>Syntax</sup>**  
+> _TypeCastExpression_ :  
+> &nbsp;&nbsp; [_Expression_] `as` [_PathInExpression_]
+
 A type cast expression is denoted with the binary operator `as`.
 
 Executing an `as` expression casts the value on the left-hand side to the type
@@ -300,6 +366,10 @@ same trait object.
 
 ## Assignment expressions
 
+> **<sup>Syntax</sup>**  
+> _AssignmentExpression_ :  
+> &nbsp;&nbsp; | [_Expression_] `=` [_Expression_]  
+
 An _assignment expression_ consists of an
 [lvalue](expressions.html#lvalues-and-rvalues) expression followed
 by an equals sign (`=`) and an
@@ -318,6 +388,19 @@ x = y;
 
 ## Compound assignment expressions
 
+> **<sup>Syntax</sup>**  
+> _CompoundAssignmentExpression_ :  
+> &nbsp;&nbsp; &nbsp;&nbsp; [_Expression_] `+=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `-=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `*=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `/=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `%=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `&=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `|=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `^=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `<<=` [_Expression_]  
+> &nbsp;&nbsp; | [_Expression_] `>>=` [_Expression_]  
+
 The `+`, `-`, `*`, `/`, `%`, `&`, `|`, `^`, `<<`, and `>>` operators may be
 composed with the `=` operator. The expression `lval OP= val` is equivalent to
 `lval = lval OP val`. For example, `x = x + 1` may be written as `x += 1`.
@@ -331,3 +414,17 @@ let mut x = 10;
 x += 4;
 assert_eq!(x, 14);
 ```
+
+[_BorrowExpression_]: #borrow-operators
+[_DereferenceExpression_]: #the-dereference-operator
+[_ErrorPropagationExpression_]: #the--operator
+[_NegationExpression_]: #negation-operators
+[_ArithmeticOrLogicalExpression_]: #arithmetic-and-logical-binary-operators
+[_ComparisonExpression_]: #comparison-operators
+[_LazyBooleanExpression_]: #lazy-boolean-operators
+[_TypeCastExpression_]: #type-cast-expressions
+[_AssignmentExpression_]: #assignment-expressions
+[_CompoundAssignmentExpression_]: #compound-assignment-expressions
+
+[_Expression_]: expressions.html
+[_PathInExpression_]: paths.html