Generalize to type-changing strategies

The `(Strategy a, dot)` semigroup generalizes very naturally to
a `(Strategy', dot)` semigroupoid. This makes it much easier to
fuse maps with strategies.

Author: treeowl

Control/Parallel/Strategies.hs

@@ -36,8 +36,9 @@
 -----------------------------------------------------------------------------
 
 module Control.Parallel.Strategies (
-         -- * The strategy type
+         -- * The strategy types
          Strategy
+       , Strategy'
 
          -- * Application of strategies
        , using             -- :: a -> Strategy a -> a
@@ -279,26 +280,27 @@ instance Monad Eval where
 -- value.  This idiom is expressed by the 'using' function.
 --
 type Strategy a = a -> Eval a
+type Strategy' a b = a -> Eval b
 
 -- | Evaluate a value using the given 'Strategy'.
 --
 -- > x `using` s = runEval (s x)
 --
-using :: a -> Strategy a -> a
+using :: a -> Strategy' a b -> b
 x `using` strat = runEval (strat x)
 
 -- | evaluate a value using the given 'Strategy'.  This is simply
 -- 'using' with the arguments reversed.
 --
-withStrategy :: Strategy a -> a -> a
+withStrategy :: Strategy' a b -> a -> b
 withStrategy = flip using
 
 -- | Compose two strategies sequentially.
 -- This is the analogue to function composition on strategies.
 --
 -- > strat2 `dot` strat1 == strat2 . withStrategy strat1
 --
-dot :: Strategy a -> Strategy a -> Strategy a
+dot :: Strategy' b c -> Strategy' a b -> Strategy' a c
 strat2 `dot` strat1 = strat2 . runEval . strat1
 
 -- Proof of strat2 `dot` strat1 == strat2 . withStrategy strat1
@@ -407,7 +409,7 @@ rpar  x = case (par# x) of { _ -> Done x }
 --    spark that does no evaluation).
 --
 --
-rparWith :: Strategy a -> Strategy a
+rparWith :: Strategy' a b -> Strategy' a b
 #if __GLASGOW_HASKELL__ >= 702
 rparWith s = rpar `dot` s
 #else
@@ -419,12 +421,12 @@ rparWith s a = do l <- rpar (s a); return (case l of Done x -> x)
 
 -- | Evaluate the elements of a traversable data structure
 -- according to the given strategy.
-evalTraversable :: Traversable t => Strategy a -> Strategy (t a)
+evalTraversable :: Traversable t => Strategy' a b -> Strategy' (t a) (t b)
 evalTraversable = traverse
 {-# INLINE evalTraversable #-}
 
 -- | Like 'evalTraversable' but evaluates all elements in parallel.
-parTraversable :: Traversable t => Strategy a -> Strategy (t a)
+parTraversable :: Traversable t => Strategy' a b -> Strategy' (t a) (t b)
 parTraversable strat = evalTraversable (rparWith strat)
 {-# INLINE parTraversable #-}
 
@@ -433,7 +435,7 @@ parTraversable strat = evalTraversable (rparWith strat)
 
 -- | Evaluate each element of a list according to the given strategy.
 --  Equivalent to 'evalTraversable' at the list type.
-evalList :: Strategy a -> Strategy [a]
+evalList :: Strategy' a b -> Strategy' [a] [b]
 evalList = evalTraversable
 -- Alternative explicitly recursive definition:
 -- evalList strat []     = return []
@@ -443,23 +445,23 @@ evalList = evalTraversable
 
 -- | Evaluate each element of a list in parallel according to given strategy.
 --  Equivalent to 'parTraversable' at the list type.
-parList :: Strategy a -> Strategy [a]
+parList :: Strategy' a b -> Strategy' [a] [b]
 parList = parTraversable
 -- Alternative definition via evalList:
 -- parList strat = evalList (rparWith strat)
 
 -- | @'evaListSplitAt' n stratPref stratSuff@ evaluates the prefix
 -- (of length @n@) of a list according to @stratPref@ and its the suffix
 -- according to @stratSuff@.
-evalListSplitAt :: Int -> Strategy [a] -> Strategy [a] -> Strategy [a]
+evalListSplitAt :: Int -> Strategy' [a] [b] -> Strategy' [a] [b] -> Strategy' [a] [b]
 evalListSplitAt n stratPref stratSuff xs
   = let (ys,zs) = splitAt n xs in
     stratPref ys >>= \ys' ->
     stratSuff zs >>= \zs' ->
     return (ys' ++ zs')
 
 -- | Like 'evalListSplitAt' but evaluates both sublists in parallel.
-parListSplitAt :: Int -> Strategy [a] -> Strategy [a] -> Strategy [a]
+parListSplitAt :: Int -> Strategy' [a] [b] -> Strategy' [a] [b] -> Strategy' [a] [b]
 parListSplitAt n stratPref stratSuff = evalListSplitAt n (rparWith stratPref) (rparWith stratSuff)
 
 -- | Evaluate the first n elements of a list according to the given strategy.
@@ -491,7 +493,7 @@ parListNth n strat = evalListNth n (rparWith strat)
 -- If the chunk size is 1 or less, 'parListChunk' is equivalent to
 -- 'parList'
 --
-parListChunk :: Int -> Strategy a -> Strategy [a]
+parListChunk :: Int -> Strategy' a b -> Strategy' [a] [b]
 parListChunk n strat xs
   | n <= 1    = parList strat xs
   | otherwise = concat `fmap` parList (evalList strat) (chunk n xs)
@@ -506,9 +508,9 @@ chunk n xs = as : chunk n bs where (as,bs) = splitAt n xs
 -- | A combination of 'parList' and 'map', encapsulating a common pattern:
 --
 -- > parMap strat f = withStrategy (parList strat) . map f
---
+-- > parMap strat f = withStrategy (parList (strat . f))
 parMap :: Strategy b -> (a -> b) -> [a] -> [b]
-parMap strat f = (`using` parList strat) . map f
+parMap strat f = withStrategy (parList (strat . f))
 
 -- --------------------------------------------------------------------------
 -- Strategies for lazy lists
@@ -535,7 +537,7 @@ evalBufferWHNF n0 xs0 = return (ret xs0 (start n0 xs0))
 --
 -- > evalBuffer n r0 == evalBuffer n rseq
 --
-evalBuffer :: Int -> Strategy a -> Strategy [a]
+evalBuffer :: Int -> Strategy' a b -> Strategy' [a] [b]
 evalBuffer n strat =  evalBufferWHNF n . map (withStrategy strat)
 
 -- Like evalBufferWHNF but sparks the list elements when pushing them
@@ -555,7 +557,7 @@ parBufferWHNF n0 xs0 = return (ret xs0 (start n0 xs0))
 
 -- | Like 'evalBuffer' but evaluates the list elements in parallel when
 -- pushing them into the buffer.
-parBuffer :: Int -> Strategy a -> Strategy [a]
+parBuffer :: Int -> Strategy' a b -> Strategy' [a] [b]
 parBuffer n strat = parBufferWHNF n . map (withStrategy strat)
 -- Alternative definition via evalBuffer (may compromise firing of RULES):
 -- parBuffer n strat = evalBuffer n (rparWith strat)
@@ -573,109 +575,151 @@ parBuffer n strat = parBufferWHNF n . map (withStrategy strat)
 -- --------------------------------------------------------------------------
 -- Strategies for tuples
 
-evalTuple2 :: Strategy a -> Strategy b -> Strategy (a,b)
+evalTuple2 :: Strategy' a a' -> Strategy' b b' -> Strategy' (a,b) (a',b')
 evalTuple2 strat1 strat2 (x1,x2) =
   pure (,) <*> strat1 x1 <*> strat2 x2
 
-evalTuple3 :: Strategy a -> Strategy b -> Strategy c -> Strategy (a,b,c)
+evalTuple3 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' (a,b,c) (a',b',c')
 evalTuple3 strat1 strat2 strat3 (x1,x2,x3) =
   pure (,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3
 
-evalTuple4 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy (a,b,c,d)
+evalTuple4 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' (a,b,c,d) (a',b',c',d')
 evalTuple4 strat1 strat2 strat3 strat4 (x1,x2,x3,x4) =
   pure (,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4
 
-evalTuple5 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy (a,b,c,d,e)
+evalTuple5 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' e e'
+           -> Strategy' (a,b,c,d,e) (a',b',c',d',e')
 evalTuple5 strat1 strat2 strat3 strat4 strat5 (x1,x2,x3,x4,x5) =
   pure (,,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4 <*> strat5 x5
 
-evalTuple6 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy (a,b,c,d,e,f)
+evalTuple6 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' e e'
+           -> Strategy' f f'
+           -> Strategy' (a,b,c,d,e,f) (a',b',c',d',e',f')
 evalTuple6 strat1 strat2 strat3 strat4 strat5 strat6 (x1,x2,x3,x4,x5,x6) =
   pure (,,,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4 <*> strat5 x5 <*> strat6 x6
 
-evalTuple7 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy (a,b,c,d,e,f,g)
+evalTuple7 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' e e'
+           -> Strategy' f f'
+           -> Strategy' g g'
+           -> Strategy' (a,b,c,d,e,f,g) (a',b',c',d',e',f',g')
 evalTuple7 strat1 strat2 strat3 strat4 strat5 strat6 strat7 (x1,x2,x3,x4,x5,x6,x7) =
   pure (,,,,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4 <*> strat5 x5 <*> strat6 x6 <*> strat7 x7
 
-evalTuple8 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy (a,b,c,d,e,f,g,h)
+evalTuple8 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' e e'
+           -> Strategy' f f'
+           -> Strategy' g g'
+           -> Strategy' h h'
+           -> Strategy' (a,b,c,d,e,f,g,h) (a',b',c',d',e',f',g',h')
 evalTuple8 strat1 strat2 strat3 strat4 strat5 strat6 strat7 strat8 (x1,x2,x3,x4,x5,x6,x7,x8) =
   pure (,,,,,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4 <*> strat5 x5 <*> strat6 x6 <*> strat7 x7 <*> strat8 x8
 
-evalTuple9 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy i -> Strategy (a,b,c,d,e,f,g,h,i)
+evalTuple9 :: Strategy' a a'
+           -> Strategy' b b'
+           -> Strategy' c c'
+           -> Strategy' d d'
+           -> Strategy' e e'
+           -> Strategy' f f'
+           -> Strategy' g g'
+           -> Strategy' h h'
+           -> Strategy' i i'
+           -> Strategy' (a,b,c,d,e,f,g,h,i) (a',b',c',d',e',f',g',h',i')
 evalTuple9 strat1 strat2 strat3 strat4 strat5 strat6 strat7 strat8 strat9 (x1,x2,x3,x4,x5,x6,x7,x8,x9) =
   pure (,,,,,,,,) <*> strat1 x1 <*> strat2 x2 <*> strat3 x3 <*> strat4 x4 <*> strat5 x5 <*> strat6 x6 <*> strat7 x7 <*> strat8 x8 <*> strat9 x9
 
-parTuple2 :: Strategy a -> Strategy b -> Strategy (a,b)
+parTuple2 :: Strategy' a a' -> Strategy' b b' -> Strategy' (a,b) (a',b')
 parTuple2 strat1 strat2 =
   evalTuple2 (rparWith strat1) (rparWith strat2)
 
-parTuple3 :: Strategy a -> Strategy b -> Strategy c -> Strategy (a,b,c)
+parTuple3 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' (a,b,c) (a',b',c')
 parTuple3 strat1 strat2 strat3 =
   evalTuple3 (rparWith strat1) (rparWith strat2) (rparWith strat3)
 
-parTuple4 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy (a,b,c,d)
+parTuple4 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' (a,b,c,d) (a',b',c',d')
 parTuple4 strat1 strat2 strat3 strat4 =
   evalTuple4 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4)
 
-parTuple5 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy (a,b,c,d,e)
+parTuple5 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' e e' -> Strategy' (a,b,c,d,e) (a',b',c',d',e')
 parTuple5 strat1 strat2 strat3 strat4 strat5 =
   evalTuple5 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4) (rparWith strat5)
 
-parTuple6 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy (a,b,c,d,e,f)
+parTuple6 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' e e' -> Strategy' f f' -> Strategy' (a,b,c,d,e,f) (a',b',c',d',e',f')
 parTuple6 strat1 strat2 strat3 strat4 strat5 strat6 =
   evalTuple6 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4) (rparWith strat5) (rparWith strat6)
 
-parTuple7 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy (a,b,c,d,e,f,g)
+parTuple7 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' e e' -> Strategy' f f' -> Strategy' g g' -> Strategy' (a,b,c,d,e,f,g) (a',b',c',d',e',f',g')
 parTuple7 strat1 strat2 strat3 strat4 strat5 strat6 strat7 =
   evalTuple7 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4) (rparWith strat5) (rparWith strat6) (rparWith strat7)
 
-parTuple8 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy (a,b,c,d,e,f,g,h)
+parTuple8 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' e e' -> Strategy' f f' -> Strategy' g g' -> Strategy' h h' -> Strategy' (a,b,c,d,e,f,g,h) (a',b',c',d',e',f',g',h')
 parTuple8 strat1 strat2 strat3 strat4 strat5 strat6 strat7 strat8 =
   evalTuple8 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4) (rparWith strat5) (rparWith strat6) (rparWith strat7) (rparWith strat8)
 
-parTuple9 :: Strategy a -> Strategy b -> Strategy c -> Strategy d -> Strategy e -> Strategy f -> Strategy g -> Strategy h -> Strategy i -> Strategy (a,b,c,d,e,f,g,h,i)
+parTuple9 :: Strategy' a a' -> Strategy' b b' -> Strategy' c c' -> Strategy' d d' -> Strategy' e e' -> Strategy' f f' -> Strategy' g g' -> Strategy' h h' -> Strategy' i i' -> Strategy' (a,b,c,d,e,f,g,h,i) (a',b',c',d',e',f',g',h',i')
 parTuple9 strat1 strat2 strat3 strat4 strat5 strat6 strat7 strat8 strat9 =
   evalTuple9 (rparWith strat1) (rparWith strat2) (rparWith strat3) (rparWith strat4) (rparWith strat5) (rparWith strat6) (rparWith strat7) (rparWith strat8) (rparWith strat9)
 
 -- --------------------------------------------------------------------------
 -- Strategic function application
 
 {-
-These are very handy when writing pipeline parallelism asa sequence of
+These are very handy when writing pipeline parallelism as a sequence of
 @$@, @$|@ and @$||@'s. There is no need of naming intermediate values
 in this case. The separation of algorithm from strategy is achieved by
 allowing strategies only as second arguments to @$|@ and @$||@.
 -}
 
 -- | Sequential function application. The argument is evaluated using
 --   the given strategy before it is given to the function.
-($|) :: (a -> b) -> Strategy a -> a -> b
+($|) :: (b -> c) -> Strategy' a b -> a -> c
 f $| s  = \ x -> let z = x `using` s in z `pseq` f z
 
 -- | Parallel function application. The argument is evaluated using
 -- the given strategy, in parallel with the function application.
-($||) :: (a -> b) -> Strategy a -> a -> b
+($||) :: (b -> c) -> Strategy' a b -> a -> c
 f $|| s = \ x -> let z = x `using` s in z `par` f z
 
 -- | Sequential function composition. The result of
 -- the second function is evaluated using the given strategy,
 -- and then given to the first function.
-(.|) :: (b -> c) -> Strategy b -> (a -> b) -> (a -> c)
+(.|) :: (c -> d) -> Strategy' b c -> (a -> b) -> (a -> d)
 (.|) f s g = \ x -> let z = g x `using` s in
                     z `pseq` f z
 
 -- | Parallel function composition. The result of the second
 -- function is evaluated using the given strategy,
 -- in parallel with the application of the first function.
-(.||) :: (b -> c) -> Strategy b -> (a -> b) -> (a -> c)
+(.||) :: (c -> d) -> Strategy' b c -> (a -> b) -> (a -> d)
 (.||) f s g = \ x -> let z = g x `using` s in
                     z `par` f z
 
 -- | Sequential inverse function composition,
 -- for those who read their programs from left to right.
 -- The result of the first function is evaluated using the
 -- given strategy, and then given to the second function.
-(-|) :: (a -> b) -> Strategy b -> (b -> c) -> (a -> c)
+(-|) :: (a -> b) -> Strategy' b c -> (c -> d) -> (a -> d)
 (-|) f s g = \ x -> let z = f x `using` s in
                     z `pseq` g z
 
@@ -684,15 +728,15 @@ f $|| s = \ x -> let z = x `using` s in z `par` f z
 -- The result of the first function is evaluated using the
 -- given strategy, in parallel with the application of the
 -- second function.
-(-||) :: (a -> b) -> Strategy b -> (b -> c) -> (a -> c)
+(-||) :: (a -> b) -> Strategy' b c -> (c -> d) -> (a -> d)
 (-||) f s g = \ x -> let z = f x `using` s in
                     z `par` g z
 
 -- -----------------------------------------------------------------------------
 -- Old/deprecated stuff
 
 {-# DEPRECATED Done "The Strategy type is now a -> Eval a, not a -> Done" #-}
--- | DEPRECCATED: replaced by the 'Eval' monad
+-- | DEPRECATED: replaced by the 'Eval' monad
 type Done = ()
 
 {-# DEPRECATED demanding "Use pseq or $| instead" #-}