GHC/Exts.hs

   1 -----------------------------------------------------------------------------
   2 -- |
   3 -- Module      :  GHC.Exts
   4 -- Copyright   :  (c) The University of Glasgow 2002
   5 -- License     :  see libraries/base/LICENSE
   6 --
   7 -- Maintainer  :  cvs-ghc@haskell.org
   8 -- Stability   :  internal
   9 -- Portability :  non-portable (GHC Extensions)
  10 --
  11 -- GHC Extensions: this is the Approved Way to get at GHC-specific extensions.
  12 --
  13 -----------------------------------------------------------------------------
  14
  15 module GHC.Exts
  16        (
  17         -- * Representations of some basic types
  18         Int(..),Word(..),Float(..),Double(..),
  19         Char(..),
  20         Ptr(..), FunPtr(..),
  21
  22         -- * The maximum tuple size
  23         maxTupleSize,
  24
  25         -- * Primitive operations
  26         module GHC.Prim,
  27         shiftL#, shiftRL#, iShiftL#, iShiftRA#, iShiftRL#,
  28         uncheckedShiftL64#, uncheckedShiftRL64#,
  29         uncheckedIShiftL64#, uncheckedIShiftRA64#,
  30
  31         -- * Fusion
  32         build, augment,
  33
  34         -- * Overloaded string literals
  35         IsString(..),
  36
  37         -- * Debugging
  38         breakpoint, breakpointCond,
  39
  40         -- * Ids with special behaviour
  41         lazy, inline,
  42
  43         -- * Transform comprehensions
  44         Down(..), groupWith, sortWith, the
  45
  46        ) where
  47
  48 import Prelude
  49
  50 import GHC.Prim
  51 import GHC.Base
  52 import GHC.Word
  53 import GHC.Int
  54 import GHC.Float
  55 import GHC.Ptr
  56 import Data.String
  57 import Data.List
  58
  59 -- XXX This should really be in Data.Tuple, where the definitions are
  60 maxTupleSize :: Int
  61 maxTupleSize = 62
  62
  63 -- | The 'Down' type allows you to reverse sort order conveniently.  A value of type
  64 -- @'Down' a@ contains a value of type @a@ (represented as @'Down' a@).
  65 -- If @a@ has an @'Ord'@ instance associated with it then comparing two
  66 -- values thus wrapped will give you the opposite of their normal sort order.
  67 -- This is particularly useful when sorting in generalised list comprehensions,
  68 -- as in: @then sortWith by 'Down' x@
  69 newtype Down a = Down a deriving (Eq)
  70
  71 instance Ord a => Ord (Down a) where
  72     compare (Down x) (Down y) = y `compare` x
  73
  74 -- | 'the' ensures that all the elements of the list are identical
  75 -- and then returns that unique element
  76 the :: Eq a => [a] -> a
  77 the (x:xs)
  78   | all (x ==) xs = x
  79   | otherwise     = error "GHC.Exts.the: non-identical elements"
  80 the []            = error "GHC.Exts.the: empty list"
  81
  82 -- | The 'sortWith' function sorts a list of elements using the
  83 -- user supplied function to project something out of each element
  84 sortWith :: Ord b => (a -> b) -> [a] -> [a]
  85 sortWith f = sortBy (\x y -> compare (f x) (f y))
  86
  87 -- | The 'groupWith' function uses the user supplied function which
  88 -- projects an element out of every list element in order to to first sort the
  89 -- input list and then to form groups by equality on these projected elements
  90 {-# INLINE groupWith #-}
  91 groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
  92 groupWith f xs = build (\c n -> groupByFB c n (\x y -> f x == f y) (sortWith f xs))
  93
  94 groupByFB :: ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
  95 groupByFB c n eq xs0 = groupByFBCore xs0
  96   where groupByFBCore [] = n
  97         groupByFBCore (x:xs) = c (x:ys) (groupByFBCore zs)
  98             where (ys, zs) = span (eq x) xs
  99