Use the reference POV and remove motivation and irrelevant info

Author: ohadravid

src/glossary.md

@@ -30,6 +30,14 @@ 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
+
+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
+are covered by `Vec`.
+
 ### Bound
 
 Bounds are constraints on a type or trait. For example, if a bound
@@ -65,6 +73,13 @@ 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
+
+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.
+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.
+
 ### Inhabited
 
 A type is inhabited if it has constructors and therefore can be instantiated. An inhabited type is
@@ -87,6 +102,19 @@ 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
+
+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`.
+
+### 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.
+
 ### Nominal types
 
 Types that can be referred to by a path directly. Specifically [enums],
@@ -158,6 +186,12 @@ 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
+
+A type which does not appear as a parameter to another type. For example,
+`T` is uncovered, but the `T` in `Vec<T>` is covered. This is only relevant for
+type parameters.
+
 ### Undefined behavior
 
 Compile-time or run-time behavior that is not specified. This may result in,

src/items/coherence.md

@@ -152,7 +152,31 @@ impl Shape for Circle {
 
 ### Trait Implementation Coherence
 
-A trait implementation must follow the [coherence] rules.
+A trait implementation is considered incoherent if either the orphan rules check fails
+or there are overlapping implementation instances.
+
+Two trait implementations overlap when there is a non-empty intersection of the
+traits the implementation is for, the implementations can be instantiated with
+the same type. <!-- This is probably wrong? Source: No two implementations can
+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
+least one of the following is true:
+
+- `Trait` is a [local trait]
+- All of
+  - At least one of the types `T0..=Tn` must be a [local type]. Let `Ti` be the
+    first such type.
+  - 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
+special. The `T` in `Box<T>` is not considered covered, and `Box<LocalType>` 
+is considered local.
+
 
 ## Generic Implementations
 
@@ -202,4 +226,7 @@ attributes].
 [path]: ../paths.md
 [the lint check attributes]: ../attributes/diagnostics.md#lint-check-attributes
 [Unsafe traits]: traits.md#unsafe-traits
-[coherence]: coherence.md
+[local trait]: ../glossary.md#local-trait
+[local type]: ../glossary.md#local-type
+[fundamental types]: ../glossary.md#fundamental-type
+[uncovered type]: ../glossary.md#uncovered-type

src/items/implementations.md

@@ -170,7 +170,7 @@ compiler, not by [implementation items].
 [Methods]: items/associated-items.md#associated-functions-and-methods
 [method resolution]: expressions/method-call-expr.md
 [operators]: expressions/operator-expr.md
-[orphan rules]: items/coherence.md
+[orphan rules]: items/implementations.md#trait-implementation-coherence
 [Raw pointers]: types/pointer.md#raw-pointers-const-and-mut
 [`static` items]: items/static-items.md
 [Shared references]: types/pointer.md#shared-references-