Add pseudo code for LUB coercion, Nits fixing

Author: ldm0

src/type-coercions.md

@@ -6,6 +6,9 @@ A coercion is implicit and has no syntax.
 [RFC 401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md
 [RFC 1558]: https://github.com/rust-lang/rfcs/blob/master/text/1558-closure-to-fn-coercion.md
 
+**Attention: The LUB coercion part is not specified in any RFC currently.
+Things described in that part may changes overtime.**
+
 ## Coercion sites
 
 A coercion can only occur at certain coercion sites in a program; these are
@@ -187,45 +190,80 @@ unsized coercion to `Foo<U>`.
 
 ## LUB Coercion
 
-This is not in the RFC 401, but it's the behavior of current compiler. In LUB
-Coercion, we tried to find the least upper bound of given types. It can be
-observed in array collection, if-else/match arms.
+**This part is not specified in any RFC directly, but it's the compiler's
+behavior.**
+
+*Least upper bound coercion* (LUB coercion) is the type of coercion take place
+when we want to unify several types. It can be observed in [match] arms,
+[if expressions] and [array literal expressions]. In LUB Coercion, the compiler
+tries to find the least upper bound of given types.
+
+[match]:                      expressions/match-expr.md
+[If expressions]:             expressions/if-expr.md
+[array literal expressions]:  expressions/array-expr.md
 
 For example:
 
 ```rust
-# let (A, B, C) = (0, 1, 2);
-let emm = if true {
-    A
+# let (a, b, c) = (0, 1, 2);
+let foo = if true {
+    a
 } else if false {
-    B
+    b
 } else {
-    C
+    c
 };
 
-let foo = match 42 {
-    0 => A,
-    1 => B,
-    _ => C,
+let bar = match 42 {
+    0 => a,
+    1 => b,
+    _ => c,
 };
 
-let bar = [A, B, C];
+let baz = [a, b, c];
 ```
-In this example, both `emm` and `foo` has type
-`LubCoerce(typeof(A), typeof(B), typeof(C))` and `bar` has type
-`[LubCoerce(typeof(A), typeof(B), typeof(C)); 3]`.
+In this example, both `foo` and `bar` get the type
+`LubCoerce(typeof(a), typeof(a), typeof(c))` and `baz` get the type
+`[LubCoerce(typeof(a), typeof(b), typeof(c)); 3]`.
 
-LUB Coercion has some features:
+LUB coercion has the following properties:
 1. Order independent: e.g. `LubCoerce(ty0, ty1, ty2, ty3)` equals to
     `LubCoerce(ty1, ty0, ty4, ty3)`.
 2. `LubCoerce(ty0, ty1, ty2, ...)` equals to
     `LubCoerce(LubCoerce(ty0, ty1), ty2, ...)`
-4. `LubCoerce(ty0, ty1) == ty2` means both `ty0` and `ty1` can be coerced to
+3. `LubCoerce(ty0, ty1) == 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 `ty2`
-equals to neither `ty0` nor `ty1`, there are only two special cases we can get
-`LubCoerce(ty0, ty1) == ty2`:
-1. `LubCoerce(FnDef, FnDef) == FnPtr`,
-2. `LubCoerce(Closure, Closure) == FnPtr`(where Closure is non-capturing).
+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
+non-capturing).
+
+If the comments above confuses you, here is the pseudo code of `LubCoerce`
+in current rustc:
+
+```txt
+Lub(a, b):
+  if a == (FnDef | Closure)
+    && b == (FnDef | Closure)
+    && a != capturing Closure
+    && b != capturing Closure:
+    return FnPtr
+
+  // Coerce(x, y) returns true when x can be coerced to y
+  if Coerce(b, a):
+    return a
+  if Coerce(a, b):
+    return b
+
+  // LubCoerce failed
+  emits error
+
+LubCoerce(vars):
+  result = vars.get(0)
+  for var in vars[1..]:
+    result = Lub(result, var)
+  return result
+```