Export pseq from Control.Parallel, and use it in Control.Parallel.Strategies

diff --git a/Control/Parallel.hs b/Control/Parallel.hs
index 504d92b..8e1a6eb 100644 (file)
--- a/Control/Parallel.hs
+++ b/Control/Parallel.hs
@@ -13,7 +13,8 @@
 -----------------------------------------------------------------------------
 
 module Control.Parallel (
-          par, seq -- re-exported
+          par, pseq,
+         seq, -- for backwards compatibility, 6.6 exported this
 #if defined(__GRANSIM__)
        , parGlobal, parLocal, parAt, parAtAbs, parAtRel, parAtForNow     
 #endif
@@ -22,7 +23,7 @@ module Control.Parallel (
 import Prelude
 
 #ifdef __GLASGOW_HASKELL__
-import qualified GHC.Conc      ( par )
+import qualified GHC.Conc      ( par, pseq )
 #endif
 
 #if defined(__GRANSIM__)
@@ -80,3 +81,24 @@ par = GHC.Conc.par
 -- For now, Hugs does not support par properly.
 par a b = b
 #endif
+
+-- | Semantically identical to 'seq', but with a subtle operational
+-- difference: 'seq' is strict in both its arguments, so the compiler
+-- may, for example, rearrange @a `seq` b@ into @b `seq` a `seq` b@.
+-- This is normally no problem when using 'seq' to express strictness,
+-- but it can be a problem when annotating code for parallelism,
+-- because we need more control over the order of evaluation; we may
+-- want to evaluate @a@ before @b@, because we know that @b@ has
+-- already been sparked in parallel with 'par'.
+--
+-- This is why we have 'pseq'.  In contrast to 'seq', 'pseq' is only
+-- strict in its first argument (as far as the compiler is concerned),
+-- which restricts the transformations that the compiler can do, and
+-- ensures that the user can retain control of the evaluation order.
+--
+pseq :: a -> b -> b
+#ifdef __GLASGOW_HASKELL__
+pseq = GHC.Conc.pseq
+#else
+pseq = seq
+#endif

diff --git a/Control/Parallel/Strategies.hs b/Control/Parallel/Strategies.hs
index ce3f7b0..9f11d77 100644 (file)
--- a/Control/Parallel/Strategies.hs
+++ b/Control/Parallel/Strategies.hs
@@ -19,15 +19,12 @@ module Control.Parallel.Strategies where
 --     Phil Trinder, Hans-Wolfgang Loidl, Kevin Hammond et al. 
 --
 
-#ifdef __HADDOCK__
-import Prelude
-#endif
-
-import Control.Parallel as Parallel
-import Data.Ix
+import Control.Parallel as Parallel (par, pseq)
 import Data.Array
 import Data.Complex
-import Data.Ratio
+
+import Prelude hiding (seq)
+import qualified Prelude (seq)
 
 -- not a terribly portable way of getting at Ratio rep.
 #ifdef __GLASGOW_HASKELL__
@@ -49,6 +46,10 @@ infixr 3 >|                 -- another name for seq
 infixl 6 $||, $|            -- strategic function application (seq and par)
 infixl 9 .|, .||, -|, -||   -- strategic (inverse) function composition
 
+-- We need 'pseq', not the Prelude 'seq' here.  See the documentation
+-- with 'pseq' in Control.Parallel.
+seq = Parallel.pseq
+
 ------------------------------------------------------------------------------
 --                     Strategy Type, Application and Semantics              
 ------------------------------------------------------------------------------
@@ -102,7 +103,7 @@ with a singleton sequence as it is not necessarily excuted
 -}
 
 demanding, sparking :: a -> Done -> a
-demanding = flip Parallel.seq
+demanding = flip seq
 sparking  = flip Parallel.par
 
 {-