Moved grouped expressions to its own page

src/SUMMARY.md

@@ -45,6 +45,7 @@
         - [Path expressions](expressions/path-expr.md)
         - [Block expressions](expressions/block-expr.md)
         - [Operator expressions](expressions/operator-expr.md)
+        - [Grouped expressions](expressions/grouped-expr.md)
         - [Array and index expressions](expressions/array-expr.md)
         - [Tuple and index expressions](expressions/tuple-expr.md)
         - [Struct expressions](expressions/struct-expr.md)

src/expressions.md

@@ -252,6 +252,7 @@ exist in `core::ops` and `core::cmp` with the same names.
 [closure expressions]:  expressions/closure-expr.html
 [enum variant]:         expressions/enum-variant-expr.html
 [field]:                expressions/field-expr.html
+[grouped]:              expressions/grouped-expr.html
 [literals]:             expressions/literal-expr.html
 [match]:                expressions/match-expr.html
 [method-call]:          expressions/method-call-expr.html
@@ -272,7 +273,6 @@ exist in `core::ops` and `core::cmp` with the same names.
 [dereferences]:         expressions/operator-expr.html#the-dereference-operator
 [dereferencing]:        expressions/operator-expr.html#the-dereference-operator
 [dereference operator]: expressions/operator-expr.html#the-dereference-operator
-[grouped]:              expressions/operator-expr.html#grouped-expressions
 [lazy boolean]:         expressions/operator-expr.html#lazy-boolean-operators
 [negation]:             expressions/operator-expr.html#negation-operators
 [overflow]:             expressions/operator-expr.html#overflow

src/expressions/grouped-expr.md

@@ -0,0 +1,38 @@
+# 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.
+
+An example of a parenthesized expression:
+
+```rust
+let x: i32 = 2 + 3 * 4;
+let y: i32 = (2 + 3) * 4;
+assert_eq!(x, 14);
+assert_eq!(y, 20);
+```
+
+An example of a necessary use of parentheses is when calling a function pointer
+that is a member of a struct:
+
+```rust
+# struct A {
+#    f: fn() -> &'static str
+# }
+# impl A {
+#    fn f(&self) -> &'static str {
+#        "The method f"
+#    }
+# }
+# let a = A{f: || "The field f"};
+# 
+assert_eq!( a.f (), "The method f");
+assert_eq!((a.f)(), "The field f");
+```
+
+[_Expression_]: expressions.html

src/expressions/operator-expr.md

@@ -32,27 +32,6 @@ overflow:
 * Using `<<` or `>>` where the right-hand argument is greater than or equal to
   the number of bits in the type of the left-hand argument, or is negative.
 
-## 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.
-
-This operator cannot be overloaded.
-
-An example of a parenthesized expression:
-
-```rust
-let x: i32 = 2 + 3 * 4;
-let y: i32 = (2 + 3) * 4;
-assert_eq!(x, 14);
-assert_eq!(y, 20);
-```
-
 ## Borrow operators
 
 > **<sup>Syntax</sup>**