doc(inline): fix for transparent

Author: robstoll

docs/docs/reference/metaprogramming/inline.md

@@ -170,17 +170,17 @@ Inline methods can override other non-inline methods. The rules are as follows:
 2. Inline methods are effectively final.
 
 3. Inline methods can also be abstract. An abstract inline method can be implemented only by other inline methods. It cannot be invoked directly:
-```scala
-abstract class A {
-  inline def f(): Int
-}
-object B extends A {
-  inline def f(): Int = 22
-}
-B.f()         // OK
-val a: A = B
-a.f()         // error: cannot inline f() in A.
-```
+    ```scala
+    abstract class A {
+      inline def f(): Int
+    }
+    object B extends A {
+      inline def f(): Int = 22
+    }
+    B.f()         // OK
+    val a: A = B
+    a.f()         // error: cannot inline f() in A.
+    ```
 
 ### Relationship to @inline
 
@@ -241,18 +241,20 @@ class B extends A {
 }
 
 transparent inline def choose(b: Boolean): A =
-  if b then A() else B
+  if b then A else B
 
 val obj1 = choose(true)  // static type is A
 val obj2 = choose(false) // static type is B
 
 // obj1.m() // compile-time error: `m` is not defined on `A`
 obj2.m()    // OK
 ```
-Here, the inline method `choose` returns an object of either of the two types `A` and `B`. If `choose` had been declared with a normal return type `: A`, the result
-of its expansion would always be of type `A`, even though the computed value might be of the subtype `B`. The inline method is a "blackbox" in the sense that details of its implementation do not leak out. But if a `transparent` modifier is given,
-the expansion is the type of the expanded body. If the argument `b`
-is `true`, that type is `A`, otherwise it is `B`. Consequently, calling `meth` on `obj2`
+Here, the inline method `choose` returns an instance of either of the two types `A` or `B`. 
+If `choose` had not been declared to be `transparent`, the result
+of its expansion would always be of type `A`, even though the computed value might be of the subtype `B`. 
+The inline method is a "blackbox" in the sense that details of its implementation do not leak out. 
+But if a `transparent` modifier is given, the expansion is the type of the expanded body. If the argument `b`
+is `true`, that type is `A`, otherwise it is `B`. Consequently, calling `m` on `obj2`
 type-checks since `obj2` has the same type as the expansion of `choose(false)`, which is `B`.
 Transparent inline methods are "whitebox" in the sense that the type
 of an application of such a method can be more specialized than its declared