Add type signatures for local declarations
authorsimonpj@microsoft.com <unknown>
Fri, 3 Sep 2010 14:44:51 +0000 (14:44 +0000)
committersimonpj@microsoft.com <unknown>
Fri, 3 Sep 2010 14:44:51 +0000 (14:44 +0000)
dph-base/Data/Array/Parallel/Arr/BBArr.hs
dph-base/Data/Array/Parallel/Arr/BUArr.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Arrays.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Combinators.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/DistST.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Flat/Permute.hs

index 149b7ba..607650c 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      : Data.Array.Parallel.BBArr
@@ -138,7 +139,7 @@ unsafeFreezeAllMBB marr = unsafeFreezeMBB marr (lengthMBB marr)
 
 -- |Extract a slice from an array (given by its start index and length)
 --
-extractBB :: BBArr e -> Int -> Int -> BBArr e
+extractBB :: forall e. BBArr e -> Int -> Int -> BBArr e
 {-# INLINE extractBB #-}
 extractBB arr i n = 
   runST (do
@@ -148,6 +149,8 @@ extractBB arr i n =
   )
   where
     fence = n `min` (lengthBB arr - i)
+   
+    copy0 :: forall s. STArray s Int e -> ST s ()
     copy0 sta = copy 0
       where
         copy off | off == fence = return ()
index bbd56ac..528d485 100644 (file)
@@ -405,7 +405,7 @@ streamBU arr = Stream next 0 (lengthBU arr) (sNoArgs "streamBU")
 
 -- | Construct an array from a stream, filling it from left to right
 --
-unstreamBU :: UAE e => Stream e -> BUArr e
+unstreamBU :: forall e. UAE e => Stream e -> BUArr e
 {-# INLINE [1] unstreamBU #-}
 unstreamBU (Stream next s n c) =
   runST (do
@@ -415,6 +415,7 @@ unstreamBU (Stream next s n c) =
     unsafeFreezeMBU marr n'
   )
   where
+    fill0 :: forall s. MBUArr s e -> ST s Int
     fill0 marr = fill s 0
       where
         fill s i = i `seq`
@@ -451,7 +452,7 @@ appBU xs ys = unstreamBU (streamBU xs +++ streamBU ys)
 
 -- |Extract a slice from an array (given by its start index and length)
 --
-extractBU :: UAE e => BUArr e -> Int -> Int -> BUArr e
+extractBU :: forall e. UAE e => BUArr e -> Int -> Int -> BUArr e
 {-# INLINE extractBU #-}
 extractBU arr i n = 
   runST (do
@@ -461,6 +462,8 @@ extractBU arr i n =
   )
   where
     fence = n `min` (lengthBU arr - i)
+
+    copy0 :: forall s. MBUArr s e -> ST s ()
     copy0 ma = copy 0
       where
         copy off | off == fence = return ()
index 01db685..9aabf06 100644 (file)
@@ -1,4 +1,4 @@
-{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE EmptyDataDecls, ScopedTypeVariables #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -35,7 +35,7 @@ import Data.Array.Parallel.Unlifted.Sequential
 import Data.Array.Parallel.Unlifted.Distributed.Gang (
   Gang, gangSize, seqGang)
 import Data.Array.Parallel.Unlifted.Distributed.DistST (
-  stToDistST, myIndex )
+  DistST, stToDistST, myIndex )
 import Data.Array.Parallel.Unlifted.Distributed.Types (
   DT, Dist, mkDPrim, indexD, lengthD, newD, writeMD, zipD, unzipD, fstD, sndD,
   elementsUSegdD,
@@ -137,13 +137,13 @@ splitD :: UA a => Gang -> Distribution -> UArr a -> Dist (UArr a)
 {-# INLINE_DIST splitD #-}
 splitD g _ arr = splitD_impl g arr
 
-joinD_impl :: UA a => Gang -> Dist (UArr a) -> UArr a
+joinD_impl :: forall a. UA a => Gang -> Dist (UArr a) -> UArr a
 {-# INLINE_DIST joinD_impl #-}
 joinD_impl g !darr = checkGangD (here "joinD") g darr $
                      newU n (\ma -> zipWithDST_ g (copy ma) di darr)
   where
     di :*: n = scanD g (+) 0 $ lengthD darr
-    --
+    copy :: forall s. MUArr a s -> Int -> UArr a -> DistST s ()
     copy ma i arr = stToDistST (copyMU ma i arr)
 
 -- | Join a distributed array.
@@ -231,12 +231,12 @@ joinDM g darr = checkGangD (here "joinDM") g darr $
   #-}
 
 -- | Permute for distributed arrays.
-permuteD :: UA a => Gang -> Dist (UArr a) -> Dist (UArr Int) -> UArr a
+permuteD :: forall a. UA a => Gang -> Dist (UArr a) -> Dist (UArr Int) -> UArr a
 {-# INLINE_DIST permuteD #-}
 permuteD g darr dis = newU n (\ma -> zipWithDST_ g (permute ma) darr dis)
   where
     n = joinLengthD g darr
-    --
+    permute :: forall s. MUArr a s -> UArr a -> UArr Int -> DistST s ()
     permute ma arr is = stToDistST (permuteMU ma arr is)
 
 
@@ -249,7 +249,7 @@ bpermuteD g !as ds = mapD g (bpermuteU as) ds
 -- NB: This does not (and cannot) try to prevent two threads from writing to
 -- the same position. We probably want to consider this an (unchecked) user
 -- error.
-atomicUpdateD :: UA a
+atomicUpdateD :: forall a. UA a
              => Gang -> Dist (UArr a) -> Dist (UArr (Int :*: a)) -> UArr a
 {-# INLINE atomicUpdateD #-}
 atomicUpdateD g darr upd = runST (
@@ -259,6 +259,7 @@ atomicUpdateD g darr upd = runST (
     unsafeFreezeAllMU marr
   )
   where
+    update :: forall s. MUArr a s -> UArr (Int :*: a) -> DistST s ()
     update marr arr = stToDistST (atomicUpdateMU marr arr)
 
 splitSegdD :: Gang -> USegd -> Dist USegd
index b43ecbf..7497f6f 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Array.Parallel.Unlifted.Distributed.Basics
@@ -29,7 +30,7 @@ import Data.Array.Parallel.Base (
 import Data.Array.Parallel.Unlifted.Distributed.Gang (
   Gang, gangSize)
 import Data.Array.Parallel.Unlifted.Distributed.Types (
-  DT, Dist, indexD, zipD, unzipD, fstD, sndD, deepSeqD,
+  DT, Dist, MDist, indexD, zipD, unzipD, fstD, sndD, deepSeqD,
   newMD, writeMD, unsafeFreezeMD,
   checkGangD, measureD)
 import Data.Array.Parallel.Unlifted.Distributed.DistST
@@ -144,7 +145,7 @@ foldD g f !d = checkGangD ("here foldD") g d $
              | otherwise = fold (i+1) (f x $ d `indexD` i)
 
 -- | Prefix sum of a distributed value.
-scanD :: DT a => Gang -> (a -> a -> a) -> a -> Dist a -> Dist a :*: a
+scanD :: forall a. DT a => Gang -> (a -> a -> a) -> a -> Dist a -> Dist a :*: a
 {-# NOINLINE scanD #-}
 scanD g f z !d = checkGangD (here "scanD") g d $
                  runST (do
@@ -154,14 +155,15 @@ scanD g f z !d = checkGangD (here "scanD") g d $
                    return (d' :*: s))
   where
     !n = gangSize g
-    --
+    scan :: forall s. MDist a s -> Int -> a -> ST s a
     scan md i !x | i == n    = return x
                  | otherwise = do
                                  writeMD md i x
                                  scan md (i+1) (f x $ d `indexD` i)
 
-mapAccumLD :: (DT a, DT b) => Gang -> (acc -> a -> acc :*: b)
-                                   -> acc -> Dist a -> acc :*: Dist b
+mapAccumLD :: forall a b acc. (DT a, DT b)
+           => Gang -> (acc -> a -> acc :*: b)
+                   -> acc -> Dist a -> acc :*: Dist b
 {-# INLINE_DIST mapAccumLD #-}
 mapAccumLD g f acc !d = checkGangD (here "mapAccumLD") g d $
                         runST (do
@@ -171,7 +173,7 @@ mapAccumLD g f acc !d = checkGangD (here "mapAccumLD") g d $
                           return (acc' :*: d'))
   where
     !n = gangSize g
-
+    go :: MDist b s -> Int -> acc -> ST s acc
     go md i acc | i == n    = return acc
                 | otherwise = case f acc (d `indexD` i) of
                                 acc' :*: b -> do
index 7fea1a8..8f7e51d 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Array.Parallel.Unlifted.Distributed.DistST
@@ -93,7 +94,7 @@ runDistST :: DT a => Gang -> (forall s. DistST s a) -> Dist a
 {-# NOINLINE runDistST #-}
 runDistST g p = runST (distST g p)
 
-runDistST_seq :: DT a => Gang -> (forall s. DistST s a) -> Dist a
+runDistST_seq :: forall a. DT a => Gang -> (forall s. DistST s a) -> Dist a
 {-# NOINLINE runDistST_seq #-}
 runDistST_seq g p = runST (
   do
@@ -102,7 +103,7 @@ runDistST_seq g p = runST (
      unsafeFreezeMD md)                           
   where
     !n = gangSize g
-    --
+    go :: forall s. MDist a s -> Int -> ST s ()
     go md i | i < n     = do
                             writeMD md i =<< unDistST p i
                             go md (i+1)
index 58f6284..b75b33e 100644 (file)
@@ -1,3 +1,4 @@
+{-# LANGUAGE ScopedTypeVariables #-}
 ----------------------------------------------------------------------------
 -- |
 -- Module      : Data.Array.Parallel.Unlifted.Sequential.Flat.Permute
@@ -141,7 +142,7 @@ reverseU :: UA e => UArr e -> UArr e
 --reverseU a = mapU (a!:) . enumFromToU 0 $ lengthU a - 1
 reverseU = rev . streamU
 
-rev :: UA e => Stream e -> UArr e
+rev :: forall e. UA e => Stream e -> UArr e
 {-# INLINE_STREAM rev #-}
 rev (Stream next s n c) =
   runST (do
@@ -151,6 +152,7 @@ rev (Stream next s n c) =
     return $ sliceU a i (n-i)
   )
   where
+    fill :: forall s. MUArr e s -> ST s Int
     fill marr = fill0 s n
       where
         fill0 s !i = case next s of