Make dropping of temporaries in conditionals part of the rule

Reformulate text so that dropping of temporaries created in condition
expression of an `if` or `if`/`else` or in the loop conditional expression
of a `while` is now part of the rule, not an exception.
Revert the paragraph concerning the `let` expression to its original form.
Move examples.
Include an example of a temporary without borrowing.

Author: Pieter Penninckx

Diff for: src/expressions.md

@@ -84,30 +84,17 @@ The following expressions can create mutable lvalues:
 ### Temporary lifetimes
 
 When using an rvalue in most lvalue contexts, a temporary unnamed lvalue is
-created and used instead. The lifetime of temporary values is typically the
-innermost enclosing statement; the tail expression of a block is considered
-part of the statement that encloses the block.
+created and used instead. The lifetime of temporary values is typically 
 
-A first exception is when a temporary value is created in the
-condition expression of an `if` or an  `if`/`else` expression or in the
-loop conditional expression of a `while` expression.
-In this case, the lifetime ends right after the condition expression or the
-loop conditional expression.
+- the innermost enclosing statement; the tail expression of a block is 
+  considered part of the statement that encloses the block, or
+- the condition expression or the loop conditional expression if the 
+  temporary is created in the condition expression of an `if` or an `if`/`else`
+  or in the loop conditional expression of a `while` expression.
 
-Here are some examples:
-
-- `let x = if foo(&temp()) {bar()} else {baz()}`. The expression `temp()` is
-  an rvalue. As the temporary is created in the condition expression
-  of an `if`/`else`, it will be freed at the end of the condition expression
-  (in this example before the call to `bar` or `baz` is made).
-- `while foo(&temp()) {bar();}`. The temporary containing the return value from
-  the call to `temp()` is created in the loop conditional expression. Hence it
-  will be freed at the end of the loop conditional expression (in this example
-  before the call to `bar` if the loop body is executed).
-
-Another exception is when a temporary rvalue is being created that is assigned
-into a `let` declaration. In this case the temporary is created with the
-lifetime of the enclosing block, as using the enclosing statement (the `let`
+When a temporary rvalue is being created that is assigned into a `let`
+declaration, however, the temporary is created with the lifetime of the
+enclosing block instead, as using the enclosing statement (the `let`
 declaration) would be a guaranteed error (since a pointer to the temporary
 would be stored into a variable, but the temporary would be freed before the
 variable could be used). The compiler uses simple syntactic rules to decide
@@ -124,6 +111,18 @@ Here are some examples:
   method-call. Here we are assuming that `foo()` is an `&self` method
   defined in some trait, say `Foo`. In other words, the expression
   `temp().foo()` is equivalent to `Foo::foo(&temp())`.
+- `let x = if foo(&temp()) {bar()} else {baz()};`. The expression `temp()` is
+  an rvalue. As the temporary is created in the condition expression
+  of an `if`/`else`, it will be freed at the end of the condition expression
+  (in this example before the call to `bar` or `baz` is made).
+- `let x = if temp().must_run_bar {bar()} else {baz()};`. 
+  Here we assume the type of `temp()` is a struct with a boolean field
+  `must_run_bar`. As the previous example, the temporary corresponding to
+  `temp()` will be freed at the end of the condition expression.
+- `while foo(&temp()) {bar();}`. The temporary containing the return value from
+  the call to `temp()` is created in the loop conditional expression. Hence it
+  will be freed at the end of the loop conditional expression (in this example
+  before the call to `bar` if the loop body is executed).
 - `let x = &temp()`. Here, the same temporary is being assigned into
   `x`, rather than being passed as a parameter, and hence the
   temporary's lifetime is considered to be the enclosing block.