dph-prim-seq: Add lockedZipWiths up to 8
authorBen Lippmeier <benl@ouroborus.net>
Mon, 6 Aug 2012 07:06:39 +0000 (17:06 +1000)
committerBen Lippmeier <benl@ouroborus.net>
Thu, 1 Nov 2012 00:39:49 +0000 (11:39 +1100)
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Locked.hs [new file with mode: 0644]
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Locked.hs [new file with mode: 0644]
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Swallow.hs [new file with mode: 0644]
dph-prim-seq/dph-prim-seq.cabal
dph-test/fusion/Generic.hs
dph-test/fusion/Main.hs
dph-test/fusion/Stream.hs
dph-test/fusion/Unboxed.hs

diff --git a/dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Locked.hs b/dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Locked.hs
new file mode 100644 (file)
index 0000000..2e51001
--- /dev/null
@@ -0,0 +1,197 @@
+{-# LANGUAGE CPP #-}
+#include "fusion-phases.h"
+
+module Data.Array.Parallel.Unlifted.Sequential.Locked
+        ( lockedZip,    lockedZipWith
+        , lockedZip3,   lockedZipWith3
+        , lockedZip4,   lockedZipWith4
+        , lockedZip5,   lockedZipWith5
+        , lockedZip6,   lockedZipWith6
+        , lockedZip7,   lockedZipWith7
+        , lockedZip8,   lockedZipWith8)
+where
+import Data.Array.Parallel.Unlifted.Stream.Locked
+import Data.Vector.Generic               as G
+
+
+-- Locked Zips ----------------------------------------------------------------
+-- | Zip two vectors of the same length.
+--   If they do not have the same length then the result is undefined.
+lockedZip
+        :: ( Vector v a, Vector v b
+           , Vector v (a, b))
+        => v a -> v b
+        -> v (a, b)
+
+lockedZip aa bb
+        = unstream $ stream2 aa bb 
+{-# INLINE_U lockedZip #-}
+
+
+-- | Zip three vectors of the same length.
+lockedZip3
+        :: ( Vector v a, Vector v b, Vector v c
+           , Vector v (a, b, c))
+        => v a -> v b -> v c
+        -> v (a, b, c)
+
+lockedZip3 aa bb cc
+        = unstream $ stream3 aa bb cc
+{-# INLINE_U lockedZip3 #-}
+
+
+-- | Zip four vectors of the same length.
+lockedZip4
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v (a, b, c, d))
+        => v a -> v b -> v c -> v d
+        -> v (a, b, c, d)
+
+lockedZip4 aa bb cc dd
+        = unstream $ stream4 aa bb cc dd
+{-# INLINE_U lockedZip4 #-}
+
+
+-- | Zip five vectors of the same length.
+lockedZip5
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e
+           , Vector v (a, b, c, d, e))
+        => v a -> v b -> v c -> v d -> v e
+        -> v (a, b, c, d, e)
+
+lockedZip5 aa bb cc dd ee
+        = unstream $ stream5 aa bb cc dd ee
+{-# INLINE_U lockedZip5 #-}
+
+
+-- | Zip six vectors of the same length.
+lockedZip6
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f
+           , Vector v (a, b, c, d, e, f))
+        => v a -> v b -> v c -> v d -> v e -> v f
+        -> v (a, b, c, d, e, f)
+
+lockedZip6 aa bb cc dd ee ff
+        = unstream $ stream6 aa bb cc dd ee ff
+{-# INLINE_U lockedZip6 #-}
+
+
+-- | Zip seven vectors of the same length.
+lockedZip7
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f, Vector v g
+           , Vector v (a, b, c, d, e, f, g))
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g
+        -> v (a, b, c, d, e, f, g)
+
+lockedZip7 aa bb cc dd ee ff gg
+        = unstream $ stream7 aa bb cc dd ee ff gg
+{-# INLINE_U lockedZip7 #-}
+
+
+-- | Zip eight vectors of the same length.
+lockedZip8
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f, Vector v g, Vector v h
+           , Vector v (a, b, c, d, e, f, g, h))
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
+        -> v (a, b, c, d, e, f, g, h)
+
+lockedZip8 aa bb cc dd ee ff gg hh
+        = unstream $ stream8 aa bb cc dd ee ff gg hh
+{-# INLINE_U lockedZip8 #-}
+
+
+-- Locked ZipWiths ------------------------------------------------------------
+lockedZipWith
+        :: ( Vector v a, Vector v b, Vector v c
+           , Vector v (a, b))
+        => (a -> b -> c)
+        -> v a -> v b -> v c
+
+lockedZipWith f aa bb
+        = G.map (\(a, b) -> f a b)
+        $ lockedZip aa bb
+{-# INLINE lockedZipWith #-}
+
+
+lockedZipWith3  
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v (a, b, c))
+        => (a -> b -> c -> d)
+        -> v a -> v b -> v c -> v d
+
+lockedZipWith3 f aa bb cc
+        = G.map (\(a, b, c) -> f a b c)
+        $ lockedZip3 aa bb cc
+{-# INLINE lockedZipWith3 #-}
+
+
+lockedZipWith4
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e
+           , Vector v (a, b, c, d))
+        => (a -> b -> c -> d -> e)
+        -> v a -> v b -> v c -> v d -> v e
+
+lockedZipWith4 f aa bb cc dd
+        = G.map (\(a, b, c, d) -> f a b c d)
+        $ lockedZip4 aa bb cc dd
+{-# INLINE lockedZipWith4 #-}
+
+
+lockedZipWith5
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f
+           , Vector v (a, b, c, d, e))
+        => (a -> b -> c -> d -> e -> f)
+        -> v a -> v b -> v c -> v d -> v e -> v f
+
+lockedZipWith5 f aa bb cc dd ee
+        = G.map (\(a, b, c, d, e) -> f a b c d e)
+        $ lockedZip5 aa bb cc dd ee
+{-# INLINE lockedZipWith5 #-}
+
+
+lockedZipWith6
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f, Vector v g
+           , Vector v (a, b, c, d, e, f))
+        => (a -> b -> c -> d -> e -> f -> g)
+        -> v a -> v b -> v c -> v d -> v e -> v f -> v g
+
+lockedZipWith6 fn aa bb cc dd ee ff
+        = G.map (\(a, b, c, d, e, f) -> fn a b c d e f)
+        $ lockedZip6 aa bb cc dd ee ff
+{-# INLINE lockedZipWith6 #-}
+
+
+lockedZipWith7
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f, Vector v g, Vector v h
+           , Vector v (a, b, c, d, e, f, g))
+        => (a -> b -> c -> d -> e -> f -> g -> h)
+        -> v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
+
+lockedZipWith7 fn aa bb cc dd ee ff gg
+        = G.map (\(a, b, c, d, e, f, g) -> fn a b c d e f g)
+        $ lockedZip7 aa bb cc dd ee ff gg
+{-# INLINE lockedZipWith7 #-}
+
+
+lockedZipWith8
+        :: ( Vector v a, Vector v b, Vector v c, Vector v d
+           , Vector v e, Vector v f, Vector v g, Vector v h
+           , Vector v i
+           , Vector v (a, b, c, d, e, f, g, h))
+        => (a -> b -> c -> d -> e -> f -> g -> h -> i)
+        -> v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h -> v i
+
+lockedZipWith8 fn aa bb cc dd ee ff gg hh
+        = G.map (\(a, b, c, d, e, f, g, h) -> fn a b c d e f g h)
+        $ lockedZip8 aa bb cc dd ee ff gg hh
+{-# INLINE lockedZipWith8 #-}
+
+
index 5df8c3d..5a549cd 100644 (file)
@@ -10,9 +10,15 @@ module Data.Array.Parallel.Unlifted.Stream
         , module Data.Array.Parallel.Unlifted.Stream.Elems
 
           -- * Streams of scattered segments
-        , module Data.Array.Parallel.Unlifted.Stream.Segments)
+        , module Data.Array.Parallel.Unlifted.Stream.Segments
+
+          -- * Locked streams
+        , module Data.Array.Parallel.Unlifted.Stream.Swallow
+        , module Data.Array.Parallel.Unlifted.Stream.Locked)
 where
 import Data.Array.Parallel.Unlifted.Stream.Segmented
 import Data.Array.Parallel.Unlifted.Stream.Ixs
 import Data.Array.Parallel.Unlifted.Stream.Elems
 import Data.Array.Parallel.Unlifted.Stream.Segments
+import Data.Array.Parallel.Unlifted.Stream.Swallow
+import Data.Array.Parallel.Unlifted.Stream.Locked
diff --git a/dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Locked.hs b/dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Locked.hs
new file mode 100644 (file)
index 0000000..5ef87f3
--- /dev/null
@@ -0,0 +1,576 @@
+{-# LANGUAGE CPP, NoMonomorphismRestriction #-}
+#include "fusion-phases.h"
+-- | Locked streamers and zippers.
+--
+--   The streams are 'locked together', meaning they have the same length and
+--   cannot yield 'Skip' states.
+-- 
+--   These functions are used for processing data read directly from vectors
+--   where we know the vectors all have the same length.
+--   
+module Data.Array.Parallel.Unlifted.Stream.Locked
+        ( stream2,      lockedZip2S
+        , stream3,      lockedZip3S
+        , stream4,      lockedZip4S
+        , stream5,      lockedZip5S
+        , stream6,      lockedZip6S
+        , stream7,      lockedZip7S
+        , stream8,      lockedZip8S)
+where
+import Data.Array.Parallel.Unlifted.Stream.Swallow
+import Data.Vector.Generic               as G
+import Data.Vector.Fusion.Stream.Monadic as S
+import Data.Vector.Fusion.Stream.Size    as S
+
+
+-------------------------------------------
+-- | Stream two vectors of the same length.
+--   The fact that they are the same length means the generated code only 
+--   needs to maintain one loop counter for all streams.
+--
+--   Trying to stream vectors of differing lengths is undefined.
+--
+stream2 :: (Monad m, Vector v a, Vector v b)
+        => v a -> v b
+        -> Stream m (a, b)
+
+stream2 aa bb
+ = lockedZip2S (G.length aa) (swallow aa) (swallow bb)
+{-# INLINE_STREAM stream2 #-}
+
+
+---------------------------------------------
+-- | Stream three vectors of the same length.
+stream3 :: (Monad m, Vector v a, Vector v b, Vector v c)
+        => v a -> v b -> v c 
+        -> Stream m (a, b, c)
+
+stream3 aa bb cc
+ = lockedZip3S (G.length aa) (swallow aa) (swallow bb) (swallow cc)
+{-# INLINE_STREAM stream3 #-}
+
+
+-- When we see that one of the vectors is being created G.new then push down a
+-- 'swallow' wrapper to signal that the consumer (lockedZip2S) knows how many
+-- elements to demand. This lets us generate better code on the producer side
+-- as it doesn't need to track how many elements still need to be generated.
+
+{-# RULES "stream3/new_1"
+    forall as bs cs
+    . stream3 (G.new as) bs cs
+    = S.map (\((b, c), a) -> (a, b, c))
+    $ lockedZip2S (G.length bs) (swallow2 bs cs) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream3/new_2"
+    forall as bs cs
+    . stream3 as (G.new bs) cs
+    = S.map (\((a, c), b) -> (a, b, c))
+    $ lockedZip2S (G.length as) (swallow2 as cs) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream3/new_3"
+    forall as bs cs
+    . stream3 as bs (G.new cs)
+    = S.map (\((a, b), c) -> (a, b, c))
+    $ lockedZip2S (G.length as) (swallow2 as bs) (swallow (G.new cs))
+  #-}
+
+
+---------------------------------------------
+-- | Stream four vectors of the same length.
+stream4 :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d)
+        => v a -> v b -> v c -> v d
+        -> Stream m (a, b, c, d)
+
+stream4 aa bb cc dd
+ = lockedZip4S (G.length aa) 
+        (swallow aa) (swallow bb) (swallow cc) (swallow dd)
+{-# INLINE_STREAM stream4 #-}
+
+{-# RULES "stream4/new_1"
+    forall as bs cs ds
+    . stream4 (G.new as) bs cs ds
+    = S.map (\((b, c, d), a) -> (a, b, c, d))
+    $ lockedZip2S (G.length bs) (swallow3 bs cs ds) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream4/new_2"
+    forall as bs cs ds
+    . stream4 as (G.new bs) cs ds
+    = S.map (\((a, c, d), b) -> (a, b, c, d))
+    $ lockedZip2S (G.length as) (swallow3 as cs ds) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream4/new_3"
+    forall as bs cs ds
+    . stream4 as bs (G.new cs) ds
+    = S.map (\((a, b, d), c) -> (a, b, c, d))
+    $ lockedZip2S (G.length as) (swallow3 as bs ds) (swallow (G.new cs))
+  #-}
+
+{-# RULES "stream4/new_4"
+    forall as bs cs ds
+    . stream4 as bs cs (G.new ds)
+    = S.map (\((a, b, c), d) -> (a, b, c, d))
+    $ lockedZip2S (G.length as) (swallow3 as bs cs) (swallow (G.new ds))
+  #-}
+
+
+---------------------------------------------
+-- | Stream five vectors of the same length.
+stream5 :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
+        => v a -> v b -> v c -> v d -> v e
+        -> Stream m (a, b, c, d, e)
+
+stream5 aa bb cc dd ee
+ = lockedZip5S (G.length aa) 
+        (swallow aa) (swallow bb) (swallow cc) (swallow dd)
+        (swallow ee)
+{-# INLINE_STREAM stream5 #-}
+
+{-# RULES "stream5/new_1"
+    forall as bs cs ds es
+    . stream5 (G.new as) bs cs ds es
+    = S.map (\((b, c, d, e), a) -> (a, b, c, d, e))
+    $ lockedZip2S (G.length bs) (swallow4 bs cs ds es) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream5/new_2"
+    forall as bs cs ds es
+    . stream5 as (G.new bs) cs ds es
+    = S.map (\((a, c, d, e), b) -> (a, b, c, d, e))
+    $ lockedZip2S (G.length as) (swallow4 as cs ds es) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream5/new_3"
+    forall as bs cs ds es
+    . stream5 as bs (G.new cs) ds es
+    = S.map (\((a, b, d, e), c) -> (a, b, c, d, e))
+    $ lockedZip2S (G.length as) (swallow4 as bs ds es) (swallow (G.new cs))
+  #-}
+
+{-# RULES "stream5/new_4"
+    forall as bs cs ds es
+    . stream5 as bs cs (G.new ds) es
+    = S.map (\((a, b, c, e), d) -> (a, b, c, d, e))
+    $ lockedZip2S (G.length as) (swallow4 as bs cs es) (swallow (G.new ds))
+  #-}
+
+{-# RULES "stream5/new_5"
+    forall as bs cs ds es
+    . stream5 as bs cs ds (G.new es)
+    = S.map (\((a, b, c, d), e) -> (a, b, c, d, e))
+    $ lockedZip2S (G.length as) (swallow4 as bs cs ds) (swallow (G.new es))
+  #-}
+
+
+---------------------------------------------
+-- | Stream six vectors of the same length.
+stream6 :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f)
+        => v a -> v b -> v c -> v d -> v e -> v f
+        -> Stream m (a, b, c, d, e, f)
+
+stream6 aa bb cc dd ee ff
+ = lockedZip6S (G.length aa) 
+        (swallow aa) (swallow bb) (swallow cc) (swallow dd)
+        (swallow ee) (swallow ff)
+{-# INLINE_STREAM stream6 #-}
+
+{-# RULES "stream6/new_1"
+    forall as bs cs ds es fs
+    . stream6 (G.new as) bs cs ds es fs
+    = S.map (\((b, c, d, e, f), a) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length bs) (swallow5 bs cs ds es fs) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream6/new_2"
+    forall as bs cs ds es fs
+    . stream6 as (G.new bs) cs ds es fs
+    = S.map (\((a, c, d, e, f), b) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length as) (swallow5 as cs ds es fs) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream6/new_3"
+    forall as bs cs ds es fs
+    . stream6 as bs (G.new cs) ds es fs
+    = S.map (\((a, b, d, e, f), c) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length as) (swallow5 as bs ds es fs) (swallow (G.new cs))
+  #-}
+
+{-# RULES "stream6/new_4"
+    forall as bs cs ds es fs
+    . stream6 as bs cs (G.new ds) es fs
+    = S.map (\((a, b, c, e, f), d) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length as) (swallow5 as bs cs es fs) (swallow (G.new ds))
+  #-}
+
+{-# RULES "stream6/new_5"
+    forall as bs cs ds es fs
+    . stream6 as bs cs ds (G.new es) fs
+    = S.map (\((a, b, c, d, f), e) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length as) (swallow5 as bs cs ds fs) (swallow (G.new es))
+  #-}
+
+{-# RULES "stream6/new_6"
+    forall as bs cs ds es fs
+    . stream6 as bs cs ds es (G.new fs)
+    = S.map (\((a, b, c, d, e), f) -> (a, b, c, d, e, f))
+    $ lockedZip2S (G.length as) (swallow5 as bs cs ds es) (swallow (G.new fs))
+  #-}
+
+
+---------------------------------------------
+-- | Stream seven vectors of the same length.
+stream7 :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g)
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g
+        -> Stream m (a, b, c, d, e, f, g)
+
+stream7 aa bb cc dd ee ff gg
+ = lockedZip7S (G.length aa) 
+        (swallow aa) (swallow bb) (swallow cc) (swallow dd)
+        (swallow ee) (swallow ff) (swallow gg)
+{-# INLINE_STREAM stream7 #-}
+
+{-# RULES "stream7/new_1"
+    forall as bs cs ds es fs gs
+    . stream7 (G.new as) bs cs ds es fs gs
+    = S.map (\((b, c, d, e, f, g), a) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length bs) (swallow6 bs cs ds es fs gs) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream7/new_2"
+    forall as bs cs ds es fs gs
+    . stream7 as (G.new bs) cs ds es fs gs
+    = S.map (\((a, c, d, e, f, g), b) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as cs ds es fs gs) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream7/new_3"
+    forall as bs cs ds es fs gs
+    . stream7 as bs (G.new cs) ds es fs gs
+    = S.map (\((a, b, d, e, f, g), c) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as bs ds es fs gs) (swallow (G.new cs))
+  #-}
+
+{-# RULES "stream7/new_4"
+    forall as bs cs ds es fs gs
+    . stream7 as bs cs (G.new ds) es fs gs
+    = S.map (\((a, b, c, e, f, g), d) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as bs cs es fs gs) (swallow (G.new ds))
+  #-}
+
+{-# RULES "stream7/new_5"
+    forall as bs cs ds es fs gs
+    . stream7 as bs cs ds (G.new es) fs gs
+    = S.map (\((a, b, c, d, f, g), e) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as bs cs ds fs gs) (swallow (G.new es))
+  #-}
+
+{-# RULES "stream7/new_6"
+    forall as bs cs ds es fs gs
+    . stream7 as bs cs ds es (G.new fs) gs
+    = S.map (\((a, b, c, d, e, g), f) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as bs cs ds es gs) (swallow (G.new fs))
+  #-}
+
+{-# RULES "stream7/new_7"
+    forall as bs cs ds es fs gs
+    . stream7 as bs cs ds es fs (G.new gs)
+    = S.map (\((a, b, c, d, e, f), g) -> (a, b, c, d, e, f, g))
+    $ lockedZip2S (G.length as) (swallow6 as bs cs ds es fs) (swallow (G.new gs))
+  #-}
+
+
+---------------------------------------------
+-- | Stream seven vectors of the same length.
+stream8 :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g, Vector v h)
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
+        -> Stream m (a, b, c, d, e, f, g, h)
+
+stream8 aa bb cc dd ee ff gg hh
+ = lockedZip8S (G.length aa) 
+        (swallow aa) (swallow bb) (swallow cc) (swallow dd)
+        (swallow ee) (swallow ff) (swallow gg) (swallow hh)
+{-# INLINE_STREAM stream8 #-}
+
+{-# RULES "stream8/new_1"
+    forall as bs cs ds es fs gs hs
+    . stream8 (G.new as) bs cs ds es fs gs hs
+    = S.map (\((b, c, d, e, f, g, h), a) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length bs) (swallow7 bs cs ds es fs gs hs) (swallow (G.new as))
+  #-}
+
+{-# RULES "stream8/new_2"
+    forall as bs cs ds es fs gs hs
+    . stream8 as (G.new bs) cs ds es fs gs hs
+    = S.map (\((a, c, d, e, f, g, h), b) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as cs ds es fs gs hs) (swallow (G.new bs))
+  #-}
+
+{-# RULES "stream8/new_3"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs (G.new cs) ds es fs gs hs
+    = S.map (\((a, b, d, e, f, g, h), c) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs ds es fs gs hs) (swallow (G.new cs))
+  #-}
+
+{-# RULES "stream8/new_4"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs cs (G.new ds) es fs gs hs
+    = S.map (\((a, b, c, e, f, g, h), d) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs cs es fs gs hs) (swallow (G.new ds))
+  #-}
+
+{-# RULES "stream8/new_5"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs cs ds (G.new es) fs gs hs
+    = S.map (\((a, b, c, d, f, g, h), e) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs cs ds fs gs hs) (swallow (G.new es))
+  #-}
+
+{-# RULES "stream8/new_6"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs cs ds es (G.new fs) gs hs
+    = S.map (\((a, b, c, d, e, g, h), f) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs cs ds es gs hs) (swallow (G.new fs))
+  #-}
+
+{-# RULES "stream8/new_7"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs cs ds es fs (G.new gs) hs
+    = S.map (\((a, b, c, d, e, f, h), g) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs cs ds es fs hs) (swallow (G.new gs))
+  #-}
+
+{-# RULES "stream8/new_8"
+    forall as bs cs ds es fs gs hs
+    . stream8 as bs cs ds es fs gs (G.new hs)
+    = S.map (\((a, b, c, d, e, f, h), g) -> (a, b, c, d, e, f, g, h))
+    $ lockedZip2S (G.length as) (swallow7 as bs cs ds es fs gs) (swallow (G.new hs))
+  #-}
+
+
+
+
+-- Locked zips ----------------------------------------------------------------
+-- | Zip the first 'n' elements of two streams.
+lockedZip2S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b 
+        -> Stream m (a, b)
+
+lockedZip2S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+ = Stream step (sa1, sa2, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                return $ case (step1, step2) of
+                          (Yield x1 s1', Yield x2 s2')
+                            | i < len   -> Yield (x1, x2) (s1', s2', i + 1)
+                          _             -> Done
+{-# INLINE_STREAM lockedZip2S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of three streams.
+lockedZip3S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c
+        -> Stream m (a, b, c)
+
+lockedZip3S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+ = Stream step (sa1, sa2, sa3, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                return $ case (step1, step2, step3) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3')  
+                           | i < len    -> Yield (x1, x2, x3) (s1', s2', s3', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip3S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of four streams.
+lockedZip4S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c -> Stream m d
+        -> Stream m (a, b, c, d)
+
+lockedZip4S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+        (Stream mkStep4 sa4 _)
+ = Stream step (sa1, sa2, sa3, sa4, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, s4, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                step4   <- mkStep4 s4
+                return $ case (step1, step2, step3, step4) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3', Yield x4 s4')  
+                           | i < len    -> Yield (x1, x2, x3, x4) (s1', s2', s3', s4', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip4S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of five streams.
+lockedZip5S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
+        -> Stream m (a, b, c, d, e)
+
+lockedZip5S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+        (Stream mkStep4 sa4 _)
+        (Stream mkStep5 sa5 _)
+ = Stream step (sa1, sa2, sa3, sa4, sa5, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, s4, s5, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                step4   <- mkStep4 s4
+                step5   <- mkStep5 s5
+                return $ case (step1, step2, step3, step4, step5) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3', Yield x4 s4', Yield x5 s5')  
+                           | i < len    -> Yield (x1, x2, x3, x4, x5) (s1', s2', s3', s4', s5', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip5S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of six streams.
+lockedZip6S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f
+        -> Stream m (a, b, c, d, e, f)
+
+lockedZip6S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+        (Stream mkStep4 sa4 _)
+        (Stream mkStep5 sa5 _)
+        (Stream mkStep6 sa6 _)
+ = Stream step (sa1, sa2, sa3, sa4, sa5, sa6, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, s4, s5, s6, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                step4   <- mkStep4 s4
+                step5   <- mkStep5 s5
+                step6   <- mkStep6 s6
+                return $ case (step1, step2, step3, step4, step5, step6) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3', Yield x4 s4', Yield x5 s5', Yield x6 s6')  
+                           | i < len    -> Yield (x1, x2, x3, x4, x5, x6) (s1', s2', s3', s4', s5', s6', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip6S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of seven streams.
+lockedZip7S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g
+        -> Stream m (a, b, c, d, e, f, g)
+
+lockedZip7S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+        (Stream mkStep4 sa4 _)
+        (Stream mkStep5 sa5 _)
+        (Stream mkStep6 sa6 _)
+        (Stream mkStep7 sa7 _)
+ = Stream step (sa1, sa2, sa3, sa4, sa5, sa6, sa7, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, s4, s5, s6, s7, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                step4   <- mkStep4 s4
+                step5   <- mkStep5 s5
+                step6   <- mkStep6 s6
+                step7   <- mkStep7 s7
+                return $ case (step1, step2, step3, step4, step5, step6, step7) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3', Yield x4 s4', Yield x5 s5', Yield x6 s6', Yield x7 s7')  
+                           | i < len    -> Yield (x1, x2, x3, x4, x5, x6, x7) (s1', s2', s3', s4', s5', s6', s7', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip7S #-}
+
+
+-------------------------------------------------
+-- | Zip the first 'n' elements of eight streams.
+lockedZip8S
+        :: Monad m 
+        => Int
+        -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m g -> Stream m h
+        -> Stream m (a, b, c, d, e, f, g, h)
+
+lockedZip8S len
+        (Stream mkStep1 sa1 _)
+        (Stream mkStep2 sa2 _)
+        (Stream mkStep3 sa3 _)
+        (Stream mkStep4 sa4 _)
+        (Stream mkStep5 sa5 _)
+        (Stream mkStep6 sa6 _)
+        (Stream mkStep7 sa7 _)
+        (Stream mkStep8 sa8 _)
+ = Stream step (sa1, sa2, sa3, sa4, sa5, sa6, sa7, sa8, 0) (S.Exact len)
+ where 
+        {-# INLINE_INNER step #-}
+        step (s1, s2, s3, s4, s5, s6, s7, s8, i)
+         = i `seq`
+           do   step1   <- mkStep1 s1
+                step2   <- mkStep2 s2
+                step3   <- mkStep3 s3
+                step4   <- mkStep4 s4
+                step5   <- mkStep5 s5
+                step6   <- mkStep6 s6
+                step7   <- mkStep7 s7
+                step8   <- mkStep8 s8
+                return $ case (step1, step2, step3, step4, step5, step6, step7, step8) of
+                          (Yield x1 s1', Yield x2 s2', Yield x3 s3', Yield x4 s4', Yield x5 s5', Yield x6 s6', Yield x7 s7', Yield x8 s8')
+                           | i < len    -> Yield (x1, x2, x3, x4, x5, x6, x7, x8) (s1', s2', s3', s4', s5', s6', s7', s8', i + 1)
+
+                          _ -> Done
+{-# INLINE_STREAM lockedZip8S #-}
diff --git a/dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Swallow.hs b/dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Swallow.hs
new file mode 100644 (file)
index 0000000..59c0622
--- /dev/null
@@ -0,0 +1,242 @@
+{-# LANGUAGE CPP, NoMonomorphismRestriction #-}
+#include "fusion-phases.h"
+module Data.Array.Parallel.Unlifted.Stream.Swallow
+        ( swallow
+        , swallow2
+        , swallow3
+        , swallow4
+        , swallow5
+        , swallow6
+        , swallow7
+        , swallow8
+
+        , repeatS
+        , swallowS)
+where
+import Data.Vector.Generic               as G
+import Data.Vector.Fusion.Stream.Monadic as S
+import Data.Vector.Fusion.Stream.Size    as S
+import Data.Vector.Fusion.Util           as S
+import qualified Data.Vector.Generic.New as New
+
+
+-- Swallow --------------------------------------------------------------------
+-- | Swallow a vector.
+--   This is like `stream`, except there is no end-of-vector check. We rely on
+--   the consumer to know how many elements to demand. Using this function 
+--   instead of 'stream' avoids the associated loop counters in fused code.
+--
+--   Trying to swallow more elements than are in the vector is undefined.
+--
+swallow :: Monad m => Vector v a => v a -> Stream m a
+swallow v 
+ = v 
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where
+        n   = G.length v
+
+        {-# INLINE_INNER get #-}
+        get i       
+         | Box a        <- basicUnsafeIndexM v i 
+         = Just (a, i + 1)
+{-# INLINE_STREAM swallow #-}
+
+
+-- | Swallow two vectors.
+swallow2 
+        :: (Monad m, Vector v a, Vector v b)
+        => v a -> v b 
+        -> Stream m (a, b)
+
+swallow2 aa bb
+ = aa `seq` bb 
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         = Just ((a, b), i + 1)
+{-# INLINE_STREAM swallow2 #-}
+
+
+-- | Swallow three vectors.
+swallow3
+        :: (Monad m, Vector v a, Vector v b, Vector v c)
+        => v a -> v b -> v c
+        -> Stream m (a, b, c)
+
+swallow3 aa bb cc
+ = aa `seq` bb `seq` cc
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         = Just ((a, b, c), i + 1)
+{-# INLINE_STREAM swallow3 #-}
+
+
+-- | Swallow four vectors.
+swallow4
+        :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d)
+        => v a -> v b -> v c -> v d
+        -> Stream m (a, b, c, d)
+
+swallow4 aa bb cc dd
+ = aa `seq` bb `seq` cc `seq` dd
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         , Box d        <- basicUnsafeIndexM dd i
+         = Just ((a, b, c, d), i + 1)
+{-# INLINE_STREAM swallow4 #-}
+
+
+-- | Swallow five vectors.
+swallow5
+        :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e)
+        => v a -> v b -> v c -> v d -> v e
+        -> Stream m (a, b, c, d, e)
+
+swallow5 aa bb cc dd ee
+ = aa `seq` bb `seq` cc `seq` dd `seq` ee
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         , Box d        <- basicUnsafeIndexM dd i
+         , Box e        <- basicUnsafeIndexM ee i
+         = Just ((a, b, c, d, e), i + 1)
+{-# INLINE_STREAM swallow5 #-}
+
+
+-- | Swallow six vectors.
+swallow6
+        :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f)
+        => v a -> v b -> v c -> v d -> v e -> v f
+        -> Stream m (a, b, c, d, e, f)
+
+swallow6 aa bb cc dd ee ff
+ = aa `seq` bb `seq` cc `seq` dd `seq` ee `seq` ff
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         , Box d        <- basicUnsafeIndexM dd i
+         , Box e        <- basicUnsafeIndexM ee i
+         , Box f        <- basicUnsafeIndexM ff i
+         = Just ((a, b, c, d, e, f), i + 1)
+{-# INLINE_STREAM swallow6 #-}
+
+
+-- | Swallow seven vectors.
+swallow7
+        :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g)
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g
+        -> Stream m (a, b, c, d, e, f, g)
+
+swallow7 aa bb cc dd ee ff gg
+ = aa `seq` bb `seq` cc `seq` dd `seq` ee `seq` ff `seq` gg
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         , Box d        <- basicUnsafeIndexM dd i
+         , Box e        <- basicUnsafeIndexM ee i
+         , Box f        <- basicUnsafeIndexM ff i
+         , Box g        <- basicUnsafeIndexM gg i
+         = Just ((a, b, c, d, e, f, g), i + 1)
+{-# INLINE_STREAM swallow7 #-}
+
+
+-- | Swallow eight vectors.
+swallow8
+        :: (Monad m, Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v g, Vector v h)
+        => v a -> v b -> v c -> v d -> v e -> v f -> v g -> v h
+        -> Stream m (a, b, c, d, e, f, g, h)
+
+swallow8 aa bb cc dd ee ff gg hh
+ = aa `seq` bb `seq` cc `seq` dd `seq` ee `seq` ff `seq` gg `seq` hh
+ `seq` n 
+ `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ where  n        = G.length aa
+
+        {-# INLINE_INNER get #-}
+        get i   
+         | Box a        <- basicUnsafeIndexM aa i
+         , Box b        <- basicUnsafeIndexM bb i
+         , Box c        <- basicUnsafeIndexM cc i
+         , Box d        <- basicUnsafeIndexM dd i
+         , Box e        <- basicUnsafeIndexM ee i
+         , Box f        <- basicUnsafeIndexM ff i
+         , Box g        <- basicUnsafeIndexM gg i
+         , Box h        <- basicUnsafeIndexM hh i
+         = Just ((a, b, c, d, e, f, g, h), i + 1)
+{-# INLINE_STREAM swallow8 #-}
+
+
+-- Repeat ---------------------------------------------------------------------
+repeatS :: Monad m => m a -> Stream m a
+repeatS x
+ = Stream step () Unknown
+ where
+        {-# INLINE_INNER step #-}
+        step _
+         = do   v <- x
+                return $ Yield v ()
+{-# INLINE_STREAM repeatS #-}
+
+
+-- | Swallow a whole stream.
+--   Indicates that the consumer knows how many elements to demand.
+swallowS :: Stream m a -> Stream m a
+swallowS s = s
+{-# INLINE [1] swallowS #-}
+
+
+-- If we're swallowing a whole vector created from a stream,
+--  then just swallow the stream directly.
+--  This is similar to the "stream/unstream" rule.
+{-# RULES "swallow/new/unstream"
+    forall s
+    . swallow (new (New.unstream s)) = swallowS s
+  #-}
+
+
+-- If the context knows how many elements to demand, 
+-- then rewrite replicate to repeat, so that the code for the generator 
+-- doesn't need to keep a loop counter for how many elements still need to
+-- be generated.
+{-# RULES "swallowS/replicate"
+    forall len x
+    . swallowS (S.replicateM len x) = repeatS x
+    #-}
index f8a37e3..41ad367 100644 (file)
@@ -32,17 +32,29 @@ Library
         Data.Array.Parallel.Unlifted.Sequential.Combinators
         Data.Array.Parallel.Unlifted.Sequential.Sums
         Data.Array.Parallel.Unlifted.Sequential.Extracts
+        Data.Array.Parallel.Unlifted.Sequential.Locked
         Data.Array.Parallel.Unlifted.Stream.Segmented
         Data.Array.Parallel.Unlifted.Stream.Ixs
         Data.Array.Parallel.Unlifted.Stream.Elems
         Data.Array.Parallel.Unlifted.Stream.Segments
+        Data.Array.Parallel.Unlifted.Stream.Swallow
+        Data.Array.Parallel.Unlifted.Stream.Locked
   
 
   Exposed: False
 
-  Extensions: TypeFamilies, GADTs, RankNTypes,
-              BangPatterns, MagicHash, UnboxedTuples, TypeOperators,
-              NoMonomorphismRestriction
+  Extensions: 
+        TypeFamilies
+        GADTs
+        RankNTypes
+        BangPatterns
+        MagicHash
+        UnboxedTuples
+        TypeOperators
+        NoMonomorphismRestriction
+        PatternGuards
+        FlexibleContexts
+
   GHC-Options:
         -Odph -Wall
         -funbox-strict-fields -fcpr-off
@@ -52,6 +64,12 @@ Library
         random    == 1.0.*,
         vector    == 0.9.*,
         primitive == 0.4.*,
+<<<<<<< HEAD
         ghc-prim  == 0.3.*,
         dph-base  == 0.8.*,
         dph-prim-interface == 0.8.*
+=======
+        ghc-prim  == 0.2.*,
+        dph-base  == 0.6.*,
+        dph-prim-interface == 0.6.*
+>>>>>>> dph-prim-seq: Add lockedZipWiths up to 8
index 30417c1..43ee055 100644 (file)
@@ -20,25 +20,23 @@ lockedZipWith f as bs
 -- Locked Zips ----------------------------------------------------------------
 -- | Zip two vectors of the same length.
 --   If they do not have the same length then the result is undefined.
-lockedZip
-        :: (Vector v a, Vector v b, Vector v (a, b))
+lockedZip    :: (Vector v a, Vector v b, Vector v (a, b))
         => v a -> v b
         -> v (a, b)
 
 lockedZip aa bb
-        = unstream $ lockedStream2 aa bb 
+        = unstream $ stream2 aa bb 
 {-# INLINE lockedZip #-}
 
 
 -- | Zip three vectors of the same length.
 --   If they do not have the same length then the result is undefined.
-lockedZip3
-        :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
+lockedZip3    :: (Vector v a, Vector v b, Vector v c, Vector v (a, b, c))
         => v a -> v b -> v c
         -> v (a, b, c)
 
 lockedZip3 aa bb cc
-        = unstream $ lockedStream3 aa bb cc
+        = unstream $ stream3 aa bb cc
 {-# INLINE lockedZip3 #-}
 
 
index ee84b9b..0ef1c48 100644 (file)
@@ -23,8 +23,7 @@ test2   :: Vector Int
         -> Vector Int
 
 test2 aa bb 
-        = lockedZipWith3 
-                (\x y z -> x + y + z)
+        = map3  (\x y z -> x + y + z)
                 aa 
                 bb
                 (V.replicate (V.length aa) 12345)
index 6698a74..2a14ca9 100644 (file)
@@ -56,61 +56,58 @@ repeatM x
 
 
 -- Locked Streamers -----------------------------------------------------------
-lockedStream2 
-        :: (Monad m, Vector v a, Vector v b)
+stream2 :: (Monad m, Vector v a, Vector v b)
         => v a -> v b
         -> Stream m (a, b)
 
-lockedStream2 aa bb
- = lockedZip2S (G.length aa) (swallow aa) (swallow bb)
-{-# INLINE [1] lockedStream2 #-}
+stream2 aa bb
+ = map2S (G.length aa) (swallow aa) (swallow bb)
+{-# INLINE [1] stream2 #-}
 
 
 -- | Stream three things.
-lockedStream3
-        :: (Monad m, Vector v a, Vector v b, Vector v c)
+stream3 :: (Monad m, Vector v a, Vector v b, Vector v c)
         => v a -> v b -> v c 
         -> Stream m (a, b, c)
 
-lockedStream3 aa bb cc
- = lockedZip3S (G.length aa) (swallow aa) (swallow bb) (swallow cc)
-{-# INLINE [1] lockedStream3 #-}
+stream3 aa bb cc
+ = map3S (G.length aa) (swallow aa) (swallow bb) (swallow cc)
+{-# INLINE [1] stream3 #-}
 
 
-{-# RULES "lockedStream3/new_1"
+{-# RULES "stream3/new_1"
     forall as bs cs
-    . lockedStream3 (G.new as) bs cs
+    . stream3 (G.new as) bs cs
     = S.map (\((b, c), a) -> (a, b, c))
-    $ lockedZip2S (G.length bs) (lockedSwallow2 bs cs) (swallow (G.new as))
+    $ map2S (G.length bs) (swallow2 bs cs) (swallow (G.new as))
   #-}
 
-{-# RULES "lockedStream3/new_2"
+{-# RULES "stream3/new_2"
     forall as bs cs
-    . lockedStream3 as (G.new bs) cs
+    . stream3 as (G.new bs) cs
     = S.map (\((a, c), b) -> (a, b, c))
-    $ lockedZip2S (G.length as) (lockedSwallow2 as cs) (swallow (G.new bs))
+    $ map2S (G.length as) (swallow2 as cs) (swallow (G.new bs))
   #-}
 
-{-# RULES "lockedStream3/new_3"
+{-# RULES "stream3/new_3"
     forall as bs cs
-    . lockedStream3 as bs (G.new cs)
+    . stream3 as bs (G.new cs)
     = S.map (\((a, b), c) -> (a, b, c))
-    $ lockedZip2S (G.length as) (lockedSwallow2 as bs) (swallow (G.new cs))
+    $ map2S (G.length as) (swallow2 as bs) (swallow (G.new cs))
   #-}
 
 
 
 -- Locked Swallowers ---------------------------------------------------------
-
 -- | Swallow two things.
 --   There is no end-of vector check.
 --   The context needs to know how many elements to demand.
-lockedSwallow2 
+swallow2 
         :: (Monad m, Vector v a, Vector v b)
         => v a -> v b 
         -> Stream m (a, b)
 
-lockedSwallow2 aa bb
+swallow2 aa bb
  = aa `seq` bb `seq` n `seq` (S.unfoldr get 0 `S.sized` Unknown)
  where  n        = G.length aa
 
@@ -119,17 +116,16 @@ lockedSwallow2 aa bb
          | Box a        <- basicUnsafeIndexM aa i
          , Box b        <- basicUnsafeIndexM bb i
          = Just ((a, b), i + 1)
-{-# INLINE [1] lockedSwallow2 #-}
+{-# INLINE [1] swallow2 #-}
 
 
--- Locked Stream Zippers -----------------------------------------------------
-lockedZip2S 
-        :: Monad m 
+-- Locked maps ----------------------------------------------------------------
+map2S   :: Monad m 
         => Int
         -> Stream m a -> Stream m b 
         -> Stream m (a, b)
 
-lockedZip2S len
+map2S len
         (Stream mkStep1 sa1 _)
         (Stream mkStep2 sa2 _)
  = Stream step (sa1, sa2, 0) (S.Exact len)
@@ -143,16 +139,16 @@ lockedZip2S len
                           (Yield x1 s1', Yield x2 s2')
                             | i < len   -> Yield (x1, x2) (s1', s2', i + 1)
                           _             -> Done
-{-# INLINE [1] lockedZip2S #-}
+{-# INLINE [1] map2S #-}
 
 
-lockedZip3S 
+map3S 
         :: Monad m 
         => Int
         -> Stream m a -> Stream m b -> Stream m c
         -> Stream m (a, b, c)
 
-lockedZip3S len
+map3S len
         (Stream mkStep1 sa1 _)
         (Stream mkStep2 sa2 _)
         (Stream mkStep3 sa3 _)
@@ -169,5 +165,5 @@ lockedZip3S len
                            | i < len    -> Yield (x1, x2, x3) (s1', s2', s3', i + 1)
 
                           _ -> Done
-{-# INLINE [1] lockedZip3S #-}
+{-# INLINE [1] map3S #-}
 
index dbbd27c..180d758 100644 (file)
@@ -23,24 +23,22 @@ lockedZip3 = G.lockedZip3
 {-# INLINE lockedZip3 #-}
 
 
--- Locked ZipWiths ------------------------------------------------------------
-lockedZipWith2 
-        :: (Unbox a, Unbox b, Unbox c)
+-- Locked Maps ----------------------------------------------------------------
+map2    :: (Unbox a, Unbox b, Unbox c)
         => (a -> b -> c)
         -> Vector a -> Vector b -> Vector c
 
-lockedZipWith2 f aa bb
+map2 f aa bb
         = U.map (\(a, b) -> f a b)
         $ lockedZip aa bb
-{-# INLINE lockedZipWith2 #-}
+{-# INLINE map2 #-}
 
 
-lockedZipWith3
-        :: (Unbox a, Unbox b, Unbox c, Unbox d)
+map3    :: (Unbox a, Unbox b, Unbox c, Unbox d)
         => (a -> b -> c -> d)
         -> Vector a -> Vector b -> Vector c -> Vector d
 
-lockedZipWith3 f aa bb cc
+map3 f aa bb cc
         = U.map (\(a, b, c) -> f a b c)
         $ lockedZip3 aa bb cc
-{-# INLINE lockedZipWith3 #-}
+{-# INLINE map3 #-}