Don't use -XParallelArrays before Data.Array.Parallel gets compiled
authorManuel M T Chakravarty <chak@cse.unsw.edu.au>
Thu, 10 Nov 2011 06:18:52 +0000 (17:18 +1100)
committerManuel M T Chakravarty <chak@cse.unsw.edu.au>
Thu, 10 Nov 2011 06:19:43 +0000 (17:19 +1100)
12 files changed:
dph-common/Data/Array/Parallel.hs
dph-common/Data/Array/Parallel/PArr.hs
dph-common/Data/Array/Parallel/Prelude/Bool.hs
dph-common/Data/Array/Parallel/Prelude/Double.hs
dph-common/Data/Array/Parallel/Prelude/Float.hs
dph-common/Data/Array/Parallel/Prelude/Int.hs
dph-common/Data/Array/Parallel/Prelude/Word8.hs
dph-common/Data/Array/Parallel/Prim.hs
dph-lifted-vseg/Data/Array/Parallel.hs
dph-lifted-vseg/Data/Array/Parallel/PArr.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Double.hs
dph-lifted-vseg/Data/Array/Parallel/Prelude/Int.hs

index dcc190b..beeaeab 100644 (file)
 -- this module is tied to the vectoriser pass of GHC invoked by passing the
 -- `-fvectorise` option.  Without vectorisation these functions will not work
 -- at all!
+--
+-- UGLY HACK ALERT: Same ugly hack as in 'base:GHC.PArr'!  We could do without in this module by
+--                  using the type synonym 'PArr' instead of '[::]', but that would lead to
+--                  significantly worse error message for end users.
 
 module Data.Array.Parallel (
   module Data.Array.Parallel.Prelude,
@@ -100,12 +104,12 @@ lengthP = lengthPArr
 
 concatP :: [:[:a:]:] -> [:a:]
 {-# NOINLINE concatP #-}
-concatP xss = xss !: 0
+concatP xss = indexPArr xss 0
 {-# VECTORISE concatP = concatPA #-}
 
 mapP :: (a -> b) -> [:a:] -> [:b:]
 {-# NOINLINE mapP #-}
-mapP !_ !_ = [::]
+mapP !_ !_ = emptyP
 {-# VECTORISE mapP = mapPA #-}
 
 filterP :: (a -> Bool) -> [:a:] -> [:a:]
@@ -132,32 +136,32 @@ filterP !_ xs = xs
 
 zipP :: [:a:] -> [:b:] -> [:(a, b):]
 {-# NOINLINE zipP #-}
-zipP !_ !_ = [::]
+zipP !_ !_ = emptyP
 {-# VECTORISE zipP = zipPA #-}
 
 zip3P :: [:a:] -> [:b:] -> [:c:] -> [:(a, b, c):]
 {-# NOINLINE zip3P #-}
-zip3P !_ !_ !_ = [::]
+zip3P !_ !_ !_ = emptyP
 {-# VECTORISE zip3P = zip3PA #-}
 
 unzipP :: [:(a, b):] -> ([:a:], [:b:])
 {-# NOINLINE unzipP #-}
-unzipP !_ = ([::], [::])
+unzipP !_ = (emptyP, emptyP)
 {-# VECTORISE unzipP = unzipPA #-}
 
 unzip3P :: [:(a, b, c):] -> ([:a:], [:b:], [:c:])
 {-# NOINLINE unzip3P #-}
-unzip3P !_ = ([::], [::], [::])
+unzip3P !_ = (emptyP, emptyP, emptyP)
 {-# VECTORISE unzip3P = unzip3PA #-}
 
 zipWithP :: (a -> b -> c) -> [:a:] -> [:b:] -> [:c:]
 {-# NOINLINE zipWithP #-}
-zipWithP !_ !_ !_ = [::]
+zipWithP !_ !_ !_ = emptyP
 {-# VECTORISE zipWithP = zipWithPA #-}
 
 zipWith3P :: (a -> b -> c -> d) -> [:a:] -> [:b:] -> [:c:] -> [:d:]
 {-# NOINLINE zipWith3P #-}
-zipWith3P !_ !_ !_ !_ = [::]
+zipWith3P !_ !_ !_ !_ = emptyP
 {-# VECTORISE zipWith3P = zipWith3PA #-}
 
 -- enumFromToP :: Enum a => a -> a -> [:a:]
@@ -185,7 +189,7 @@ bpermuteP xs !_ = xs
 
 indexedP :: [:a:] -> [:(Int, a):]
 {-# NOINLINE indexedP #-}
-indexedP !_ = [::]
+indexedP !_ = emptyP
 {-# VECTORISE indexedP = indexedPA #-}
 
 sliceP :: Int -> Int -> [:e:] -> [:e:]
@@ -195,7 +199,7 @@ sliceP !_ !_ xs = xs
 
 crossMapP :: [:a:] -> (a -> [:b:]) -> [:(a, b):]
 {-# NOINLINE crossMapP #-}
-crossMapP !_ !_ = [::]
+crossMapP !_ !_ = emptyP
 {-# VECTORISE crossMapP = crossMapPA #-}
 
 fromPArrayP :: PArray a -> [:a:]
index 4270f3a..95ae0d2 100644 (file)
@@ -1,32 +1,32 @@
-{-# LANGUAGE ParallelArrays, UnboxedTuples, MagicHash #-}
+{-# LANGUAGE UnboxedTuples, MagicHash #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 {-# OPTIONS_HADDOCK hide #-}
 
 -- #hide
 module Data.Array.Parallel.PArr (
-  emptyPArr, replicatePArr, singletonPArr, indexPArr, lengthPArr
+  PArr, emptyPArr, replicatePArr, singletonPArr, indexPArr, lengthPArr
 ) where
 
 import GHC.ST   ( ST(..), runST )
 import GHC.Base ( Int (I#), MutableArray#, newArray#,
                   unsafeFreezeArray#, indexArray#, {- writeArray# -} )
-import GHC.PArr -- provides the definition of '[::]'
+import GHC.PArr -- provides the definition of '[::]' and 'PArr'
 
-emptyPArr :: [:a:]
+emptyPArr :: PArr a
 {-# NOINLINE emptyPArr #-}
 emptyPArr = replicatePArr 0 undefined
 
-replicatePArr :: Int -> a -> [:a:]
+replicatePArr :: Int -> a -> PArr a
 {-# NOINLINE replicatePArr #-}
 replicatePArr n e  = runST (do
   marr# <- newArray n e
   mkPArr n marr#)
 
-singletonPArr :: a -> [:a:]
+singletonPArr :: a -> PArr a
 {-# NOINLINE singletonPArr #-}
 singletonPArr e = replicatePArr 1 e
 
-indexPArr :: [:e:] -> Int -> e
+indexPArr :: PArr e -> Int -> e
 {-# NOINLINE indexPArr #-}
 indexPArr (PArr n arr#) i@(I# i#)
   | i >= 0 && i < n =
@@ -35,7 +35,7 @@ indexPArr (PArr n arr#) i@(I# i#)
                         "idx = " ++ show i ++ ", arr len = "
                         ++ show n
 
-lengthPArr :: [:a:] -> Int
+lengthPArr :: PArr a -> Int
 {-# NOINLINE lengthPArr #-}
 lengthPArr (PArr n _) = n
 
@@ -56,7 +56,7 @@ newArray n@(I# n#) e  = ST $ \s1# ->
 
 -- convert a mutable array into the external parallel array representation
 --
-mkPArr :: Int -> MPArr s e -> ST s [:e:]
+mkPArr :: Int -> MPArr s e -> ST s (PArr e)
 {-# INLINE mkPArr #-}
 mkPArr n (MPArr _ marr#)  = ST $ \s1# ->
   case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->
index 4429c2d..423b468 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
   -- NB: Cannot use any parallel array syntax except the type constructor
 
@@ -14,7 +13,7 @@ module Data.Array.Parallel.Prelude.Bool (
 
 import Data.Array.Parallel.Prim ()       -- dependency required by the vectoriser
 
-import Data.Array.Parallel.PArr ()
+import Data.Array.Parallel.PArr                     (PArr)
 import Data.Array.Parallel.Lifted.Closure
 import Data.Array.Parallel.PArray.PReprInstances
 import Data.Array.Parallel.Lifted.Scalar
@@ -71,7 +70,7 @@ not_l (PArray n# bs)
       PBool $ U.tagsToSel2 (U.map complement (U.tagsSel2 sel)) }
 {-# NOVECTORISE not_l #-}
 
-andP:: [:Bool:] -> Bool
+andP:: PArr Bool -> Bool
 {-# NOINLINE andP #-}
 andP _ = True
 {-# VECTORISE andP = andP_v #-}
@@ -80,7 +79,7 @@ andP_v :: PArray Bool :-> Bool
 andP_v = closure1 (scalar_fold (&&) True) (scalar_folds (&&) True)
 {-# NOVECTORISE andP_v #-}
 
-orP:: [:Bool:] -> Bool
+orP:: PArr Bool -> Bool
 {-# NOINLINE orP #-}
 orP _ = True
 {-# VECTORISE orP = orP_v #-}
index 33f8e9e..52e4c63 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
   -- NB: Cannot use any parallel array syntax except the type constructor
 
@@ -67,7 +66,7 @@ min = P.min
 max = P.max
 {-# VECTORISE SCALAR max #-}
 
-minimumP, maximumP :: [:Double:] -> Double
+minimumP, maximumP :: PArr Double -> Double
 {-# NOINLINE minimumP #-}
 minimumP a = a `indexPArr` 0
 {-# VECTORISE minimumP = minimumP_v #-}
@@ -83,7 +82,7 @@ minimumP_v = closure1 (scalar_fold1 P.min) (scalar_fold1s P.min)
 maximumP_v = closure1 (scalar_fold1 P.max) (scalar_fold1s P.max)
 {-# NOVECTORISE maximumP_v #-}
 
-minIndexP :: [:Double:] -> Int
+minIndexP :: PArr Double -> Int
 {-# NOINLINE minIndexP #-}
 minIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE minIndexP = minIndexPA #-}
@@ -97,7 +96,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
                  | P.otherwise = (j,y)
 {-# NOVECTORISE min' #-}
 
-maxIndexP :: [:Double:] -> Int
+maxIndexP :: PArr Double -> Int
 {-# NOINLINE maxIndexP #-}
 maxIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE maxIndexP = maxIndexPA #-}
@@ -125,7 +124,7 @@ negate = P.negate
 abs = P.abs
 {-# VECTORISE SCALAR abs #-}
 
-sumP, productP :: [:Double:] -> Double
+sumP, productP :: PArr Double -> Double
 {-# NOINLINE sumP #-}
 sumP a = a `indexPArr` 0
 {-# VECTORISE sumP = sumP_v #-}
index 259c635..122b245 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
   -- NB: Cannot use any parallel array syntax except the type constructor
 
@@ -67,7 +66,7 @@ min = P.min
 max = P.max
 {-# VECTORISE SCALAR max #-}
 
-minimumP, maximumP :: [:Float:] -> Float
+minimumP, maximumP :: PArr Float -> Float
 {-# NOINLINE minimumP #-}
 minimumP a = a `indexPArr` 0
 {-# VECTORISE minimumP = minimumP_v #-}
@@ -83,7 +82,7 @@ minimumP_v = closure1 (scalar_fold1 P.min) (scalar_fold1s P.min)
 maximumP_v = closure1 (scalar_fold1 P.max) (scalar_fold1s P.max)
 {-# NOVECTORISE maximumP_v #-}
 
-minIndexP :: [:Float:] -> Int
+minIndexP :: PArr Float -> Int
 {-# NOINLINE minIndexP #-}
 minIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE minIndexP = minIndexPA #-}
@@ -97,7 +96,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
                  | P.otherwise = (j,y)
 {-# NOVECTORISE min' #-}
 
-maxIndexP :: [:Float:] -> Int
+maxIndexP :: PArr Float -> Int
 {-# NOINLINE maxIndexP #-}
 maxIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE maxIndexP = maxIndexPA #-}
@@ -125,7 +124,7 @@ negate = P.negate
 abs = P.abs
 {-# VECTORISE SCALAR abs #-}
 
-sumP, productP :: [:Float:] -> Float
+sumP, productP :: PArr Float -> Float
 {-# NOINLINE sumP #-}
 sumP a = a `indexPArr` 0
 {-# VECTORISE sumP = sumP_v #-}
index 0b2f718..d355c34 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
   -- NB: Cannot use any parallel array syntax except the type constructor
 
@@ -60,7 +59,7 @@ min = P.min
 max = P.max
 {-# VECTORISE SCALAR max #-}
 
-minimumP, maximumP :: [:Int:] -> Int
+minimumP, maximumP :: PArr Int -> Int
 {-# NOINLINE minimumP #-}
 minimumP a = a `indexPArr` 0
 {-# VECTORISE minimumP = minimumP_v #-}
@@ -76,7 +75,7 @@ minimumP_v = closure1 (scalar_fold1 P.min) (scalar_fold1s P.min)
 maximumP_v = closure1 (scalar_fold1 P.max) (scalar_fold1s P.max)
 {-# NOVECTORISE maximumP_v #-}
 
-minIndexP :: [:Int:] -> Int
+minIndexP :: PArr Int -> Int
 {-# NOINLINE minIndexP #-}
 minIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE minIndexP = minIndexPA #-}
@@ -90,7 +89,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
                  | P.otherwise = (j,y)
 {-# NOVECTORISE min' #-}
 
-maxIndexP :: [:Int:] -> Int
+maxIndexP :: PArr Int -> Int
 {-# NOINLINE maxIndexP #-}
 maxIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE maxIndexP = maxIndexPA #-}
@@ -118,7 +117,7 @@ negate = P.negate
 abs = P.abs
 {-# VECTORISE SCALAR abs #-}
 
-sumP, productP :: [:Int:] -> Int
+sumP, productP :: PArr Int -> Int
 {-# NOINLINE sumP #-}
 sumP a = a `indexPArr` 0
 {-# VECTORISE sumP = sumP_v #-}
@@ -144,7 +143,7 @@ sqrt ::  Int -> Int
 sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 {-# VECTORISE SCALAR sqrt #-}
 
-enumFromToP :: Int -> Int ->  [:Int:]
+enumFromToP :: Int -> Int ->  PArr Int
 {-# NOINLINE enumFromToP #-}
 enumFromToP x y = singletonPArr (x P.+ y)
 {-# VECTORISE enumFromToP = enumFromToPA_Int #-}
index 8b94896..00ad604 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
   -- NB: Cannot use any parallel array syntax except the type constructor
 
@@ -59,7 +58,7 @@ min = P.min
 max = P.max
 {-# VECTORISE SCALAR max #-}
 
-minimumP, maximumP :: [:Word8:] -> Word8
+minimumP, maximumP :: PArr Word8 -> Word8
 {-# NOINLINE minimumP #-}
 minimumP a = a `indexPArr` 0
 {-# VECTORISE minimumP = minimumP_v #-}
@@ -75,7 +74,7 @@ minimumP_v = closure1 (scalar_fold1 P.min) (scalar_fold1s P.min)
 maximumP_v = closure1 (scalar_fold1 P.max) (scalar_fold1s P.max)
 {-# NOVECTORISE maximumP_v #-}
 
-minIndexP :: [:Word8:] -> Int
+minIndexP :: PArr Word8 -> Int
 {-# NOINLINE minIndexP #-}
 minIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE minIndexP = minIndexPA #-}
@@ -89,7 +88,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
                  | P.otherwise = (j,y)
 {-# NOVECTORISE min' #-}
 
-maxIndexP :: [:Word8:] -> Int
+maxIndexP :: PArr Word8 -> Int
 {-# NOINLINE maxIndexP #-}
 maxIndexP _ = 0   -- FIXME: add proper implementation
 {-# VECTORISE maxIndexP = maxIndexPA #-}
@@ -117,7 +116,7 @@ negate = P.negate
 abs = P.abs
 {-# VECTORISE SCALAR abs #-}
 
-sumP, productP :: [:Word8:] -> Word8
+sumP, productP :: PArr Word8 -> Word8
 {-# NOINLINE sumP #-}
 sumP a = a `indexPArr` 0
 {-# VECTORISE sumP = sumP_v #-}
index a70f763..93c0a33 100644 (file)
@@ -1,15 +1,16 @@
 {-# OPTIONS_HADDOCK hide #-}
 
 -- |This modules defines the interface between the DPH libraries and the compiler.  In particular,
--- it exports exactly those definitions that are used by either the desugarer (to remove parallel array
--- syntax) or by the vectoriser (to generate vectorised code).
+-- it exports exactly those definitions that are used by either the desugarer (to remove parallel
+-- array syntax) or by the vectoriser (to generate vectorised code).
 --
--- The DPH libraries can evolve between compiler releases as long as this interface remains the same.
+-- The DPH libraries can evolve between compiler releases as long as this interface remains the
+-- same.
 --
 -- WARNING: All modules in this package that need to be vectorised (i.e., are compiled with
---          '-fvectorise' must directly or indirectly import this module).  This is to ensure that the
---          build system does not attempt to compile a vectorised module before all definitions that are
---          required by the vectoriser are available.
+--          '-fvectorise' must directly or indirectly import this module).  This is to ensure that
+--          the build system does not attempt to compile a vectorised module before all definitions
+--          that are required by the vectoriser are available.
 
 -- #hide
 module Data.Array.Parallel.Prim (
@@ -32,20 +33,21 @@ module Data.Array.Parallel.Prim (
   tup2, tup3
 ) where
 
--- We use explicit import lists here to make the vectoriser interface explicit and keep it under tight
--- control.
+-- We use explicit import lists here to make the vectoriser interface explicit and keep it under
+-- tight control.
 --
 import Data.Array.Parallel.PArray.Base            (PArray(..))
 import Data.Array.Parallel.PArray.Scalar          (Scalar(..))
-import Data.Array.Parallel.PArray.ScalarInstances ( {-we requires instances-} )
+import Data.Array.Parallel.PArray.ScalarInstances ( {-we require instances-} )
 import Data.Array.Parallel.PArray.PRepr           (PRepr, PA(..), replicatePD, emptyPD, packByTagPD,
                                                    combine2PD)
-import Data.Array.Parallel.PArray.Types           (Void, Sum2(..), Sum3(..), Wrap(..), void, fromVoid)
-import Data.Array.Parallel.PArray.PReprInstances  ( {-we requires instances-} )
+import Data.Array.Parallel.PArray.Types           (Void, Sum2(..), Sum3(..), Wrap(..), void,
+                                                   fromVoid)
+import Data.Array.Parallel.PArray.PReprInstances  ( {-we required instances-} )
 import Data.Array.Parallel.PArray.PData           (PData, PR(..))
 import Data.Array.Parallel.PArray.PDataInstances  (pvoid, punit)
-import Data.Array.Parallel.Lifted.Closure         ((:->)(..), closure, liftedClosure, ($:), liftedApply,
-                                                   closure1, closure2, closure3)
+import Data.Array.Parallel.Lifted.Closure         ((:->)(..), closure, liftedClosure, ($:),
+                                                   liftedApply, closure1, closure2, closure3)
 import Data.Array.Parallel.Lifted.Unboxed         (Sel2, replicateSel2#, tagsSel2, elementsSel2_0#,
                                                    elementsSel2_1#,
                                                    PArray_Int#, PArray_Double#, 
index 2ba2398..2007e56 100644 (file)
 --  `-fvectorise` option.  Without vectorisation these functions will not work
 --  at all!
 --
+--  UGLY HACK ALERT: Same ugly hack as in 'base:GHC.PArr'!  We could do without in this module by
+--                   using the type synonym 'PArr' instead of '[::]', but that would lead to
+--                   significantly worse error message for end users.
+--
 module Data.Array.Parallel 
         ( module Data.Array.Parallel.Prelude
 
@@ -133,18 +137,18 @@ replicateP      = replicatePArr
 
 -- | Append two arrays.
 appendP, (+:+) :: [:a:] -> [:a:] -> [:a:]
-(+:+) !_ !_     = [::]
+(+:+) !_ !_     = emptyP
 {-# NOINLINE  (+:+) #-}
 {-# VECTORISE (+:+)     = appendPP #-}
 
-appendP !_ !_   = [::]
+appendP !_ !_   = emptyP
 {-# NOINLINE  appendP #-}
 {-# VECTORISE appendP   = appendPP #-}
 
 
 -- | Concatenate an array of arrays.
 concatP :: [:[:a:]:] -> [:a:]
-concatP !_      = [::]
+concatP !_      = emptyP
 {-# NOINLINE  concatP #-}
 {-# VECTORISE concatP = concatPP #-}
 
@@ -169,7 +173,7 @@ indexP            = indexPArr
 
 -- | Extract a slice from an array.
 sliceP :: Int -> Int -> [:a:] -> [:a:]
-sliceP !_ !_ !_ = [::]
+sliceP !_ !_ !_ = emptyP
 {-# NOINLINE sliceP #-}
 {-# VECTORISE sliceP    = slicePP #-}
 
@@ -177,20 +181,20 @@ sliceP !_ !_ !_ = [::]
 -- Traversals -----------------------------------------------------------------
 -- | Apply a worker function to every element of an array.
 mapP :: (a -> b) -> [:a:] -> [:b:]
-mapP !_ !_              = [::]
+mapP !_ !_              = emptyP
 {-# NOINLINE  mapP #-}
 {-# VECTORISE mapP      = mapPP #-}
 
 -- | Apply a worker function to every pair of two arrays.
 zipWithP :: (a -> b -> c) -> [:a:] -> [:b:] -> [:c:]
-zipWithP !_ !_ !_       = [::]
+zipWithP !_ !_ !_       = emptyP
 {-# NOINLINE  zipWithP #-}
 {-# VECTORISE zipWithP  = zipWithPP #-}
 
 
 -- Filtering -----------------------------------------------------------------
 filterP :: (a -> Bool) -> [:a:] -> [:a:]
-filterP !_ !_   = [::]
+filterP !_ !_   = emptyP
 {-# NOINLINE  filterP #-}
 {-# VECTORISE filterP = filterPP #-}
 
@@ -198,13 +202,13 @@ filterP !_ !_   = [::]
 -- Zipping and Unzipping ------------------------------------------------------
 -- | Zip a pair of arrays into an array of pairs.
 zipP :: [:a:] -> [:b:] -> [:(a, b):]
-zipP !_ !_      = [::]
+zipP !_ !_      = emptyP
 {-# NOINLINE  zipP #-}
 {-# VECTORISE zipP      = zipPP #-}
 
 
 -- | Unzip an array of pairs into a pair of arrays.
 unzipP :: [:(a, b):] -> ([:a:], [:b:])
-unzipP !_       = ([::], [::])
+unzipP !_       = (PArr, PArr)
 {-# NOINLINE  unzipP #-}
 {-# VECTORISE unzipP    = unzipPP #-}
index 7ab89f4..c0db201 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 {-# OPTIONS_HADDOCK hide #-}
 
@@ -8,7 +7,8 @@
 --   Only vectorised functions are visible in the DPH client programs.
 --
 module Data.Array.Parallel.PArr 
-        ( emptyPArr
+        ( PArr
+        , emptyPArr
         , replicatePArr
         , singletonPArr
         , indexPArr
@@ -20,19 +20,19 @@ import GHC.Base
 import GHC.PArr
 
 -- | Construct an empty array, with no elements.
-emptyPArr :: [:a:]
+emptyPArr :: PArr a
 {-# NOINLINE emptyPArr #-}
 emptyPArr = replicatePArr 0 undefined
 
 
 -- | Construct an array with a single element.
-singletonPArr :: a -> [:a:]
+singletonPArr :: a -> PArr a
 {-# NOINLINE singletonPArr #-}
 singletonPArr e = replicatePArr 1 e
 
 
 -- | Construct an array by replicating the given element some number of times.
-replicatePArr :: Int -> a -> [:a:]
+replicatePArr :: Int -> a -> PArr a
 {-# NOINLINE replicatePArr #-}
 replicatePArr n e  
  = runST (do
@@ -41,13 +41,13 @@ replicatePArr n e
 
 
 -- | Take the length of an array.
-lengthPArr :: [:a:] -> Int
+lengthPArr :: PArr a -> Int
 {-# NOINLINE lengthPArr #-}
 lengthPArr (PArr n _) = n
 
 
 -- | Lookup a single element from the source array.
-indexPArr :: [:e:] -> Int -> e
+indexPArr :: PArr e -> Int -> e
 {-# NOINLINE indexPArr #-}
 indexPArr (PArr n arr#) i@(I# i#)
   | i >= 0 && i < n 
@@ -60,7 +60,7 @@ indexPArr (PArr n arr#) i@(I# i#)
 
 -- | Take the first element of the source array, 
 --   or `error` if there isn't one.
-headPArr :: [:a:] -> a
+headPArr :: PArr a -> a
 headPArr arr = indexPArr arr 0
 
 
@@ -78,7 +78,7 @@ newArray n@(I# n#) e  = ST $ \s1# ->
 
 
 -- | Convert a mutable array into the external parallel array representation
-mkPArr :: Int -> MPArr s e -> ST s [:e:]
+mkPArr :: Int -> MPArr s e -> ST s PArr e
 {-# INLINE mkPArr #-}
 mkPArr n (MPArr _ marr#)  = ST $ \s1# ->
   case unsafeFreezeArray# marr# s1#   of { (# s2#, arr# #) ->
index 7a49988..a584033 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
 
 module Data.Array.Parallel.Prelude.Double 
@@ -79,7 +78,7 @@ max = P.max
 
 
 -- minimum/maximum --------------------
-minimumP, maximumP :: [:Double:] -> Double
+minimumP, maximumP :: PArr Double -> Double
 
 minimumP arr    = headPArr arr
 {-# NOINLINE  minimumP #-}
@@ -100,7 +99,7 @@ maximumPP      = L.closure1' (SC.fold1 P.max) (SC.fold1s P.max)
 
 
 -- minIndex/maxIndex ------------------
-minIndexP :: [:Double:] -> Int
+minIndexP :: PArr Double -> Int
 minIndexP !_    = 0 
 {-# NOINLINE  minIndexP #-}
 {-# VECTORISE minIndexP = minIndexPP #-}
@@ -116,7 +115,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
 {-# NOVECTORISE min' #-}
 
 
-maxIndexP :: [:Double:] -> Int
+maxIndexP :: PArr Double -> Int
 maxIndexP _     = 0
 {-# NOINLINE  maxIndexP #-}
 {-# VECTORISE maxIndexP = maxIndexPP #-}
@@ -156,7 +155,7 @@ abs     = P.abs
 
 
 -- sum/product ------------------------
-sumP, productP :: [:Double:] -> Double
+sumP, productP :: PArr Double -> Double
 
 sumP arr        = headPArr arr
 {-# NOINLINE  sumP #-}
index dbf2295..3acc48f 100644 (file)
@@ -1,4 +1,3 @@
-{-# LANGUAGE ParallelArrays #-}
 {-# OPTIONS_GHC -fvectorise #-}
 
 module Data.Array.Parallel.Prelude.Int 
@@ -72,7 +71,7 @@ max = P.max
 
 
 -- minimum/maximum --------------------
-minimumP, maximumP :: [:Int:] -> Int
+minimumP, maximumP :: PArr Int -> Int
 
 minimumP arr    = headPArr arr
 {-# NOINLINE  minimumP #-}
@@ -93,7 +92,7 @@ maximumPP      = L.closure1' (SC.fold1 P.max) (SC.fold1s P.max)
 
 
 -- minIndex/maxIndex ------------------
-minIndexP :: [:Int:] -> Int
+minIndexP :: PArr Int -> Int
 minIndexP !_    = 0 
 {-# NOINLINE  minIndexP #-}
 {-# VECTORISE minIndexP = minIndexPP #-}
@@ -109,7 +108,7 @@ min' (i,x) (j,y) | x P.<= y    = (i,x)
 {-# NOVECTORISE min' #-}
 
 
-maxIndexP :: [:Int:] -> Int
+maxIndexP :: PArr Int -> Int
 maxIndexP _     = 0
 {-# NOINLINE  maxIndexP #-}
 {-# VECTORISE maxIndexP = maxIndexPP #-}
@@ -149,7 +148,7 @@ abs     = P.abs
 
 
 -- sum/product ------------------------
-sumP, productP :: [:Int:] -> Int
+sumP, productP :: PArr Int -> Int
 
 sumP arr        = headPArr arr
 {-# NOINLINE  sumP #-}
@@ -185,7 +184,7 @@ sqrt n = P.floor (P.sqrt (P.fromIntegral n) :: P.Double)
 
 
 -- Enum -----------------------------------------------------------------------
-enumFromToP :: Int -> Int -> [:Int:]
+enumFromToP :: Int -> Int -> PArr Int
 enumFromToP !_ !_       = emptyPArr
 {-# NOINLINE  enumFromToP #-}
 {-# VECTORISE enumFromToP = enumFromToPP #-}