updates for ! type stabilisation

Remove section on diverging function since they are no longer special.
Modify wording around description of `loop` accordingly.
Add `!` to any coercion to list of coercions.

Author: canndrew

src/expressions/loop-expr.md

@@ -36,12 +36,10 @@ Only `loop` supports [evaluation to non-trivial values](#break-and-loop-values).
 A `loop` expression repeats execution of its body continuously:
 `loop { println!("I live."); }`.
 
-A `loop` expression without an associated `break` expression is
-[diverging](items/functions.html#diverging-functions), and doesn't
-return anything. A `loop` expression containing associated
-[`break` expression(s)](#break-expressions)
-may terminate, and must have type compatible with the value of the `break`
-expression(s).
+A `loop` expression without an associated `break` expression is diverging and
+so has type `!`. A `loop` expression containing associated 
+[`break` expression(s)](#break-expressions) may terminate, and must have type
+compatible with the value of the `break` expression(s).
 
 ## Predicate loops
 

src/items/functions.md

@@ -93,52 +93,6 @@ sufficient context to determine the type parameters. For example,
 
 [path]: paths.html
 
-## Diverging functions
-
-A special kind of function can be declared with a `!` character where the
-output type would normally be. For example:
-
-```rust
-fn my_err(s: &str) -> ! {
-    println!("{}", s);
-    panic!();
-}
-```
-
-We call such functions "diverging" because they never return a value to the
-caller. Every control path in a diverging function must end with a `panic!()`,
-a loop expression without an associated break expression, or a call to another
-diverging function on every control path. The `!` annotation does *not* denote
-a type.
-
-It might be necessary to declare a diverging function because as mentioned
-previously, the typechecker checks that every control path in a function ends
-with a [`return`] or diverging expression. So, if `my_err` were declared
-without the `!` annotation, the following code would not typecheck:
-
-[`return`]: expressions/return-expr.html
-
-```rust
-# fn my_err(s: &str) -> ! { panic!() }
-
-fn f(i: i32) -> i32 {
-    if i == 42 {
-        return 42;
-    }
-    else {
-        my_err("Bad number!");
-    }
-}
-```
-
-This will not compile without the `!` annotation on `my_err`, since the `else`
-branch of the conditional in `f` does not return an `i32`, as required by the
-signature of `f`. Adding the `!` annotation to `my_err` informs the typechecker
-that, should control ever enter `my_err`, no further type judgments about `f`
-need to hold, since control will never resume in any context that relies on
-those judgments. Thus the return type on `f` only needs to reflect the `if`
-branch of the conditional.
-
 ## Extern functions
 
 Extern functions are part of Rust's foreign function interface, providing the

src/type-coercions.md

@@ -148,6 +148,8 @@ Coercion is allowed between the following types:
 
 * Non capturing closures to `fn` pointers
 
+* `!` to any `T`
+
 ### Unsized Coercions
 
 The following coercions are called `unsized coercions`, since they