Add explanation for LubCoerce with expected type

Author: ldm0

src/type-coercions.md

@@ -231,14 +231,14 @@ LUB coercion has the following properties:
     `LubCoerce(ty1, ty0, ty4, ty3)`.
 2. `LubCoerce(ty0, ty1, ty2, ...)` equals to
     `LubCoerce(LubCoerce(ty0, ty1), ty2, ...)`
-3. `LubCoerce(ty0, ty1) == ty2` means both `ty0` and `ty1` can be coerced to
+3. `LubCoerce(ty0, ty1) == Some(ty2)` means both `ty0` and `ty1` can be coerced to
     `ty2`.
 
 Notice the feature No.3, it uses the word "means" rather than "if and only if".
 That's because currently if `ty0` and `ty1` can be coerced to `ty2` and
 unfortunately `ty2` equals to neither `ty0` nor `ty1`, there are only one
-special situation where we can get `LubCoerce(ty0, ty1) == ty2`:
-`LubCoerce((FnDef | Closure), (FnDef | Closure)) == FnPtr` (where Closure is
+special situation where we can get `LubCoerce(ty0, ty1) == Some(ty2)`:
+`LubCoerce((FnDef | Closure), (FnDef | Closure)) == Some(FnPtr)` (where Closure is
 non-capturing).
 
 If the comments above confuses you, here is the pseudo code of `LubCoerce`
@@ -267,3 +267,28 @@ LubCoerce(vars):
     result = Lub(result, var)
   return result
 ```
+
+It also worth mentioning code below compiles if and only if
+`LubCoerce(Ty, typeof(a), typeof(b)).is_some()`:
+
+```rust
+# #[derive(Clone, Copy)]
+# struct Ty;
+# let (a, b) = (Ty, Ty);
+let foo: Ty = if true {
+    a
+} else {
+    b
+};
+
+let bar: Ty = match true {
+    true => a,
+    false => b,
+};
+
+let baz: [Ty; 2] = [a, b];
+```
+
+That's because with expected type, the compiler checks
+`LubCoerce(expected, ty0, ty1, ty2...).is_some()` rather than
+`LubCoerce(ty0, ty1, ty2...) == expected`.