Update glossary and implementations

Co-Authored-By: Mazdak Farrokhzad <[email protected]>

Author: ohadravid

src/glossary.md

@@ -30,12 +30,12 @@ items are defined in [implementations] and declared in [traits]. Only
 functions, constants, and type aliases can be associated. Contrast to a [free
 item].
 
-### Blanket Implementation
+### Blanket implementation
 
 Any implementation where a type appears [uncovered](#uncovered-type). `impl<T> Foo
 for T`, `impl<T> Bar<T> for T`, `impl<T> Bar<Vec<T>> for T`, and `impl<T> Bar<T>
 for Vec<T>` are considered blanket impls. However, `impl<T> Bar<Vec<T>> for
-Vec<T>` is not a blanket impl, as all instances of `T` which appear in this impl
+Vec<T>` is not a blanket impl, as all instances of `T` which appear in this `impl`
 are covered by `Vec`.
 
 ### Bound
@@ -73,12 +73,12 @@ For example, `2 + (3 * 4)` is an expression that returns the value 14.
 An [item] that is not a member of an [implementation], such as a *free
 function* or a *free const*. Contrast to an [associated item].
 
-### Fundamental Type
+### Fundamental type
 
 Includes `&`, `&mut`, `Box` and `Pin`. Any time a type `T` is
-considered [local](#local-type), `&T`, `&mut T`, `Box<T>` and `Pin<T>` are also considered local.
+considered [local](#local-type), `&T`, `&mut T`, `Box<T>`, and `Pin<T>` are also considered local.
 Fundamental types cannot [cover](#uncovered-type) other types. Any time the term "covered type" is
-used, the `T` in `&T`, `&mut T`, `Box<T>` and `Pin<T>` is not considered covered.
+used, the `T` in `&T`, `&mut T`, `Box<T>`, and `Pin<T>` is not considered covered.
 
 ### Inhabited
 
@@ -102,18 +102,18 @@ A variable is initialized if it has been assigned a value and hasn't since been
 moved from. All other memory locations are assumed to be uninitialized. Only
 unsafe Rust can create such a memory without initializing it.
 
-### Local Trait
+### Local trait
 
-A trait which was defined in the current crate. Whether a trait is
-local or not has nothing to do with type parameters. Given `trait Foo<T, U>`,
-`Foo` is always local, regardless of the types used for `T` or `U`.
+A `trait` which was defined in the current crate. A trait definition is local
+or not independent of applied type arguments. Given `trait Foo<T, U>`,
+`Foo` is always local, regardless of the types substituted for `T` and `U`.
 
-### Local Type
+### Local type
 
-A struct, enum, or union which was defined in the current crate.
-This is not affected by type parameters. `struct Foo` is considered local, but
-`Vec<Foo>` is not. `LocalType<ForeignType>` is local. Type aliases and trait
-aliases do not affect locality.
+A `struct`, `enum`, or `union` which was defined in the current crate.
+This is not affected by applied type arguments. `struct Foo` is considered local, but
+`Vec<Foo>` is not. `LocalType<ForeignType>` is local. Type aliases do not 
+affect locality.
 
 ### Nominal types
 
@@ -186,11 +186,11 @@ It allows a type to make certain promises about its behavior.
 
 Generic functions and generic structs can use traits to constrain, or bound, the types they accept.
 
-### Uncovered Type
+### Uncovered type
 
-A type which does not appear as a parameter to another type. For example,
+A type which does not appear as an argument to another type. For example,
 `T` is uncovered, but the `T` in `Vec<T>` is covered. This is only relevant for
-type parameters.
+type arguments.
 
 ### Undefined behavior
 

src/items/implementations.md

@@ -162,7 +162,7 @@ be instantiable with the same set of types for the input type parameters. -->
 
 #### Orphan rules
 
-Given `impl<P1..=Pn> Trait<T1..=Tn> for T0`, an impl is valid only if at
+Given `impl<P1..=Pn> Trait<T1..=Tn> for T0`, an `impl` is valid only if at
 least one of the following is true:
 
 - `Trait` is a [local trait]
@@ -172,8 +172,8 @@ least one of the following is true:
   - No [uncovered type] parameters `P1..=Pn` may appear in `T0..Ti` (excluding
     `Ti`)
 
-We only restrict the appearance of *uncovered* type parameters. Once again, it is
-important to note that for the purposes of coherence, [fundamental types] are
+Only the appearance of *uncovered* type parameters is restricted.
+Note that for the purposes of coherence, [fundamental types] are
 special. The `T` in `Box<T>` is not considered covered, and `Box<LocalType>` 
 is considered local.
 
@@ -229,4 +229,4 @@ attributes].
 [local trait]: ../glossary.md#local-trait
 [local type]: ../glossary.md#local-type
 [fundamental types]: ../glossary.md#fundamental-type
-[uncovered type]: ../glossary.md#uncovered-type
+[uncovered type]: ../glossary.md#uncovered-type