From fc955475f8912d4ef0a92d12fac6d0805e2d18a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Br=C3=A1ulio=20Bezerra?= Date: Sat, 10 Mar 2018 07:56:57 -0300 Subject: [PATCH 1/2] Moved grouped expressions to its own page. Added another example of its use. --- src/SUMMARY.md | 1 + src/expressions.md | 2 +- src/expressions/grouped-expr.md | 40 ++++++++++++++++++++++++++++++++ src/expressions/operator-expr.md | 21 ----------------- 4 files changed, 42 insertions(+), 22 deletions(-) create mode 100644 src/expressions/grouped-expr.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index aa0832bcf..a7fe60e44 100644 --- a/src/SUMMARY.md +++ b/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) diff --git a/src/expressions.md b/src/expressions.md index 8de000937..08a2d4fab 100644 --- a/src/expressions.md +++ b/src/expressions.md @@ -247,6 +247,7 @@ Many of the following operators and expressions can also be overloaded for other types using traits in `std::ops` or `std::cmp`. These traits also exist in `core::ops` and `core::cmp` with the same names. +[grouped]: expressions/grouped-expr.html [block expressions]: expressions/block-expr.html [call expressions]: expressions/call-expr.html [closure expressions]: expressions/closure-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 diff --git a/src/expressions/grouped-expr.md b/src/expressions/grouped-expr.md new file mode 100644 index 000000000..0802c8fde --- /dev/null +++ b/src/expressions/grouped-expr.md @@ -0,0 +1,40 @@ +# Grouped expressions + +> **Syntax** +> _GroupedExpression_ : +>    `(` [_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); +``` + +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 diff --git a/src/expressions/operator-expr.md b/src/expressions/operator-expr.md index eb2c45276..cbd3358fa 100644 --- a/src/expressions/operator-expr.md +++ b/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 - -> **Syntax** -> _GroupedExpression_ : ->    `(` [_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 > **Syntax** From 9ae7b6f20aecf9a0bba4822e8252d72e71aaf0e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Br=C3=A1ulio=20Bezerra?= Date: Sat, 10 Mar 2018 11:08:23 -0300 Subject: [PATCH 2/2] Adjustments after review --- src/expressions.md | 2 +- src/expressions/grouped-expr.md | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/src/expressions.md b/src/expressions.md index 08a2d4fab..57282cfbf 100644 --- a/src/expressions.md +++ b/src/expressions.md @@ -247,12 +247,12 @@ Many of the following operators and expressions can also be overloaded for other types using traits in `std::ops` or `std::cmp`. These traits also exist in `core::ops` and `core::cmp` with the same names. -[grouped]: expressions/grouped-expr.html [block expressions]: expressions/block-expr.html [call expressions]: expressions/call-expr.html [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 diff --git a/src/expressions/grouped-expr.md b/src/expressions/grouped-expr.md index 0802c8fde..00aef883c 100644 --- a/src/expressions/grouped-expr.md +++ b/src/expressions/grouped-expr.md @@ -8,8 +8,6 @@ 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 @@ -33,8 +31,8 @@ that is a member of a struct: # } # let a = A{f: || "The field f"}; # -assert_eq!( a.f (), "The method f"); -assert_eq!( (a.f)(), "The field f"); +assert_eq!( a.f (), "The method f"); +assert_eq!((a.f)(), "The field f"); ``` [_Expression_]: expressions.html