Ignore some orphan warnings

[ghc-base.git] / GHC / Base.lhs

diff --git a/GHC/Base.lhs b/GHC/Base.lhs
index 5e5d6bb..9951b5a 100644 (file)
--- a/GHC/Base.lhs
+++ b/GHC/Base.lhs
@@ -63,6 +63,7 @@ Other Prelude modules are much easier with fewer complex dependencies.
 
 \begin{code}
 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
 {-# OPTIONS_HADDOCK hide #-}
 -----------------------------------------------------------------------------
 -- |
@@ -85,24 +86,25 @@ module GHC.Base
         (
         module GHC.Base,
         module GHC.Bool,
+        module GHC.Classes,
         module GHC.Generics,
         module GHC.Ordering,
+        module GHC.Types,
         module GHC.Prim,        -- Re-export GHC.Prim and GHC.Err, to avoid lots
         module GHC.Err          -- of people having to import it explicitly
   ) 
         where
 
+import GHC.Types
 import GHC.Bool
+import GHC.Classes
 import GHC.Generics
 import GHC.Ordering
 import GHC.Prim
 import {-# SOURCE #-} GHC.Err
 
 infixr 9  .
-infixr 5  ++, :
-infix  4  ==, /=, <, <=, >=, >
-infixr 3  &&
-infixr 2  ||
+infixr 5  ++
 infixl 1  >>, >>=
 infixr 0  $
 
@@ -148,61 +150,6 @@ unpackCStringUtf8# a = error "urk"
 
 %*********************************************************
 %*                                                      *
-\subsection{Standard classes @Eq@, @Ord@}
-%*                                                      *
-%*********************************************************
-
-\begin{code}
-
--- | The 'Eq' class defines equality ('==') and inequality ('/=').
--- All the basic datatypes exported by the "Prelude" are instances of 'Eq',
--- and 'Eq' may be derived for any datatype whose constituents are also
--- instances of 'Eq'.
---
--- Minimal complete definition: either '==' or '/='.
---
-class  Eq a  where
-    (==), (/=)           :: a -> a -> Bool
-
-    x /= y               = not (x == y)
-    x == y               = not (x /= y)
-
--- | The 'Ord' class is used for totally ordered datatypes.
---
--- Instances of 'Ord' can be derived for any user-defined
--- datatype whose constituent types are in 'Ord'.  The declared order
--- of the constructors in the data declaration determines the ordering
--- in derived 'Ord' instances.  The 'Ordering' datatype allows a single
--- comparison to determine the precise ordering of two objects.
---
--- Minimal complete definition: either 'compare' or '<='.
--- Using 'compare' can be more efficient for complex types.
---
-class  (Eq a) => Ord a  where
-    compare              :: a -> a -> Ordering
-    (<), (<=), (>), (>=) :: a -> a -> Bool
-    max, min             :: a -> a -> a
-
-    compare x y
-        | x == y    = EQ
-        | x <= y    = LT        -- NB: must be '<=' not '<' to validate the
-                                -- above claim about the minimal things that
-                                -- can be defined for an instance of Ord
-        | otherwise = GT
-
-    x <  y = case compare x y of { LT -> True;  _other -> False }
-    x <= y = case compare x y of { GT -> False; _other -> True }
-    x >  y = case compare x y of { GT -> True;  _other -> False }
-    x >= y = case compare x y of { LT -> False; _other -> True }
-
-        -- These two default methods use '<=' rather than 'compare'
-        -- because the latter is often more expensive
-    max x y = if x <= y then y else x
-    min x y = if x <= y then x else y
-\end{code}
-
-%*********************************************************
-%*                                                      *
 \subsection{Monadic classes @Functor@, @Monad@ }
 %*                                                      *
 %*********************************************************
@@ -274,9 +221,8 @@ class  Monad m  where
 %*********************************************************
 
 \begin{code}
-data [] a = [] | a : [a]  -- do explicitly: deriving (Eq, Ord)
-                          -- to avoid weird names like con2tag_[]#
-
+-- do explicitly: deriving (Eq, Ord)
+-- to avoid weird names like con2tag_[]#
 
 instance (Eq a) => Eq [a] where
     {-# SPECIALISE instance Eq [Char] #-}
@@ -494,23 +440,6 @@ instance Ord Bool where
 
 -- Read is in GHC.Read, Show in GHC.Show
 
--- Boolean functions
-
--- | Boolean \"and\"
-(&&)                    :: Bool -> Bool -> Bool
-True  && x              =  x
-False && _              =  False
-
--- | Boolean \"or\"
-(||)                    :: Bool -> Bool -> Bool
-True  || _              =  True
-False || x              =  x
-
--- | Boolean \"not\"
-not                     :: Bool -> Bool
-not True                =  False
-not False               =  True
-
 -- |'otherwise' is defined as the value 'True'.  It helps to make
 -- guards more readable.  eg.
 --
@@ -574,7 +503,6 @@ To convert a 'Char' to or from the corresponding 'Int' value defined
 by Unicode, use 'Prelude.toEnum' and 'Prelude.fromEnum' from the
 'Prelude.Enum' class respectively (or equivalently 'ord' and 'chr').
 -}
-data Char = C# Char#
 
 -- We don't use deriving for Eq and Ord, because for Ord the derived
 -- instance defines only compare, which takes two primops.  Then
@@ -633,11 +561,6 @@ eqString _        _        = False
 %*********************************************************
 
 \begin{code}
-data Int = I# Int#
--- ^A fixed-precision integer type with at least the range @[-2^29 .. 2^29-1]@.
--- The exact range for a given implementation can be determined by using
--- 'Prelude.minBound' and 'Prelude.maxBound' from the 'Prelude.Bounded' class.
-
 zeroInt, oneInt, twoInt, maxInt, minInt :: Int
 zeroInt = I# 0#
 oneInt  = I# 1#