Ch6 - Remove section on Overlapping and Orphan Instances (#242)

Author: milesfrain

text/chapter6.md

@@ -392,74 +392,6 @@ forall a. Semiring a => a -> a
 
 Here, we might have annotated this function as `Int -> Int`, or `Number -> Number`, but PSCi shows us that the most general type works for any `Semiring`, allowing us to use our function with both `Int`s and `Number`s.
 
-## Overlapping and Orphan Instances
-
-PureScript has another rule regarding type class instances, called the _overlapping instances rule_. Whenever a type class instance is required at a function call site, PureScript will use the information inferred by the type checker to choose the correct instance. At that time, there should be exactly one appropriate instance for that type. If there are multiple valid instances, then it is unclear which instance to select, and the compiler will issue an error.
-
-To demonstrate this, we can try creating two conflicting type class instances for an example type. In the following code, we create two overlapping `Show` instances for the type `T`:
-
-```haskell
-module Overlapped where
-
-import Prelude
-
-data T = T
-
-instance showT1 :: Show T where
-  show _ = "Instance 1"
-
-instance showT2 :: Show T where
-  show _ = "Instance 2"
-```
-
-This module will not compile. The overlapping instances rule will be enforced, resulting in an error:
-
-```text
-Overlapping type class instances found for Data.Show.Show T
-```
-
-Furthermore, PureScript forbids _orphan instances_.  An _orphan instance_ is an instance that is defined outside of both the module which defined the class and the module which defined the type. A problem with orphan instances is that they let library creators evade explicit violations of the overlapping instances rule, while potentially setting-up their users for instance collisions.
-
-For example, consider our original type `T`:
-```hs
-module T where
-
-data T = T
-```
-
-And a library that defines an orphan `Show` instance for `T`:
-```hs
-module LibA where
-
-import T
-import Prelude
-
-instance showT1 :: Show T where
-  show _ = "Instance 1"
-```
-
-If we were to include `LibA` in our project, there would be no overlap issues. But let's say we later include `LibB`, which has the following implementation with another orphan instance:
-```hs
-module LibB where
-
-import T
-import Prelude
-
-instance showT2 :: Show T where
-  show _ = "Instance 2"
-```
-
-Now we're faced with an overlapping instance dilemma. To address this problem head-on, PureScript simply bans orphan instances, and would present the creator of `LibA` (and `LibB`) with the following error:
-```text
-  Orphan instance showT1 found for Data.Show.Show T
-
-  This problem can be resolved by declaring the instance in Data.Show or T, or by defining the instance on a newtype wrapper.
-```
-
-By forcing instances to be defined in either the module which defined the class or the module which defined the type, PureScript guarantees that all instances are globally unique across the entire ecosystem.
-
-If it is truly the case that there are two valid type class instances for a type, satisfying the appropriate laws, then a common approach is to define newtypes which wrap the existing type. Since different newtypes are allowed to have different type class instances under the overlapping instances rule, there is no longer an issue. This approach is taken in PureScript's standard libraries, for example in the `maybe` package, the `Maybe a` type has multiple valid instances for the `Monoid` type class via `newtype` wrappers `First` and `Last`.
-
 ## Instance Dependencies
 
 Just as the implementation of functions can depend on type class instances using constrained types, so can the implementation of type class instances depend on other type class instances. This provides a powerful form of program inference, in which the implementation of a program can be inferred using its types.