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 -- XXX This doesn't work:
  93 -- deriving instance Eq Bool
  94 -- <wired into compiler>:
  95 --     Illegal binding of built-in syntax: con2tag_Bool#
  96 instance Eq Bool where
  97     True  == True  = True
  98     False == False = True
  99     _     == _     = False
 100
 101 -- XXX This doesn't work:
 102 -- deriving instance Eq Ordering
 103 -- Illegal binding of built-in syntax: con2tag_Ordering#
 104 instance Eq Ordering where
 105     EQ == EQ = True
 106     LT == LT = True
 107     GT == GT = True
 108     _  == _  = False
 109
 110 instance Eq Char where
 111     (C# c1) == (C# c2) = c1 `eqChar#` c2
 112     (C# c1) /= (C# c2) = c1 `neChar#` c2
 113
 114 -- | The 'Ord' class is used for totally ordered datatypes.
 115 --
 116 -- Instances of 'Ord' can be derived for any user-defined
 117 -- datatype whose constituent types are in 'Ord'.  The declared order
 118 -- of the constructors in the data declaration determines the ordering
 119 -- in derived 'Ord' instances.  The 'Ordering' datatype allows a single
 120 -- comparison to determine the precise ordering of two objects.
 121 --
 122 -- Minimal complete definition: either 'compare' or '<='.
 123 -- Using 'compare' can be more efficient for complex types.
 124 --
 125 class  (Eq a) => Ord a  where
 126     compare              :: a -> a -> Ordering
 127     (<), (<=), (>), (>=) :: a -> a -> Bool
 128     max, min             :: a -> a -> a
 129
 130     compare x y = if x == y then EQ
 131                   -- NB: must be '<=' not '<' to validate the
 132                   -- above claim about the minimal things that
 133                   -- can be defined for an instance of Ord:
 134                   else if x <= y then LT
 135                   else GT
 136
 137     x <  y = case compare x y of { LT -> True;  _ -> False }
 138     x <= y = case compare x y of { GT -> False; _ -> True }
 139     x >  y = case compare x y of { GT -> True;  _ -> False }
 140     x >= y = case compare x y of { LT -> False; _ -> True }
 141
 142         -- These two default methods use '<=' rather than 'compare'
 143         -- because the latter is often more expensive
 144     max x y = if x <= y then y else x
 145     min x y = if x <= y then x else y
 146
 147 deriving instance Ord ()
 148 deriving instance (Ord a, Ord b) => Ord (a, b)
 149 deriving instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
 150 deriving instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
 151 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
 152 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f)
 153                => Ord (a, b, c, d, e, f)
 154 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g)
 155                => Ord (a, b, c, d, e, f, g)
 156 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 157                    Ord h)
 158                => Ord (a, b, c, d, e, f, g, h)
 159 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 160                    Ord h, Ord i)
 161                => Ord (a, b, c, d, e, f, g, h, i)
 162 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 163                    Ord h, Ord i, Ord j)
 164                => Ord (a, b, c, d, e, f, g, h, i, j)
 165 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 166                    Ord h, Ord i, Ord j, Ord k)
 167                => Ord (a, b, c, d, e, f, g, h, i, j, k)
 168 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 169                    Ord h, Ord i, Ord j, Ord k, Ord l)
 170                => Ord (a, b, c, d, e, f, g, h, i, j, k, l)
 171 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 172                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m)
 173                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
 174 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 175                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n)
 176                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
 177 deriving instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
 178                    Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o)
 179                => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
 180
 181 instance (Ord a) => Ord [a] where
 182     {-# SPECIALISE instance Ord [Char] #-}
 183     compare []     []     = EQ
 184     compare []     (_:_)  = LT
 185     compare (_:_)  []     = GT
 186     compare (x:xs) (y:ys) = case compare x y of
 187                                 EQ    -> compare xs ys
 188                                 other -> other
 189
 190 -- XXX This doesn't work:
 191 -- deriving instance Ord Bool
 192 -- <wired into compiler>:
 193 --     Illegal binding of built-in syntax: con2tag_Bool#
 194 instance Ord Bool where
 195     compare False True  = LT
 196     compare True  False = GT
 197     compare _     _     = EQ
 198
 199 -- XXX This doesn't work:
 200 -- deriving instance Ord Ordering
 201 -- Illegal binding of built-in syntax: con2tag_Ordering#
 202 instance Ord Ordering where
 203     LT <= _  = True
 204     _  <= LT = False
 205     EQ <= _  = True
 206     _  <= EQ = False
 207     GT <= GT = True
 208
 209 -- We don't use deriving for Ord Char, because for Ord the derived
 210 -- instance defines only compare, which takes two primops.  Then
 211 -- '>' uses compare, and therefore takes two primops instead of one.
 212 instance Ord Char where
 213     (C# c1) >  (C# c2) = c1 `gtChar#` c2
 214     (C# c1) >= (C# c2) = c1 `geChar#` c2
 215     (C# c1) <= (C# c2) = c1 `leChar#` c2
 216     (C# c1) <  (C# c2) = c1 `ltChar#` c2
 217
 218 -- OK, so they're technically not part of a class...:
 219
 220 -- Boolean functions
 221
 222 -- | Boolean \"and\"
 223 (&&)                    :: Bool -> Bool -> Bool
 224 True  && x              =  x
 225 False && _              =  False
 226
 227 -- | Boolean \"or\"
 228 (||)                    :: Bool -> Bool -> Bool
 229 True  || _              =  True
 230 False || x              =  x
 231
 232 -- | Boolean \"not\"
 233 not                     :: Bool -> Bool
 234 not True                =  False
 235 not False               =  True
 236