Adapt to new version of the vector library.
authorGeoffrey Mainland <mainland@apeiron.net>
Sun, 28 Oct 2012 18:06:16 +0000 (18:06 +0000)
committerGeoffrey Mainland <mainland@apeiron.net>
Thu, 2 Oct 2014 21:39:02 +0000 (17:39 -0400)
20 files changed:
dph-base/dph-base.cabal
dph-examples/dph-examples.cabal
dph-lifted-base/dph-lifted-base.cabal
dph-lifted-boxed/dph-lifted-boxed.cabal
dph-lifted-copy/dph-lifted-copy.cabal
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple7.hs
dph-lifted-vseg/dph-lifted-vseg.cabal
dph-prim-interface/dph-prim-interface.cabal
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Segmented.hs
dph-prim-par/dph-prim-par.cabal
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Basics.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/USel.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Vector.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Elems.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Ixs.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Locked.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Segmented.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Segments.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Stream/Swallow.hs
dph-prim-seq/dph-prim-seq.cabal

index 89714dd..aec2cd6 100644 (file)
@@ -53,7 +53,7 @@ Library
         ghc-prim == 0.3.*,
         array    == 0.5.*,
         random   == 1.0.*,
-        vector   == 0.10.*,
+        vector   == 0.11.*,
         pretty   == 1.1.*
 
           
index f0dcfa7..95f6c36 100644 (file)
@@ -17,7 +17,7 @@ Synopsis:            Data Parallel Haskell example programs.
 -- Smoke ----------------------------------------------------------------------
 -- examples/smoke/data
 Executable dph-smoke-bool
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
   hs-source-dirs: examples/smoke/data/Bool
@@ -26,7 +26,7 @@ Executable dph-smoke-bool
 
 -- examples/smoke/prims
 Executable dph-smoke-concat
-  build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   main-is:        Main.hs
   other-modules:  Vectorised
   hs-source-dirs: examples/smoke/prims/Concat
@@ -34,7 +34,7 @@ Executable dph-smoke-concat
 
 
 Executable dph-smoke-sumsq
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vector
                   Vectorised
@@ -44,7 +44,7 @@ Executable dph-smoke-sumsq
  
  
 Executable dph-smoke-evens
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vector
                   Vectorised
@@ -55,7 +55,7 @@ Executable dph-smoke-evens
 
 -- examples/smoke/sharing
 Executable dph-smoke-indices
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised Vector
   hs-source-dirs: examples/smoke/sharing/Indices lib
@@ -63,7 +63,7 @@ Executable dph-smoke-indices
  
  
 Executable dph-smoke-rank
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised Util Timing Randomish
   hs-source-dirs: examples/smoke/sharing/Rank lib
@@ -71,7 +71,7 @@ Executable dph-smoke-rank
 
 
 Executable dph-smoke-reverse
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised Vector Randomish
   hs-source-dirs: examples/smoke/sharing/Reverse lib
@@ -80,14 +80,14 @@ Executable dph-smoke-reverse
 
 -- Imaginary ------------------------------------------------------------------
 -- Executable dph-imaginary-primes
---   Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+--   Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
 --   Main-is:        Main.hs
 --   other-modules:  Vectorised
 --   hs-source-dirs: examples/imaginary/Primes lib
 --   ghc-options:    -eventlog -rtsopts -threaded -fllvm -optlo-O3 -Odph -package dph-lifted-vseg -fcpr-off -fsimpl-tick-factor=1000
 
 Executable dph-imaginary-stringsearch
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
                   Vector
@@ -96,7 +96,7 @@ Executable dph-imaginary-stringsearch
   ghc-options:    -eventlog -rtsopts -threaded -fllvm -optlo-O3 -Odph -package dph-lifted-vseg -fcpr-off -fsimpl-tick-factor=1000
 
 Executable dph-imaginads
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
   hs-source-dirs: examples/imaginary/Words lib
@@ -105,7 +105,7 @@ Executable dph-imaginads
 
 -- Spectral -------------------------------------------------------------------
 Executable dph-spectral-closestpairs
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vector
                   Vector1
@@ -116,7 +116,7 @@ Executable dph-spectral-closestpairs
   ghc-options:    -eventlog -rtsopts -threaded -fllvm -optlo-O3 -Odph -package dph-lifted-vseg -fcpr-off -fsimpl-tick-factor=1000
 
 Executable dph-spectral-dotp
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vector
                   Vectorised
@@ -126,7 +126,7 @@ Executable dph-spectral-dotp
 
 
 -- Executable dph-spectral-smvm
---   Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, repa-flow == 3.2.*
+--   Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, repa-flow == 3.2.*
 --   Main-is:        Main.hs
 --   other-modules:  Vectorised
 --                   Vector
@@ -136,7 +136,7 @@ Executable dph-spectral-dotp
 
 
 Executable dph-spectral-quickhull
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
                   Timing Points2D.Types SVG
@@ -145,7 +145,7 @@ Executable dph-spectral-quickhull
 
 
 Executable dph-spectral-quickhull-vector
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  QuickHullIO
                   QuickHullSplit
@@ -156,7 +156,7 @@ Executable dph-spectral-quickhull-vector
 
 
 -- Executable dph-spectral-quickhull-handvec
---   Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, dph-lifted-copy
+--   Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, dph-lifted-copy
 --   Main-is:        Main.hs
 --   other-modules:  Handvec
 --                   HandvecWrp
@@ -166,7 +166,7 @@ Executable dph-spectral-quickhull-vector
 
 
 Executable dph-spectral-quicksort
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
                   Timing
@@ -175,7 +175,7 @@ Executable dph-spectral-quicksort
 
 
 Executable dph-spectral-quickselect
-  Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+  Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
   Main-is:        Main.hs
   other-modules:  Vectorised
                   Vector
@@ -195,7 +195,7 @@ Executable dph-spectral-quickselect
 --                     Timing Points2D.Types Points2D.Generate
 --                     System.Console.ParseArgs
 --                     Gloss.MainArgs Gloss.Draw Gloss.Config
---    Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, gloss == 1.6.*
+--    Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*, gloss == 1.6.*
 --    hs-source-dirs: examples/real/NBody examples/real/NBody/Gloss lib
 --    ghc-options:    -eventlog -rtsopts -threaded -fllvm -optlo-O3 -Odph -package dph-lifted-vseg -fcpr-off -fsimpl-tick-factor=1000
 
@@ -208,7 +208,7 @@ Executable dph-real-nbody
                            Solver.VectorNaive.Solver
                     Timing Points2D.Types Points2D.Generate
                     Batch.MainArgs Batch.Config
-    Build-depends:  base == 4.7.*, vector == 0.10.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
+    Build-depends:  base == 4.7.*, vector == 0.11.*, random == 1.0.*, old-time == 1.1.*, containers == 0.5.*, dph-base == 0.8.*, dph-prim-par == 0.8.*, dph-lifted-vseg == 0.8.*, HUnit == 1.2.*
     hs-source-dirs: examples/real/NBody examples/real/NBody/Batch lib
     ghc-options:    -eventlog -rtsopts -threaded -fllvm -optlo-O3 -Odph -package dph-lifted-vseg -fcpr-off -fsimpl-tick-factor=1000
 
index 591b4be..0927430 100644 (file)
@@ -60,6 +60,6 @@ Library
         template-haskell        == 2.10.*,
         dph-base                == 0.8.*,
         dph-prim-par            == 0.8.*,
-        vector                  == 0.10.*,
+        vector                  == 0.11.*,
         pretty                  == 1.1.*,
         containers              == 0.5.*
index b33f540..49d2d6d 100644 (file)
@@ -64,7 +64,7 @@ Library
         ghc              == 7.*,
         array            == 0.5.*,
         pretty           == 1.1.*,
-        vector           == 0.10.*,
+        vector           == 0.11.*,
         containers       == 0.5.*,
         dph-base         == 0.8.*,
         dph-prim-par     == 0.8.*
index fbda5a3..c87e41d 100644 (file)
@@ -69,4 +69,4 @@ Library
         template-haskell == 2.10.*,
         dph-base         == 0.8.*,
         dph-prim-par     == 0.8.*,
-        vector           == 0.10.*
+        vector           == 0.11.*
index fb4d1ee..19d0bad 100644 (file)
@@ -20,9 +20,10 @@ import qualified Data.List                      as P
 -- The following are only imported for zip7,
 -- remove once that's where it's supposed to be
 import qualified Data.Vector as DV
-import qualified Data.Vector.Fusion.Stream.Monadic  as MS 
+import qualified Data.Vector.Fusion.Bundle.Monadic  as MB
+import qualified Data.Vector.Fusion.Stream.Monadic  as MS
 import qualified Data.Vector.Generic                as G
-import Data.Vector.Fusion.Stream (inplace)
+import Data.Vector.Fusion.Bundle (inplace)
 
 -------------------------------------------------------------------------------
 data instance PData (a, b, c, d, e, f, g)
@@ -399,8 +400,8 @@ instance ( PR a, PR b, PR c, PR d, PR e, PR f, PR g, Show a, Show b, Show c, Sho
 -- should be in Data.Vector
 
 zipWith7MS :: Monad m => (a -> b -> c -> d -> e -> f -> g -> h)
-                    -> MS.Stream m a -> MS.Stream m b -> MS.Stream m c -> MS.Stream m d
-                    -> MS.Stream m e -> MS.Stream m f -> MS.Stream m g -> MS.Stream m h
+                    -> MB.Bundle m v a -> MB.Bundle m v b -> MB.Bundle m v c -> MB.Bundle m v d
+                    -> MB.Bundle m v e -> MB.Bundle m v f -> MB.Bundle m v g -> MB.Bundle m v h
 {-# INLINE zipWith7MS #-}
 zipWith7MS fn = zipWith7M (\a b c d e f g -> return (fn a b c d e f g))
 
@@ -440,27 +441,27 @@ unzip7Generic xs =
     -- | /O(n)/ Map a function over a vector
     mapG :: (G.Vector v a, G.Vector v b) => (a -> b) -> v a -> v b
     {-# INLINE mapG #-}
-    mapG f = G.unstream . inplace (MS.map f) . G.stream
+    mapG f = G.unstream . inplace (MS.map f) id . G.stream
 
 zipWith7M :: Monad m => (a -> b -> c -> d -> e -> f -> g -> m h)
-                     -> MS.Stream m a -> MS.Stream m b -> MS.Stream m c -> MS.Stream m d
-                     -> MS.Stream m e -> MS.Stream m f -> MS.Stream m g -> MS.Stream m h
+                     -> MB.Bundle m v a -> MB.Bundle m v b -> MB.Bundle m v c -> MB.Bundle m v d
+                     -> MB.Bundle m v e -> MB.Bundle m v f -> MB.Bundle m v g -> MB.Bundle m v h
 {-# INLINE zipWith7M #-}
 zipWith7M fn sa sb sc sd se sf sg
-  = MS.zipWithM (\(a,b,c) (d,e,(f, g)) -> fn a b c d e f g) (MS.zip3 sa sb sc)
-                                                  (MS.zip3 sd se (MS.zip sf sg))
+  = MB.zipWithM (\(a,b,c) (d,e,(f, g)) -> fn a b c d e f g) (MB.zip3 sa sb sc)
+                                                  (MB.zip3 sd se (MB.zip sf sg))
 
 {-}                                                  
 zipWith7Monad :: Monad m => (a -> b -> c -> d -> e -> f -> g -> h)
-                    -> MS.Stream m a -> MS.Stream m b -> MS.Stream m c -> MS.Stream m d
-                    -> MS.Stream m e -> MS.Stream m f -> MS.Stream m g -> MS.Stream m h
+                    -> MB.Bundle m a -> MB.Bundle m b -> MB.Bundle m c -> MB.Bundle m d
+                    -> MB.Bundle m e -> MB.Bundle m f -> MB.Bundle m g -> MB.Bundle m h
 {-# INLINE zipWith7Monad #-}
 zipWith7Monad fn = zipWith7M (\a b c d e f g -> return (fn a b c d e f g))
 
 
 
-zip7Monad :: Monad m => MS.Stream m a -> MS.Stream m b -> MS.Stream m c -> MS.Stream m d
-                -> MS.Stream m e -> MS.Stream m f -> MS.Stream m g -> MS.Stream m (a,b,c,d,e,f,g)
+zip7Monad :: Monad m => MB.Bundle m a -> MB.Bundle m b -> MB.Bundle m c -> MB.Bundle m d
+                -> MB.Bundle m e -> MB.Bundle m f -> MB.Bundle m g -> MB.Bundle m (a,b,c,d,e,f,g)
 {-# INLINE zip7Monad #-}
 zip7Monad = zipWith7Monad (,,,,,,)
 -}
index 3657890..37f9c6c 100644 (file)
@@ -101,6 +101,7 @@ Library
         dph-base                == 0.8.*,
         dph-prim-par            == 0.8.*,
         dph-lifted-base         == 0.8.*,
-        vector                  == 0.10.*,
+        vector                  == 0.11.*,
         pretty                  == 1.1.*,
+        primitive               == 0.5.*,
         containers              == 0.5.*
index 25b644e..156a1b1 100644 (file)
@@ -37,5 +37,5 @@ Library
         base     == 4.7.*,
         random   == 1.0.*,
         dph-base == 0.8.*,
-        vector   == 0.10.*
+        vector   == 0.11.*
 
index b8b0a60..e3e03f0 100644 (file)
@@ -23,9 +23,10 @@ import qualified Data.Array.Parallel.Unlifted.Sequential.USegd          as USegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd         as USSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPVSegd          as UPVSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSSegd          as UPSSegd
+import Data.Vector.Fusion.Bundle.Monadic ( Bundle(..), fromStream )
 import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..) )
-import Data.Vector.Fusion.Stream.Size    ( Size(..) )
-import qualified Data.Vector.Fusion.Stream                              as S
+import Data.Vector.Fusion.Bundle.Size    ( Size(..) )
+import qualified Data.Vector.Fusion.Bundle                              as S
 
 import GHC.Exts -- for unboxed primops
 import GHC.Base ( isTrue# )
@@ -82,10 +83,10 @@ appendSegS
         -> Int          -- ^ How many elements to return
         -> Int          -- ^ Segment offset
         -> Int          -- ^ Element offset
-        -> S.Stream a
+        -> S.Bundle v a
 
 appendSegS !xd !xs !yd !ys !n seg_off el_off
-  = Stream next state (Exact n)
+  = fromStream (Stream next state) (Exact n)
   where
     !xlens = USegd.takeLengths xd
     !ylens = USegd.takeLengths yd
@@ -212,10 +213,10 @@ appendUPVSegS
         -> Int              -- ^ How many elements to return
         -> Int              -- ^ Segment offset
         -> Int              -- ^ Element offset
-        -> S.Stream a
+        -> S.Bundle v a
 
 appendUPVSegS !xd !xs !yd !ys !n seg_off el_off
-  = Stream next state (Exact n)
+  = fromStream (Stream next state) (Exact n)
   where
     !xvsegs= UPVSegd.takeVSegidsRedundant xd
     !yvsegs= UPVSegd.takeVSegidsRedundant yd
@@ -401,10 +402,10 @@ appendSegS_old
         -> Int
         -> Int
         -> Int
-        -> S.Stream a
+        -> S.Bundle v a
 
 appendSegS_old !xd !xs !yd !ys !n seg_off el_off
-  = Stream next state (Exact n)
+  = fromStream (Stream next state) (Exact n)
   where
     !xlens = USegd.takeLengths xd
     !ylens = USegd.takeLengths yd
index d9c67d3..27ffa3a 100644 (file)
@@ -77,8 +77,9 @@ Library
   Build-Depends:  
         base               == 4.7.*,
         random             == 1.0.*,
-        vector             == 0.10.*,
+        vector             == 0.11.*,
         old-time           == 1.1.*,
+        primitive          == 0.5.*,
         dph-base           == 0.8.*,
         dph-prim-interface == 0.8.*,
         dph-prim-seq       == 0.8.*
index bc396b6..3077084 100644 (file)
@@ -11,7 +11,7 @@ import Data.Array.Parallel.Unlifted.Stream
 import Data.Array.Parallel.Unlifted.Sequential.Vector
 import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd)
 import qualified Data.Array.Parallel.Unlifted.Sequential.USegd  as USegd
-import qualified Data.Vector.Fusion.Stream as S
+import qualified Data.Vector.Fusion.Bundle as S
 
 
 -- | Segmented replicate of a vector based on the lengths of the segments
index e35be93..622fc6d 100644 (file)
@@ -17,8 +17,10 @@ module Data.Array.Parallel.Unlifted.Sequential.USel
         , tagsToIndices2)
 where
 import Data.Array.Parallel.Unlifted.Sequential.Vector   as V
-import qualified Data.Vector.Fusion.Stream              as S
+import qualified Data.Vector.Fusion.Bundle              as S
+import qualified Data.Vector.Fusion.Bundle.Monadic      as M
 import Data.Vector.Fusion.Stream.Monadic                ( Stream(..) )
+import Data.Vector.Fusion.Bundle.Monadic                ( Bundle(..) )
 import Data.Array.Parallel.Base                         (Tag)
 
 
@@ -86,9 +88,9 @@ tagsToIndices2 tags
 {-# INLINE_STREAM tagsToIndices2 #-}
 
 
-mapAccumS :: (acc -> a -> (acc,b)) -> acc -> S.Stream a -> S.Stream b
-mapAccumS f acc0 (Stream step s0 n)
-  = Stream step' (acc0,s0) n
+mapAccumS :: (acc -> a -> (acc,b)) -> acc -> S.Bundle v a -> S.Bundle v b
+mapAccumS f acc0 (Bundle{sElems=Stream step s0,sSize=n})
+  = M.fromStream (Stream step' (acc0,s0)) n
   where
    {-# INLINE_INNER step' #-}
    step' (acc,s) 
index 20b6170..4881236 100644 (file)
@@ -97,19 +97,20 @@ module Data.Array.Parallel.Unlifted.Sequential.Vector (
 where
 import Data.Array.Parallel.Unlifted.Stream.Segmented
 import Data.Array.Parallel.Base ( Tag, checkEq, ST )
-import qualified Data.Array.Parallel.Base       as B
-import qualified Data.Vector.Unboxed            as V
-import qualified Data.Vector.Unboxed.Mutable    as M
-import qualified Data.Vector.Unboxed.Base       as VBase
-import qualified Data.Vector.Generic            as G
-import qualified Data.Vector.Generic.Mutable    as MG
-import qualified Data.Vector.Storable           as Storable
-import qualified Data.Vector.Storable.Mutable   as MStorable
-import qualified Data.Vector.Generic.New        as New
-import qualified Data.Vector.Fusion.Stream      as S
-import Data.Vector.Fusion.Stream.Monadic        ( Stream(..), Step(..) )
-import Data.Vector.Fusion.Stream.Size           ( Size(..) )
-import Data.Vector.Generic                      ( stream, unstream )
+import qualified Data.Array.Parallel.Base          as B
+import qualified Data.Vector.Unboxed               as V
+import qualified Data.Vector.Unboxed.Mutable       as M
+import qualified Data.Vector.Unboxed.Base          as VBase
+import qualified Data.Vector.Generic               as G
+import qualified Data.Vector.Generic.Mutable       as MG
+import qualified Data.Vector.Storable              as Storable
+import qualified Data.Vector.Storable.Mutable      as MStorable
+import qualified Data.Vector.Generic.New           as New
+import qualified Data.Vector.Fusion.Bundle         as S
+import qualified Data.Vector.Fusion.Bundle.Monadic as SM
+import Data.Vector.Fusion.Stream.Monadic           ( Stream(..), Step(..) )
+import Data.Vector.Fusion.Bundle.Size              ( Size(..) )
+import Data.Vector.Generic                         ( stream, unstream )
 
 import Data.Vector.Unboxed 
         hiding ( slice, zip, unzip, zip3, unzip3, foldl, foldl1, scanl, scanl1,
@@ -170,9 +171,9 @@ repeat n xs = unstream (repeatS n xs)
 {-# INLINE_U repeat #-}
 
 
-repeatS :: Unbox e => Int -> Vector e -> S.Stream e
+repeatS :: Unbox e => Int -> Vector e -> S.Bundle v e
 {-# INLINE_STREAM repeatS #-}
-repeatS k !xs = Stream next (0,k) (Exact (k*n))
+repeatS k !xs = SM.fromStream (Stream next (0,k)) (Exact (k*n))
   where
     !n = length xs
 
@@ -250,13 +251,13 @@ mbpermute f es is
 {-# INLINE_STREAM mbpermute #-}
 
 
-bpermuteS :: Unbox e => Vector e -> S.Stream Int -> S.Stream e
+bpermuteS :: Unbox e => Vector e -> S.Bundle v Int -> S.Bundle v e
 bpermuteS !a s 
         = S.map (a!) s
 {-# INLINE_STREAM bpermuteS #-}
 
 
-mbpermuteS:: Unbox e => (e -> d) -> Vector e -> S.Stream Int -> S.Stream d
+mbpermuteS:: Unbox e => (e -> d) -> Vector e -> S.Bundle v Int -> S.Bundle v d
 mbpermuteS f !a 
         = S.map (f . (a!))
 {-# INLINE_STREAM mbpermuteS #-}
@@ -452,9 +453,9 @@ randomR n r = unstream . randomRS n r
 {-# INLINE_U randomR #-}
 
 
-randomS :: (R.RandomGen g, R.Random a) => Int -> g -> S.Stream a
+randomS :: (R.RandomGen g, R.Random a) => Int -> g -> S.Bundle v a
 randomS n g 
-  = Stream step (g,n) (Exact n)
+  = SM.fromStream (Stream step (g,n)) (Exact n)
   where
     {-# INLINE step #-}
     step (g,0) = return Done
@@ -463,9 +464,9 @@ randomS n g
 {-# INLINE_STREAM randomS #-}
 
 
-randomRS :: (R.RandomGen g, R.Random a) => Int -> (a,a) -> g -> S.Stream a
-randomRS n r g 
-  = Stream step (g,n) (Exact n)
+randomRS :: (R.RandomGen g, R.Random a) => Int -> (a,a) -> g -> S.Bundle v a
+randomRS n r g
+  = SM.fromStream (Stream step (g,n)) (Exact n)
   where
     {-# INLINE step #-}
     step (g,0) = return Done
index c69a0ad..7695c3b 100644 (file)
@@ -6,7 +6,8 @@ module Data.Array.Parallel.Unlifted.Stream.Elems
         , streamElemsFromVectorsVSegd)
 where
 import Data.Array.Parallel.Unlifted.Stream.Ixs
-import Data.Vector.Fusion.Stream.Monadic
+import Data.Vector.Fusion.Bundle.Monadic                         (Bundle(..), fromStream)
+import Data.Vector.Fusion.Stream.Monadic                         (Stream(..), Step(..))
 import Data.Array.Parallel.Unlifted.Sequential.Vector            (Unbox, Vector)
 import Data.Array.Parallel.Unlifted.Vectors                      (Unboxes, Vectors)
 import Data.Array.Parallel.Unlifted.Sequential.UVSegd            (UVSegd(..))
@@ -19,10 +20,10 @@ import qualified Data.Array.Parallel.Unlifted.Sequential.UVSegd  as UVSegd
 --    and produce a stream of elements.
 streamElemsFromVector
         :: (Monad m, Unbox a)
-        => Vector a -> Stream m Int -> Stream m a
+        => Vector a -> Bundle m v Int -> Bundle m v a
 
-streamElemsFromVector vector (Stream mkStep s0 size0)
- = vector `seq` Stream mkStep' s0 size0
+streamElemsFromVector vector Bundle{sElems=Stream mkStep s0,sSize=size0}
+ = vector `seq` fromStream (Stream mkStep' s0) size0
  where
         {-# INLINE_INNER mkStep' #-}
         mkStep' s
@@ -42,10 +43,10 @@ streamElemsFromVector vector (Stream mkStep s0 size0)
 --    and produce a stream of elements.
 streamElemsFromVectors 
         :: (Monad m, Unboxes a) 
-        => Vectors a -> Stream m (Int, Int) -> Stream m a
+        => Vectors a -> Bundle m v (Int, Int) -> Bundle m v a
 
-streamElemsFromVectors vectors (Stream mkStep s0 size0)
- = vectors `seq` Stream mkStep' s0 size0
+streamElemsFromVectors vectors Bundle{sElems=Stream mkStep s0,sSize=size0}
+ = vectors `seq` fromStream (Stream mkStep' s0) size0
   where
         {-# INLINE_INNER mkStep' #-}
         mkStep' s
@@ -65,7 +66,7 @@ streamElemsFromVectors vectors (Stream mkStep s0 size0)
 --   and produce a stream of elements.
 streamElemsFromVectorsVSegd
         :: (Monad m, Unboxes a)
-        => Vectors a -> UVSegd -> Stream m (Int, Int) -> Stream m a
+        => Vectors a -> UVSegd -> Bundle m v (Int, Int) -> Bundle m v a
 
 streamElemsFromVectorsVSegd vectors uvsegd vsrcixs
  = let  -- Because we're just doing indexing here, we don't need the culled
index 5ef7182..c169c46 100644 (file)
@@ -4,7 +4,8 @@ module Data.Array.Parallel.Unlifted.Stream.Ixs
         ( streamSrcIxsThroughVSegids
         , streamSrcIxsThroughUSSegd)
 where
-import Data.Vector.Fusion.Stream.Monadic
+import Data.Vector.Fusion.Bundle.Monadic                         (Bundle(..), fromStream)
+import Data.Vector.Fusion.Stream.Monadic                         (Stream(..), Step(..))
 import Data.Array.Parallel.Unlifted.Sequential.USSegd            (USSegd(..))
 import qualified Data.Array.Parallel.Unlifted.Sequential.USSegd  as USSegd
 import qualified Data.Vector.Unboxed                             as U
@@ -15,10 +16,10 @@ import qualified Data.Vector.Unboxed                             as U
 --   and convert it to a stream of physical segment and segment element indices.
 streamSrcIxsThroughVSegids
         :: Monad m
-        => U.Vector Int -> Stream m (Int, Int) -> Stream m (Int, Int)
+        => U.Vector Int -> Bundle m v (Int, Int) -> Bundle m v (Int, Int)
 
-streamSrcIxsThroughVSegids vsegids (Stream mkStep s0 size0)
- = vsegids `seq` Stream mkStep' s0 size0
+streamSrcIxsThroughVSegids vsegids Bundle{sElems=Stream mkStep s0,sSize=size0}
+ = vsegids `seq` fromStream (Stream mkStep' s0) size0
  where
         {-# INLINE_INNER mkStep' #-}
         mkStep' s
@@ -38,10 +39,10 @@ streamSrcIxsThroughVSegids vsegids (Stream mkStep s0 size0)
 --   and convert it to a stream of chunk and chunk element indices.
 streamSrcIxsThroughUSSegd 
         :: Monad m
-        => USSegd -> Stream m (Int, Int) -> Stream m (Int, Int)
+        => USSegd -> Bundle m v (Int, Int) -> Bundle m v (Int, Int)
         
-streamSrcIxsThroughUSSegd ussegd (Stream mkStep s0 size0)
- = ussegd `seq` Stream mkStep' s0 size0
+streamSrcIxsThroughUSSegd ussegd Bundle{sElems=Stream mkStep s0,sSize=size0}
+ = ussegd `seq` fromStream(Stream  mkStep' s0) size0
  where
         !sources = USSegd.takeSources ussegd
         !starts  = USSegd.takeStarts  ussegd
index 5ef87f3..0d67d70 100644 (file)
@@ -20,7 +20,8 @@ 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
+import Data.Vector.Fusion.Bundle.Monadic as B
+import Data.Vector.Fusion.Bundle.Size    as S
 
 
 -------------------------------------------
@@ -32,7 +33,7 @@ import Data.Vector.Fusion.Stream.Size    as S
 --
 stream2 :: (Monad m, Vector v a, Vector v b)
         => v a -> v b
-        -> Stream m (a, b)
+        -> Bundle m v (a, b)
 
 stream2 aa bb
  = lockedZip2S (G.length aa) (swallow aa) (swallow bb)
@@ -43,7 +44,7 @@ stream2 aa bb
 -- | 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)
+        -> Bundle m v (a, b, c)
 
 stream3 aa bb cc
  = lockedZip3S (G.length aa) (swallow aa) (swallow bb) (swallow cc)
@@ -58,21 +59,21 @@ stream3 aa bb cc
 {-# RULES "stream3/new_1"
     forall as bs cs
     . stream3 (G.new as) bs cs
-    = S.map (\((b, c), a) -> (a, b, c))
+    = B.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))
+    = B.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))
+    = B.map (\((a, b), c) -> (a, b, c))
     $ lockedZip2S (G.length as) (swallow2 as bs) (swallow (G.new cs))
   #-}
 
@@ -81,7 +82,7 @@ stream3 aa bb cc
 -- | 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)
+        -> Bundle m v (a, b, c, d)
 
 stream4 aa bb cc dd
  = lockedZip4S (G.length aa) 
@@ -91,28 +92,28 @@ stream4 aa bb cc dd
 {-# 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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.map (\((a, b, c), d) -> (a, b, c, d))
     $ lockedZip2S (G.length as) (swallow3 as bs cs) (swallow (G.new ds))
   #-}
 
@@ -121,7 +122,7 @@ stream4 aa bb cc dd
 -- | 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)
+        -> Bundle m v (a, b, c, d, e)
 
 stream5 aa bb cc dd ee
  = lockedZip5S (G.length aa) 
@@ -132,35 +133,35 @@ stream5 aa bb cc dd ee
 {-# 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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.map (\((a, b, c, d), e) -> (a, b, c, d, e))
     $ lockedZip2S (G.length as) (swallow4 as bs cs ds) (swallow (G.new es))
   #-}
 
@@ -169,7 +170,7 @@ stream5 aa bb cc dd ee
 -- | 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)
+        -> Bundle m v (a, b, c, d, e, f)
 
 stream6 aa bb cc dd ee ff
  = lockedZip6S (G.length aa) 
@@ -180,42 +181,42 @@ stream6 aa bb cc dd ee ff
 {-# 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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
   #-}
 
@@ -224,7 +225,7 @@ stream6 aa bb cc dd ee ff
 -- | 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)
+        -> Bundle m v (a, b, c, d, e, f, g)
 
 stream7 aa bb cc dd ee ff gg
  = lockedZip7S (G.length aa) 
@@ -235,49 +236,49 @@ stream7 aa bb cc dd ee ff gg
 {-# 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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
   #-}
 
@@ -286,7 +287,7 @@ stream7 aa bb cc dd ee ff gg
 -- | 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)
+        -> Bundle m v (a, b, c, d, e, f, g, h)
 
 stream8 aa bb cc dd ee ff gg hh
  = lockedZip8S (G.length aa) 
@@ -297,56 +298,56 @@ stream8 aa bb cc dd ee ff gg hh
 {-# 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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
+    = B.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))
   #-}
 
@@ -358,13 +359,13 @@ stream8 aa bb cc dd ee ff gg hh
 lockedZip2S
         :: Monad m 
         => Int
-        -> Stream m a -> Stream m b 
-        -> Stream m (a, b)
+        -> Bundle m v a -> Bundle m v b 
+        -> Bundle m v (a, b)
 
 lockedZip2S len
-        (Stream mkStep1 sa1 _)
-        (Stream mkStep2 sa2 _)
- = Stream step (sa1, sa2, 0) (S.Exact len)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+ = B.fromStream (Stream step (sa1, sa2, 0)) (S.Exact len)
  where 
         {-# INLINE_INNER step #-}
         step (s1, s2, i)
@@ -383,14 +384,14 @@ lockedZip2S len
 lockedZip3S
         :: Monad m 
         => Int
-        -> Stream m a -> Stream m b -> Stream m c
-        -> Stream m (a, b, c)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c
+        -> Bundle m v (a, b, c)
 
 lockedZip3S len
-        (Stream mkStep1 sa1 _)
-        (Stream mkStep2 sa2 _)
-        (Stream mkStep3 sa3 _)
- = Stream step (sa1, sa2, sa3, 0) (S.Exact len)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+ = B.fromStream (Stream step (sa1, sa2, sa3, 0)) (S.Exact len)
  where 
         {-# INLINE_INNER step #-}
         step (s1, s2, s3, i)
@@ -411,15 +412,15 @@ lockedZip3S len
 lockedZip4S
         :: Monad m 
         => Int
-        -> Stream m a -> Stream m b -> Stream m c -> Stream m d
-        -> Stream m (a, b, c, d)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d
+        -> Bundle m v (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)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+        (Bundle {sElems=Stream mkStep4 sa4})
+ = B.fromStream (Stream step (sa1, sa2, sa3, sa4, 0)) (S.Exact len)
  where 
         {-# INLINE_INNER step #-}
         step (s1, s2, s3, s4, i)
@@ -441,16 +442,16 @@ lockedZip4S len
 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)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d -> Bundle m v e
+        -> Bundle m v (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)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+        (Bundle {sElems=Stream mkStep4 sa4})
+        (Bundle {sElems=Stream mkStep5 sa5})
+ = B.fromStream (Stream step (sa1, sa2, sa3, sa4, sa5, 0)) (S.Exact len)
  where 
         {-# INLINE_INNER step #-}
         step (s1, s2, s3, s4, s5, i)
@@ -473,17 +474,17 @@ lockedZip5S len
 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)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d -> Bundle m v e -> Bundle m v f
+        -> Bundle m v (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)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+        (Bundle {sElems=Stream mkStep4 sa4})
+        (Bundle {sElems=Stream mkStep5 sa5})
+        (Bundle {sElems=Stream mkStep6 sa6})
+ = B.fromStream (Stream step (sa1, sa2, sa3, sa4, sa5, sa6, 0)) (S.Exact len)
  where 
         {-# INLINE_INNER step #-}
         step (s1, s2, s3, s4, s5, s6, i)
@@ -507,18 +508,18 @@ lockedZip6S len
 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)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d -> Bundle m v e -> Bundle m v f -> Bundle m v g
+        -> Bundle m v (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)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+        (Bundle {sElems=Stream mkStep4 sa4})
+        (Bundle {sElems=Stream mkStep5 sa5})
+        (Bundle {sElems=Stream mkStep6 sa6})
+        (Bundle {sElems=Stream mkStep7 sa7})
+ = B.fromStream (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)
@@ -543,19 +544,19 @@ lockedZip7S len
 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)
+        -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d -> Bundle m v e -> Bundle m v f -> Bundle m v g -> Bundle m v h
+        -> Bundle m v (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)
+        (Bundle {sElems=Stream mkStep1 sa1})
+        (Bundle {sElems=Stream mkStep2 sa2})
+        (Bundle {sElems=Stream mkStep3 sa3})
+        (Bundle {sElems=Stream mkStep4 sa4})
+        (Bundle {sElems=Stream mkStep5 sa5})
+        (Bundle {sElems=Stream mkStep6 sa6})
+        (Bundle {sElems=Stream mkStep7 sa7})
+        (Bundle {sElems=Stream mkStep8 sa8})
+ = B.fromStream (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)
index 383d8fa..fdf1f3f 100644 (file)
@@ -28,10 +28,12 @@ module Data.Array.Parallel.Unlifted.Stream.Segmented
         , appendSS
         , indicesSS)
 where
-import Data.Array.Parallel.Base                 (Tag)
-import qualified Data.Vector.Fusion.Stream      as S
-import Data.Vector.Fusion.Stream.Monadic        (Stream(..), Step(..))
-import Data.Vector.Fusion.Stream.Size           (Size(..))
+import Data.Array.Parallel.Base                    (Tag)
+import qualified Data.Vector.Fusion.Bundle         as B
+import qualified Data.Vector.Fusion.Bundle.Monadic as M
+import Data.Vector.Fusion.Bundle.Monadic           (Bundle(..))
+import Data.Vector.Fusion.Stream.Monadic           (Stream(..), Step(..))
+import Data.Vector.Fusion.Bundle.Size              (Size(..))
 
 
 -- Indexed --------------------------------------------------------------------
@@ -41,9 +43,10 @@ import Data.Vector.Fusion.Stream.Size           (Size(..))
 -- indexed [42,93,13]
 --  = [(0,42), (1,93), (2,13)]
 -- @
-indexedS :: S.Stream a -> S.Stream (Int,a)
+indexedS :: B.Bundle v a -> B.Bundle v (Int,a)
 {-# INLINE_STREAM indexedS #-}
-indexedS (Stream next s n) = Stream next' (0,s) n
+indexedS Bundle{sElems=Stream next s,sSize=n} =
+    M.fromStream (Stream next' (0,s)) n
   where
     {-# INLINE_INNER next' #-}
     next' (i,s) = do
@@ -64,10 +67,10 @@ indexedS (Stream next s n) = Stream next' (0,s) n
 -- replicateEach 10 [(2,10), (5,20), (3,30)]
 --   = [10,10,20,20,20,20,20,30,30,30]
 -- @
-replicateEachS :: Int -> S.Stream (Int,a) -> S.Stream a
+replicateEachS :: Int -> B.Bundle v (Int,a) -> B.Bundle v a
 {-# INLINE_STREAM replicateEachS #-}
-replicateEachS n (Stream next s _) =
-  Stream next' (0,Nothing,s) (Exact n)
+replicateEachS n Bundle{sElems=Stream next s} =
+  M.fromStream (Stream next' (0,Nothing,s)) (Exact n)
   where
     {-# INLINE next' #-}
     next' (0, _, s) =
@@ -88,10 +91,10 @@ replicateEachS n (Stream next s _) =
 --  = [10,10,20,20,30,30]
 -- @
 --
-replicateEachRS :: Int -> S.Stream a -> S.Stream a
+replicateEachRS :: Int -> B.Bundle v a -> B.Bundle v a
 {-# INLINE_STREAM replicateEachRS #-}
-replicateEachRS !n (Stream next s sz)
-  = Stream next' (0,Nothing,s) (sz `multSize` n)
+replicateEachRS !n Bundle{sElems=Stream next s,sSize=sz}
+  = M.fromStream (Stream next' (0,Nothing,s)) (sz `multSize` n)
   where
     next' (0,_,s) =
       do
@@ -121,10 +124,11 @@ multSize Unknown   _ = Unknown
 -- interleave [2,3,4] [10,20]    = [2,10,3,20,4]
 -- @
 --
-interleaveS :: S.Stream a -> S.Stream a -> S.Stream a
+interleaveS :: B.Bundle v a -> B.Bundle v a -> B.Bundle v a
 {-# INLINE_STREAM interleaveS #-}
-interleaveS (Stream next1 s1 n1) (Stream next2 s2 n2)
-  = Stream next (False,s1,s2) (n1+n2)
+interleaveS (Bundle{sElems=Stream next1 s1,sSize=n1})
+            (Bundle{sElems=Stream next2 s2,sSize=n2})
+  = M.fromStream (Stream next (False,s1,s2)) (n1+n2)
   where
     {-# INLINE next #-}
     next (False,s1,s2) =
@@ -156,11 +160,12 @@ interleaveS (Stream next1 s1 n1) (Stream next2 s2 n2)
 --  = [1,4,5,2,3,6]
 -- @
 --
-combine2ByTagS :: S.Stream Tag -> S.Stream a -> S.Stream a -> S.Stream a
+combine2ByTagS :: B.Bundle v Tag -> B.Bundle v a -> B.Bundle v a -> B.Bundle v a
 {-# INLINE_STREAM combine2ByTagS #-}
-combine2ByTagS (Stream next_tag s m) (Stream next0 s0 _)
-                                     (Stream next1 s1 _)
-  = Stream next (Nothing,s,s0,s1) m
+combine2ByTagS (Bundle{sElems=Stream next_tag s,sSize=m})
+               (Bundle{sElems=Stream next0 s0})
+               (Bundle{sElems=Stream next1 s1})
+  = M.fromStream (Stream next (Nothing,s,s0,s1)) m
   where
     {-# INLINE_INNER next #-}
     next (Nothing,s,s0,s1)
@@ -203,19 +208,19 @@ combine2ByTagS (Stream next_tag s m) (Stream next0 s0 _)
 --   elements from the first stream...
 --
 combineSS 
-        :: S.Stream Bool        -- ^ tag values
-        -> S.Stream Int         -- ^ segment lengths for first data stream
-        -> S.Stream a           -- ^ first data stream
-        -> S.Stream Int         -- ^ segment lengths for second data stream
-        -> S.Stream a           -- ^ second data stream
-        -> S.Stream a
+        :: B.Bundle v Bool      -- ^ tag values
+        -> B.Bundle v Int       -- ^ segment lengths for first data stream
+        -> B.Bundle v a         -- ^ first data stream
+        -> B.Bundle v Int       -- ^ segment lengths for second data stream
+        -> B.Bundle v a         -- ^ second data stream
+        -> B.Bundle v a
 
 {-# INLINE_STREAM combineSS #-}
-combineSS (Stream nextf sf _) 
-          (Stream nexts1 ss1 _) (Stream nextv1 vs1 nv1)
-          (Stream nexts2 ss2 _) (Stream nextv2 vs2 nv2)
-  = Stream next (Nothing,True,sf,ss1,vs1,ss2,vs2)
-                (nv1+nv2)
+combineSS (Bundle{sElems=Stream nextf sf})
+          (Bundle{sElems=Stream nexts1 ss1}) (Bundle{sElems=Stream nextv1 vs1,sSize=nv1})
+          (Bundle{sElems=Stream nexts2 ss2}) (Bundle{sElems=Stream nextv2 vs2,sSize=nv2})
+  = M.fromStream (Stream next (Nothing,True,sf,ss1,vs1,ss2,vs2))
+                 (nv1+nv2)
   where
     {-# INLINE next #-}
     next (Nothing,f,sf,ss1,vs1,ss2,vs2) =
@@ -272,10 +277,10 @@ combineSS (Stream nextf sf _)
 --  = [2,3,4,5,10,11,12,13,14,15,16,20,21,22]
 -- @
 --
-enumFromToEachS :: Int -> S.Stream (Int,Int) -> S.Stream Int
+enumFromToEachS :: Int -> B.Bundle v (Int,Int) -> B.Bundle v Int
 {-# INLINE_STREAM enumFromToEachS #-}
-enumFromToEachS n (Stream next s _) 
-  = Stream next' (Nothing,s) (Exact n)
+enumFromToEachS n (Bundle{sElems=Stream next s})
+  = M.fromStream (Stream next' (Nothing,s)) (Exact n)
   where
     {-# INLINE_INNER next' #-}
     next' (Nothing,s)
@@ -301,10 +306,10 @@ enumFromToEachS n (Stream next s _)
 --  = [1,2,3,4,5,10,12,14,16,20,23,26,29,32]
 -- @
 --               
-enumFromStepLenEachS :: Int -> S.Stream (Int,Int,Int) -> S.Stream Int 
+enumFromStepLenEachS :: Int -> B.Bundle v (Int,Int,Int) -> B.Bundle v Int 
 {-# INLINE_STREAM enumFromStepLenEachS #-}
-enumFromStepLenEachS len (Stream next s _)
-  = Stream next' (Nothing,s) (Exact len)
+enumFromStepLenEachS len (Bundle{sElems=Stream next s})
+  = M.fromStream (Stream next' (Nothing,s)) (Exact len)
   where
     {-# INLINE_INNER next' #-}
     next' (Nothing,s) 
@@ -331,13 +336,13 @@ enumFromStepLenEachS len (Stream next s _)
 --
 foldSS  :: (a -> b -> a)        -- ^ function to perform the fold
         -> a                    -- ^ initial element of each fold
-        -> S.Stream Int         -- ^ stream of segment lengths
-        -> S.Stream b           -- ^ stream of input data
-        -> S.Stream a           -- ^ stream of fold results
+        -> B.Bundle v Int       -- ^ stream of segment lengths
+        -> B.Bundle v b         -- ^ stream of input data
+        -> B.Bundle v a         -- ^ stream of fold results
         
 {-# INLINE_STREAM foldSS #-}
-foldSS f z (Stream nexts ss sz) (Stream nextv vs _) =
-  Stream next (Nothing,z,ss,vs) sz
+foldSS f z (Bundle{sElems=Stream nexts ss,sSize=sz}) (Bundle{sElems=Stream nextv vs}) =
+  M.fromStream (Stream next (Nothing,z,ss,vs)) sz
   where
     {-# INLINE next #-}
     next (Nothing,x,ss,vs) =
@@ -362,10 +367,10 @@ foldSS f z (Stream nexts ss sz) (Stream nextv vs _) =
 
 -- | Like `foldSS`, but use the first member of each chunk as the initial
 --   element for the fold.
-fold1SS :: (a -> a -> a) -> S.Stream Int -> S.Stream a -> S.Stream a
+fold1SS :: (a -> a -> a) -> B.Bundle v Int -> B.Bundle v a -> B.Bundle v a
 {-# INLINE_STREAM fold1SS #-}
-fold1SS f (Stream nexts ss sz) (Stream nextv vs _) =
-  Stream next (Nothing,Nothing,ss,vs) sz
+fold1SS f (Bundle{sElems=Stream nexts ss,sSize=sz}) (Bundle{sElems=Stream nextv vs}) =
+  M.fromStream (Stream next (Nothing,Nothing,ss,vs)) sz
   where
     {-# INLINE [0] next #-}
     next (Nothing,Nothing,ss,vs) =
@@ -405,12 +410,13 @@ foldValuesR
         :: (a -> b -> a)        -- ^ function to perform the fold
         -> a                    -- ^ initial element for fold
         -> Int                  -- ^ length of each segment
-        -> S.Stream b           -- ^ data stream
-        -> S.Stream a
+        -> B.Bundle v b         -- ^ data stream
+        -> B.Bundle v a
+
 
 {-# INLINE_STREAM foldValuesR #-}
-foldValuesR f z segSize (Stream nextv vs nv) =
-  Stream next (segSize,z,vs) (nv `divSize` segSize)
+foldValuesR f z segSize (Bundle{sElems=Stream nextv vs,sSize=nv}) =
+  M.fromStream (Stream next (segSize,z,vs)) (nv `divSize` segSize)
   where
     {-# INLINE next #-}  
     next (0,x,vs) = return $ Yield x (segSize,z,vs)
@@ -442,16 +448,16 @@ divSize Unknown   _ = Unknown
 -- @
 --
 appendSS
-        :: S.Stream Int         -- ^ segment lengths for first data stream
-        -> S.Stream a           -- ^ first data stream
-        -> S.Stream Int         -- ^ segment lengths for second data stream
-        -> S.Stream a           -- ^ second data stream
-        -> S.Stream a
+        :: B.Bundle v Int         -- ^ segment lengths for first data stream
+        -> B.Bundle v a           -- ^ first data stream
+        -> B.Bundle v Int         -- ^ segment lengths for second data stream
+        -> B.Bundle v a           -- ^ second data stream
+        -> B.Bundle v a
 
 {-# INLINE_STREAM appendSS #-}
-appendSS (Stream nexts1 ss1 ns1) (Stream nextv1 sv1 nv1)
-         (Stream nexts2 ss2 ns2) (Stream nextv2 sv2 nv2)
-  = Stream next (True,Nothing,ss1,sv1,ss2,sv2) (nv1 + nv2)
+appendSS (Bundle{sElems=Stream nexts1 ss1,sSize=ns1}) (Bundle{sElems=Stream nextv1 sv1,sSize=nv1})
+         (Bundle{sElems=Stream nexts2 ss2,sSize=ns2}) (Bundle{sElems=Stream nextv2 sv2,sSize=nv2})
+  = M.fromStream (Stream next (True,Nothing,ss1,sv1,ss2,sv2)) (nv1 + nv2)
   where
     {-# INLINE next #-}
     next (True,Nothing,ss1,sv1,ss2,sv2) =
@@ -510,12 +516,12 @@ appendSS (Stream nexts1 ss1 ns1) (Stream nextv1 sv1 nv1)
 indicesSS 
         :: Int
         -> Int
-        -> S.Stream Int
-        -> S.Stream Int
+        -> B.Bundle v Int
+        -> B.Bundle v Int
 
 {-# INLINE_STREAM indicesSS #-}
-indicesSS n i (Stream next s _) =
-  Stream next' (i,Nothing,s) (Exact n)
+indicesSS n i (Bundle{sElems=Stream next s}) =
+  M.fromStream (Stream next' (i,Nothing,s)) (Exact n)
   where
     {-# INLINE next' #-}
     next' (i,Nothing,s) =
index 0656562..5c74ea1 100644 (file)
@@ -7,8 +7,9 @@ module Data.Array.Parallel.Unlifted.Stream.Segments
         , streamSegsFromVectorsUSSegdSegmap
         , streamSegsFromVectorsUSSegd_split)
 where
-import Data.Vector.Fusion.Stream.Size
-import Data.Vector.Fusion.Stream.Monadic
+import Data.Vector.Fusion.Bundle.Monadic                        (Bundle(..), fromStream)
+import Data.Vector.Fusion.Bundle.Size
+import Data.Vector.Fusion.Stream.Monadic                        (Stream(..), Step(..))
 import Data.Array.Parallel.Unlifted.Sequential.Vector           (Unbox,   Vector, index)
 import Data.Array.Parallel.Unlifted.Vectors                     (Unboxes, Vectors)
 import Data.Array.Parallel.Unlifted.Sequential.USegd            (USegd(..))
@@ -38,7 +39,7 @@ streamSegsFromNestedUSSegd
         :: (Unbox a, Monad m)
         => V.Vector (Vector a)  -- ^ Source arrays.
         -> USSegd               -- ^ Segment descriptor defining segments base on source vectors.
-        -> Stream m a
+        -> Bundle m v a
 
 streamSegsFromNestedUSSegd
         pdatas
@@ -68,7 +69,7 @@ streamSegsFromNestedUSSegd
                 !result  = index here pdata  (start + ix)
            in   return $ Yield result (pseg, ix + 1)
 
-   in   Stream fn (0, 0) Unknown
+   in   fromStream (Stream fn (0, 0)) Unknown
 {-# INLINE_STREAM streamSegsFromNestedUSSegd #-}
 
 
@@ -83,7 +84,7 @@ streamSegsFromVectorsUSSegd
         :: (Unboxes a, Monad m)
         => Vectors a            -- ^ Vectors holding source data.
         -> USSegd               -- ^ Scattered segment descriptor
-        -> Stream m a
+        -> Bundle m v a
 
 streamSegsFromVectorsUSSegd
         vectors
@@ -146,7 +147,7 @@ streamSegsFromVectorsUSSegd
 
         -- It's important that we set the result stream size, so Data.Vector
         -- doesn't need to add code to grow the result when it overflows.
-   in   Stream fnSeg initState (Exact elements)
+   in   fromStream (Stream fnSeg initState) (Exact elements)
 {-# INLINE_STREAM streamSegsFromVectorsUSSegd #-}
 
 
@@ -162,7 +163,7 @@ streamSegsFromVectorsUVSegd
         :: (Unboxes a, Monad m)
         => Vectors a            -- ^ Vectors holding source data.
         -> UVSegd               -- ^ Scattered segment descriptor
-        -> Stream m a
+        -> Bundle m v a
 
 streamSegsFromVectorsUVSegd
         vectors
@@ -176,7 +177,7 @@ streamSegsFromVectorsUSSegdSegmap
         => Vectors a            -- ^ Vectors holding source data.
         -> USSegd               -- ^ Scattered segment descriptor
         -> Vector Int           -- ^ Segmap
-        -> Stream m a
+        -> Bundle m v a
 
 streamSegsFromVectorsUSSegdSegmap
         vectors ussegd@(USSegd _ segStarts segSources usegd) segmap
@@ -233,7 +234,7 @@ streamSegsFromVectorsUSSegdSegmap
 
         -- It's important that we set the result stream size, so Data.Vector
         -- doesn't need to add code to grow the result when it overflows.
-   in   Stream fnSeg initState (Exact elemsTotal)
+   in   fromStream (Stream fnSeg initState) (Exact elemsTotal)
 {-# INLINE_STREAM streamSegsFromVectorsUSSegdSegmap #-}
 
 
@@ -245,7 +246,7 @@ streamSegsFromVectorsUSSegd_split
         -> USSegd               -- ^ Scattered segment descriptor
         -> Vector Int           -- ^ Virtual segment ids
         -> ((USegd,Int),Int)    -- ^ Segmap
-        -> Stream m a
+        -> Bundle m v a
 
 streamSegsFromVectorsUSSegd_split
         !vectors !ussegd
@@ -311,6 +312,6 @@ streamSegsFromVectorsUSSegd_split
 
         -- It's important that we set the result stream size, so Data.Vector
         -- doesn't need to add code to grow the result when it overflows.
-   in   Stream fnSeg initState (Exact elemsTotal)
+   in   fromStream (Stream fnSeg initState) (Exact elemsTotal)
 {-# INLINE_STREAM streamSegsFromVectorsUSSegd_split #-}
 
index 59c0622..2fff0e9 100644 (file)
@@ -15,7 +15,8 @@ module Data.Array.Parallel.Unlifted.Stream.Swallow
 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.Bundle.Monadic as B
+import Data.Vector.Fusion.Bundle.Size    ( Size(..) )
 import Data.Vector.Fusion.Util           as S
 import qualified Data.Vector.Generic.New as New
 
@@ -28,11 +29,11 @@ import qualified Data.Vector.Generic.New as New
 --
 --   Trying to swallow more elements than are in the vector is undefined.
 --
-swallow :: Monad m => Vector v a => v a -> Stream m a
+swallow :: Monad m => Vector v a => v a -> Bundle m v a
 swallow v 
  = v 
  `seq` n 
- `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where
         n   = G.length v
 
@@ -47,12 +48,12 @@ swallow v
 swallow2 
         :: (Monad m, Vector v a, Vector v b)
         => v a -> v b 
-        -> Stream m (a, b)
+        -> Bundle m v (a, b)
 
 swallow2 aa bb
  = aa `seq` bb 
  `seq` n 
- `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -67,12 +68,12 @@ swallow2 aa bb
 swallow3
         :: (Monad m, Vector v a, Vector v b, Vector v c)
         => v a -> v b -> v c
-        -> Stream m (a, b, c)
+        -> Bundle m v (a, b, c)
 
 swallow3 aa bb cc
  = aa `seq` bb `seq` cc
  `seq` n 
- `seq` (S.unfoldr get 0 `S.sized` Unknown)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -88,12 +89,12 @@ swallow3 aa bb cc
 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)
+        -> Bundle m v (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)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -110,12 +111,12 @@ swallow4 aa bb cc dd
 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)
+        -> Bundle m v (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)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -133,12 +134,12 @@ swallow5 aa bb cc dd ee
 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)
+        -> Bundle m v (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)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -157,12 +158,12 @@ swallow6 aa bb cc dd ee ff
 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)
+        -> Bundle m v (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)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -182,12 +183,12 @@ swallow7 aa bb cc dd ee ff gg
 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)
+        -> Bundle m v (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)
+ `seq` (B.fromStream (S.unfoldr get 0) Unknown)
  where  n        = G.length aa
 
         {-# INLINE_INNER get #-}
@@ -205,9 +206,9 @@ swallow8 aa bb cc dd ee ff gg hh
 
 
 -- Repeat ---------------------------------------------------------------------
-repeatS :: Monad m => m a -> Stream m a
+repeatS :: Monad m => m a -> Bundle m v a
 repeatS x
- = Stream step () Unknown
+ = B.fromStream (Stream step ()) Unknown
  where
         {-# INLINE_INNER step #-}
         step _
@@ -218,7 +219,7 @@ repeatS x
 
 -- | Swallow a whole stream.
 --   Indicates that the consumer knows how many elements to demand.
-swallowS :: Stream m a -> Stream m a
+swallowS :: Bundle m v a -> Bundle m v a
 swallowS s = s
 {-# INLINE [1] swallowS #-}
 
@@ -238,5 +239,5 @@ swallowS s = s
 -- be generated.
 {-# RULES "swallowS/replicate"
     forall len x
-    . swallowS (S.replicateM len x) = repeatS x
+    . swallowS (B.replicateM len x) = repeatS x
     #-}
index 38b2658..c8f67db 100644 (file)
@@ -62,7 +62,7 @@ Library
   Build-Depends:  
         base      == 4.7.*,
         random    == 1.0.*,
-        vector    == 0.10.*,
+        vector    == 0.11.*,
         primitive == 0.5.*,
         ghc-prim  == 0.3.*,
         dph-base  == 0.8.*,