Use explicit language extensions & remove extension fields from base.cabal

[ghc-base.git] / GHC / PArr.hs

diff --git a/GHC/PArr.hs b/GHC/PArr.hs
index 716dbb7..6a5328f 100644 (file)
--- a/GHC/PArr.hs
+++ b/GHC/PArr.hs
@@ -1,4 +1,6 @@
-{-# OPTIONS_GHC -fparr -funbox-strict-fields #-}
+{-# LANGUAGE CPP, ParallelArrays, MagicHash, UnboxedTuples #-}
+{-# OPTIONS_GHC -funbox-strict-fields #-}
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -93,6 +95,7 @@ module GHC.PArr (
   scanr1P,              -- :: (a -> a -> a) ->      [:a:] -> [:a:]
 --  iterate, repeat,          -- parallel arrays must be finite
   singletonP,           -- :: a -> [:a:]
+  emptyP,               -- :: [:a:]
   replicateP,           -- :: Int -> a -> [:a:]
 --  cycle,                    -- parallel arrays must be finite
   takeP,                -- :: Int -> [:a:] -> [:a:]
@@ -146,8 +149,8 @@ module GHC.PArr (
 
 import Prelude
 
-import GHC.ST   ( ST(..), STRep, runST )
-import GHC.Exts ( Int#, Array#, Int(I#), MutableArray#, newArray#,
+import GHC.ST   ( ST(..), runST )
+import GHC.Base ( Int#, Array#, Int(I#), MutableArray#, newArray#,
                   unsafeFreezeArray#, indexArray#, writeArray#, (<#), (>=#) )
 
 infixl 9  !:
@@ -213,14 +216,14 @@ foldlP     :: (a -> b -> a) -> a -> [:b:] -> a
 foldlP f z  = snd . loop (foldEFL (flip f)) z
 
 foldl1P        :: (a -> a -> a) -> [:a:] -> a
-foldl1P f [::]  = error "Prelude.foldl1P: empty array"
+foldl1P _ [::]  = error "Prelude.foldl1P: empty array"
 foldl1P f a     = snd $ loopFromTo 1 (lengthP a - 1) (foldEFL f) (a!:0) a
 
 scanlP     :: (a -> b -> a) -> a -> [:b:] -> [:a:]
 scanlP f z  = fst . loop (scanEFL (flip f)) z
 
 scanl1P        :: (a -> a -> a) -> [:a:] -> [:a:]
-scanl1P f [::]  = error "Prelude.scanl1P: empty array"
+scanl1P _ [::]  = error "Prelude.scanl1P: empty array"
 scanl1P f a     = fst $ loopFromTo 1 (lengthP a - 1) (scanEFL f) (a!:0) a
 
 foldrP :: (a -> b -> b) -> b -> [:a:] -> b
@@ -240,6 +243,11 @@ scanr1P  = error "Prelude.scanr1P: not implemented yet" -- FIXME
 singletonP             :: a -> [:a:]
 {-# INLINE singletonP #-}
 singletonP e = replicateP 1 e
+  
+emptyP:: [:a:]
+{- NOINLINE emptyP #-}
+emptyP = replicateP 0 undefined
+
 
 replicateP             :: Int -> a -> [:a:]
 {-# INLINE replicateP #-}
@@ -346,9 +354,9 @@ unzipP   :: [:(a, b):] -> ([:a:], [:b:])
 unzipP a  = (fst $ loop (mapEFL fst) noAL a, fst $ loop (mapEFL snd) noAL a)
 -- FIXME: these two functions should be optimised using a tupled custom loop
 unzip3P   :: [:(a, b, c):] -> ([:a:], [:b:], [:c:])
-unzip3P a  = (fst $ loop (mapEFL fst3) noAL a, 
-              fst $ loop (mapEFL snd3) noAL a,
-              fst $ loop (mapEFL trd3) noAL a)
+unzip3P x  = (fst $ loop (mapEFL fst3) noAL x, 
+              fst $ loop (mapEFL snd3) noAL x,
+              fst $ loop (mapEFL trd3) noAL x)
              where
                fst3 (a, _, _) = a
                snd3 (_, b, _) = b
@@ -413,13 +421,13 @@ instance Read a => Read [:a:]  where
 -- properly fuse the following definitions.
 
 enumFromToP     :: Enum a => a -> a -> [:a:]
-enumFromToP x y  = mapP toEnum (eftInt (fromEnum x) (fromEnum y))
+enumFromToP x0 y0  = mapP toEnum (eftInt (fromEnum x0) (fromEnum y0))
   where
     eftInt x y = scanlP (+) x $ replicateP (y - x + 1) 1
 
 enumFromThenToP       :: Enum a => a -> a -> a -> [:a:]
-enumFromThenToP x y z  = 
-  mapP toEnum (efttInt (fromEnum x) (fromEnum y) (fromEnum z))
+enumFromThenToP x0 y0 z0  = 
+  mapP toEnum (efttInt (fromEnum x0) (fromEnum y0) (fromEnum z0))
   where
     efttInt x y z = scanlP (+) x $ 
                       replicateP (abs (z - x) `div` abs delta + 1) delta
@@ -499,7 +507,7 @@ dpermuteP is es dft
   | isLen /= esLen = error "GHC.PArr: arguments must be of the same length"
   | otherwise      = runST (do
                        marr <- newArray dftLen noElem
-                       trans 0 (isLen - 1) marr dft copyOne noAL
+                       _ <- trans 0 (isLen - 1) marr dft copyOne noAL
                        permute marr is es
                        mkPArr dftLen marr)
   where
@@ -616,8 +624,8 @@ loopFromTo :: Int                        -- from index
 loopFromTo from to mf start arr = runST (do
   marr      <- newArray (to - from + 1) noElem
   (n', acc) <- trans from to marr arr mf start
-  arr       <- mkPArr n' marr
-  return (arr, acc))
+  arr'      <- mkPArr n' marr
+  return (arr', acc))
   where
     noElem = error "GHC.PArr.loopFromTo: I do not exist!"
              -- unlike standard Haskell arrays, this value represents an
@@ -674,13 +682,13 @@ noAL  = ()
 --
 mapEFL   :: (e -> e') -> (e -> () -> (Maybe e', ()))
 {-# INLINE mapEFL #-}
-mapEFL f  = \e a -> (Just $ f e, ())
+mapEFL f  = \e _ -> (Just $ f e, ())
 
 -- `loop' mutator that filter elements according to a predicate
 --
 filterEFL   :: (e -> Bool) -> (e -> () -> (Maybe e, ()))
 {-# INLINE filterEFL #-}
-filterEFL p  = \e a -> if p e then (Just e, ()) else (Nothing, ())
+filterEFL p  = \e _ -> if p e then (Just e, ()) else (Nothing, ())
 
 -- `loop' mutator for array folding
 --