GHC/Classes.hs

   1
   2 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
   3 {-# OPTIONS_GHC -fno-warn-unused-imports #-}
   4 -- XXX -fno-warn-unused-imports needed for the GHC.Tuple import below. Sigh.
   5 {-# OPTIONS_HADDOCK hide #-}
   6 -----------------------------------------------------------------------------
   7 -- |
   8 -- Module      :  GHC.Classes
   9 -- Copyright   :  (c) The University of Glasgow, 1992-2002
  10 -- License     :  see libraries/base/LICENSE
  11 --
  12 -- Maintainer  :  cvs-ghc@haskell.org
  13 -- Stability   :  internal
  14 -- Portability :  non-portable (GHC extensions)
  15 --
  16 -- Basic classes.
  17 --
  18 -----------------------------------------------------------------------------
  19
  20 module GHC.Classes where
  21
  22 import GHC.Bool
  23 -- GHC.Magic is used in some derived instances
  24 import GHC.Magic ()
  25 import GHC.Ordering
  26 import GHC.Prim
  27 import GHC.Tuple
  28 import GHC.Types
  29 import GHC.Unit
  30
  31 infix  4  ==, /=, <, <=, >=, >
  32 infixr 3  &&
  33 infixr 2  ||
  34
  35 default ()              -- Double isn't available yet
  36
  37 -- | The 'Eq' class defines equality ('==') and inequality ('/=').
  38 -- All the basic datatypes exported by the "Prelude" are instances of 'Eq',
  39 -- and 'Eq' may be derived for any datatype whose constituents are also
  40 -- instances of 'Eq'.
  41 --
  42 -- Minimal complete definition: either '==' or '/='.
  43 --
  44 class  Eq a  where
  45     (==), (/=)           :: a -> a -> Bool
  46
  47     {-# INLINE (/=) #-}
  48     {-# INLINE (==) #-}
  49     x /= y               = not (x == y)
  50     x == y               = not (x /= y)
  51
  52 deriving instance Eq ()
  53 deriving instance (Eq  a, Eq  b) => Eq  (a, b)
  54 deriving instance (Eq  a, Eq  b, Eq  c) => Eq  (a, b, c)
  55 deriving instance (Eq  a, Eq  b, Eq  c, Eq  d) => Eq  (a, b, c, d)
  56 deriving instance (Eq  a, Eq  b, Eq  c, Eq  d, Eq  e) => Eq  (a, b, c, d, e)
  57 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f)
  58                => Eq (a, b, c, d, e, f)
  59 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g)
  60                => Eq (a, b, c, d, e, f, g)
  61 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  62                    Eq h)
  63                => Eq (a, b, c, d, e, f, g, h)
  64 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  65                    Eq h, Eq i)
  66                => Eq (a, b, c, d, e, f, g, h, i)
  67 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  68                    Eq h, Eq i, Eq j)
  69                => Eq (a, b, c, d, e, f, g, h, i, j)
  70 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  71                    Eq h, Eq i, Eq j, Eq k)
  72                => Eq (a, b, c, d, e, f, g, h, i, j, k)
  73 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  74                    Eq h, Eq i, Eq j, Eq k, Eq l)
  75                => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
  76 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  77                    Eq h, Eq i, Eq j, Eq k, Eq l, Eq m)
  78                => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
  79 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  80                    Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n)
  81                => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  82 deriving instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g,
  83                    Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o)
  84                => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  85
  86 instance (Eq a) => Eq [a] where
  87     {-# SPECIALISE instance Eq [Char] #-}
  88     []     == []     = True
  89     (x:xs) == (y:ys) = x == y && xs == ys
  90     _xs    == _ys    = False
  91
  92 deriving instance Eq Bool
  93 deriving instance Eq Ordering
  94
  95 instance Eq Char where
  96     (C# c1) == (C# c2) = c1 `eqChar#` c2
  97     (C# c1) /= (C# c2) = c1 `neChar#` c2
  98
  99 -- | The 'Ord' class is used for totally ordered datatypes.
 100 --
 101 -- Instances of 'Ord' can be derived for any user-defined
 102 -- datatype whose constituent types are in 'Ord'.  The declared order
 103 -- of the constructors in the data declaration determines the ordering
 104 -- in derived 'Ord' instances.  The 'Ordering' datatype allows a single
 105 -- comparison to determine the precise ordering of two objects.
 106 --
 107 -- Minimal complete definition: either 'compare' or '<='.
 108 -- Using 'compare' can be more efficient for complex types.
 109 --
 110 class  (Eq a) => Ord a  where
 111     compare              :: a -> a -> Ordering
 112     (<), (<=), (>), (>=) :: a -> a -> Bool
 113     max, min             :: a -> a -> a
 114
 115     compare x y = if x == y then EQ
 116                   -- NB: must be '<=' not '<' to validate the
 117                   -- above claim about the minimal things that
 118                   -- can be defined for an instance of Ord:
 119                   else if x <= y then LT
 120                   else GT
 121
 122     x <  y = case compare x y of { LT -> True;  _ -> False }
 123     x <= y = case compare x y of { GT -> False; _ -> True }
 124     x >  y = case compare x y of { GT -> True;  _ -> False }
 125     x >= y = case compare x y of { LT -> False; _ -> True }
 126
 127         -- These two default methods use '<=' rather than 'compare'
 128         -- because the latter is often more expensive
 129     max x y = if x <= y then y else x
 130     min x y = if x <= y then x else y
 131
 132 deriving instance Ord ()
 133 deriving instance (Ord a, Ord b) => Ord (a, b)
 134 deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
 135 deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
 136 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
 137 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f)
 138                => Ord (a, b, c, d, e, f)
 139 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g)
 140                => Ord (a, b, c, d, e, f, g)
 141 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 142                    Ord h)
 143                => Ord (a, b, c, d, e, f, g, h)
 144 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 145                    Ord h, Ord i)
 146                => Ord (a, b, c, d, e, f, g, h, i)
 147 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 148                    Ord h, Ord i, Ord j)
 149                => Ord (a, b, c, d, e, f, g, h, i, j)
 150 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 151                    Ord h, Ord i, Ord j, Ord k)
 152                => Ord (a, b, c, d, e, f, g, h, i, j, k)
 153 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 154                    Ord h, Ord i, Ord j, Ord k, Ord l)
 155                => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
 156 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 157                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m)
 158                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
 159 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 160                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n)
 161                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
 162 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 163                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o)
 164                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
 165
 166 instance (Ord a) => Ord [a] where
 167     {-# SPECIALISE instance Ord [Char] #-}
 168     compare []     []     = EQ
 169     compare []     (_:_)  = LT
 170     compare (_:_)  []     = GT
 171     compare (x:xs) (y:ys) = case compare x y of
 172                                 EQ    -> compare xs ys
 173                                 other -> other
 174
 175 deriving instance Ord Bool
 176 deriving instance Ord Ordering
 177
 178 -- We don't use deriving for Ord Char, because for Ord the derived
 179 -- instance defines only compare, which takes two primops.  Then
 180 -- '>' uses compare, and therefore takes two primops instead of one.
 181 instance Ord Char where
 182     (C# c1) >  (C# c2) = c1 `gtChar#` c2
 183     (C# c1) >= (C# c2) = c1 `geChar#` c2
 184     (C# c1) <= (C# c2) = c1 `leChar#` c2
 185     (C# c1) <  (C# c2) = c1 `ltChar#` c2
 186
 187 -- OK, so they're technically not part of a class...:
 188
 189 -- Boolean functions
 190
 191 -- | Boolean \"and\"
 192 (&&)                    :: Bool -> Bool -> Bool
 193 True  && x              =  x
 194 False && _              =  False
 195
 196 -- | Boolean \"or\"
 197 (||)                    :: Bool -> Bool -> Bool
 198 True  || _              =  True
 199 False || x              =  x
 200
 201 -- | Boolean \"not\"
 202 not                     :: Bool -> Bool
 203 not True                =  False
 204 not False               =  True
 205