diff --git a/Data/Vector.hs b/Data/Vector.hs --- a/Data/Vector.hs +++ b/Data/Vector.hs @@ -159,7 +159,7 @@ import qualified Data.Vector.Generic as G import Data.Vector.Mutable ( MVector(..) ) import Data.Primitive.Array -import qualified Data.Vector.Fusion.Stream as Stream +import qualified Data.Vector.Fusion.Bundle as Bundle import Control.DeepSeq ( NFData, rnf ) import Control.Monad ( MonadPlus(..), liftM, ap ) @@ -244,27 +244,27 @@ -- See http://trac.haskell.org/vector/ticket/12 instance Eq a => Eq (Vector a) where {-# INLINE (==) #-} - xs == ys = Stream.eq (G.stream xs) (G.stream ys) + xs == ys = Bundle.eq (G.stream xs) (G.stream ys) {-# INLINE (/=) #-} - xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys)) + xs /= ys = not (Bundle.eq (G.stream xs) (G.stream ys)) -- See http://trac.haskell.org/vector/ticket/12 instance Ord a => Ord (Vector a) where {-# INLINE compare #-} - compare xs ys = Stream.cmp (G.stream xs) (G.stream ys) + compare xs ys = Bundle.cmp (G.stream xs) (G.stream ys) {-# INLINE (<) #-} - xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT + xs < ys = Bundle.cmp (G.stream xs) (G.stream ys) == LT {-# INLINE (<=) #-} - xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT + xs <= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= GT {-# INLINE (>) #-} - xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT + xs > ys = Bundle.cmp (G.stream xs) (G.stream ys) == GT {-# INLINE (>=) #-} - xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT + xs >= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= LT instance Monoid (Vector a) where {-# INLINE mempty #-} diff --git a/Data/Vector/Fusion/Bundle.hs b/Data/Vector/Fusion/Bundle.hs new file mode 100644 --- /dev/null +++ b/Data/Vector/Fusion/Bundle.hs @@ -0,0 +1,631 @@ +{-# LANGUAGE FlexibleInstances, Rank2Types, BangPatterns #-} + +-- | +-- Module : Data.Vector.Fusion.Bundle +-- Copyright : (c) Roman Leshchinskiy 2008-2010 +-- License : BSD-style +-- +-- Maintainer : Roman Leshchinskiy +-- Stability : experimental +-- Portability : non-portable +-- +-- Bundles for stream fusion +-- + +module Data.Vector.Fusion.Bundle ( + -- * Types + Step(..), Chunk(..), Bundle, MBundle, + + -- * In-place markers + inplace, + + -- * Size hints + size, sized, + + -- * Length information + length, null, + + -- * Construction + empty, singleton, cons, snoc, replicate, generate, (++), + + -- * Accessing individual elements + head, last, (!!), (!?), + + -- * Substreams + slice, init, tail, take, drop, + + -- * Mapping + map, concatMap, flatten, unbox, + + -- * Zipping + indexed, indexedR, + zipWith, zipWith3, zipWith4, zipWith5, zipWith6, + zip, zip3, zip4, zip5, zip6, + + -- * Filtering + filter, takeWhile, dropWhile, + + -- * Searching + elem, notElem, find, findIndex, + + -- * Folding + foldl, foldl1, foldl', foldl1', foldr, foldr1, + + -- * Specialised folds + and, or, + + -- * Unfolding + unfoldr, unfoldrN, iterateN, + + -- * Scans + prescanl, prescanl', + postscanl, postscanl', + scanl, scanl', + scanl1, scanl1', + + -- * Enumerations + enumFromStepN, enumFromTo, enumFromThenTo, + + -- * Conversions + toList, fromList, fromListN, unsafeFromList, lift, + fromVector, reVector, fromVectors, concatVectors, + + -- * Monadic combinators + mapM, mapM_, zipWithM, zipWithM_, filterM, foldM, fold1M, foldM', fold1M', + + eq, cmp +) where + +import Data.Vector.Generic.Base ( Vector ) +import Data.Vector.Fusion.Bundle.Size +import Data.Vector.Fusion.Util +import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..), SPEC(..) ) +import Data.Vector.Fusion.Bundle.Monadic ( Chunk(..) ) +import qualified Data.Vector.Fusion.Bundle.Monadic as M +import qualified Data.Vector.Fusion.Stream.Monadic as S + +import Prelude hiding ( length, null, + replicate, (++), + head, last, (!!), + init, tail, take, drop, + map, concatMap, + zipWith, zipWith3, zip, zip3, + filter, takeWhile, dropWhile, + elem, notElem, + foldl, foldl1, foldr, foldr1, + and, or, + scanl, scanl1, + enumFromTo, enumFromThenTo, + mapM, mapM_ ) + +import GHC.Base ( build ) + +#include "vector.h" + +-- | The type of pure streams +type Bundle = M.Bundle Id + +-- | Alternative name for monadic streams +type MBundle = M.Bundle + +inplace :: (forall m. Monad m => S.Stream m a -> S.Stream m b) + -> (Size -> Size) -> Bundle v a -> Bundle v b +{-# INLINE_FUSED inplace #-} +inplace f g b = b `seq` M.fromStream (f (M.elements b)) (g (M.size b)) + +{-# RULES + +"inplace/inplace [Vector]" + forall (f1 :: forall m. Monad m => S.Stream m a -> S.Stream m a) + (f2 :: forall m. Monad m => S.Stream m a -> S.Stream m a) + g1 g2 s. + inplace f1 g1 (inplace f2 g2 s) = inplace (f1 . f2) (g1 . g2) s + + #-} + +-- | Convert a pure stream to a monadic stream +lift :: Monad m => Bundle v a -> M.Bundle m v a +{-# INLINE_FUSED lift #-} +lift (M.Bundle (Stream step s) (Stream vstep t) v sz) + = M.Bundle (Stream (return . unId . step) s) + (Stream (return . unId . vstep) t) v sz + +-- | 'Size' hint of a 'Bundle' +size :: Bundle v a -> Size +{-# INLINE size #-} +size = M.size + +-- | Attach a 'Size' hint to a 'Bundle' +sized :: Bundle v a -> Size -> Bundle v a +{-# INLINE sized #-} +sized = M.sized + +-- Length +-- ------ + +-- | Length of a 'Bundle' +length :: Bundle v a -> Int +{-# INLINE length #-} +length = unId . M.length + +-- | Check if a 'Bundle' is empty +null :: Bundle v a -> Bool +{-# INLINE null #-} +null = unId . M.null + +-- Construction +-- ------------ + +-- | Empty 'Bundle' +empty :: Bundle v a +{-# INLINE empty #-} +empty = M.empty + +-- | Singleton 'Bundle' +singleton :: a -> Bundle v a +{-# INLINE singleton #-} +singleton = M.singleton + +-- | Replicate a value to a given length +replicate :: Int -> a -> Bundle v a +{-# INLINE replicate #-} +replicate = M.replicate + +-- | Generate a stream from its indices +generate :: Int -> (Int -> a) -> Bundle v a +{-# INLINE generate #-} +generate = M.generate + +-- | Prepend an element +cons :: a -> Bundle v a -> Bundle v a +{-# INLINE cons #-} +cons = M.cons + +-- | Append an element +snoc :: Bundle v a -> a -> Bundle v a +{-# INLINE snoc #-} +snoc = M.snoc + +infixr 5 ++ +-- | Concatenate two 'Bundle's +(++) :: Bundle v a -> Bundle v a -> Bundle v a +{-# INLINE (++) #-} +(++) = (M.++) + +-- Accessing elements +-- ------------------ + +-- | First element of the 'Bundle' or error if empty +head :: Bundle v a -> a +{-# INLINE head #-} +head = unId . M.head + +-- | Last element of the 'Bundle' or error if empty +last :: Bundle v a -> a +{-# INLINE last #-} +last = unId . M.last + +infixl 9 !! +-- | Element at the given position +(!!) :: Bundle v a -> Int -> a +{-# INLINE (!!) #-} +s !! i = unId (s M.!! i) + +infixl 9 !? +-- | Element at the given position or 'Nothing' if out of bounds +(!?) :: Bundle v a -> Int -> Maybe a +{-# INLINE (!?) #-} +s !? i = unId (s M.!? i) + +-- Substreams +-- ---------- + +-- | Extract a substream of the given length starting at the given position. +slice :: Int -- ^ starting index + -> Int -- ^ length + -> Bundle v a + -> Bundle v a +{-# INLINE slice #-} +slice = M.slice + +-- | All but the last element +init :: Bundle v a -> Bundle v a +{-# INLINE init #-} +init = M.init + +-- | All but the first element +tail :: Bundle v a -> Bundle v a +{-# INLINE tail #-} +tail = M.tail + +-- | The first @n@ elements +take :: Int -> Bundle v a -> Bundle v a +{-# INLINE take #-} +take = M.take + +-- | All but the first @n@ elements +drop :: Int -> Bundle v a -> Bundle v a +{-# INLINE drop #-} +drop = M.drop + +-- Mapping +-- --------------- + +-- | Map a function over a 'Bundle' +map :: (a -> b) -> Bundle v a -> Bundle v b +{-# INLINE map #-} +map = M.map + +unbox :: Bundle v (Box a) -> Bundle v a +{-# INLINE unbox #-} +unbox = M.unbox + +concatMap :: (a -> Bundle v b) -> Bundle v a -> Bundle v b +{-# INLINE concatMap #-} +concatMap = M.concatMap + +-- Zipping +-- ------- + +-- | Pair each element in a 'Bundle' with its index +indexed :: Bundle v a -> Bundle v (Int,a) +{-# INLINE indexed #-} +indexed = M.indexed + +-- | Pair each element in a 'Bundle' with its index, starting from the right +-- and counting down +indexedR :: Int -> Bundle v a -> Bundle v (Int,a) +{-# INLINE_FUSED indexedR #-} +indexedR = M.indexedR + +-- | Zip two 'Bundle's with the given function +zipWith :: (a -> b -> c) -> Bundle v a -> Bundle v b -> Bundle v c +{-# INLINE zipWith #-} +zipWith = M.zipWith + +-- | Zip three 'Bundle's with the given function +zipWith3 :: (a -> b -> c -> d) -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d +{-# INLINE zipWith3 #-} +zipWith3 = M.zipWith3 + +zipWith4 :: (a -> b -> c -> d -> e) + -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v e +{-# INLINE zipWith4 #-} +zipWith4 = M.zipWith4 + +zipWith5 :: (a -> b -> c -> d -> e -> f) + -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v e -> Bundle v f +{-# INLINE zipWith5 #-} +zipWith5 = M.zipWith5 + +zipWith6 :: (a -> b -> c -> d -> e -> f -> g) + -> Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v e -> Bundle v f -> Bundle v g +{-# INLINE zipWith6 #-} +zipWith6 = M.zipWith6 + +zip :: Bundle v a -> Bundle v b -> Bundle v (a,b) +{-# INLINE zip #-} +zip = M.zip + +zip3 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v (a,b,c) +{-# INLINE zip3 #-} +zip3 = M.zip3 + +zip4 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v (a,b,c,d) +{-# INLINE zip4 #-} +zip4 = M.zip4 + +zip5 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v e -> Bundle v (a,b,c,d,e) +{-# INLINE zip5 #-} +zip5 = M.zip5 + +zip6 :: Bundle v a -> Bundle v b -> Bundle v c -> Bundle v d + -> Bundle v e -> Bundle v f -> Bundle v (a,b,c,d,e,f) +{-# INLINE zip6 #-} +zip6 = M.zip6 + +-- Filtering +-- --------- + +-- | Drop elements which do not satisfy the predicate +filter :: (a -> Bool) -> Bundle v a -> Bundle v a +{-# INLINE filter #-} +filter = M.filter + +-- | Longest prefix of elements that satisfy the predicate +takeWhile :: (a -> Bool) -> Bundle v a -> Bundle v a +{-# INLINE takeWhile #-} +takeWhile = M.takeWhile + +-- | Drop the longest prefix of elements that satisfy the predicate +dropWhile :: (a -> Bool) -> Bundle v a -> Bundle v a +{-# INLINE dropWhile #-} +dropWhile = M.dropWhile + +-- Searching +-- --------- + +infix 4 `elem` +-- | Check whether the 'Bundle' contains an element +elem :: Eq a => a -> Bundle v a -> Bool +{-# INLINE elem #-} +elem x = unId . M.elem x + +infix 4 `notElem` +-- | Inverse of `elem` +notElem :: Eq a => a -> Bundle v a -> Bool +{-# INLINE notElem #-} +notElem x = unId . M.notElem x + +-- | Yield 'Just' the first element matching the predicate or 'Nothing' if no +-- such element exists. +find :: (a -> Bool) -> Bundle v a -> Maybe a +{-# INLINE find #-} +find f = unId . M.find f + +-- | Yield 'Just' the index of the first element matching the predicate or +-- 'Nothing' if no such element exists. +findIndex :: (a -> Bool) -> Bundle v a -> Maybe Int +{-# INLINE findIndex #-} +findIndex f = unId . M.findIndex f + +-- Folding +-- ------- + +-- | Left fold +foldl :: (a -> b -> a) -> a -> Bundle v b -> a +{-# INLINE foldl #-} +foldl f z = unId . M.foldl f z + +-- | Left fold on non-empty 'Bundle's +foldl1 :: (a -> a -> a) -> Bundle v a -> a +{-# INLINE foldl1 #-} +foldl1 f = unId . M.foldl1 f + +-- | Left fold with strict accumulator +foldl' :: (a -> b -> a) -> a -> Bundle v b -> a +{-# INLINE foldl' #-} +foldl' f z = unId . M.foldl' f z + +-- | Left fold on non-empty 'Bundle's with strict accumulator +foldl1' :: (a -> a -> a) -> Bundle v a -> a +{-# INLINE foldl1' #-} +foldl1' f = unId . M.foldl1' f + +-- | Right fold +foldr :: (a -> b -> b) -> b -> Bundle v a -> b +{-# INLINE foldr #-} +foldr f z = unId . M.foldr f z + +-- | Right fold on non-empty 'Bundle's +foldr1 :: (a -> a -> a) -> Bundle v a -> a +{-# INLINE foldr1 #-} +foldr1 f = unId . M.foldr1 f + +-- Specialised folds +-- ----------------- + +and :: Bundle v Bool -> Bool +{-# INLINE and #-} +and = unId . M.and + +or :: Bundle v Bool -> Bool +{-# INLINE or #-} +or = unId . M.or + +-- Unfolding +-- --------- + +-- | Unfold +unfoldr :: (s -> Maybe (a, s)) -> s -> Bundle v a +{-# INLINE unfoldr #-} +unfoldr = M.unfoldr + +-- | Unfold at most @n@ elements +unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Bundle v a +{-# INLINE unfoldrN #-} +unfoldrN = M.unfoldrN + +-- | Apply function n-1 times to value. Zeroth element is original value. +iterateN :: Int -> (a -> a) -> a -> Bundle v a +{-# INLINE iterateN #-} +iterateN = M.iterateN + +-- Scans +-- ----- + +-- | Prefix scan +prescanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE prescanl #-} +prescanl = M.prescanl + +-- | Prefix scan with strict accumulator +prescanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE prescanl' #-} +prescanl' = M.prescanl' + +-- | Suffix scan +postscanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE postscanl #-} +postscanl = M.postscanl + +-- | Suffix scan with strict accumulator +postscanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE postscanl' #-} +postscanl' = M.postscanl' + +-- | Haskell-style scan +scanl :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE scanl #-} +scanl = M.scanl + +-- | Haskell-style scan with strict accumulator +scanl' :: (a -> b -> a) -> a -> Bundle v b -> Bundle v a +{-# INLINE scanl' #-} +scanl' = M.scanl' + +-- | Scan over a non-empty 'Bundle' +scanl1 :: (a -> a -> a) -> Bundle v a -> Bundle v a +{-# INLINE scanl1 #-} +scanl1 = M.scanl1 + +-- | Scan over a non-empty 'Bundle' with a strict accumulator +scanl1' :: (a -> a -> a) -> Bundle v a -> Bundle v a +{-# INLINE scanl1' #-} +scanl1' = M.scanl1' + + +-- Comparisons +-- ----------- + +-- | Check if two 'Bundle's are equal +eq :: Eq a => Bundle v a -> Bundle v a -> Bool +{-# INLINE eq #-} +eq x y = unId (M.eq x y) + +-- | Lexicographically compare two 'Bundle's +cmp :: Ord a => Bundle v a -> Bundle v a -> Ordering +{-# INLINE cmp #-} +cmp x y = unId (M.cmp x y) + +instance Eq a => Eq (M.Bundle Id v a) where + {-# INLINE (==) #-} + (==) = eq + +instance Ord a => Ord (M.Bundle Id v a) where + {-# INLINE compare #-} + compare = cmp + +-- Monadic combinators +-- ------------------- + +-- | Apply a monadic action to each element of the stream, producing a monadic +-- stream of results +mapM :: Monad m => (a -> m b) -> Bundle v a -> M.Bundle m v b +{-# INLINE mapM #-} +mapM f = M.mapM f . lift + +-- | Apply a monadic action to each element of the stream +mapM_ :: Monad m => (a -> m b) -> Bundle v a -> m () +{-# INLINE mapM_ #-} +mapM_ f = M.mapM_ f . lift + +zipWithM :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> M.Bundle m v c +{-# INLINE zipWithM #-} +zipWithM f as bs = M.zipWithM f (lift as) (lift bs) + +zipWithM_ :: Monad m => (a -> b -> m c) -> Bundle v a -> Bundle v b -> m () +{-# INLINE zipWithM_ #-} +zipWithM_ f as bs = M.zipWithM_ f (lift as) (lift bs) + +-- | Yield a monadic stream of elements that satisfy the monadic predicate +filterM :: Monad m => (a -> m Bool) -> Bundle v a -> M.Bundle m v a +{-# INLINE filterM #-} +filterM f = M.filterM f . lift + +-- | Monadic fold +foldM :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a +{-# INLINE foldM #-} +foldM m z = M.foldM m z . lift + +-- | Monadic fold over non-empty stream +fold1M :: Monad m => (a -> a -> m a) -> Bundle v a -> m a +{-# INLINE fold1M #-} +fold1M m = M.fold1M m . lift + +-- | Monadic fold with strict accumulator +foldM' :: Monad m => (a -> b -> m a) -> a -> Bundle v b -> m a +{-# INLINE foldM' #-} +foldM' m z = M.foldM' m z . lift + +-- | Monad fold over non-empty stream with strict accumulator +fold1M' :: Monad m => (a -> a -> m a) -> Bundle v a -> m a +{-# INLINE fold1M' #-} +fold1M' m = M.fold1M' m . lift + +-- Enumerations +-- ------------ + +-- | Yield a 'Bundle' of the given length containing the values @x@, @x+y@, +-- @x+y+y@ etc. +enumFromStepN :: Num a => a -> a -> Int -> Bundle v a +{-# INLINE enumFromStepN #-} +enumFromStepN = M.enumFromStepN + +-- | Enumerate values +-- +-- /WARNING:/ This operations can be very inefficient. If at all possible, use +-- 'enumFromStepN' instead. +enumFromTo :: Enum a => a -> a -> Bundle v a +{-# INLINE enumFromTo #-} +enumFromTo = M.enumFromTo + +-- | Enumerate values with a given step. +-- +-- /WARNING:/ This operations is very inefficient. If at all possible, use +-- 'enumFromStepN' instead. +enumFromThenTo :: Enum a => a -> a -> a -> Bundle v a +{-# INLINE enumFromThenTo #-} +enumFromThenTo = M.enumFromThenTo + +-- Conversions +-- ----------- + +-- | Convert a 'Bundle' to a list +toList :: Bundle v a -> [a] +{-# INLINE toList #-} +-- toList s = unId (M.toList s) +toList s = build (\c n -> toListFB c n s) + +-- This supports foldr/build list fusion that GHC implements +toListFB :: (a -> b -> b) -> b -> Bundle v a -> b +{-# INLINE [0] toListFB #-} +toListFB c n M.Bundle{M.sElems = Stream step s} = go s + where + go s = case unId (step s) of + Yield x s' -> x `c` go s' + Skip s' -> go s' + Done -> n + +-- | Create a 'Bundle' from a list +fromList :: [a] -> Bundle v a +{-# INLINE fromList #-} +fromList = M.fromList + +-- | Create a 'Bundle' from the first @n@ elements of a list +-- +-- > fromListN n xs = fromList (take n xs) +fromListN :: Int -> [a] -> Bundle v a +{-# INLINE fromListN #-} +fromListN = M.fromListN + +unsafeFromList :: Size -> [a] -> Bundle v a +{-# INLINE unsafeFromList #-} +unsafeFromList = M.unsafeFromList + +fromVector :: Vector v a => v a -> Bundle v a +{-# INLINE fromVector #-} +fromVector = M.fromVector + +reVector :: Bundle u a -> Bundle v a +{-# INLINE reVector #-} +reVector = M.reVector + +fromVectors :: Vector v a => [v a] -> Bundle v a +{-# INLINE fromVectors #-} +fromVectors = M.fromVectors + +concatVectors :: Vector v a => Bundle u (v a) -> Bundle v a +{-# INLINE concatVectors #-} +concatVectors = M.concatVectors + +-- | Create a 'Bundle' of values from a 'Bundle' of streamable things +flatten :: (a -> s) -> (s -> Step s b) -> Size -> Bundle v a -> Bundle v b +{-# INLINE_FUSED flatten #-} +flatten mk istep sz = M.flatten (return . mk) (return . istep) sz . lift + diff --git a/Data/Vector/Fusion/Bundle/Monadic.hs b/Data/Vector/Fusion/Bundle/Monadic.hs new file mode 100644 --- /dev/null +++ b/Data/Vector/Fusion/Bundle/Monadic.hs @@ -0,0 +1,1098 @@ +{-# LANGUAGE ExistentialQuantification, MultiParamTypeClasses, FlexibleInstances, Rank2Types, BangPatterns, KindSignatures, GADTs, ScopedTypeVariables #-} + +-- | +-- Module : Data.Vector.Fusion.Bundle.Monadic +-- Copyright : (c) Roman Leshchinskiy 2008-2010 +-- License : BSD-style +-- +-- Maintainer : Roman Leshchinskiy +-- Stability : experimental +-- Portability : non-portable +-- +-- Monadic bundles. +-- + +module Data.Vector.Fusion.Bundle.Monadic ( + Bundle(..), Chunk(..), + + -- * Size hints + size, sized, + + -- * Length + length, null, + + -- * Construction + empty, singleton, cons, snoc, replicate, replicateM, generate, generateM, (++), + + -- * Accessing elements + head, last, (!!), (!?), + + -- * Substreams + slice, init, tail, take, drop, + + -- * Mapping + map, mapM, mapM_, trans, unbox, concatMap, flatten, + + -- * Zipping + indexed, indexedR, zipWithM_, + zipWithM, zipWith3M, zipWith4M, zipWith5M, zipWith6M, + zipWith, zipWith3, zipWith4, zipWith5, zipWith6, + zip, zip3, zip4, zip5, zip6, + + -- * Comparisons + eq, cmp, + + -- * Filtering + filter, filterM, takeWhile, takeWhileM, dropWhile, dropWhileM, + + -- * Searching + elem, notElem, find, findM, findIndex, findIndexM, + + -- * Folding + foldl, foldlM, foldl1, foldl1M, foldM, fold1M, + foldl', foldlM', foldl1', foldl1M', foldM', fold1M', + foldr, foldrM, foldr1, foldr1M, + + -- * Specialised folds + and, or, concatMapM, + + -- * Unfolding + unfoldr, unfoldrM, + unfoldrN, unfoldrNM, + iterateN, iterateNM, + + -- * Scans + prescanl, prescanlM, prescanl', prescanlM', + postscanl, postscanlM, postscanl', postscanlM', + scanl, scanlM, scanl', scanlM', + scanl1, scanl1M, scanl1', scanl1M', + + -- * Enumerations + enumFromStepN, enumFromTo, enumFromThenTo, + + -- * Conversions + toList, fromList, fromListN, unsafeFromList, + fromVector, reVector, fromVectors, concatVectors, + fromStream, chunks, elements +) where + +import Data.Vector.Generic.Base +import qualified Data.Vector.Generic.Mutable.Base as M +import Data.Vector.Fusion.Bundle.Size +import Data.Vector.Fusion.Util ( Box(..), delay_inline ) +import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..), SPEC(..) ) +import qualified Data.Vector.Fusion.Stream.Monadic as S +import Control.Monad.Primitive + +import qualified Data.List as List +import Data.Char ( ord ) +import GHC.Base ( unsafeChr ) +import Control.Monad ( liftM ) +import Prelude hiding ( length, null, + replicate, (++), + head, last, (!!), + init, tail, take, drop, + map, mapM, mapM_, concatMap, + zipWith, zipWith3, zip, zip3, + filter, takeWhile, dropWhile, + elem, notElem, + foldl, foldl1, foldr, foldr1, + and, or, + scanl, scanl1, + enumFromTo, enumFromThenTo ) + +import Data.Int ( Int8, Int16, Int32, Int64 ) +import Data.Word ( Word8, Word16, Word32, Word, Word64 ) + +#include "vector.h" + +data Chunk v a = Chunk Int (forall m. (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> m ()) + +-- | Monadic streams +data Bundle m v a = Bundle { sElems :: Stream m a + , sChunks :: Stream m (Chunk v a) + , sVector :: Maybe (v a) + , sSize :: Size + } + +fromStream :: Monad m => Stream m a -> Size -> Bundle m v a +{-# INLINE fromStream #-} +fromStream (Stream step s) sz = Bundle (Stream step s) (Stream step' s) Nothing sz + where + step' s = do r <- step s + return $ fmap (\x -> Chunk 1 (\v -> M.basicUnsafeWrite v 0 x)) r + +chunks :: Bundle m v a -> Stream m (Chunk v a) +{-# INLINE chunks #-} +chunks = sChunks + +elements :: Bundle m v a -> Stream m a +{-# INLINE elements #-} +elements = sElems + +-- | 'Size' hint of a 'Bundle' +size :: Bundle m v a -> Size +{-# INLINE size #-} +size = sSize + +-- | Attach a 'Size' hint to a 'Bundle' +sized :: Bundle m v a -> Size -> Bundle m v a +{-# INLINE_FUSED sized #-} +sized s sz = s { sSize = sz } + +-- Length +-- ------ + +-- | Length of a 'Bundle' +length :: Monad m => Bundle m v a -> m Int +{-# INLINE_FUSED length #-} +length Bundle{sSize = Exact n} = return n +length Bundle{sChunks = s} = S.foldl' (\n (Chunk k _) -> n+k) 0 s + +-- | Check if a 'Bundle' is empty +null :: Monad m => Bundle m v a -> m Bool +{-# INLINE_FUSED null #-} +null Bundle{sSize = Exact n} = return (n == 0) +null Bundle{sChunks = s} = S.foldr (\(Chunk n _) z -> n == 0 && z) True s + +-- Construction +-- ------------ + +-- | Empty 'Bundle' +empty :: Monad m => Bundle m v a +{-# INLINE_FUSED empty #-} +empty = fromStream S.empty (Exact 0) + +-- | Singleton 'Bundle' +singleton :: Monad m => a -> Bundle m v a +{-# INLINE_FUSED singleton #-} +singleton x = fromStream (S.singleton x) (Exact 1) + +-- | Replicate a value to a given length +replicate :: Monad m => Int -> a -> Bundle m v a +{-# INLINE_FUSED replicate #-} +replicate n x = Bundle (S.replicate n x) + (S.singleton $ Chunk len (\v -> M.basicSet v x)) + Nothing + (Exact len) + where + len = delay_inline max n 0 + +-- | Yield a 'Bundle' of values obtained by performing the monadic action the +-- given number of times +replicateM :: Monad m => Int -> m a -> Bundle m v a +{-# INLINE_FUSED replicateM #-} +-- NOTE: We delay inlining max here because GHC will create a join point for +-- the call to newArray# otherwise which is not really nice. +replicateM n p = fromStream (S.replicateM n p) (Exact (delay_inline max n 0)) + +generate :: Monad m => Int -> (Int -> a) -> Bundle m v a +{-# INLINE generate #-} +generate n f = generateM n (return . f) + +-- | Generate a stream from its indices +generateM :: Monad m => Int -> (Int -> m a) -> Bundle m v a +{-# INLINE_FUSED generateM #-} +generateM n f = fromStream (S.generateM n f) (Exact (delay_inline max n 0)) + +-- | Prepend an element +cons :: Monad m => a -> Bundle m v a -> Bundle m v a +{-# INLINE cons #-} +cons x s = singleton x ++ s + +-- | Append an element +snoc :: Monad m => Bundle m v a -> a -> Bundle m v a +{-# INLINE snoc #-} +snoc s x = s ++ singleton x + +infixr 5 ++ +-- | Concatenate two 'Bundle's +(++) :: Monad m => Bundle m v a -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED (++) #-} +Bundle sa ta _ na ++ Bundle sb tb _ nb = Bundle (sa S.++ sb) (ta S.++ tb) Nothing (na + nb) + +-- Accessing elements +-- ------------------ + +-- | First element of the 'Bundle' or error if empty +head :: Monad m => Bundle m v a -> m a +{-# INLINE_FUSED head #-} +head = S.head . sElems + +-- | Last element of the 'Bundle' or error if empty +last :: Monad m => Bundle m v a -> m a +{-# INLINE_FUSED last #-} +last = S.last . sElems + +infixl 9 !! +-- | Element at the given position +(!!) :: Monad m => Bundle m v a -> Int -> m a +{-# INLINE (!!) #-} +b !! i = sElems b S.!! i + +infixl 9 !? +-- | Element at the given position or 'Nothing' if out of bounds +(!?) :: Monad m => Bundle m v a -> Int -> m (Maybe a) +{-# INLINE (!?) #-} +b !? i = sElems b S.!? i + +-- Substreams +-- ---------- + +-- | Extract a substream of the given length starting at the given position. +slice :: Monad m => Int -- ^ starting index + -> Int -- ^ length + -> Bundle m v a + -> Bundle m v a +{-# INLINE slice #-} +slice i n s = take n (drop i s) + +-- | All but the last element +init :: Monad m => Bundle m v a -> Bundle m v a +{-# INLINE_FUSED init #-} +init Bundle{sElems = s, sSize = sz} = fromStream (S.init s) (sz-1) + +-- | All but the first element +tail :: Monad m => Bundle m v a -> Bundle m v a +{-# INLINE_FUSED tail #-} +tail Bundle{sElems = s, sSize = sz} = fromStream (S.tail s) (sz-1) + +-- | The first @n@ elements +take :: Monad m => Int -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED take #-} +take n Bundle{sElems = s, sSize = sz} = fromStream (S.take n s) (smaller (Exact n) sz) + +-- | All but the first @n@ elements +drop :: Monad m => Int -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED drop #-} +drop n Bundle{sElems = s, sSize = sz} = fromStream (S.drop n s) (sz - Exact n) + +-- Mapping +-- ------- + +instance Monad m => Functor (Bundle m v) where + {-# INLINE fmap #-} + fmap = map + +-- | Map a function over a 'Bundle' +map :: Monad m => (a -> b) -> Bundle m v a -> Bundle m v b +{-# INLINE map #-} +map f = mapM (return . f) + +-- | Map a monadic function over a 'Bundle' +mapM :: Monad m => (a -> m b) -> Bundle m v a -> Bundle m v b +{-# INLINE_FUSED mapM #-} +mapM f Bundle{sElems = s, sSize = n} = fromStream (S.mapM f s) n + +-- | Execute a monadic action for each element of the 'Bundle' +mapM_ :: Monad m => (a -> m b) -> Bundle m v a -> m () +{-# INLINE_FUSED mapM_ #-} +mapM_ m = S.mapM_ m . sElems + +-- | Transform a 'Bundle' to use a different monad +trans :: (Monad m, Monad m') => (forall a. m a -> m' a) + -> Bundle m v a -> Bundle m' v a +{-# INLINE_FUSED trans #-} +trans f Bundle{sElems = s, sChunks = cs, sVector = v, sSize = n} + = Bundle { sElems = S.trans f s, sChunks = S.trans f cs, sVector = v, sSize = n } + +unbox :: Monad m => Bundle m v (Box a) -> Bundle m v a +{-# INLINE_FUSED unbox #-} +unbox Bundle{sElems = s, sSize = n} = fromStream (S.unbox s) n + +-- Zipping +-- ------- + +-- | Pair each element in a 'Bundle' with its index +indexed :: Monad m => Bundle m v a -> Bundle m v (Int,a) +{-# INLINE_FUSED indexed #-} +indexed Bundle{sElems = s, sSize = n} = fromStream (S.indexed s) n + +-- | Pair each element in a 'Bundle' with its index, starting from the right +-- and counting down +indexedR :: Monad m => Int -> Bundle m v a -> Bundle m v (Int,a) +{-# INLINE_FUSED indexedR #-} +indexedR m Bundle{sElems = s, sSize = n} = fromStream (S.indexedR m s) n + +-- | Zip two 'Bundle's with the given monadic function +zipWithM :: Monad m => (a -> b -> m c) -> Bundle m v a -> Bundle m v b -> Bundle m v c +{-# INLINE_FUSED zipWithM #-} +zipWithM f Bundle{sElems = sa, sSize = na} + Bundle{sElems = sb, sSize = nb} = fromStream (S.zipWithM f sa sb) (smaller na nb) + +-- FIXME: This might expose an opportunity for inplace execution. +{-# RULES + +"zipWithM xs xs [Vector.Bundle]" forall f xs. + zipWithM f xs xs = mapM (\x -> f x x) xs + + #-} + +zipWithM_ :: Monad m => (a -> b -> m c) -> Bundle m v a -> Bundle m v b -> m () +{-# INLINE zipWithM_ #-} +zipWithM_ f sa sb = S.zipWithM_ f (sElems sa) (sElems sb) + +zipWith3M :: Monad m => (a -> b -> c -> m d) -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d +{-# INLINE_FUSED zipWith3M #-} +zipWith3M f Bundle{sElems = sa, sSize = na} + Bundle{sElems = sb, sSize = nb} + Bundle{sElems = sc, sSize = nc} + = fromStream (S.zipWith3M f sa sb sc) (smaller na (smaller nb nc)) + +zipWith4M :: Monad m => (a -> b -> c -> d -> m e) + -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d + -> Bundle m v e +{-# INLINE zipWith4M #-} +zipWith4M f sa sb sc sd + = zipWithM (\(a,b) (c,d) -> f a b c d) (zip sa sb) (zip sc sd) + +zipWith5M :: Monad m => (a -> b -> c -> d -> e -> m 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 +{-# INLINE zipWith5M #-} +zipWith5M f sa sb sc sd se + = zipWithM (\(a,b,c) (d,e) -> f a b c d e) (zip3 sa sb sc) (zip sd se) + +zipWith6M :: Monad m => (a -> b -> c -> d -> e -> f -> m 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 +{-# INLINE zipWith6M #-} +zipWith6M fn sa sb sc sd se sf + = zipWithM (\(a,b,c) (d,e,f) -> fn a b c d e f) (zip3 sa sb sc) + (zip3 sd se sf) + +zipWith :: Monad m => (a -> b -> c) -> Bundle m v a -> Bundle m v b -> Bundle m v c +{-# INLINE zipWith #-} +zipWith f = zipWithM (\a b -> return (f a b)) + +zipWith3 :: Monad m => (a -> b -> c -> d) + -> Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d +{-# INLINE zipWith3 #-} +zipWith3 f = zipWith3M (\a b c -> return (f a b c)) + +zipWith4 :: Monad 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 +{-# INLINE zipWith4 #-} +zipWith4 f = zipWith4M (\a b c d -> return (f a b c d)) + +zipWith5 :: Monad 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 +{-# INLINE zipWith5 #-} +zipWith5 f = zipWith5M (\a b c d e -> return (f a b c d e)) + +zipWith6 :: Monad 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 +{-# INLINE zipWith6 #-} +zipWith6 fn = zipWith6M (\a b c d e f -> return (fn a b c d e f)) + +zip :: Monad m => Bundle m v a -> Bundle m v b -> Bundle m v (a,b) +{-# INLINE zip #-} +zip = zipWith (,) + +zip3 :: Monad m => Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v (a,b,c) +{-# INLINE zip3 #-} +zip3 = zipWith3 (,,) + +zip4 :: Monad m => Bundle m v a -> Bundle m v b -> Bundle m v c -> Bundle m v d + -> Bundle m v (a,b,c,d) +{-# INLINE zip4 #-} +zip4 = zipWith4 (,,,) + +zip5 :: Monad m => 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) +{-# INLINE zip5 #-} +zip5 = zipWith5 (,,,,) + +zip6 :: Monad m => 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) +{-# INLINE zip6 #-} +zip6 = zipWith6 (,,,,,) + +-- Comparisons +-- ----------- + +-- | Check if two 'Bundle's are equal +eq :: (Monad m, Eq a) => Bundle m v a -> Bundle m v a -> m Bool +{-# INLINE_FUSED eq #-} +eq x y = sElems x `S.eq` sElems y + +-- | Lexicographically compare two 'Bundle's +cmp :: (Monad m, Ord a) => Bundle m v a -> Bundle m v a -> m Ordering +{-# INLINE_FUSED cmp #-} +cmp x y = sElems x `S.cmp` sElems y + +-- Filtering +-- --------- + +-- | Drop elements which do not satisfy the predicate +filter :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE filter #-} +filter f = filterM (return . f) + +-- | Drop elements which do not satisfy the monadic predicate +filterM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED filterM #-} +filterM f Bundle{sElems = s, sSize = n} = fromStream (S.filterM f s) (toMax n) + +-- | Longest prefix of elements that satisfy the predicate +takeWhile :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE takeWhile #-} +takeWhile f = takeWhileM (return . f) + +-- | Longest prefix of elements that satisfy the monadic predicate +takeWhileM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED takeWhileM #-} +takeWhileM f Bundle{sElems = s, sSize = n} = fromStream (S.takeWhileM f s) (toMax n) + +-- | Drop the longest prefix of elements that satisfy the predicate +dropWhile :: Monad m => (a -> Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE dropWhile #-} +dropWhile f = dropWhileM (return . f) + +-- | Drop the longest prefix of elements that satisfy the monadic predicate +dropWhileM :: Monad m => (a -> m Bool) -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED dropWhileM #-} +dropWhileM f Bundle{sElems = s, sSize = n} = fromStream (S.dropWhileM f s) (toMax n) + +-- Searching +-- --------- + +infix 4 `elem` +-- | Check whether the 'Bundle' contains an element +elem :: (Monad m, Eq a) => a -> Bundle m v a -> m Bool +{-# INLINE_FUSED elem #-} +elem x = S.elem x . sElems + +infix 4 `notElem` +-- | Inverse of `elem` +notElem :: (Monad m, Eq a) => a -> Bundle m v a -> m Bool +{-# INLINE notElem #-} +notElem x = S.notElem x . sElems + +-- | Yield 'Just' the first element that satisfies the predicate or 'Nothing' +-- if no such element exists. +find :: Monad m => (a -> Bool) -> Bundle m v a -> m (Maybe a) +{-# INLINE find #-} +find f = findM (return . f) + +-- | Yield 'Just' the first element that satisfies the monadic predicate or +-- 'Nothing' if no such element exists. +findM :: Monad m => (a -> m Bool) -> Bundle m v a -> m (Maybe a) +{-# INLINE_FUSED findM #-} +findM f = S.findM f . sElems + +-- | Yield 'Just' the index of the first element that satisfies the predicate +-- or 'Nothing' if no such element exists. +findIndex :: Monad m => (a -> Bool) -> Bundle m v a -> m (Maybe Int) +{-# INLINE_FUSED findIndex #-} +findIndex f = findIndexM (return . f) + +-- | Yield 'Just' the index of the first element that satisfies the monadic +-- predicate or 'Nothing' if no such element exists. +findIndexM :: Monad m => (a -> m Bool) -> Bundle m v a -> m (Maybe Int) +{-# INLINE_FUSED findIndexM #-} +findIndexM f = S.findIndexM f . sElems + +-- Folding +-- ------- + +-- | Left fold +foldl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> m a +{-# INLINE foldl #-} +foldl f = foldlM (\a b -> return (f a b)) + +-- | Left fold with a monadic operator +foldlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a +{-# INLINE_FUSED foldlM #-} +foldlM m z = S.foldlM m z . sElems + +-- | Same as 'foldlM' +foldM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a +{-# INLINE foldM #-} +foldM = foldlM + +-- | Left fold over a non-empty 'Bundle' +foldl1 :: Monad m => (a -> a -> a) -> Bundle m v a -> m a +{-# INLINE foldl1 #-} +foldl1 f = foldl1M (\a b -> return (f a b)) + +-- | Left fold over a non-empty 'Bundle' with a monadic operator +foldl1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a +{-# INLINE_FUSED foldl1M #-} +foldl1M f = S.foldl1M f . sElems + +-- | Same as 'foldl1M' +fold1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a +{-# INLINE fold1M #-} +fold1M = foldl1M + +-- | Left fold with a strict accumulator +foldl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> m a +{-# INLINE foldl' #-} +foldl' f = foldlM' (\a b -> return (f a b)) + +-- | Left fold with a strict accumulator and a monadic operator +foldlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a +{-# INLINE_FUSED foldlM' #-} +foldlM' m z = S.foldlM' m z . sElems + +-- | Same as 'foldlM'' +foldM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> m a +{-# INLINE foldM' #-} +foldM' = foldlM' + +-- | Left fold over a non-empty 'Bundle' with a strict accumulator +foldl1' :: Monad m => (a -> a -> a) -> Bundle m v a -> m a +{-# INLINE foldl1' #-} +foldl1' f = foldl1M' (\a b -> return (f a b)) + +-- | Left fold over a non-empty 'Bundle' with a strict accumulator and a +-- monadic operator +foldl1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a +{-# INLINE_FUSED foldl1M' #-} +foldl1M' f = S.foldl1M' f . sElems + +-- | Same as 'foldl1M'' +fold1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a +{-# INLINE fold1M' #-} +fold1M' = foldl1M' + +-- | Right fold +foldr :: Monad m => (a -> b -> b) -> b -> Bundle m v a -> m b +{-# INLINE foldr #-} +foldr f = foldrM (\a b -> return (f a b)) + +-- | Right fold with a monadic operator +foldrM :: Monad m => (a -> b -> m b) -> b -> Bundle m v a -> m b +{-# INLINE_FUSED foldrM #-} +foldrM f z = S.foldrM f z . sElems + +-- | Right fold over a non-empty stream +foldr1 :: Monad m => (a -> a -> a) -> Bundle m v a -> m a +{-# INLINE foldr1 #-} +foldr1 f = foldr1M (\a b -> return (f a b)) + +-- | Right fold over a non-empty stream with a monadic operator +foldr1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> m a +{-# INLINE_FUSED foldr1M #-} +foldr1M f = S.foldr1M f . sElems + +-- Specialised folds +-- ----------------- + +and :: Monad m => Bundle m v Bool -> m Bool +{-# INLINE_FUSED and #-} +and = S.and . sElems + +or :: Monad m => Bundle m v Bool -> m Bool +{-# INLINE_FUSED or #-} +or = S.or . sElems + +concatMap :: Monad m => (a -> Bundle m v b) -> Bundle m v a -> Bundle m v b +{-# INLINE concatMap #-} +concatMap f = concatMapM (return . f) + +concatMapM :: Monad m => (a -> m (Bundle m v b)) -> Bundle m v a -> Bundle m v b +{-# INLINE_FUSED concatMapM #-} +concatMapM f Bundle{sElems = s} = fromStream (S.concatMapM (liftM sElems . f) s) Unknown + +-- | Create a 'Bundle' of values from a 'Bundle' of streamable things +flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Size + -> Bundle m v a -> Bundle m v b +{-# INLINE_FUSED flatten #-} +flatten mk istep sz Bundle{sElems = s} = fromStream (S.flatten mk istep s) sz + +-- Unfolding +-- --------- + +-- | Unfold +unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Bundle m u a +{-# INLINE_FUSED unfoldr #-} +unfoldr f = unfoldrM (return . f) + +-- | Unfold with a monadic function +unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Bundle m u a +{-# INLINE_FUSED unfoldrM #-} +unfoldrM f s = fromStream (S.unfoldrM f s) Unknown + +-- | Unfold at most @n@ elements +unfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Bundle m u a +{-# INLINE_FUSED unfoldrN #-} +unfoldrN n f = unfoldrNM n (return . f) + +-- | Unfold at most @n@ elements with a monadic functions +unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Bundle m u a +{-# INLINE_FUSED unfoldrNM #-} +unfoldrNM n f s = fromStream (S.unfoldrNM n f s) (Max (delay_inline max n 0)) + +-- | Apply monadic function n times to value. Zeroth element is original value. +iterateNM :: Monad m => Int -> (a -> m a) -> a -> Bundle m u a +{-# INLINE_FUSED iterateNM #-} +iterateNM n f x0 = fromStream (S.iterateNM n f x0) (Exact (delay_inline max n 0)) + +-- | Apply function n times to value. Zeroth element is original value. +iterateN :: Monad m => Int -> (a -> a) -> a -> Bundle m u a +{-# INLINE_FUSED iterateN #-} +iterateN n f x0 = iterateNM n (return . f) x0 + +-- Scans +-- ----- + +-- | Prefix scan +prescanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE prescanl #-} +prescanl f = prescanlM (\a b -> return (f a b)) + +-- | Prefix scan with a monadic operator +prescanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE_FUSED prescanlM #-} +prescanlM f z Bundle{sElems = s, sSize = sz} = fromStream (S.prescanlM f z s) sz + +-- | Prefix scan with strict accumulator +prescanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE prescanl' #-} +prescanl' f = prescanlM' (\a b -> return (f a b)) + +-- | Prefix scan with strict accumulator and a monadic operator +prescanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE_FUSED prescanlM' #-} +prescanlM' f z Bundle{sElems = s, sSize = sz} = fromStream (S.prescanlM' f z s) sz + +-- | Suffix scan +postscanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE postscanl #-} +postscanl f = postscanlM (\a b -> return (f a b)) + +-- | Suffix scan with a monadic operator +postscanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE_FUSED postscanlM #-} +postscanlM f z Bundle{sElems = s, sSize = sz} = fromStream (S.postscanlM f z s) sz + +-- | Suffix scan with strict accumulator +postscanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE postscanl' #-} +postscanl' f = postscanlM' (\a b -> return (f a b)) + +-- | Suffix scan with strict acccumulator and a monadic operator +postscanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE_FUSED postscanlM' #-} +postscanlM' f z Bundle{sElems = s, sSize = sz} = fromStream (S.postscanlM' f z s) sz + +-- | Haskell-style scan +scanl :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE scanl #-} +scanl f = scanlM (\a b -> return (f a b)) + +-- | Haskell-style scan with a monadic operator +scanlM :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE scanlM #-} +scanlM f z s = z `cons` postscanlM f z s + +-- | Haskell-style scan with strict accumulator +scanl' :: Monad m => (a -> b -> a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE scanl' #-} +scanl' f = scanlM' (\a b -> return (f a b)) + +-- | Haskell-style scan with strict accumulator and a monadic operator +scanlM' :: Monad m => (a -> b -> m a) -> a -> Bundle m v b -> Bundle m v a +{-# INLINE scanlM' #-} +scanlM' f z s = z `seq` (z `cons` postscanlM f z s) + +-- | Scan over a non-empty 'Bundle' +scanl1 :: Monad m => (a -> a -> a) -> Bundle m v a -> Bundle m v a +{-# INLINE scanl1 #-} +scanl1 f = scanl1M (\x y -> return (f x y)) + +-- | Scan over a non-empty 'Bundle' with a monadic operator +scanl1M :: Monad m => (a -> a -> m a) -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED scanl1M #-} +scanl1M f Bundle{sElems = s, sSize = sz} = fromStream (S.scanl1M f s) sz + +-- | Scan over a non-empty 'Bundle' with a strict accumulator +scanl1' :: Monad m => (a -> a -> a) -> Bundle m v a -> Bundle m v a +{-# INLINE scanl1' #-} +scanl1' f = scanl1M' (\x y -> return (f x y)) + +-- | Scan over a non-empty 'Bundle' with a strict accumulator and a monadic +-- operator +scanl1M' :: Monad m => (a -> a -> m a) -> Bundle m v a -> Bundle m v a +{-# INLINE_FUSED scanl1M' #-} +scanl1M' f Bundle{sElems = s, sSize = sz} = fromStream (S.scanl1M' f s) sz + +-- Enumerations +-- ------------ + +-- The Enum class is broken for this, there just doesn't seem to be a +-- way to implement this generically. We have to specialise for as many types +-- as we can but this doesn't help in polymorphic loops. + +-- | Yield a 'Bundle' of the given length containing the values @x@, @x+y@, +-- @x+y+y@ etc. +enumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Bundle m v a +{-# INLINE_FUSED enumFromStepN #-} +enumFromStepN x y n = fromStream (S.enumFromStepN x y n) (Exact (delay_inline max n 0)) + +-- | Enumerate values +-- +-- /WARNING:/ This operation can be very inefficient. If at all possible, use +-- 'enumFromStepN' instead. +enumFromTo :: (Enum a, Monad m) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo #-} +enumFromTo x y = fromList [x .. y] + +-- NOTE: We use (x+1) instead of (succ x) below because the latter checks for +-- overflow which can't happen here. + +-- FIXME: add "too large" test for Int +enumFromTo_small :: (Integral a, Monad m) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo_small #-} +enumFromTo_small x y = x `seq` y `seq` fromStream (Stream step x) (Exact n) + where + n = delay_inline max (fromIntegral y - fromIntegral x + 1) 0 + + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Int8 -> Int8 -> Bundle m v Int8 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Int16 -> Int16 -> Bundle m v Int16 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Word8 -> Word8 -> Bundle m v Word8 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Word16 -> Word16 -> Bundle m v Word16 + + #-} + +#if WORD_SIZE_IN_BITS > 32 + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Int32 -> Int32 -> Bundle m v Int32 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_small :: Monad m => Word32 -> Word32 -> Bundle m v Word32 + + #-} + +#endif + +-- NOTE: We could implement a generic "too large" test: +-- +-- len x y | x > y = 0 +-- | n > 0 && n <= fromIntegral (maxBound :: Int) = fromIntegral n +-- | otherwise = error +-- where +-- n = y-x+1 +-- +-- Alas, GHC won't eliminate unnecessary comparisons (such as n >= 0 for +-- unsigned types). See http://hackage.haskell.org/trac/ghc/ticket/3744 +-- + +enumFromTo_int :: forall m v. Monad m => Int -> Int -> Bundle m v Int +{-# INLINE_FUSED enumFromTo_int #-} +enumFromTo_int x y = x `seq` y `seq` fromStream (Stream step x) (Exact (len x y)) + where + {-# INLINE [0] len #-} + len :: Int -> Int -> Int + len x y | x > y = 0 + | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" + (n > 0) + $ n + where + n = y-x+1 + + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + +enumFromTo_intlike :: (Integral a, Monad m) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo_intlike #-} +enumFromTo_intlike x y = x `seq` y `seq` fromStream (Stream step x) (Exact (len x y)) + where + {-# INLINE [0] len #-} + len x y | x > y = 0 + | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" + (n > 0) + $ fromIntegral n + where + n = y-x+1 + + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_int :: Monad m => Int -> Int -> Bundle m v Int + +#if WORD_SIZE_IN_BITS > 32 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_intlike :: Monad m => Int64 -> Int64 -> Bundle m v Int64 + +#else + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_intlike :: Monad m => Int32 -> Int32 -> Bundle m v Int32 + +#endif + + #-} + +enumFromTo_big_word :: (Integral a, Monad m) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo_big_word #-} +enumFromTo_big_word x y = x `seq` y `seq` fromStream (Stream step x) (Exact (len x y)) + where + {-# INLINE [0] len #-} + len x y | x > y = 0 + | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" + (n < fromIntegral (maxBound :: Int)) + $ fromIntegral (n+1) + where + n = y-x + + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_big_word :: Monad m => Word -> Word -> Bundle m v Word + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_big_word + :: Monad m => Word64 -> Word64 -> Bundle m v Word64 + +#if WORD_SIZE_IN_BITS == 32 + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_big_word + :: Monad m => Word32 -> Word32 -> Bundle m v Word32 + +#endif + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_big_word + :: Monad m => Integer -> Integer -> Bundle m v Integer + + #-} + +-- FIXME: the "too large" test is totally wrong +enumFromTo_big_int :: (Integral a, Monad m) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo_big_int #-} +enumFromTo_big_int x y = x `seq` y `seq` fromStream (Stream step x) (Exact (len x y)) + where + {-# INLINE [0] len #-} + len x y | x > y = 0 + | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" + (n > 0 && n <= fromIntegral (maxBound :: Int)) + $ fromIntegral n + where + n = y-x+1 + + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + +#if WORD_SIZE_IN_BITS > 32 + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_big :: Monad m => Int64 -> Int64 -> Bundle m v Int64 + + #-} + +#endif + +enumFromTo_char :: Monad m => Char -> Char -> Bundle m v Char +{-# INLINE_FUSED enumFromTo_char #-} +enumFromTo_char x y = x `seq` y `seq` fromStream (Stream step xn) (Exact n) + where + xn = ord x + yn = ord y + + n = delay_inline max 0 (yn - xn + 1) + + {-# INLINE_INNER step #-} + step xn | xn <= yn = return $ Yield (unsafeChr xn) (xn+1) + | otherwise = return $ Done + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_char + + #-} + +------------------------------------------------------------------------ + +-- Specialise enumFromTo for Float and Double. +-- Also, try to do something about pairs? + +enumFromTo_double :: (Monad m, Ord a, RealFrac a) => a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromTo_double #-} +enumFromTo_double n m = n `seq` m `seq` fromStream (Stream step n) (Max (len n m)) + where + lim = m + 1/2 -- important to float out + + {-# INLINE [0] len #-} + len x y | x > y = 0 + | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" + (n > 0) + $ fromIntegral n + where + n = truncate (y-x)+2 + + {-# INLINE_INNER step #-} + step x | x <= lim = return $ Yield x (x+1) + | otherwise = return $ Done + +{-# RULES + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_double :: Monad m => Double -> Double -> Bundle m v Double + +"enumFromTo [Bundle]" + enumFromTo = enumFromTo_double :: Monad m => Float -> Float -> Bundle m v Float + + #-} + +------------------------------------------------------------------------ + +-- | Enumerate values with a given step. +-- +-- /WARNING:/ This operation is very inefficient. If at all possible, use +-- 'enumFromStepN' instead. +enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Bundle m v a +{-# INLINE_FUSED enumFromThenTo #-} +enumFromThenTo x y z = fromList [x, y .. z] + +-- FIXME: Specialise enumFromThenTo. + +-- Conversions +-- ----------- + +-- | Convert a 'Bundle' to a list +toList :: Monad m => Bundle m v a -> m [a] +{-# INLINE toList #-} +toList = foldr (:) [] + +-- | Convert a list to a 'Bundle' +fromList :: Monad m => [a] -> Bundle m v a +{-# INLINE fromList #-} +fromList xs = unsafeFromList Unknown xs + +-- | Convert the first @n@ elements of a list to a 'Bundle' +fromListN :: Monad m => Int -> [a] -> Bundle m v a +{-# INLINE_FUSED fromListN #-} +fromListN n xs = fromStream (S.fromListN n xs) (Max (delay_inline max n 0)) + +-- | Convert a list to a 'Bundle' with the given 'Size' hint. +unsafeFromList :: Monad m => Size -> [a] -> Bundle m v a +{-# INLINE_FUSED unsafeFromList #-} +unsafeFromList sz xs = fromStream (S.fromList xs) sz + +fromVector :: (Monad m, Vector v a) => v a -> Bundle m v a +{-# INLINE_FUSED fromVector #-} +fromVector v = v `seq` n `seq` Bundle (Stream step 0) + (Stream vstep True) + (Just v) + (Exact n) + where + n = basicLength v + + {-# INLINE step #-} + step i | i >= n = return Done + | otherwise = case basicUnsafeIndexM v i of + Box x -> return $ Yield x (i+1) + + + {-# INLINE vstep #-} + vstep True = return (Yield (Chunk (basicLength v) (\mv -> basicUnsafeCopy mv v)) False) + vstep False = return Done + +fromVectors :: forall m v a. (Monad m, Vector v a) => [v a] -> Bundle m v a +{-# INLINE_FUSED fromVectors #-} +fromVectors vs = Bundle (Stream pstep (Left vs)) + (Stream vstep vs) + Nothing + (Exact n) + where + n = List.foldl' (\k v -> k + basicLength v) 0 vs + + pstep (Left []) = return Done + pstep (Left (v:vs)) = basicLength v `seq` return (Skip (Right (v,0,vs))) + + pstep (Right (v,i,vs)) + | i >= basicLength v = return $ Skip (Left vs) + | otherwise = case basicUnsafeIndexM v i of + Box x -> return $ Yield x (Right (v,i+1,vs)) + + -- FIXME: work around bug in GHC 7.6.1 + vstep :: [v a] -> m (Step [v a] (Chunk v a)) + vstep [] = return Done + vstep (v:vs) = return $ Yield (Chunk (basicLength v) + (\mv -> INTERNAL_CHECK(check) "concatVectors" "length mismatch" + (M.basicLength mv == basicLength v) + $ basicUnsafeCopy mv v)) vs + + +concatVectors :: (Monad m, Vector v a) => Bundle m u (v a) -> Bundle m v a +{-# INLINE_FUSED concatVectors #-} +concatVectors Bundle{sElems = Stream step s} + = Bundle (Stream pstep (Left s)) + (Stream vstep s) + Nothing + Unknown + where + pstep (Left s) = do + r <- step s + case r of + Yield v s' -> basicLength v `seq` return (Skip (Right (v,0,s'))) + Skip s' -> return (Skip (Left s')) + Done -> return Done + + pstep (Right (v,i,s)) + | i >= basicLength v = return (Skip (Left s)) + | otherwise = case basicUnsafeIndexM v i of + Box x -> return (Yield x (Right (v,i+1,s))) + + + vstep s = do + r <- step s + case r of + Yield v s' -> return (Yield (Chunk (basicLength v) + (\mv -> INTERNAL_CHECK(check) "concatVectors" "length mismatch" + (M.basicLength mv == basicLength v) + $ basicUnsafeCopy mv v)) s') + Skip s' -> return (Skip s') + Done -> return Done + +reVector :: Monad m => Bundle m u a -> Bundle m v a +{-# INLINE_FUSED reVector #-} +reVector Bundle{sElems = s, sSize = n} = fromStream s n + +{-# RULES + +"reVector [Vector]" + reVector = id + +"reVector/reVector [Vector]" forall s. + reVector (reVector s) = s + + #-} + diff --git a/Data/Vector/Fusion/Bundle/Size.hs b/Data/Vector/Fusion/Bundle/Size.hs new file mode 100644 --- /dev/null +++ b/Data/Vector/Fusion/Bundle/Size.hs @@ -0,0 +1,87 @@ +-- | +-- Module : Data.Vector.Fusion.Bundle.Size +-- Copyright : (c) Roman Leshchinskiy 2008-2010 +-- License : BSD-style +-- +-- Maintainer : Roman Leshchinskiy +-- Stability : experimental +-- Portability : portable +-- +-- Size hints for streams. +-- + +module Data.Vector.Fusion.Bundle.Size ( + Size(..), smaller, larger, toMax, upperBound +) where + +import Data.Vector.Fusion.Util ( delay_inline ) + +-- | Size hint +data Size = Exact Int -- ^ Exact size + | Max Int -- ^ Upper bound on the size + | Unknown -- ^ Unknown size + deriving( Eq, Show ) + +instance Num Size where + Exact m + Exact n = Exact (m+n) + Exact m + Max n = Max (m+n) + + Max m + Exact n = Max (m+n) + Max m + Max n = Max (m+n) + + _ + _ = Unknown + + + Exact m - Exact n = Exact (m-n) + Exact m - Max n = Max m + + Max m - Exact n = Max (m-n) + Max m - Max n = Max m + Max m - Unknown = Max m + + _ - _ = Unknown + + + fromInteger n = Exact (fromInteger n) + +-- | Minimum of two size hints +smaller :: Size -> Size -> Size +{-# INLINE smaller #-} +smaller (Exact m) (Exact n) = Exact (delay_inline min m n) +smaller (Exact m) (Max n) = Max (delay_inline min m n) +smaller (Exact m) Unknown = Max m +smaller (Max m) (Exact n) = Max (delay_inline min m n) +smaller (Max m) (Max n) = Max (delay_inline min m n) +smaller (Max m) Unknown = Max m +smaller Unknown (Exact n) = Max n +smaller Unknown (Max n) = Max n +smaller Unknown Unknown = Unknown + +-- | Maximum of two size hints +larger :: Size -> Size -> Size +{-# INLINE larger #-} +larger (Exact m) (Exact n) = Exact (delay_inline max m n) +larger (Exact m) (Max n) | m >= n = Exact m + | otherwise = Max n +larger (Max m) (Exact n) | n >= m = Exact n + | otherwise = Max m +larger (Max m) (Max n) = Max (delay_inline max m n) +larger _ _ = Unknown + +-- | Convert a size hint to an upper bound +toMax :: Size -> Size +toMax (Exact n) = Max n +toMax (Max n) = Max n +toMax Unknown = Unknown + +-- | Compute the minimum size from a size hint +lowerBound :: Size -> Int +lowerBound (Exact n) = n +lowerBound _ = 0 + +-- | Compute the maximum size from a size hint if possible +upperBound :: Size -> Maybe Int +upperBound (Exact n) = Just n +upperBound (Max n) = Just n +upperBound Unknown = Nothing + diff --git a/Data/Vector/Fusion/Stream.hs b/Data/Vector/Fusion/Stream.hs deleted file mode 100644 --- a/Data/Vector/Fusion/Stream.hs +++ /dev/null @@ -1,634 +0,0 @@ -{-# LANGUAGE FlexibleInstances, Rank2Types, BangPatterns #-} - --- | --- Module : Data.Vector.Fusion.Stream --- Copyright : (c) Roman Leshchinskiy 2008-2010 --- License : BSD-style --- --- Maintainer : Roman Leshchinskiy --- Stability : experimental --- Portability : non-portable --- --- Streams for stream fusion --- - -module Data.Vector.Fusion.Stream ( - -- * Types - Step(..), Stream, MStream, - - -- * In-place markers - inplace, - - -- * Size hints - size, sized, - - -- * Length information - length, null, - - -- * Construction - empty, singleton, cons, snoc, replicate, generate, (++), - - -- * Accessing individual elements - head, last, (!!), (!?), - - -- * Substreams - slice, init, tail, take, drop, - - -- * Mapping - map, concatMap, flatten, unbox, - - -- * Zipping - indexed, indexedR, - zipWith, zipWith3, zipWith4, zipWith5, zipWith6, - zip, zip3, zip4, zip5, zip6, - - -- * Filtering - filter, takeWhile, dropWhile, - - -- * Searching - elem, notElem, find, findIndex, - - -- * Folding - foldl, foldl1, foldl', foldl1', foldr, foldr1, - - -- * Specialised folds - and, or, - - -- * Unfolding - unfoldr, unfoldrN, iterateN, - - -- * Scans - prescanl, prescanl', - postscanl, postscanl', - scanl, scanl', - scanl1, scanl1', - - -- * Enumerations - enumFromStepN, enumFromTo, enumFromThenTo, - - -- * Conversions - toList, fromList, fromListN, unsafeFromList, liftStream, - - -- * Monadic combinators - mapM, mapM_, zipWithM, zipWithM_, filterM, foldM, fold1M, foldM', fold1M', - - eq, cmp -) where - -import Data.Vector.Fusion.Stream.Size -import Data.Vector.Fusion.Util -import Data.Vector.Fusion.Stream.Monadic ( Step(..), SPEC(..) ) -import qualified Data.Vector.Fusion.Stream.Monadic as M - -import Prelude hiding ( length, null, - replicate, (++), - head, last, (!!), - init, tail, take, drop, - map, concatMap, - zipWith, zipWith3, zip, zip3, - filter, takeWhile, dropWhile, - elem, notElem, - foldl, foldl1, foldr, foldr1, - and, or, - scanl, scanl1, - enumFromTo, enumFromThenTo, - mapM, mapM_ ) - -import GHC.Base ( build ) - -#include "vector.h" - --- | The type of pure streams -type Stream = M.Stream Id - --- | Alternative name for monadic streams -type MStream = M.Stream - -inplace :: (forall m. Monad m => M.Stream m a -> M.Stream m b) - -> Stream a -> Stream b -{-# INLINE_STREAM inplace #-} -inplace f s = s `seq` f s - -{-# RULES - -"inplace/inplace [Vector]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) - (g :: forall m. Monad m => MStream m a -> MStream m a) - s. - inplace f (inplace g s) = inplace (f . g) s - - #-} - --- | Convert a pure stream to a monadic stream -liftStream :: Monad m => Stream a -> M.Stream m a -{-# INLINE_STREAM liftStream #-} -liftStream (M.Stream step s sz) = M.Stream (return . unId . step) s sz - --- | 'Size' hint of a 'Stream' -size :: Stream a -> Size -{-# INLINE size #-} -size = M.size - --- | Attach a 'Size' hint to a 'Stream' -sized :: Stream a -> Size -> Stream a -{-# INLINE sized #-} -sized = M.sized - --- Length --- ------ - --- | Length of a 'Stream' -length :: Stream a -> Int -{-# INLINE length #-} -length = unId . M.length - --- | Check if a 'Stream' is empty -null :: Stream a -> Bool -{-# INLINE null #-} -null = unId . M.null - --- Construction --- ------------ - --- | Empty 'Stream' -empty :: Stream a -{-# INLINE empty #-} -empty = M.empty - --- | Singleton 'Stream' -singleton :: a -> Stream a -{-# INLINE singleton #-} -singleton = M.singleton - --- | Replicate a value to a given length -replicate :: Int -> a -> Stream a -{-# INLINE replicate #-} -replicate = M.replicate - --- | Generate a stream from its indices -generate :: Int -> (Int -> a) -> Stream a -{-# INLINE generate #-} -generate = M.generate - --- | Prepend an element -cons :: a -> Stream a -> Stream a -{-# INLINE cons #-} -cons = M.cons - --- | Append an element -snoc :: Stream a -> a -> Stream a -{-# INLINE snoc #-} -snoc = M.snoc - -infixr 5 ++ --- | Concatenate two 'Stream's -(++) :: Stream a -> Stream a -> Stream a -{-# INLINE (++) #-} -(++) = (M.++) - --- Accessing elements --- ------------------ - --- | First element of the 'Stream' or error if empty -head :: Stream a -> a -{-# INLINE head #-} -head = unId . M.head - --- | Last element of the 'Stream' or error if empty -last :: Stream a -> a -{-# INLINE last #-} -last = unId . M.last - -infixl 9 !! --- | Element at the given position -(!!) :: Stream a -> Int -> a -{-# INLINE (!!) #-} -s !! i = unId (s M.!! i) - -infixl 9 !? --- | Element at the given position or 'Nothing' if out of bounds -(!?) :: Stream a -> Int -> Maybe a -{-# INLINE (!?) #-} -s !? i = unId (s M.!? i) - --- Substreams --- ---------- - --- | Extract a substream of the given length starting at the given position. -slice :: Int -- ^ starting index - -> Int -- ^ length - -> Stream a - -> Stream a -{-# INLINE slice #-} -slice = M.slice - --- | All but the last element -init :: Stream a -> Stream a -{-# INLINE init #-} -init = M.init - --- | All but the first element -tail :: Stream a -> Stream a -{-# INLINE tail #-} -tail = M.tail - --- | The first @n@ elements -take :: Int -> Stream a -> Stream a -{-# INLINE take #-} -take = M.take - --- | All but the first @n@ elements -drop :: Int -> Stream a -> Stream a -{-# INLINE drop #-} -drop = M.drop - --- Mapping --- --------------- - --- | Map a function over a 'Stream' -map :: (a -> b) -> Stream a -> Stream b -{-# INLINE map #-} -map = M.map - -unbox :: Stream (Box a) -> Stream a -{-# INLINE unbox #-} -unbox = M.unbox - -concatMap :: (a -> Stream b) -> Stream a -> Stream b -{-# INLINE concatMap #-} -concatMap = M.concatMap - --- Zipping --- ------- - --- | Pair each element in a 'Stream' with its index -indexed :: Stream a -> Stream (Int,a) -{-# INLINE indexed #-} -indexed = M.indexed - --- | Pair each element in a 'Stream' with its index, starting from the right --- and counting down -indexedR :: Int -> Stream a -> Stream (Int,a) -{-# INLINE_STREAM indexedR #-} -indexedR = M.indexedR - --- | Zip two 'Stream's with the given function -zipWith :: (a -> b -> c) -> Stream a -> Stream b -> Stream c -{-# INLINE zipWith #-} -zipWith = M.zipWith - --- | Zip three 'Stream's with the given function -zipWith3 :: (a -> b -> c -> d) -> Stream a -> Stream b -> Stream c -> Stream d -{-# INLINE zipWith3 #-} -zipWith3 = M.zipWith3 - -zipWith4 :: (a -> b -> c -> d -> e) - -> Stream a -> Stream b -> Stream c -> Stream d - -> Stream e -{-# INLINE zipWith4 #-} -zipWith4 = M.zipWith4 - -zipWith5 :: (a -> b -> c -> d -> e -> f) - -> Stream a -> Stream b -> Stream c -> Stream d - -> Stream e -> Stream f -{-# INLINE zipWith5 #-} -zipWith5 = M.zipWith5 - -zipWith6 :: (a -> b -> c -> d -> e -> f -> g) - -> Stream a -> Stream b -> Stream c -> Stream d - -> Stream e -> Stream f -> Stream g -{-# INLINE zipWith6 #-} -zipWith6 = M.zipWith6 - -zip :: Stream a -> Stream b -> Stream (a,b) -{-# INLINE zip #-} -zip = M.zip - -zip3 :: Stream a -> Stream b -> Stream c -> Stream (a,b,c) -{-# INLINE zip3 #-} -zip3 = M.zip3 - -zip4 :: Stream a -> Stream b -> Stream c -> Stream d - -> Stream (a,b,c,d) -{-# INLINE zip4 #-} -zip4 = M.zip4 - -zip5 :: Stream a -> Stream b -> Stream c -> Stream d - -> Stream e -> Stream (a,b,c,d,e) -{-# INLINE zip5 #-} -zip5 = M.zip5 - -zip6 :: Stream a -> Stream b -> Stream c -> Stream d - -> Stream e -> Stream f -> Stream (a,b,c,d,e,f) -{-# INLINE zip6 #-} -zip6 = M.zip6 - --- Filtering --- --------- - --- | Drop elements which do not satisfy the predicate -filter :: (a -> Bool) -> Stream a -> Stream a -{-# INLINE filter #-} -filter = M.filter - --- | Longest prefix of elements that satisfy the predicate -takeWhile :: (a -> Bool) -> Stream a -> Stream a -{-# INLINE takeWhile #-} -takeWhile = M.takeWhile - --- | Drop the longest prefix of elements that satisfy the predicate -dropWhile :: (a -> Bool) -> Stream a -> Stream a -{-# INLINE dropWhile #-} -dropWhile = M.dropWhile - --- Searching --- --------- - -infix 4 `elem` --- | Check whether the 'Stream' contains an element -elem :: Eq a => a -> Stream a -> Bool -{-# INLINE elem #-} -elem x = unId . M.elem x - -infix 4 `notElem` --- | Inverse of `elem` -notElem :: Eq a => a -> Stream a -> Bool -{-# INLINE notElem #-} -notElem x = unId . M.notElem x - --- | Yield 'Just' the first element matching the predicate or 'Nothing' if no --- such element exists. -find :: (a -> Bool) -> Stream a -> Maybe a -{-# INLINE find #-} -find f = unId . M.find f - --- | Yield 'Just' the index of the first element matching the predicate or --- 'Nothing' if no such element exists. -findIndex :: (a -> Bool) -> Stream a -> Maybe Int -{-# INLINE findIndex #-} -findIndex f = unId . M.findIndex f - --- Folding --- ------- - --- | Left fold -foldl :: (a -> b -> a) -> a -> Stream b -> a -{-# INLINE foldl #-} -foldl f z = unId . M.foldl f z - --- | Left fold on non-empty 'Stream's -foldl1 :: (a -> a -> a) -> Stream a -> a -{-# INLINE foldl1 #-} -foldl1 f = unId . M.foldl1 f - --- | Left fold with strict accumulator -foldl' :: (a -> b -> a) -> a -> Stream b -> a -{-# INLINE foldl' #-} -foldl' f z = unId . M.foldl' f z - --- | Left fold on non-empty 'Stream's with strict accumulator -foldl1' :: (a -> a -> a) -> Stream a -> a -{-# INLINE foldl1' #-} -foldl1' f = unId . M.foldl1' f - --- | Right fold -foldr :: (a -> b -> b) -> b -> Stream a -> b -{-# INLINE foldr #-} -foldr f z = unId . M.foldr f z - --- | Right fold on non-empty 'Stream's -foldr1 :: (a -> a -> a) -> Stream a -> a -{-# INLINE foldr1 #-} -foldr1 f = unId . M.foldr1 f - --- Specialised folds --- ----------------- - -and :: Stream Bool -> Bool -{-# INLINE and #-} -and = unId . M.and - -or :: Stream Bool -> Bool -{-# INLINE or #-} -or = unId . M.or - --- Unfolding --- --------- - --- | Unfold -unfoldr :: (s -> Maybe (a, s)) -> s -> Stream a -{-# INLINE unfoldr #-} -unfoldr = M.unfoldr - --- | Unfold at most @n@ elements -unfoldrN :: Int -> (s -> Maybe (a, s)) -> s -> Stream a -{-# INLINE unfoldrN #-} -unfoldrN = M.unfoldrN - --- | Apply function n-1 times to value. Zeroth element is original value. -iterateN :: Int -> (a -> a) -> a -> Stream a -{-# INLINE iterateN #-} -iterateN = M.iterateN - --- Scans --- ----- - --- | Prefix scan -prescanl :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE prescanl #-} -prescanl = M.prescanl - --- | Prefix scan with strict accumulator -prescanl' :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE prescanl' #-} -prescanl' = M.prescanl' - --- | Suffix scan -postscanl :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE postscanl #-} -postscanl = M.postscanl - --- | Suffix scan with strict accumulator -postscanl' :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE postscanl' #-} -postscanl' = M.postscanl' - --- | Haskell-style scan -scanl :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE scanl #-} -scanl = M.scanl - --- | Haskell-style scan with strict accumulator -scanl' :: (a -> b -> a) -> a -> Stream b -> Stream a -{-# INLINE scanl' #-} -scanl' = M.scanl' - --- | Scan over a non-empty 'Stream' -scanl1 :: (a -> a -> a) -> Stream a -> Stream a -{-# INLINE scanl1 #-} -scanl1 = M.scanl1 - --- | Scan over a non-empty 'Stream' with a strict accumulator -scanl1' :: (a -> a -> a) -> Stream a -> Stream a -{-# INLINE scanl1' #-} -scanl1' = M.scanl1' - - --- Comparisons --- ----------- - --- FIXME: Move these to Monadic - --- | Check if two 'Stream's are equal -eq :: Eq a => Stream a -> Stream a -> Bool -{-# INLINE_STREAM eq #-} -eq (M.Stream step1 s1 _) (M.Stream step2 s2 _) = eq_loop0 SPEC s1 s2 - where - eq_loop0 !sPEC s1 s2 = case unId (step1 s1) of - Yield x s1' -> eq_loop1 SPEC x s1' s2 - Skip s1' -> eq_loop0 SPEC s1' s2 - Done -> null (M.Stream step2 s2 Unknown) - - eq_loop1 !sPEC x s1 s2 = case unId (step2 s2) of - Yield y s2' -> x == y && eq_loop0 SPEC s1 s2' - Skip s2' -> eq_loop1 SPEC x s1 s2' - Done -> False - --- | Lexicographically compare two 'Stream's -cmp :: Ord a => Stream a -> Stream a -> Ordering -{-# INLINE_STREAM cmp #-} -cmp (M.Stream step1 s1 _) (M.Stream step2 s2 _) = cmp_loop0 SPEC s1 s2 - where - cmp_loop0 !sPEC s1 s2 = case unId (step1 s1) of - Yield x s1' -> cmp_loop1 SPEC x s1' s2 - Skip s1' -> cmp_loop0 SPEC s1' s2 - Done -> if null (M.Stream step2 s2 Unknown) - then EQ else LT - - cmp_loop1 !sPEC x s1 s2 = case unId (step2 s2) of - Yield y s2' -> case x `compare` y of - EQ -> cmp_loop0 SPEC s1 s2' - c -> c - Skip s2' -> cmp_loop1 SPEC x s1 s2' - Done -> GT - -instance Eq a => Eq (M.Stream Id a) where - {-# INLINE (==) #-} - (==) = eq - -instance Ord a => Ord (M.Stream Id a) where - {-# INLINE compare #-} - compare = cmp - --- Monadic combinators --- ------------------- - --- | Apply a monadic action to each element of the stream, producing a monadic --- stream of results -mapM :: Monad m => (a -> m b) -> Stream a -> M.Stream m b -{-# INLINE mapM #-} -mapM f = M.mapM f . liftStream - --- | Apply a monadic action to each element of the stream -mapM_ :: Monad m => (a -> m b) -> Stream a -> m () -{-# INLINE mapM_ #-} -mapM_ f = M.mapM_ f . liftStream - -zipWithM :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> M.Stream m c -{-# INLINE zipWithM #-} -zipWithM f as bs = M.zipWithM f (liftStream as) (liftStream bs) - -zipWithM_ :: Monad m => (a -> b -> m c) -> Stream a -> Stream b -> m () -{-# INLINE zipWithM_ #-} -zipWithM_ f as bs = M.zipWithM_ f (liftStream as) (liftStream bs) - --- | Yield a monadic stream of elements that satisfy the monadic predicate -filterM :: Monad m => (a -> m Bool) -> Stream a -> M.Stream m a -{-# INLINE filterM #-} -filterM f = M.filterM f . liftStream - --- | Monadic fold -foldM :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a -{-# INLINE foldM #-} -foldM m z = M.foldM m z . liftStream - --- | Monadic fold over non-empty stream -fold1M :: Monad m => (a -> a -> m a) -> Stream a -> m a -{-# INLINE fold1M #-} -fold1M m = M.fold1M m . liftStream - --- | Monadic fold with strict accumulator -foldM' :: Monad m => (a -> b -> m a) -> a -> Stream b -> m a -{-# INLINE foldM' #-} -foldM' m z = M.foldM' m z . liftStream - --- | Monad fold over non-empty stream with strict accumulator -fold1M' :: Monad m => (a -> a -> m a) -> Stream a -> m a -{-# INLINE fold1M' #-} -fold1M' m = M.fold1M' m . liftStream - --- Enumerations --- ------------ - --- | Yield a 'Stream' of the given length containing the values @x@, @x+y@, --- @x+y+y@ etc. -enumFromStepN :: Num a => a -> a -> Int -> Stream a -{-# INLINE enumFromStepN #-} -enumFromStepN = M.enumFromStepN - --- | Enumerate values --- --- /WARNING:/ This operations can be very inefficient. If at all possible, use --- 'enumFromStepN' instead. -enumFromTo :: Enum a => a -> a -> Stream a -{-# INLINE enumFromTo #-} -enumFromTo = M.enumFromTo - --- | Enumerate values with a given step. --- --- /WARNING:/ This operations is very inefficient. If at all possible, use --- 'enumFromStepN' instead. -enumFromThenTo :: Enum a => a -> a -> a -> Stream a -{-# INLINE enumFromThenTo #-} -enumFromThenTo = M.enumFromThenTo - --- Conversions --- ----------- - --- | Convert a 'Stream' to a list -toList :: Stream a -> [a] -{-# INLINE toList #-} --- toList s = unId (M.toList s) -toList s = build (\c n -> toListFB c n s) - --- This supports foldr/build list fusion that GHC implements -toListFB :: (a -> b -> b) -> b -> Stream a -> b -{-# INLINE [0] toListFB #-} -toListFB c n (M.Stream step s _) = go s - where - go s = case unId (step s) of - Yield x s' -> x `c` go s' - Skip s' -> go s' - Done -> n - --- | Create a 'Stream' from a list -fromList :: [a] -> Stream a -{-# INLINE fromList #-} -fromList = M.fromList - --- | Create a 'Stream' from the first @n@ elements of a list --- --- > fromListN n xs = fromList (take n xs) -fromListN :: Int -> [a] -> Stream a -{-# INLINE fromListN #-} -fromListN = M.fromListN - -unsafeFromList :: Size -> [a] -> Stream a -{-# INLINE unsafeFromList #-} -unsafeFromList = M.unsafeFromList - --- | Create a 'Stream' of values from a 'Stream' of streamable things -flatten :: (a -> s) -> (s -> Step s b) -> Size -> Stream a -> Stream b -{-# INLINE_STREAM flatten #-} -flatten mk istep sz = M.flatten (return . mk) (return . istep) sz . liftStream - diff --git a/Data/Vector/Fusion/Stream/Monadic.hs b/Data/Vector/Fusion/Stream/Monadic.hs --- a/Data/Vector/Fusion/Stream/Monadic.hs +++ b/Data/Vector/Fusion/Stream/Monadic.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE ExistentialQuantification, Rank2Types, BangPatterns #-} +{-# LANGUAGE ExistentialQuantification, MultiParamTypeClasses, FlexibleInstances, Rank2Types, BangPatterns, KindSignatures, GADTs, ScopedTypeVariables #-} -- | -- Module : Data.Vector.Fusion.Stream.Monadic @@ -15,9 +15,6 @@ module Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..), SPEC(..), - -- * Size hints - size, sized, - -- * Length length, null, @@ -39,6 +36,9 @@ zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zip, zip3, zip4, zip5, zip6, + -- * Comparisons + eq, cmp, + -- * Filtering filter, filterM, takeWhile, takeWhileM, dropWhile, dropWhileM, @@ -68,12 +68,12 @@ enumFromStepN, enumFromTo, enumFromThenTo, -- * Conversions - toList, fromList, fromListN, unsafeFromList + toList, fromList, fromListN ) where -import Data.Vector.Fusion.Stream.Size -import Data.Vector.Fusion.Util ( Box(..), delay_inline ) +import Data.Vector.Fusion.Util ( Box(..) ) +import qualified Data.List as List import Data.Char ( ord ) import GHC.Base ( unsafeChr ) import Control.Monad ( liftM ) @@ -111,49 +111,52 @@ #define EMPTY_STREAM (\s -> ERROR s emptyStream) -- | Result of taking a single step in a stream -data Step s a = Yield a s -- ^ a new element and a new seed - | Skip s -- ^ just a new seed - | Done -- ^ end of stream - --- | Monadic streams -data Stream m a = forall s. Stream (s -> m (Step s a)) s Size +data Step s a where + Yield :: a -> s -> Step s a + Skip :: s -> Step s a + Done :: Step s a --- | 'Size' hint of a 'Stream' -size :: Stream m a -> Size -{-# INLINE size #-} -size (Stream _ _ sz) = sz +instance Functor (Step s) where + {-# INLINE fmap #-} + fmap f (Yield x s) = Yield (f x) s + fmap f (Skip s) = Skip s + fmap f Done = Done --- | Attach a 'Size' hint to a 'Stream' -sized :: Stream m a -> Size -> Stream m a -{-# INLINE_STREAM sized #-} -sized (Stream step s _) sz = Stream step s sz +-- | Monadic streams +data Stream m a = forall s. Stream (s -> m (Step s a)) s -- Length -- ------ -- | Length of a 'Stream' length :: Monad m => Stream m a -> m Int -{-# INLINE_STREAM length #-} -length s = foldl' (\n _ -> n+1) 0 s +{-# INLINE_FUSED length #-} +length = foldl' (\n _ -> n+1) 0 -- | Check if a 'Stream' is empty null :: Monad m => Stream m a -> m Bool -{-# INLINE_STREAM null #-} -null s = foldr (\_ _ -> False) True s - +{-# INLINE_FUSED null #-} +null (Stream step s) = null_loop s + where + null_loop s = do + r <- step s + case r of + Yield _ _ -> return False + Skip s' -> null_loop s' + Done -> return True -- Construction -- ------------ -- | Empty 'Stream' empty :: Monad m => Stream m a -{-# INLINE_STREAM empty #-} -empty = Stream (const (return Done)) () (Exact 0) +{-# INLINE_FUSED empty #-} +empty = Stream (const (return Done)) () -- | Singleton 'Stream' singleton :: Monad m => a -> Stream m a -{-# INLINE_STREAM singleton #-} -singleton x = Stream (return . step) True (Exact 1) +{-# INLINE_FUSED singleton #-} +singleton x = Stream (return . step) True where {-# INLINE_INNER step #-} step True = Yield x False @@ -161,16 +164,14 @@ -- | Replicate a value to a given length replicate :: Monad m => Int -> a -> Stream m a -{-# INLINE replicate #-} +{-# INLINE_FUSED replicate #-} replicate n x = replicateM n (return x) -- | Yield a 'Stream' of values obtained by performing the monadic action the -- given number of times replicateM :: Monad m => Int -> m a -> Stream m a -{-# INLINE_STREAM replicateM #-} --- NOTE: We delay inlining max here because GHC will create a join point for --- the call to newArray# otherwise which is not really nice. -replicateM n p = Stream step n (Exact (delay_inline max n 0)) +{-# INLINE_FUSED replicateM #-} +replicateM n p = Stream step n where {-# INLINE_INNER step #-} step i | i <= 0 = return Done @@ -182,8 +183,8 @@ -- | Generate a stream from its indices generateM :: Monad m => Int -> (Int -> m a) -> Stream m a -{-# INLINE_STREAM generateM #-} -generateM n f = n `seq` Stream step 0 (Exact (delay_inline max n 0)) +{-# INLINE_FUSED generateM #-} +generateM n f = n `seq` Stream step 0 where {-# INLINE_INNER step #-} step i | i < n = do @@ -204,8 +205,8 @@ infixr 5 ++ -- | Concatenate two 'Stream's (++) :: Monad m => Stream m a -> Stream m a -> Stream m a -{-# INLINE_STREAM (++) #-} -Stream stepa sa na ++ Stream stepb sb nb = Stream step (Left sa) (na + nb) +{-# INLINE_FUSED (++) #-} +Stream stepa sa ++ Stream stepb sb = Stream step (Left sa) where {-# INLINE_INNER step #-} step (Left sa) = do @@ -226,8 +227,8 @@ -- | First element of the 'Stream' or error if empty head :: Monad m => Stream m a -> m a -{-# INLINE_STREAM head #-} -head (Stream step s _) = head_loop SPEC s +{-# INLINE_FUSED head #-} +head (Stream step s) = head_loop SPEC s where head_loop !sPEC s = do @@ -241,8 +242,8 @@ -- | Last element of the 'Stream' or error if empty last :: Monad m => Stream m a -> m a -{-# INLINE_STREAM last #-} -last (Stream step s _) = last_loop0 SPEC s +{-# INLINE_FUSED last #-} +last (Stream step s) = last_loop0 SPEC s where last_loop0 !sPEC s = do @@ -264,8 +265,8 @@ -- | Element at the given position (!!) :: Monad m => Stream m a -> Int -> m a {-# INLINE (!!) #-} -Stream step s _ !! i | i < 0 = ERROR "!!" "negative index" - | otherwise = index_loop SPEC s i +Stream step s !! i | i < 0 = ERROR "!!" "negative index" + | otherwise = index_loop SPEC s i where index_loop !sPEC s i = i `seq` @@ -281,7 +282,7 @@ -- | Element at the given position or 'Nothing' if out of bounds (!?) :: Monad m => Stream m a -> Int -> m (Maybe a) {-# INLINE (!?) #-} -Stream step s _ !? i = index_loop SPEC s i +Stream step s !? i = index_loop SPEC s i where index_loop !sPEC s i = i `seq` @@ -306,8 +307,8 @@ -- | All but the last element init :: Monad m => Stream m a -> Stream m a -{-# INLINE_STREAM init #-} -init (Stream step s sz) = Stream step' (Nothing, s) (sz - 1) +{-# INLINE_FUSED init #-} +init (Stream step s) = Stream step' (Nothing, s) where {-# INLINE_INNER step' #-} step' (Nothing, s) = liftM (\r -> @@ -326,8 +327,8 @@ -- | All but the first element tail :: Monad m => Stream m a -> Stream m a -{-# INLINE_STREAM tail #-} -tail (Stream step s sz) = Stream step' (Left s) (sz - 1) +{-# INLINE_FUSED tail #-} +tail (Stream step s) = Stream step' (Left s) where {-# INLINE_INNER step' #-} step' (Left s) = liftM (\r -> @@ -346,8 +347,8 @@ -- | The first @n@ elements take :: Monad m => Int -> Stream m a -> Stream m a -{-# INLINE_STREAM take #-} -take n (Stream step s sz) = Stream step' (s, 0) (smaller (Exact n) sz) +{-# INLINE_FUSED take #-} +take n (Stream step s) = n `seq` Stream step' (s, 0) where {-# INLINE_INNER step' #-} step' (s, i) | i < n = liftM (\r -> @@ -360,8 +361,8 @@ -- | All but the first @n@ elements drop :: Monad m => Int -> Stream m a -> Stream m a -{-# INLINE_STREAM drop #-} -drop n (Stream step s sz) = Stream step' (s, Just n) (sz - Exact n) +{-# INLINE_FUSED drop #-} +drop n (Stream step s) = Stream step' (s, Just n) where {-# INLINE_INNER step' #-} step' (s, Just i) | i > 0 = liftM (\r -> @@ -394,8 +395,8 @@ -- | Map a monadic function over a 'Stream' mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b -{-# INLINE_STREAM mapM #-} -mapM f (Stream step s n) = Stream step' s n +{-# INLINE_FUSED mapM #-} +mapM f (Stream step s) = Stream step' s where {-# INLINE_INNER step' #-} step' s = do @@ -406,8 +407,8 @@ Done -> return Done consume :: Monad m => Stream m a -> m () -{-# INLINE_STREAM consume #-} -consume (Stream step s _) = consume_loop SPEC s +{-# INLINE_FUSED consume #-} +consume (Stream step s) = consume_loop SPEC s where consume_loop !sPEC s = do @@ -419,18 +420,18 @@ -- | Execute a monadic action for each element of the 'Stream' mapM_ :: Monad m => (a -> m b) -> Stream m a -> m () -{-# INLINE_STREAM mapM_ #-} +{-# INLINE_FUSED mapM_ #-} mapM_ m = consume . mapM m -- | Transform a 'Stream' to use a different monad -trans :: (Monad m, Monad m') => (forall a. m a -> m' a) - -> Stream m a -> Stream m' a -{-# INLINE_STREAM trans #-} -trans f (Stream step s n) = Stream (f . step) s n +trans :: (Monad m, Monad m') + => (forall a. m a -> m' a) -> Stream m a -> Stream m' a +{-# INLINE_FUSED trans #-} +trans f (Stream step s) = Stream (f . step) s unbox :: Monad m => Stream m (Box a) -> Stream m a -{-# INLINE_STREAM unbox #-} -unbox (Stream step s n) = Stream step' s n +{-# INLINE_FUSED unbox #-} +unbox (Stream step s) = Stream step' s where {-# INLINE_INNER step' #-} step' s = do @@ -445,8 +446,8 @@ -- | Pair each element in a 'Stream' with its index indexed :: Monad m => Stream m a -> Stream m (Int,a) -{-# INLINE_STREAM indexed #-} -indexed (Stream step s n) = Stream step' (s,0) n +{-# INLINE_FUSED indexed #-} +indexed (Stream step s) = Stream step' (s,0) where {-# INLINE_INNER step' #-} step' (s,i) = i `seq` @@ -460,8 +461,8 @@ -- | Pair each element in a 'Stream' with its index, starting from the right -- and counting down indexedR :: Monad m => Int -> Stream m a -> Stream m (Int,a) -{-# INLINE_STREAM indexedR #-} -indexedR m (Stream step s n) = Stream step' (s,m) n +{-# INLINE_FUSED indexedR #-} +indexedR m (Stream step s) = Stream step' (s,m) where {-# INLINE_INNER step' #-} step' (s,i) = i `seq` @@ -476,9 +477,8 @@ -- | Zip two 'Stream's with the given monadic function zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c -{-# INLINE_STREAM zipWithM #-} -zipWithM f (Stream stepa sa na) (Stream stepb sb nb) - = Stream step (sa, sb, Nothing) (smaller na nb) +{-# INLINE_FUSED zipWithM #-} +zipWithM f (Stream stepa sa) (Stream stepb sb) = Stream step (sa, sb, Nothing) where {-# INLINE_INNER step #-} step (sa, sb, Nothing) = liftM (\r -> @@ -511,9 +511,10 @@ zipWithM_ f sa sb = consume (zipWithM f sa sb) zipWith3M :: Monad m => (a -> b -> c -> m d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -{-# INLINE_STREAM zipWith3M #-} -zipWith3M f (Stream stepa sa na) (Stream stepb sb nb) (Stream stepc sc nc) - = Stream step (sa, sb, sc, Nothing) (smaller na (smaller nb nc)) +{-# INLINE_FUSED zipWith3M #-} +zipWith3M f (Stream stepa sa) + (Stream stepb sb) + (Stream stepc sc) = Stream step (sa, sb, sc, Nothing) where {-# INLINE_INNER step #-} step (sa, sb, sc, Nothing) = do @@ -609,6 +610,65 @@ {-# INLINE zip6 #-} zip6 = zipWith6 (,,,,,) +-- Comparisons +-- ----------- + +-- | Check if two 'Stream's are equal +eq :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool +{-# INLINE_FUSED eq #-} +eq (Stream step1 s1) (Stream step2 s2) = eq_loop0 SPEC s1 s2 + where + eq_loop0 !sPEC s1 s2 = do + r <- step1 s1 + case r of + Yield x s1' -> eq_loop1 SPEC x s1' s2 + Skip s1' -> eq_loop0 SPEC s1' s2 + Done -> eq_null s2 + + eq_loop1 !sPEC x s1 s2 = do + r <- step2 s2 + case r of + Yield y s2' + | x == y -> eq_loop0 SPEC s1 s2' + | otherwise -> return False + Skip s2' -> eq_loop1 SPEC x s1 s2' + Done -> return False + + eq_null s2 = do + r <- step2 s2 + case r of + Yield _ _ -> return False + Skip s2' -> eq_null s2' + Done -> return True + +-- | Lexicographically compare two 'Stream's +cmp :: (Monad m, Ord a) => Stream m a -> Stream m a -> m Ordering +{-# INLINE_FUSED cmp #-} +cmp (Stream step1 s1) (Stream step2 s2) = cmp_loop0 SPEC s1 s2 + where + cmp_loop0 !sPEC s1 s2 = do + r <- step1 s1 + case r of + Yield x s1' -> cmp_loop1 SPEC x s1' s2 + Skip s1' -> cmp_loop0 SPEC s1' s2 + Done -> cmp_null s2 + + cmp_loop1 !sPEC x s1 s2 = do + r <- step2 s2 + case r of + Yield y s2' -> case x `compare` y of + EQ -> cmp_loop0 SPEC s1 s2' + c -> return c + Skip s2' -> cmp_loop1 SPEC x s1 s2' + Done -> return GT + + cmp_null s2 = do + r <- step2 s2 + case r of + Yield _ _ -> return LT + Skip s2' -> cmp_null s2' + Done -> return EQ + -- Filtering -- --------- @@ -619,8 +679,8 @@ -- | Drop elements which do not satisfy the monadic predicate filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a -{-# INLINE_STREAM filterM #-} -filterM f (Stream step s n) = Stream step' s (toMax n) +{-# INLINE_FUSED filterM #-} +filterM f (Stream step s) = Stream step' s where {-# INLINE_INNER step' #-} step' s = do @@ -640,8 +700,8 @@ -- | Longest prefix of elements that satisfy the monadic predicate takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a -{-# INLINE_STREAM takeWhileM #-} -takeWhileM f (Stream step s n) = Stream step' s (toMax n) +{-# INLINE_FUSED takeWhileM #-} +takeWhileM f (Stream step s) = Stream step' s where {-# INLINE_INNER step' #-} step' s = do @@ -662,8 +722,8 @@ -- | Drop the longest prefix of elements that satisfy the monadic predicate dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a -{-# INLINE_STREAM dropWhileM #-} -dropWhileM f (Stream step s n) = Stream step' (DropWhile_Drop s) (toMax n) +{-# INLINE_FUSED dropWhileM #-} +dropWhileM f (Stream step s) = Stream step' (DropWhile_Drop s) where -- NOTE: we jump through hoops here to have only one Yield; local data -- declarations would be nice! @@ -696,8 +756,8 @@ infix 4 `elem` -- | Check whether the 'Stream' contains an element elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool -{-# INLINE_STREAM elem #-} -elem x (Stream step s _) = elem_loop SPEC s +{-# INLINE_FUSED elem #-} +elem x (Stream step s) = elem_loop SPEC s where elem_loop !sPEC s = do @@ -723,8 +783,8 @@ -- | Yield 'Just' the first element that satisfies the monadic predicate or -- 'Nothing' if no such element exists. findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a) -{-# INLINE_STREAM findM #-} -findM f (Stream step s _) = find_loop SPEC s +{-# INLINE_FUSED findM #-} +findM f (Stream step s) = find_loop SPEC s where find_loop !sPEC s = do @@ -740,14 +800,14 @@ -- | Yield 'Just' the index of the first element that satisfies the predicate -- or 'Nothing' if no such element exists. findIndex :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe Int) -{-# INLINE_STREAM findIndex #-} +{-# INLINE_FUSED findIndex #-} findIndex f = findIndexM (return . f) -- | Yield 'Just' the index of the first element that satisfies the monadic -- predicate or 'Nothing' if no such element exists. findIndexM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe Int) -{-# INLINE_STREAM findIndexM #-} -findIndexM f (Stream step s _) = findIndex_loop SPEC s 0 +{-# INLINE_FUSED findIndexM #-} +findIndexM f (Stream step s) = findIndex_loop SPEC s 0 where findIndex_loop !sPEC s i = do @@ -770,8 +830,8 @@ -- | Left fold with a monadic operator foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a -{-# INLINE_STREAM foldlM #-} -foldlM m z (Stream step s _) = foldlM_loop SPEC z s +{-# INLINE_FUSED foldlM #-} +foldlM m z (Stream step s) = foldlM_loop SPEC z s where foldlM_loop !sPEC z s = do @@ -793,14 +853,14 @@ -- | Left fold over a non-empty 'Stream' with a monadic operator foldl1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a -{-# INLINE_STREAM foldl1M #-} -foldl1M f (Stream step s sz) = foldl1M_loop SPEC s +{-# INLINE_FUSED foldl1M #-} +foldl1M f (Stream step s) = foldl1M_loop SPEC s where foldl1M_loop !sPEC s = do r <- step s case r of - Yield x s' -> foldlM f x (Stream step s' (sz - 1)) + Yield x s' -> foldlM f x (Stream step s') Skip s' -> foldl1M_loop SPEC s' Done -> EMPTY_STREAM "foldl1M" @@ -816,8 +876,8 @@ -- | Left fold with a strict accumulator and a monadic operator foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a -{-# INLINE_STREAM foldlM' #-} -foldlM' m z (Stream step s _) = foldlM'_loop SPEC z s +{-# INLINE_FUSED foldlM' #-} +foldlM' m z (Stream step s) = foldlM'_loop SPEC z s where foldlM'_loop !sPEC z s = z `seq` @@ -841,14 +901,14 @@ -- | Left fold over a non-empty 'Stream' with a strict accumulator and a -- monadic operator foldl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> m a -{-# INLINE_STREAM foldl1M' #-} -foldl1M' f (Stream step s sz) = foldl1M'_loop SPEC s +{-# INLINE_FUSED foldl1M' #-} +foldl1M' f (Stream step s) = foldl1M'_loop SPEC s where foldl1M'_loop !sPEC s = do r <- step s case r of - Yield x s' -> foldlM' f x (Stream step s' (sz - 1)) + Yield x s' -> foldlM' f x (Stream step s') Skip s' -> foldl1M'_loop SPEC s' Done -> EMPTY_STREAM "foldl1M'" @@ -864,8 +924,8 @@ -- | Right fold with a monadic operator foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b -{-# INLINE_STREAM foldrM #-} -foldrM f z (Stream step s _) = foldrM_loop SPEC s +{-# INLINE_FUSED foldrM #-} +foldrM f z (Stream step s) = foldrM_loop SPEC s where foldrM_loop !sPEC s = do @@ -882,8 +942,8 @@ -- | Right fold over a non-empty stream with a monadic operator foldr1M :: Monad m => (a -> a -> m a) -> Stream m a -> m a -{-# INLINE_STREAM foldr1M #-} -foldr1M f (Stream step s _) = foldr1M_loop0 SPEC s +{-# INLINE_FUSED foldr1M #-} +foldr1M f (Stream step s) = foldr1M_loop0 SPEC s where foldr1M_loop0 !sPEC s = do @@ -905,8 +965,8 @@ -- ----------------- and :: Monad m => Stream m Bool -> m Bool -{-# INLINE_STREAM and #-} -and (Stream step s _) = and_loop SPEC s +{-# INLINE_FUSED and #-} +and (Stream step s) = and_loop SPEC s where and_loop !sPEC s = do @@ -918,8 +978,8 @@ Done -> return True or :: Monad m => Stream m Bool -> m Bool -{-# INLINE_STREAM or #-} -or (Stream step s _) = or_loop SPEC s +{-# INLINE_FUSED or #-} +or (Stream step s) = or_loop SPEC s where or_loop !sPEC s = do @@ -935,8 +995,8 @@ concatMap f = concatMapM (return . f) concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b -{-# INLINE_STREAM concatMapM #-} -concatMapM f (Stream step s _) = Stream concatMap_go (Left s) Unknown +{-# INLINE_FUSED concatMapM #-} +concatMapM f (Stream step s) = Stream concatMap_go (Left s) where concatMap_go (Left s) = do r <- step s @@ -946,18 +1006,17 @@ return $ Skip (Right (b_stream, s')) Skip s' -> return $ Skip (Left s') Done -> return Done - concatMap_go (Right (Stream inner_step inner_s sz, s)) = do + concatMap_go (Right (Stream inner_step inner_s, s)) = do r <- inner_step inner_s case r of - Yield b inner_s' -> return $ Yield b (Right (Stream inner_step inner_s' sz, s)) - Skip inner_s' -> return $ Skip (Right (Stream inner_step inner_s' sz, s)) + Yield b inner_s' -> return $ Yield b (Right (Stream inner_step inner_s', s)) + Skip inner_s' -> return $ Skip (Right (Stream inner_step inner_s', s)) Done -> return $ Skip (Left s) -- | Create a 'Stream' of values from a 'Stream' of streamable things -flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Size - -> Stream m a -> Stream m b -{-# INLINE_STREAM flatten #-} -flatten mk istep sz (Stream ostep t _) = Stream step (Left t) sz +flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b +{-# INLINE_FUSED flatten #-} +flatten mk istep (Stream ostep t) = Stream step (Left t) where {-# INLINE_INNER step #-} step (Left t) = do @@ -982,13 +1041,13 @@ -- | Unfold unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a -{-# INLINE_STREAM unfoldr #-} +{-# INLINE_FUSED unfoldr #-} unfoldr f = unfoldrM (return . f) -- | Unfold with a monadic function unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a -{-# INLINE_STREAM unfoldrM #-} -unfoldrM f s = Stream step s Unknown +{-# INLINE_FUSED unfoldrM #-} +unfoldrM f s = Stream step s where {-# INLINE_INNER step #-} step s = liftM (\r -> @@ -997,15 +1056,14 @@ Nothing -> Done ) (f s) --- | Unfold at most @n@ elements unfoldrN :: Monad m => Int -> (s -> Maybe (a, s)) -> s -> Stream m a -{-# INLINE_STREAM unfoldrN #-} +{-# INLINE_FUSED unfoldrN #-} unfoldrN n f = unfoldrNM n (return . f) -- | Unfold at most @n@ elements with a monadic functions unfoldrNM :: Monad m => Int -> (s -> m (Maybe (a, s))) -> s -> Stream m a -{-# INLINE_STREAM unfoldrNM #-} -unfoldrNM n f s = Stream step (s,n) (Max (delay_inline max n 0)) +{-# INLINE_FUSED unfoldrNM #-} +unfoldrNM n f s = Stream step (s,n) where {-# INLINE_INNER step #-} step (s,n) | n <= 0 = return Done @@ -1017,8 +1075,8 @@ -- | Apply monadic function n times to value. Zeroth element is original value. iterateNM :: Monad m => Int -> (a -> m a) -> a -> Stream m a -{-# INLINE_STREAM iterateNM #-} -iterateNM n f x0 = Stream step (x0,n) (Exact (delay_inline max n 0)) +{-# INLINE_FUSED iterateNM #-} +iterateNM n f x0 = Stream step (x0,n) where {-# INLINE_INNER step #-} step (x,i) | i <= 0 = return Done @@ -1028,7 +1086,7 @@ -- | Apply function n times to value. Zeroth element is original value. iterateN :: Monad m => Int -> (a -> a) -> a -> Stream m a -{-# INLINE_STREAM iterateN #-} +{-# INLINE_FUSED iterateN #-} iterateN n f x0 = iterateNM n (return . f) x0 -- Scans @@ -1041,8 +1099,8 @@ -- | Prefix scan with a monadic operator prescanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a -{-# INLINE_STREAM prescanlM #-} -prescanlM f z (Stream step s sz) = Stream step' (s,z) sz +{-# INLINE_FUSED prescanlM #-} +prescanlM f z (Stream step s) = Stream step' (s,z) where {-# INLINE_INNER step' #-} step' (s,x) = do @@ -1061,8 +1119,8 @@ -- | Prefix scan with strict accumulator and a monadic operator prescanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a -{-# INLINE_STREAM prescanlM' #-} -prescanlM' f z (Stream step s sz) = Stream step' (s,z) sz +{-# INLINE_FUSED prescanlM' #-} +prescanlM' f z (Stream step s) = Stream step' (s,z) where {-# INLINE_INNER step' #-} step' (s,x) = x `seq` @@ -1082,8 +1140,8 @@ -- | Suffix scan with a monadic operator postscanlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a -{-# INLINE_STREAM postscanlM #-} -postscanlM f z (Stream step s sz) = Stream step' (s,z) sz +{-# INLINE_FUSED postscanlM #-} +postscanlM f z (Stream step s) = Stream step' (s,z) where {-# INLINE_INNER step' #-} step' (s,x) = do @@ -1102,8 +1160,8 @@ -- | Suffix scan with strict acccumulator and a monadic operator postscanlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> Stream m a -{-# INLINE_STREAM postscanlM' #-} -postscanlM' f z (Stream step s sz) = z `seq` Stream step' (s,z) sz +{-# INLINE_FUSED postscanlM' #-} +postscanlM' f z (Stream step s) = z `seq` Stream step' (s,z) where {-# INLINE_INNER step' #-} step' (s,x) = x `seq` @@ -1143,8 +1201,8 @@ -- | Scan over a non-empty 'Stream' with a monadic operator scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a -{-# INLINE_STREAM scanl1M #-} -scanl1M f (Stream step s sz) = Stream step' (s, Nothing) sz +{-# INLINE_FUSED scanl1M #-} +scanl1M f (Stream step s) = Stream step' (s, Nothing) where {-# INLINE_INNER step' #-} step' (s, Nothing) = do @@ -1171,8 +1229,8 @@ -- | Scan over a non-empty 'Stream' with a strict accumulator and a monadic -- operator scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a -{-# INLINE_STREAM scanl1M' #-} -scanl1M' f (Stream step s sz) = Stream step' (s, Nothing) sz +{-# INLINE_FUSED scanl1M' #-} +scanl1M' f (Stream step s) = Stream step' (s, Nothing) where {-# INLINE_INNER step' #-} step' (s, Nothing) = do @@ -1202,9 +1260,8 @@ -- | Yield a 'Stream' of the given length containing the values @x@, @x+y@, -- @x+y+y@ etc. enumFromStepN :: (Num a, Monad m) => a -> a -> Int -> Stream m a -{-# INLINE_STREAM enumFromStepN #-} -enumFromStepN x y n = x `seq` y `seq` n `seq` - Stream step (x,n) (Exact (delay_inline max n 0)) +{-# INLINE_FUSED enumFromStepN #-} +enumFromStepN x y n = x `seq` y `seq` n `seq` Stream step (x,n) where {-# INLINE_INNER step #-} step (x,n) | n > 0 = return $ Yield x (x+y,n-1) @@ -1215,7 +1272,7 @@ -- /WARNING:/ This operation can be very inefficient. If at all possible, use -- 'enumFromStepN' instead. enumFromTo :: (Enum a, Monad m) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo #-} +{-# INLINE_FUSED enumFromTo #-} enumFromTo x y = fromList [x .. y] -- NOTE: We use (x+1) instead of (succ x) below because the latter checks for @@ -1223,11 +1280,9 @@ -- FIXME: add "too large" test for Int enumFromTo_small :: (Integral a, Monad m) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo_small #-} -enumFromTo_small x y = x `seq` y `seq` Stream step x (Exact n) +{-# INLINE_FUSED enumFromTo_small #-} +enumFromTo_small x y = x `seq` y `seq` Stream step x where - n = delay_inline max (fromIntegral y - fromIntegral x + 1) 0 - {-# INLINE_INNER step #-} step x | x <= y = return $ Yield x (x+1) | otherwise = return $ Done @@ -1274,15 +1329,16 @@ -- unsigned types). See http://hackage.haskell.org/trac/ghc/ticket/3744 -- -enumFromTo_int :: (Integral a, Monad m) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo_int #-} -enumFromTo_int x y = x `seq` y `seq` Stream step x (Exact (len x y)) +enumFromTo_int :: forall m. Monad m => Int -> Int -> Stream m Int +{-# INLINE_FUSED enumFromTo_int #-} +enumFromTo_int x y = x `seq` y `seq` Stream step x where {-# INLINE [0] len #-} + len :: Int -> Int -> Int len x y | x > y = 0 | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" (n > 0) - $ fromIntegral n + $ n where n = y-x+1 @@ -1290,6 +1346,14 @@ step x | x <= y = return $ Yield x (x+1) | otherwise = return $ Done +enumFromTo_intlike :: (Integral a, Monad m) => a -> a -> Stream m a +{-# INLINE_FUSED enumFromTo_intlike #-} +enumFromTo_intlike x y = x `seq` y `seq` Stream step x + where + {-# INLINE_INNER step #-} + step x | x <= y = return $ Yield x (x+1) + | otherwise = return $ Done + {-# RULES "enumFromTo [Stream]" @@ -1298,29 +1362,21 @@ #if WORD_SIZE_IN_BITS > 32 "enumFromTo [Stream]" - enumFromTo = enumFromTo_int :: Monad m => Int64 -> Int64 -> Stream m Int64 + enumFromTo = enumFromTo_intlike :: Monad m => Int64 -> Int64 -> Stream m Int64 #else "enumFromTo [Stream]" - enumFromTo = enumFromTo_int :: Monad m => Int32 -> Int32 -> Stream m Int32 + enumFromTo = enumFromTo_intlike :: Monad m => Int32 -> Int32 -> Stream m Int32 #endif #-} enumFromTo_big_word :: (Integral a, Monad m) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo_big_word #-} -enumFromTo_big_word x y = x `seq` y `seq` Stream step x (Exact (len x y)) +{-# INLINE_FUSED enumFromTo_big_word #-} +enumFromTo_big_word x y = x `seq` y `seq` Stream step x where - {-# INLINE [0] len #-} - len x y | x > y = 0 - | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" - (n < fromIntegral (maxBound :: Int)) - $ fromIntegral (n+1) - where - n = y-x - {-# INLINE_INNER step #-} step x | x <= y = return $ Yield x (x+1) | otherwise = return $ Done @@ -1350,17 +1406,9 @@ -- FIXME: the "too large" test is totally wrong enumFromTo_big_int :: (Integral a, Monad m) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo_big_int #-} -enumFromTo_big_int x y = x `seq` y `seq` Stream step x (Exact (len x y)) +{-# INLINE_FUSED enumFromTo_big_int #-} +enumFromTo_big_int x y = x `seq` y `seq` Stream step x where - {-# INLINE [0] len #-} - len x y | x > y = 0 - | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" - (n > 0 && n <= fromIntegral (maxBound :: Int)) - $ fromIntegral n - where - n = y-x+1 - {-# INLINE_INNER step #-} step x | x <= y = return $ Yield x (x+1) | otherwise = return $ Done @@ -1377,14 +1425,12 @@ #endif enumFromTo_char :: Monad m => Char -> Char -> Stream m Char -{-# INLINE_STREAM enumFromTo_char #-} -enumFromTo_char x y = x `seq` y `seq` Stream step xn (Exact n) +{-# INLINE_FUSED enumFromTo_char #-} +enumFromTo_char x y = x `seq` y `seq` Stream step xn where xn = ord x yn = ord y - n = delay_inline max 0 (yn - xn + 1) - {-# INLINE_INNER step #-} step xn | xn <= yn = return $ Yield (unsafeChr xn) (xn+1) | otherwise = return $ Done @@ -1402,19 +1448,11 @@ -- Also, try to do something about pairs? enumFromTo_double :: (Monad m, Ord a, RealFrac a) => a -> a -> Stream m a -{-# INLINE_STREAM enumFromTo_double #-} -enumFromTo_double n m = n `seq` m `seq` Stream step n (Max (len n m)) +{-# INLINE_FUSED enumFromTo_double #-} +enumFromTo_double n m = n `seq` m `seq` Stream step n where lim = m + 1/2 -- important to float out - {-# INLINE [0] len #-} - len x y | x > y = 0 - | otherwise = BOUNDS_CHECK(check) "enumFromTo" "vector too large" - (n > 0) - $ fromIntegral n - where - n = truncate (y-x)+2 - {-# INLINE_INNER step #-} step x | x <= lim = return $ Yield x (x+1) | otherwise = return $ Done @@ -1436,7 +1474,7 @@ -- /WARNING:/ This operation is very inefficient. If at all possible, use -- 'enumFromStepN' instead. enumFromThenTo :: (Enum a, Monad m) => a -> a -> a -> Stream m a -{-# INLINE_STREAM enumFromThenTo #-} +{-# INLINE_FUSED enumFromThenTo #-} enumFromThenTo x y z = fromList [x, y .. z] -- FIXME: Specialise enumFromThenTo. @@ -1452,23 +1490,110 @@ -- | Convert a list to a 'Stream' fromList :: Monad m => [a] -> Stream m a {-# INLINE fromList #-} -fromList xs = unsafeFromList Unknown xs +fromList xs = Stream step xs + where + step (x:xs) = return (Yield x xs) + step [] = return Done --- | Convert the first @n@ elements of a list to a 'Stream' +-- | Convert the first @n@ elements of a list to a 'Bundle' fromListN :: Monad m => Int -> [a] -> Stream m a -{-# INLINE_STREAM fromListN #-} -fromListN n xs = Stream step (xs,n) (Max (delay_inline max n 0)) +{-# INLINE_FUSED fromListN #-} +fromListN n xs = Stream step (xs,n) where {-# INLINE_INNER step #-} step (xs,n) | n <= 0 = return Done step (x:xs,n) = return (Yield x (xs,n-1)) step ([],n) = return Done --- | Convert a list to a 'Stream' with the given 'Size' hint. -unsafeFromList :: Monad m => Size -> [a] -> Stream m a -{-# INLINE_STREAM unsafeFromList #-} -unsafeFromList sz xs = Stream step xs sz +{- +fromVector :: (Monad m, Vector v a) => v a -> Stream m a +{-# INLINE_FUSED fromVector #-} +fromVector v = v `seq` n `seq` Stream (Unf step 0) + (Unf vstep True) + (Just v) + (Exact n) where - step (x:xs) = return (Yield x xs) - step [] = return Done + n = basicLength v + + {-# INLINE step #-} + step i | i >= n = return Done + | otherwise = case basicUnsafeIndexM v i of + Box x -> return $ Yield x (i+1) + + + {-# INLINE vstep #-} + vstep True = return (Yield (Chunk (basicLength v) (\mv -> basicUnsafeCopy mv v)) False) + vstep False = return Done + +fromVectors :: forall m a. (Monad m, Vector v a) => [v a] -> Stream m a +{-# INLINE_FUSED fromVectors #-} +fromVectors vs = Stream (Unf pstep (Left vs)) + (Unf vstep vs) + Nothing + (Exact n) + where + n = List.foldl' (\k v -> k + basicLength v) 0 vs + + pstep (Left []) = return Done + pstep (Left (v:vs)) = basicLength v `seq` return (Skip (Right (v,0,vs))) + + pstep (Right (v,i,vs)) + | i >= basicLength v = return $ Skip (Left vs) + | otherwise = case basicUnsafeIndexM v i of + Box x -> return $ Yield x (Right (v,i+1,vs)) + + -- FIXME: work around bug in GHC 7.6.1 + vstep :: [v a] -> m (Step [v a] (Chunk v a)) + vstep [] = return Done + vstep (v:vs) = return $ Yield (Chunk (basicLength v) + (\mv -> INTERNAL_CHECK(check) "concatVectors" "length mismatch" + (M.basicLength mv == basicLength v) + $ basicUnsafeCopy mv v)) vs + + +concatVectors :: (Monad m, Vector v a) => Stream m (v a) -> Stream m a +{-# INLINE_FUSED concatVectors #-} +concatVectors (Stream step s} + = Stream (Unf pstep (Left s)) + (Unf vstep s) + Nothing + Unknown + where + pstep (Left s) = do + r <- step s + case r of + Yield v s' -> basicLength v `seq` return (Skip (Right (v,0,s'))) + Skip s' -> return (Skip (Left s')) + Done -> return Done + + pstep (Right (v,i,s)) + | i >= basicLength v = return (Skip (Left s)) + | otherwise = case basicUnsafeIndexM v i of + Box x -> return (Yield x (Right (v,i+1,s))) + + + vstep s = do + r <- step s + case r of + Yield v s' -> return (Yield (Chunk (basicLength v) + (\mv -> INTERNAL_CHECK(check) "concatVectors" "length mismatch" + (M.basicLength mv == basicLength v) + $ basicUnsafeCopy mv v)) s') + Skip s' -> return (Skip s') + Done -> return Done + +reVector :: Monad m => Stream m a -> Stream m a +{-# INLINE_FUSED reVector #-} +reVector (Stream step s, sSize = n} = Stream step s n + +{-# RULES + +"reVector [Vector]" + reVector = id + +"reVector/reVector [Vector]" forall s. + reVector (reVector s) = s + + #-} +-} diff --git a/Data/Vector/Fusion/Stream/Size.hs b/Data/Vector/Fusion/Stream/Size.hs deleted file mode 100644 --- a/Data/Vector/Fusion/Stream/Size.hs +++ /dev/null @@ -1,87 +0,0 @@ --- | --- Module : Data.Vector.Fusion.Stream.Size --- Copyright : (c) Roman Leshchinskiy 2008-2010 --- License : BSD-style --- --- Maintainer : Roman Leshchinskiy --- Stability : experimental --- Portability : portable --- --- Size hints for streams. --- - -module Data.Vector.Fusion.Stream.Size ( - Size(..), smaller, larger, toMax, upperBound -) where - -import Data.Vector.Fusion.Util ( delay_inline ) - --- | Size hint -data Size = Exact Int -- ^ Exact size - | Max Int -- ^ Upper bound on the size - | Unknown -- ^ Unknown size - deriving( Eq, Show ) - -instance Num Size where - Exact m + Exact n = Exact (m+n) - Exact m + Max n = Max (m+n) - - Max m + Exact n = Max (m+n) - Max m + Max n = Max (m+n) - - _ + _ = Unknown - - - Exact m - Exact n = Exact (m-n) - Exact m - Max n = Max m - - Max m - Exact n = Max (m-n) - Max m - Max n = Max m - Max m - Unknown = Max m - - _ - _ = Unknown - - - fromInteger n = Exact (fromInteger n) - --- | Minimum of two size hints -smaller :: Size -> Size -> Size -{-# INLINE smaller #-} -smaller (Exact m) (Exact n) = Exact (delay_inline min m n) -smaller (Exact m) (Max n) = Max (delay_inline min m n) -smaller (Exact m) Unknown = Max m -smaller (Max m) (Exact n) = Max (delay_inline min m n) -smaller (Max m) (Max n) = Max (delay_inline min m n) -smaller (Max m) Unknown = Max m -smaller Unknown (Exact n) = Max n -smaller Unknown (Max n) = Max n -smaller Unknown Unknown = Unknown - --- | Maximum of two size hints -larger :: Size -> Size -> Size -{-# INLINE larger #-} -larger (Exact m) (Exact n) = Exact (delay_inline max m n) -larger (Exact m) (Max n) | m >= n = Exact m - | otherwise = Max n -larger (Max m) (Exact n) | n >= m = Exact n - | otherwise = Max m -larger (Max m) (Max n) = Max (delay_inline max m n) -larger _ _ = Unknown - --- | Convert a size hint to an upper bound -toMax :: Size -> Size -toMax (Exact n) = Max n -toMax (Max n) = Max n -toMax Unknown = Unknown - --- | Compute the minimum size from a size hint -lowerBound :: Size -> Int -lowerBound (Exact n) = n -lowerBound _ = 0 - --- | Compute the maximum size from a size hint if possible -upperBound :: Size -> Maybe Int -upperBound (Exact n) = Just n -upperBound (Max n) = Just n -upperBound Unknown = Nothing - diff --git a/Data/Vector/Generic.hs b/Data/Vector/Generic.hs --- a/Data/Vector/Generic.hs +++ b/Data/Vector/Generic.hs @@ -142,7 +142,7 @@ -- * Fusion support - -- ** Conversion to/from Streams + -- ** Conversion to/from Bundles stream, unstream, streamR, unstreamR, -- ** Recycling support @@ -168,10 +168,12 @@ import qualified Data.Vector.Generic.New as New import Data.Vector.Generic.New ( New ) -import qualified Data.Vector.Fusion.Stream as Stream -import Data.Vector.Fusion.Stream ( Stream, MStream, Step(..), inplace, liftStream ) -import qualified Data.Vector.Fusion.Stream.Monadic as MStream -import Data.Vector.Fusion.Stream.Size +import qualified Data.Vector.Fusion.Bundle as Bundle +import Data.Vector.Fusion.Bundle ( Bundle, MBundle, Step(..), lift, inplace ) +import qualified Data.Vector.Fusion.Bundle.Monadic as MBundle +import Data.Vector.Fusion.Stream.Monadic ( Stream ) +import qualified Data.Vector.Fusion.Stream.Monadic as S +import Data.Vector.Fusion.Bundle.Size import Data.Vector.Fusion.Util import Control.Monad.ST ( ST, runST ) @@ -194,7 +196,12 @@ showsPrec ) import qualified Text.Read as Read + +#if __GLASGOW_HASKELL__ >= 707 +import Data.Typeable ( Typeable, gcast1 ) +#else import Data.Typeable ( Typeable1, gcast1 ) +#endif #include "vector.h" @@ -212,27 +219,13 @@ -- | /O(1)/ Yield the length of the vector. length :: Vector v a => v a -> Int -{-# INLINE_STREAM length #-} -length v = basicLength v - -{-# RULES - -"length/unstream [Vector]" forall s. - length (new (New.unstream s)) = Stream.length s - - #-} +{-# INLINE length #-} +length = Bundle.length . stream -- | /O(1)/ Test whether a vector if empty null :: Vector v a => v a -> Bool -{-# INLINE_STREAM null #-} -null v = basicLength v == 0 - -{-# RULES - -"null/unstream [Vector]" forall s. - null (new (New.unstream s)) = Stream.null s - - #-} +{-# INLINE null #-} +null = Bundle.null . stream -- Indexing -- -------- @@ -240,65 +233,65 @@ infixl 9 ! -- | O(1) Indexing (!) :: Vector v a => v a -> Int -> a -{-# INLINE_STREAM (!) #-} +{-# INLINE_FUSED (!) #-} (!) v i = BOUNDS_CHECK(checkIndex) "(!)" i (length v) $ unId (basicUnsafeIndexM v i) infixl 9 !? -- | O(1) Safe indexing (!?) :: Vector v a => v a -> Int -> Maybe a -{-# INLINE_STREAM (!?) #-} +{-# INLINE_FUSED (!?) #-} v !? i | i < 0 || i >= length v = Nothing | otherwise = Just $ unsafeIndex v i -- | /O(1)/ First element head :: Vector v a => v a -> a -{-# INLINE_STREAM head #-} +{-# INLINE_FUSED head #-} head v = v ! 0 -- | /O(1)/ Last element last :: Vector v a => v a -> a -{-# INLINE_STREAM last #-} +{-# INLINE_FUSED last #-} last v = v ! (length v - 1) -- | /O(1)/ Unsafe indexing without bounds checking unsafeIndex :: Vector v a => v a -> Int -> a -{-# INLINE_STREAM unsafeIndex #-} +{-# INLINE_FUSED unsafeIndex #-} unsafeIndex v i = UNSAFE_CHECK(checkIndex) "unsafeIndex" i (length v) $ unId (basicUnsafeIndexM v i) -- | /O(1)/ First element without checking if the vector is empty unsafeHead :: Vector v a => v a -> a -{-# INLINE_STREAM unsafeHead #-} +{-# INLINE_FUSED unsafeHead #-} unsafeHead v = unsafeIndex v 0 -- | /O(1)/ Last element without checking if the vector is empty unsafeLast :: Vector v a => v a -> a -{-# INLINE_STREAM unsafeLast #-} +{-# INLINE_FUSED unsafeLast #-} unsafeLast v = unsafeIndex v (length v - 1) {-# RULES "(!)/unstream [Vector]" forall i s. - new (New.unstream s) ! i = s Stream.!! i + new (New.unstream s) ! i = s Bundle.!! i "(!?)/unstream [Vector]" forall i s. - new (New.unstream s) !? i = s Stream.!? i + new (New.unstream s) !? i = s Bundle.!? i "head/unstream [Vector]" forall s. - head (new (New.unstream s)) = Stream.head s + head (new (New.unstream s)) = Bundle.head s "last/unstream [Vector]" forall s. - last (new (New.unstream s)) = Stream.last s + last (new (New.unstream s)) = Bundle.last s "unsafeIndex/unstream [Vector]" forall i s. - unsafeIndex (new (New.unstream s)) i = s Stream.!! i + unsafeIndex (new (New.unstream s)) i = s Bundle.!! i "unsafeHead/unstream [Vector]" forall s. - unsafeHead (new (New.unstream s)) = Stream.head s + unsafeHead (new (New.unstream s)) = Bundle.head s "unsafeLast/unstream [Vector]" forall s. - unsafeLast (new (New.unstream s)) = Stream.last s + unsafeLast (new (New.unstream s)) = Bundle.last s #-} @@ -325,60 +318,60 @@ -- elements) is evaluated eagerly. -- indexM :: (Vector v a, Monad m) => v a -> Int -> m a -{-# INLINE_STREAM indexM #-} +{-# INLINE_FUSED indexM #-} indexM v i = BOUNDS_CHECK(checkIndex) "indexM" i (length v) $ basicUnsafeIndexM v i -- | /O(1)/ First element of a vector in a monad. See 'indexM' for an -- explanation of why this is useful. headM :: (Vector v a, Monad m) => v a -> m a -{-# INLINE_STREAM headM #-} +{-# INLINE_FUSED headM #-} headM v = indexM v 0 -- | /O(1)/ Last element of a vector in a monad. See 'indexM' for an -- explanation of why this is useful. lastM :: (Vector v a, Monad m) => v a -> m a -{-# INLINE_STREAM lastM #-} +{-# INLINE_FUSED lastM #-} lastM v = indexM v (length v - 1) -- | /O(1)/ Indexing in a monad without bounds checks. See 'indexM' for an -- explanation of why this is useful. unsafeIndexM :: (Vector v a, Monad m) => v a -> Int -> m a -{-# INLINE_STREAM unsafeIndexM #-} +{-# INLINE_FUSED unsafeIndexM #-} unsafeIndexM v i = UNSAFE_CHECK(checkIndex) "unsafeIndexM" i (length v) $ basicUnsafeIndexM v i -- | /O(1)/ First element in a monad without checking for empty vectors. -- See 'indexM' for an explanation of why this is useful. unsafeHeadM :: (Vector v a, Monad m) => v a -> m a -{-# INLINE_STREAM unsafeHeadM #-} +{-# INLINE_FUSED unsafeHeadM #-} unsafeHeadM v = unsafeIndexM v 0 -- | /O(1)/ Last element in a monad without checking for empty vectors. -- See 'indexM' for an explanation of why this is useful. unsafeLastM :: (Vector v a, Monad m) => v a -> m a -{-# INLINE_STREAM unsafeLastM #-} +{-# INLINE_FUSED unsafeLastM #-} unsafeLastM v = unsafeIndexM v (length v - 1) {-# RULES "indexM/unstream [Vector]" forall s i. - indexM (new (New.unstream s)) i = liftStream s MStream.!! i + indexM (new (New.unstream s)) i = lift s MBundle.!! i "headM/unstream [Vector]" forall s. - headM (new (New.unstream s)) = MStream.head (liftStream s) + headM (new (New.unstream s)) = MBundle.head (lift s) "lastM/unstream [Vector]" forall s. - lastM (new (New.unstream s)) = MStream.last (liftStream s) + lastM (new (New.unstream s)) = MBundle.last (lift s) "unsafeIndexM/unstream [Vector]" forall s i. - unsafeIndexM (new (New.unstream s)) i = liftStream s MStream.!! i + unsafeIndexM (new (New.unstream s)) i = lift s MBundle.!! i "unsafeHeadM/unstream [Vector]" forall s. - unsafeHeadM (new (New.unstream s)) = MStream.head (liftStream s) + unsafeHeadM (new (New.unstream s)) = MBundle.head (lift s) "unsafeLastM/unstream [Vector]" forall s. - unsafeLastM (new (New.unstream s)) = MStream.last (liftStream s) + unsafeLastM (new (New.unstream s)) = MBundle.last (lift s) #-} @@ -391,33 +384,33 @@ -> Int -- ^ @n@ length -> v a -> v a -{-# INLINE_STREAM slice #-} +{-# INLINE_FUSED slice #-} slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v) $ basicUnsafeSlice i n v -- | /O(1)/ Yield all but the last element without copying. The vector may not -- be empty. init :: Vector v a => v a -> v a -{-# INLINE_STREAM init #-} +{-# INLINE_FUSED init #-} init v = slice 0 (length v - 1) v -- | /O(1)/ Yield all but the first element without copying. The vector may not -- be empty. tail :: Vector v a => v a -> v a -{-# INLINE_STREAM tail #-} +{-# INLINE_FUSED tail #-} tail v = slice 1 (length v - 1) v -- | /O(1)/ Yield the first @n@ elements without copying. The vector may -- contain less than @n@ elements in which case it is returned unchanged. take :: Vector v a => Int -> v a -> v a -{-# INLINE_STREAM take #-} +{-# INLINE_FUSED take #-} take n v = unsafeSlice 0 (delay_inline min n' (length v)) v where n' = max n 0 -- | /O(1)/ Yield all but the first @n@ elements without copying. The vector may -- contain less than @n@ elements in which case an empty vector is returned. drop :: Vector v a => Int -> v a -> v a -{-# INLINE_STREAM drop #-} +{-# INLINE_FUSED drop #-} drop n v = unsafeSlice (delay_inline min n' len) (delay_inline max 0 (len - n')) v where n' = max n 0 @@ -427,7 +420,7 @@ -- -- Note that @'splitAt' n v@ is equivalent to @('take' n v, 'drop' n v)@ -- but slightly more efficient. -{-# INLINE_STREAM splitAt #-} +{-# INLINE_FUSED splitAt #-} splitAt :: Vector v a => Int -> v a -> (v a, v a) splitAt n v = ( unsafeSlice 0 m v , unsafeSlice m (delay_inline max 0 (len - n')) v @@ -443,20 +436,20 @@ -> Int -- ^ @n@ length -> v a -> v a -{-# INLINE_STREAM unsafeSlice #-} +{-# INLINE_FUSED unsafeSlice #-} unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v) $ basicUnsafeSlice i n v -- | /O(1)/ Yield all but the last element without copying. The vector may not -- be empty but this is not checked. unsafeInit :: Vector v a => v a -> v a -{-# INLINE_STREAM unsafeInit #-} +{-# INLINE_FUSED unsafeInit #-} unsafeInit v = unsafeSlice 0 (length v - 1) v -- | /O(1)/ Yield all but the first element without copying. The vector may not -- be empty but this is not checked. unsafeTail :: Vector v a => v a -> v a -{-# INLINE_STREAM unsafeTail #-} +{-# INLINE_FUSED unsafeTail #-} unsafeTail v = unsafeSlice 1 (length v - 1) v -- | /O(1)/ Yield the first @n@ elements without copying. The vector must @@ -505,31 +498,31 @@ -- | /O(1)/ Empty vector empty :: Vector v a => v a {-# INLINE empty #-} -empty = unstream Stream.empty +empty = unstream Bundle.empty -- | /O(1)/ Vector with exactly one element singleton :: forall v a. Vector v a => a -> v a {-# INLINE singleton #-} singleton x = elemseq (undefined :: v a) x - $ unstream (Stream.singleton x) + $ unstream (Bundle.singleton x) -- | /O(n)/ Vector of the given length with the same value in each position replicate :: forall v a. Vector v a => Int -> a -> v a {-# INLINE replicate #-} replicate n x = elemseq (undefined :: v a) x $ unstream - $ Stream.replicate n x + $ Bundle.replicate n x -- | /O(n)/ Construct a vector of the given length by applying the function to -- each index generate :: Vector v a => Int -> (Int -> a) -> v a {-# INLINE generate #-} -generate n f = unstream (Stream.generate n f) +generate n f = unstream (Bundle.generate n f) -- | /O(n)/ Apply function n times to value. Zeroth element is original value. iterateN :: Vector v a => Int -> (a -> a) -> a -> v a {-# INLINE iterateN #-} -iterateN n f x = unstream (Stream.iterateN n f x) +iterateN n f x = unstream (Bundle.iterateN n f x) -- Unfolding -- --------- @@ -542,7 +535,7 @@ -- > = <10,9,8,7,6,5,4,3,2,1> unfoldr :: Vector v a => (b -> Maybe (a, b)) -> b -> v a {-# INLINE unfoldr #-} -unfoldr f = unstream . Stream.unfoldr f +unfoldr f = unstream . Bundle.unfoldr f -- | /O(n)/ Construct a vector with at most @n@ by repeatedly applying the -- generator function to the a seed. The generator function yields 'Just' the @@ -551,7 +544,7 @@ -- > unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8> unfoldrN :: Vector v a => Int -> (b -> Maybe (a, b)) -> b -> v a {-# INLINE unfoldrN #-} -unfoldrN n f = unstream . Stream.unfoldrN n f +unfoldrN n f = unstream . Bundle.unfoldrN n f -- | /O(n)/ Construct a vector with @n@ elements by repeatedly applying the -- generator function to the already constructed part of the vector. @@ -631,7 +624,7 @@ enumFromStepN x y n = elemseq (undefined :: v a) x $ elemseq (undefined :: v a) y $ unstream - $ Stream.enumFromStepN x y n + $ Bundle.enumFromStepN x y n -- | /O(n)/ Enumerate values from @x@ to @y@. -- @@ -639,7 +632,7 @@ -- 'enumFromN' instead. enumFromTo :: (Vector v a, Enum a) => a -> a -> v a {-# INLINE enumFromTo #-} -enumFromTo x y = unstream (Stream.enumFromTo x y) +enumFromTo x y = unstream (Bundle.enumFromTo x y) -- | /O(n)/ Enumerate values from @x@ to @y@ with a specific step @z@. -- @@ -647,7 +640,7 @@ -- 'enumFromStepN' instead. enumFromThenTo :: (Vector v a, Enum a) => a -> a -> a -> v a {-# INLINE enumFromThenTo #-} -enumFromThenTo x y z = unstream (Stream.enumFromThenTo x y z) +enumFromThenTo x y z = unstream (Bundle.enumFromThenTo x y z) -- Concatenation -- ------------- @@ -657,7 +650,7 @@ {-# INLINE cons #-} cons x v = elemseq (undefined :: v a) x $ unstream - $ Stream.cons x + $ Bundle.cons x $ stream v -- | /O(n)/ Append an element @@ -665,31 +658,34 @@ {-# INLINE snoc #-} snoc v x = elemseq (undefined :: v a) x $ unstream - $ Stream.snoc (stream v) x + $ Bundle.snoc (stream v) x infixr 5 ++ -- | /O(m+n)/ Concatenate two vectors (++) :: Vector v a => v a -> v a -> v a {-# INLINE (++) #-} -v ++ w = unstream (stream v Stream.++ stream w) +v ++ w = unstream (stream v Bundle.++ stream w) -- | /O(n)/ Concatenate all vectors in the list concat :: Vector v a => [v a] -> v a {-# INLINE concat #-} -concat vs = unstream (Stream.flatten mk step (Exact n) (Stream.fromList vs)) +concat = unstream . Bundle.fromVectors +{- +concat vs = unstream (Bundle.flatten mk step (Exact n) (Bundle.fromList vs)) where n = List.foldl' (\k v -> k + length v) 0 vs {-# INLINE_INNER step #-} step (v,i,k) | i < k = case unsafeIndexM v i of - Box x -> Stream.Yield x (v,i+1,k) - | otherwise = Stream.Done + Box x -> Bundle.Yield x (v,i+1,k) + | otherwise = Bundle.Done {-# INLINE mk #-} mk v = let k = length v in k `seq` (v,0,k) +-} -- Monadic initialisation -- ---------------------- @@ -698,13 +694,13 @@ -- results in a vector. replicateM :: (Monad m, Vector v a) => Int -> m a -> m (v a) {-# INLINE replicateM #-} -replicateM n m = unstreamM (MStream.replicateM n m) +replicateM n m = unstreamM (MBundle.replicateM n m) -- | /O(n)/ Construct a vector of the given length by applying the monadic -- action to each index generateM :: (Monad m, Vector v a) => Int -> (Int -> m a) -> m (v a) {-# INLINE generateM #-} -generateM n f = unstreamM (MStream.generateM n f) +generateM n f = unstreamM (MBundle.generateM n f) -- | Execute the monadic action and freeze the resulting vector. -- @@ -731,7 +727,7 @@ force :: Vector v a => v a -> v a -- FIXME: we probably ought to inline this later as the rules still might fire -- otherwise -{-# INLINE_STREAM force #-} +{-# INLINE_FUSED force #-} force v = new (clone v) -- Bulk updates @@ -746,7 +742,7 @@ -> [(Int, a)] -- ^ list of index/value pairs (of length @n@) -> v a {-# INLINE (//) #-} -v // us = update_stream v (Stream.fromList us) +v // us = update_stream v (Bundle.fromList us) -- | /O(m+n)/ For each pair @(i,a)@ from the vector of index/value pairs, -- replace the vector element at position @i@ by @a@. @@ -778,16 +774,16 @@ -> v a -- ^ value vector (of length @n2@) -> v a {-# INLINE update_ #-} -update_ v is w = update_stream v (Stream.zipWith (,) (stream is) (stream w)) +update_ v is w = update_stream v (Bundle.zipWith (,) (stream is) (stream w)) -update_stream :: Vector v a => v a -> Stream (Int,a) -> v a +update_stream :: Vector v a => v a -> Bundle u (Int,a) -> v a {-# INLINE update_stream #-} -update_stream = modifyWithStream M.update +update_stream = modifyWithBundle M.update -- | Same as ('//') but without bounds checking. unsafeUpd :: Vector v a => v a -> [(Int, a)] -> v a {-# INLINE unsafeUpd #-} -unsafeUpd v us = unsafeUpdate_stream v (Stream.fromList us) +unsafeUpd v us = unsafeUpdate_stream v (Bundle.fromList us) -- | Same as 'update' but without bounds checking. unsafeUpdate :: (Vector v a, Vector v (Int, a)) => v a -> v (Int, a) -> v a @@ -798,11 +794,11 @@ unsafeUpdate_ :: (Vector v a, Vector v Int) => v a -> v Int -> v a -> v a {-# INLINE unsafeUpdate_ #-} unsafeUpdate_ v is w - = unsafeUpdate_stream v (Stream.zipWith (,) (stream is) (stream w)) + = unsafeUpdate_stream v (Bundle.zipWith (,) (stream is) (stream w)) -unsafeUpdate_stream :: Vector v a => v a -> Stream (Int,a) -> v a +unsafeUpdate_stream :: Vector v a => v a -> Bundle u (Int,a) -> v a {-# INLINE unsafeUpdate_stream #-} -unsafeUpdate_stream = modifyWithStream M.unsafeUpdate +unsafeUpdate_stream = modifyWithBundle M.unsafeUpdate -- Accumulations -- ------------- @@ -817,7 +813,7 @@ -> [(Int,b)] -- ^ list of index/value pairs (of length @n@) -> v a {-# INLINE accum #-} -accum f v us = accum_stream f v (Stream.fromList us) +accum f v us = accum_stream f v (Bundle.fromList us) -- | /O(m+n)/ For each pair @(i,b)@ from the vector of pairs, replace the vector -- element @a@ at position @i@ by @f a b@. @@ -851,18 +847,18 @@ -> v b -- ^ value vector (of length @n2@) -> v a {-# INLINE accumulate_ #-} -accumulate_ f v is xs = accum_stream f v (Stream.zipWith (,) (stream is) +accumulate_ f v is xs = accum_stream f v (Bundle.zipWith (,) (stream is) (stream xs)) -accum_stream :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a +accum_stream :: Vector v a => (a -> b -> a) -> v a -> Bundle u (Int,b) -> v a {-# INLINE accum_stream #-} -accum_stream f = modifyWithStream (M.accum f) +accum_stream f = modifyWithBundle (M.accum f) -- | Same as 'accum' but without bounds checking. unsafeAccum :: Vector v a => (a -> b -> a) -> v a -> [(Int,b)] -> v a {-# INLINE unsafeAccum #-} -unsafeAccum f v us = unsafeAccum_stream f v (Stream.fromList us) +unsafeAccum f v us = unsafeAccum_stream f v (Bundle.fromList us) -- | Same as 'accumulate' but without bounds checking. unsafeAccumulate :: (Vector v a, Vector v (Int, b)) @@ -875,12 +871,12 @@ => (a -> b -> a) -> v a -> v Int -> v b -> v a {-# INLINE unsafeAccumulate_ #-} unsafeAccumulate_ f v is xs - = unsafeAccum_stream f v (Stream.zipWith (,) (stream is) (stream xs)) + = unsafeAccum_stream f v (Bundle.zipWith (,) (stream is) (stream xs)) unsafeAccum_stream - :: Vector v a => (a -> b -> a) -> v a -> Stream (Int,b) -> v a + :: Vector v a => (a -> b -> a) -> v a -> Bundle u (Int,b) -> v a {-# INLINE unsafeAccum_stream #-} -unsafeAccum_stream f = modifyWithStream (M.unsafeAccum f) +unsafeAccum_stream f = modifyWithBundle (M.unsafeAccum f) -- Permutations -- ------------ @@ -907,8 +903,8 @@ backpermute v is = seq v $ seq n $ unstream - $ Stream.unbox - $ Stream.map index + $ Bundle.unbox + $ Bundle.map index $ stream is where n = length v @@ -925,8 +921,8 @@ unsafeBackpermute v is = seq v $ seq n $ unstream - $ Stream.unbox - $ Stream.map index + $ Bundle.unbox + $ Bundle.map index $ stream is where n = length v @@ -953,11 +949,11 @@ -- We have to make sure that this is strict in the stream but we can't seq on -- it while fusion is happening. Hence this ugliness. -modifyWithStream :: Vector v a - => (forall s. Mutable v s a -> Stream b -> ST s ()) - -> v a -> Stream b -> v a -{-# INLINE modifyWithStream #-} -modifyWithStream p v s = new (New.modifyWithStream p (clone v) s) +modifyWithBundle :: Vector v a + => (forall s. Mutable v s a -> Bundle u b -> ST s ()) + -> v a -> Bundle u b -> v a +{-# INLINE modifyWithBundle #-} +modifyWithBundle p v s = new (New.modifyWithBundle p (clone v) s) -- Indexing -- -------- @@ -965,7 +961,7 @@ -- | /O(n)/ Pair each element in a vector with its index indexed :: (Vector v a, Vector v (Int,a)) => v a -> v (Int,a) {-# INLINE indexed #-} -indexed = unstream . Stream.indexed . stream +indexed = unstream . Bundle.indexed . stream -- Mapping -- ------- @@ -973,12 +969,12 @@ -- | /O(n)/ Map a function over a vector map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b {-# INLINE map #-} -map f = unstream . inplace (MStream.map f) . stream +map f = unstream . inplace (S.map f) id . stream -- | /O(n)/ Apply a function to every element of a vector and its index imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b {-# INLINE imap #-} -imap f = unstream . inplace (MStream.map (uncurry f) . MStream.indexed) +imap f = unstream . inplace (S.map (uncurry f) . S.indexed) id . stream -- | Map a function over a vector and concatenate the results. @@ -986,28 +982,36 @@ {-# INLINE concatMap #-} -- NOTE: We can't fuse concatMap anyway so don't pretend we do. -- This seems to be slightly slower --- concatMap f = concat . Stream.toList . Stream.map f . stream +-- concatMap f = concat . Bundle.toList . Bundle.map f . stream -- Slowest --- concatMap f = unstream . Stream.concatMap (stream . f) . stream +-- concatMap f = unstream . Bundle.concatMap (stream . f) . stream --- Seems to be fastest +-- Used to be fastest +{- concatMap f = unstream - . Stream.flatten mk step Unknown + . Bundle.flatten mk step Unknown . stream where {-# INLINE_INNER step #-} step (v,i,k) | i < k = case unsafeIndexM v i of - Box x -> Stream.Yield x (v,i+1,k) - | otherwise = Stream.Done + Box x -> Bundle.Yield x (v,i+1,k) + | otherwise = Bundle.Done {-# INLINE mk #-} mk x = let v = f x k = length v in k `seq` (v,0,k) +-} +-- This seems to be fastest now +concatMap f = unstream + . Bundle.concatVectors + . Bundle.map f + . stream + -- Monadic mapping -- --------------- @@ -1015,13 +1019,13 @@ -- vector of results mapM :: (Monad m, Vector v a, Vector v b) => (a -> m b) -> v a -> m (v b) {-# INLINE mapM #-} -mapM f = unstreamM . Stream.mapM f . stream +mapM f = unstreamM . Bundle.mapM f . stream -- | /O(n)/ Apply the monadic action to all elements of a vector and ignore the -- results mapM_ :: (Monad m, Vector v a) => (a -> m b) -> v a -> m () {-# INLINE mapM_ #-} -mapM_ f = Stream.mapM_ f . stream +mapM_ f = Bundle.mapM_ f . stream -- | /O(n)/ Apply the monadic action to all elements of the vector, yielding a -- vector of results. Equvalent to @flip 'mapM'@. @@ -1042,13 +1046,13 @@ zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c {-# INLINE zipWith #-} -zipWith f xs ys = unstream (Stream.zipWith f (stream xs) (stream ys)) +zipWith f xs ys = unstream (Bundle.zipWith f (stream xs) (stream ys)) -- | Zip three vectors with the given function. zipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (a -> b -> c -> d) -> v a -> v b -> v c -> v d {-# INLINE zipWith3 #-} -zipWith3 f as bs cs = unstream (Stream.zipWith3 f (stream as) +zipWith3 f as bs cs = unstream (Bundle.zipWith3 f (stream as) (stream bs) (stream cs)) @@ -1056,7 +1060,7 @@ => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e {-# INLINE zipWith4 #-} zipWith4 f as bs cs ds - = unstream (Stream.zipWith4 f (stream as) + = unstream (Bundle.zipWith4 f (stream as) (stream bs) (stream cs) (stream ds)) @@ -1067,7 +1071,7 @@ -> v f {-# INLINE zipWith5 #-} zipWith5 f as bs cs ds es - = unstream (Stream.zipWith5 f (stream as) + = unstream (Bundle.zipWith5 f (stream as) (stream bs) (stream cs) (stream ds) @@ -1079,7 +1083,7 @@ -> v a -> v b -> v c -> v d -> v e -> v f -> v g {-# INLINE zipWith6 #-} zipWith6 f as bs cs ds es fs - = unstream (Stream.zipWith6 f (stream as) + = unstream (Bundle.zipWith6 f (stream as) (stream bs) (stream cs) (stream ds) @@ -1092,14 +1096,14 @@ => (Int -> a -> b -> c) -> v a -> v b -> v c {-# INLINE izipWith #-} izipWith f xs ys = unstream - (Stream.zipWith (uncurry f) (Stream.indexed (stream xs)) + (Bundle.zipWith (uncurry f) (Bundle.indexed (stream xs)) (stream ys)) izipWith3 :: (Vector v a, Vector v b, Vector v c, Vector v d) => (Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d {-# INLINE izipWith3 #-} izipWith3 f as bs cs - = unstream (Stream.zipWith3 (uncurry f) (Stream.indexed (stream as)) + = unstream (Bundle.zipWith3 (uncurry f) (Bundle.indexed (stream as)) (stream bs) (stream cs)) @@ -1107,7 +1111,7 @@ => (Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e {-# INLINE izipWith4 #-} izipWith4 f as bs cs ds - = unstream (Stream.zipWith4 (uncurry f) (Stream.indexed (stream as)) + = unstream (Bundle.zipWith4 (uncurry f) (Bundle.indexed (stream as)) (stream bs) (stream cs) (stream ds)) @@ -1118,7 +1122,7 @@ -> v e -> v f {-# INLINE izipWith5 #-} izipWith5 f as bs cs ds es - = unstream (Stream.zipWith5 (uncurry f) (Stream.indexed (stream as)) + = unstream (Bundle.zipWith5 (uncurry f) (Bundle.indexed (stream as)) (stream bs) (stream cs) (stream ds) @@ -1130,7 +1134,7 @@ -> v a -> v b -> v c -> v d -> v e -> v f -> v g {-# INLINE izipWith6 #-} izipWith6 f as bs cs ds es fs - = unstream (Stream.zipWith6 (uncurry f) (Stream.indexed (stream as)) + = unstream (Bundle.zipWith6 (uncurry f) (Bundle.indexed (stream as)) (stream bs) (stream cs) (stream ds) @@ -1173,14 +1177,14 @@ => (a -> b -> m c) -> v a -> v b -> m (v c) -- FIXME: specialise for ST and IO? {-# INLINE zipWithM #-} -zipWithM f as bs = unstreamM $ Stream.zipWithM f (stream as) (stream bs) +zipWithM f as bs = unstreamM $ Bundle.zipWithM f (stream as) (stream bs) -- | /O(min(m,n))/ Zip the two vectors with the monadic action and ignore the -- results zipWithM_ :: (Monad m, Vector v a, Vector v b) => (a -> b -> m c) -> v a -> v b -> m () {-# INLINE zipWithM_ #-} -zipWithM_ f as bs = Stream.zipWithM_ f (stream as) (stream bs) +zipWithM_ f as bs = Bundle.zipWithM_ f (stream as) (stream bs) -- Unzipping -- --------- @@ -1233,33 +1237,32 @@ -- | /O(n)/ Drop elements that do not satisfy the predicate filter :: Vector v a => (a -> Bool) -> v a -> v a {-# INLINE filter #-} -filter f = unstream . inplace (MStream.filter f) . stream +filter f = unstream . inplace (S.filter f) toMax . stream -- | /O(n)/ Drop elements that do not satisfy the predicate which is applied to -- values and their indices ifilter :: Vector v a => (Int -> a -> Bool) -> v a -> v a {-# INLINE ifilter #-} ifilter f = unstream - . inplace (MStream.map snd . MStream.filter (uncurry f) - . MStream.indexed) + . inplace (S.map snd . S.filter (uncurry f) . S.indexed) toMax . stream -- | /O(n)/ Drop elements that do not satisfy the monadic predicate filterM :: (Monad m, Vector v a) => (a -> m Bool) -> v a -> m (v a) {-# INLINE filterM #-} -filterM f = unstreamM . Stream.filterM f . stream +filterM f = unstreamM . Bundle.filterM f . stream -- | /O(n)/ Yield the longest prefix of elements satisfying the predicate -- without copying. takeWhile :: Vector v a => (a -> Bool) -> v a -> v a {-# INLINE takeWhile #-} -takeWhile f = unstream . Stream.takeWhile f . stream +takeWhile f = unstream . Bundle.takeWhile f . stream -- | /O(n)/ Drop the longest prefix of elements that satisfy the predicate -- without copying. dropWhile :: Vector v a => (a -> Bool) -> v a -> v a {-# INLINE dropWhile #-} -dropWhile f = unstream . Stream.dropWhile f . stream +dropWhile f = unstream . Bundle.dropWhile f . stream -- Parititioning -- ------------- @@ -1275,11 +1278,11 @@ -- FIXME: Make this inplace-fusible (look at how stable_partition is -- implemented in C++) -partition_stream :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a) -{-# INLINE_STREAM partition_stream #-} +partition_stream :: Vector v a => (a -> Bool) -> Bundle u a -> (v a, v a) +{-# INLINE_FUSED partition_stream #-} partition_stream f s = s `seq` runST ( do - (mv1,mv2) <- M.partitionStream f s + (mv1,mv2) <- M.partitionBundle f s v1 <- unsafeFreeze mv1 v2 <- unsafeFreeze mv2 return (v1,v2)) @@ -1293,17 +1296,17 @@ unstablePartition f = unstablePartition_stream f . stream unstablePartition_stream - :: Vector v a => (a -> Bool) -> Stream a -> (v a, v a) -{-# INLINE_STREAM unstablePartition_stream #-} + :: Vector v a => (a -> Bool) -> Bundle u a -> (v a, v a) +{-# INLINE_FUSED unstablePartition_stream #-} unstablePartition_stream f s = s `seq` runST ( do - (mv1,mv2) <- M.unstablePartitionStream f s + (mv1,mv2) <- M.unstablePartitionBundle f s v1 <- unsafeFreeze mv1 v2 <- unsafeFreeze mv2 return (v1,v2)) unstablePartition_new :: Vector v a => (a -> Bool) -> New v a -> (v a, v a) -{-# INLINE_STREAM unstablePartition_new #-} +{-# INLINE_FUSED unstablePartition_new #-} unstablePartition_new f (New.New p) = runST ( do mv <- p @@ -1344,33 +1347,32 @@ -- | /O(n)/ Check if the vector contains an element elem :: (Vector v a, Eq a) => a -> v a -> Bool {-# INLINE elem #-} -elem x = Stream.elem x . stream +elem x = Bundle.elem x . stream infix 4 `notElem` -- | /O(n)/ Check if the vector does not contain an element (inverse of 'elem') notElem :: (Vector v a, Eq a) => a -> v a -> Bool {-# INLINE notElem #-} -notElem x = Stream.notElem x . stream +notElem x = Bundle.notElem x . stream -- | /O(n)/ Yield 'Just' the first element matching the predicate or 'Nothing' -- if no such element exists. find :: Vector v a => (a -> Bool) -> v a -> Maybe a {-# INLINE find #-} -find f = Stream.find f . stream +find f = Bundle.find f . stream -- | /O(n)/ Yield 'Just' the index of the first element matching the predicate -- or 'Nothing' if no such element exists. findIndex :: Vector v a => (a -> Bool) -> v a -> Maybe Int {-# INLINE findIndex #-} -findIndex f = Stream.findIndex f . stream +findIndex f = Bundle.findIndex f . stream -- | /O(n)/ Yield the indices of elements satisfying the predicate in ascending -- order. findIndices :: (Vector v a, Vector v Int) => (a -> Bool) -> v a -> v Int {-# INLINE findIndices #-} findIndices f = unstream - . inplace (MStream.map fst . MStream.filter (f . snd) - . MStream.indexed) + . inplace (S.map fst . S.filter (f . snd) . S.indexed) toMax . stream -- | /O(n)/ Yield 'Just' the index of the first occurence of the given element or @@ -1392,65 +1394,65 @@ -- | /O(n)/ Left fold foldl :: Vector v b => (a -> b -> a) -> a -> v b -> a {-# INLINE foldl #-} -foldl f z = Stream.foldl f z . stream +foldl f z = Bundle.foldl f z . stream -- | /O(n)/ Left fold on non-empty vectors foldl1 :: Vector v a => (a -> a -> a) -> v a -> a {-# INLINE foldl1 #-} -foldl1 f = Stream.foldl1 f . stream +foldl1 f = Bundle.foldl1 f . stream -- | /O(n)/ Left fold with strict accumulator foldl' :: Vector v b => (a -> b -> a) -> a -> v b -> a {-# INLINE foldl' #-} -foldl' f z = Stream.foldl' f z . stream +foldl' f z = Bundle.foldl' f z . stream -- | /O(n)/ Left fold on non-empty vectors with strict accumulator foldl1' :: Vector v a => (a -> a -> a) -> v a -> a {-# INLINE foldl1' #-} -foldl1' f = Stream.foldl1' f . stream +foldl1' f = Bundle.foldl1' f . stream -- | /O(n)/ Right fold foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b {-# INLINE foldr #-} -foldr f z = Stream.foldr f z . stream +foldr f z = Bundle.foldr f z . stream -- | /O(n)/ Right fold on non-empty vectors foldr1 :: Vector v a => (a -> a -> a) -> v a -> a {-# INLINE foldr1 #-} -foldr1 f = Stream.foldr1 f . stream +foldr1 f = Bundle.foldr1 f . stream -- | /O(n)/ Right fold with a strict accumulator foldr' :: Vector v a => (a -> b -> b) -> b -> v a -> b {-# INLINE foldr' #-} -foldr' f z = Stream.foldl' (flip f) z . streamR +foldr' f z = Bundle.foldl' (flip f) z . streamR -- | /O(n)/ Right fold on non-empty vectors with strict accumulator foldr1' :: Vector v a => (a -> a -> a) -> v a -> a {-# INLINE foldr1' #-} -foldr1' f = Stream.foldl1' (flip f) . streamR +foldr1' f = Bundle.foldl1' (flip f) . streamR -- | /O(n)/ Left fold (function applied to each element and its index) ifoldl :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a {-# INLINE ifoldl #-} -ifoldl f z = Stream.foldl (uncurry . f) z . Stream.indexed . stream +ifoldl f z = Bundle.foldl (uncurry . f) z . Bundle.indexed . stream -- | /O(n)/ Left fold with strict accumulator (function applied to each element -- and its index) ifoldl' :: Vector v b => (a -> Int -> b -> a) -> a -> v b -> a {-# INLINE ifoldl' #-} -ifoldl' f z = Stream.foldl' (uncurry . f) z . Stream.indexed . stream +ifoldl' f z = Bundle.foldl' (uncurry . f) z . Bundle.indexed . stream -- | /O(n)/ Right fold (function applied to each element and its index) ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b {-# INLINE ifoldr #-} -ifoldr f z = Stream.foldr (uncurry f) z . Stream.indexed . stream +ifoldr f z = Bundle.foldr (uncurry f) z . Bundle.indexed . stream -- | /O(n)/ Right fold with strict accumulator (function applied to each -- element and its index) ifoldr' :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b {-# INLINE ifoldr' #-} -ifoldr' f z xs = Stream.foldl' (flip (uncurry f)) z - $ Stream.indexedR (length xs) $ streamR xs +ifoldr' f z xs = Bundle.foldl' (flip (uncurry f)) z + $ Bundle.indexedR (length xs) $ streamR xs -- Specialised folds -- ----------------- @@ -1458,44 +1460,44 @@ -- | /O(n)/ Check if all elements satisfy the predicate. all :: Vector v a => (a -> Bool) -> v a -> Bool {-# INLINE all #-} -all f = Stream.and . Stream.map f . stream +all f = Bundle.and . Bundle.map f . stream -- | /O(n)/ Check if any element satisfies the predicate. any :: Vector v a => (a -> Bool) -> v a -> Bool {-# INLINE any #-} -any f = Stream.or . Stream.map f . stream +any f = Bundle.or . Bundle.map f . stream -- | /O(n)/ Check if all elements are 'True' and :: Vector v Bool => v Bool -> Bool {-# INLINE and #-} -and = Stream.and . stream +and = Bundle.and . stream -- | /O(n)/ Check if any element is 'True' or :: Vector v Bool => v Bool -> Bool {-# INLINE or #-} -or = Stream.or . stream +or = Bundle.or . stream -- | /O(n)/ Compute the sum of the elements sum :: (Vector v a, Num a) => v a -> a {-# INLINE sum #-} -sum = Stream.foldl' (+) 0 . stream +sum = Bundle.foldl' (+) 0 . stream -- | /O(n)/ Compute the produce of the elements product :: (Vector v a, Num a) => v a -> a {-# INLINE product #-} -product = Stream.foldl' (*) 1 . stream +product = Bundle.foldl' (*) 1 . stream -- | /O(n)/ Yield the maximum element of the vector. The vector may not be -- empty. maximum :: (Vector v a, Ord a) => v a -> a {-# INLINE maximum #-} -maximum = Stream.foldl1' max . stream +maximum = Bundle.foldl1' max . stream -- | /O(n)/ Yield the maximum element of the vector according to the given -- comparison function. The vector may not be empty. maximumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a {-# INLINE maximumBy #-} -maximumBy cmp = Stream.foldl1' maxBy . stream +maximumBy cmp = Bundle.foldl1' maxBy . stream where {-# INLINE maxBy #-} maxBy x y = case cmp x y of @@ -1506,13 +1508,13 @@ -- empty. minimum :: (Vector v a, Ord a) => v a -> a {-# INLINE minimum #-} -minimum = Stream.foldl1' min . stream +minimum = Bundle.foldl1' min . stream -- | /O(n)/ Yield the minimum element of the vector according to the given -- comparison function. The vector may not be empty. minimumBy :: Vector v a => (a -> a -> Ordering) -> v a -> a {-# INLINE minimumBy #-} -minimumBy cmp = Stream.foldl1' minBy . stream +minimumBy cmp = Bundle.foldl1' minBy . stream where {-# INLINE minBy #-} minBy x y = case cmp x y of @@ -1529,7 +1531,7 @@ -- the given comparison function. The vector may not be empty. maxIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int {-# INLINE maxIndexBy #-} -maxIndexBy cmp = fst . Stream.foldl1' imax . Stream.indexed . stream +maxIndexBy cmp = fst . Bundle.foldl1' imax . Bundle.indexed . stream where imax (i,x) (j,y) = i `seq` j `seq` case cmp x y of @@ -1546,7 +1548,7 @@ -- the given comparison function. The vector may not be empty. minIndexBy :: Vector v a => (a -> a -> Ordering) -> v a -> Int {-# INLINE minIndexBy #-} -minIndexBy cmp = fst . Stream.foldl1' imin . Stream.indexed . stream +minIndexBy cmp = fst . Bundle.foldl1' imin . Bundle.indexed . stream where imin (i,x) (j,y) = i `seq` j `seq` case cmp x y of @@ -1559,22 +1561,22 @@ -- | /O(n)/ Monadic fold foldM :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a {-# INLINE foldM #-} -foldM m z = Stream.foldM m z . stream +foldM m z = Bundle.foldM m z . stream -- | /O(n)/ Monadic fold over non-empty vectors fold1M :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a {-# INLINE fold1M #-} -fold1M m = Stream.fold1M m . stream +fold1M m = Bundle.fold1M m . stream -- | /O(n)/ Monadic fold with strict accumulator foldM' :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m a {-# INLINE foldM' #-} -foldM' m z = Stream.foldM' m z . stream +foldM' m z = Bundle.foldM' m z . stream -- | /O(n)/ Monadic fold over non-empty vectors with strict accumulator fold1M' :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m a {-# INLINE fold1M' #-} -fold1M' m = Stream.fold1M' m . stream +fold1M' m = Bundle.fold1M' m . stream discard :: Monad m => m a -> m () {-# INLINE discard #-} @@ -1583,23 +1585,23 @@ -- | /O(n)/ Monadic fold that discards the result foldM_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m () {-# INLINE foldM_ #-} -foldM_ m z = discard . Stream.foldM m z . stream +foldM_ m z = discard . Bundle.foldM m z . stream -- | /O(n)/ Monadic fold over non-empty vectors that discards the result fold1M_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m () {-# INLINE fold1M_ #-} -fold1M_ m = discard . Stream.fold1M m . stream +fold1M_ m = discard . Bundle.fold1M m . stream -- | /O(n)/ Monadic fold with strict accumulator that discards the result foldM'_ :: (Monad m, Vector v b) => (a -> b -> m a) -> a -> v b -> m () {-# INLINE foldM'_ #-} -foldM'_ m z = discard . Stream.foldM' m z . stream +foldM'_ m z = discard . Bundle.foldM' m z . stream -- | /O(n)/ Monad fold over non-empty vectors with strict accumulator -- that discards the result fold1M'_ :: (Monad m, Vector v a) => (a -> a -> m a) -> v a -> m () {-# INLINE fold1M'_ #-} -fold1M'_ m = discard . Stream.fold1M' m . stream +fold1M'_ m = discard . Bundle.fold1M' m . stream -- Monadic sequencing -- ------------------ @@ -1627,12 +1629,12 @@ -- prescanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE prescanl #-} -prescanl f z = unstream . inplace (MStream.prescanl f z) . stream +prescanl f z = unstream . inplace (S.prescanl f z) id . stream -- | /O(n)/ Prescan with strict accumulator prescanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE prescanl' #-} -prescanl' f z = unstream . inplace (MStream.prescanl' f z) . stream +prescanl' f z = unstream . inplace (S.prescanl' f z) id . stream -- | /O(n)/ Scan -- @@ -1644,12 +1646,12 @@ -- postscanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE postscanl #-} -postscanl f z = unstream . inplace (MStream.postscanl f z) . stream +postscanl f z = unstream . inplace (S.postscanl f z) id . stream -- | /O(n)/ Scan with strict accumulator postscanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE postscanl' #-} -postscanl' f z = unstream . inplace (MStream.postscanl' f z) . stream +postscanl' f z = unstream . inplace (S.postscanl' f z) id . stream -- | /O(n)/ Haskell-style scan -- @@ -1661,12 +1663,12 @@ -- scanl :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE scanl #-} -scanl f z = unstream . Stream.scanl f z . stream +scanl f z = unstream . Bundle.scanl f z . stream -- | /O(n)/ Haskell-style scan with strict accumulator scanl' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a {-# INLINE scanl' #-} -scanl' f z = unstream . Stream.scanl' f z . stream +scanl' f z = unstream . Bundle.scanl' f z . stream -- | /O(n)/ Scan over a non-empty vector -- @@ -1676,12 +1678,12 @@ -- scanl1 :: Vector v a => (a -> a -> a) -> v a -> v a {-# INLINE scanl1 #-} -scanl1 f = unstream . inplace (MStream.scanl1 f) . stream +scanl1 f = unstream . inplace (S.scanl1 f) id . stream -- | /O(n)/ Scan over a non-empty vector with a strict accumulator scanl1' :: Vector v a => (a -> a -> a) -> v a -> v a {-# INLINE scanl1' #-} -scanl1' f = unstream . inplace (MStream.scanl1' f) . stream +scanl1' f = unstream . inplace (S.scanl1' f) id . stream -- | /O(n)/ Right-to-left prescan -- @@ -1691,43 +1693,43 @@ -- prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE prescanr #-} -prescanr f z = unstreamR . inplace (MStream.prescanl (flip f) z) . streamR +prescanr f z = unstreamR . inplace (S.prescanl (flip f) z) id . streamR -- | /O(n)/ Right-to-left prescan with strict accumulator prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE prescanr' #-} -prescanr' f z = unstreamR . inplace (MStream.prescanl' (flip f) z) . streamR +prescanr' f z = unstreamR . inplace (S.prescanl' (flip f) z) id . streamR -- | /O(n)/ Right-to-left scan postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE postscanr #-} -postscanr f z = unstreamR . inplace (MStream.postscanl (flip f) z) . streamR +postscanr f z = unstreamR . inplace (S.postscanl (flip f) z) id . streamR -- | /O(n)/ Right-to-left scan with strict accumulator postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE postscanr' #-} -postscanr' f z = unstreamR . inplace (MStream.postscanl' (flip f) z) . streamR +postscanr' f z = unstreamR . inplace (S.postscanl' (flip f) z) id . streamR -- | /O(n)/ Right-to-left Haskell-style scan scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE scanr #-} -scanr f z = unstreamR . Stream.scanl (flip f) z . streamR +scanr f z = unstreamR . Bundle.scanl (flip f) z . streamR -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b {-# INLINE scanr' #-} -scanr' f z = unstreamR . Stream.scanl' (flip f) z . streamR +scanr' f z = unstreamR . Bundle.scanl' (flip f) z . streamR -- | /O(n)/ Right-to-left scan over a non-empty vector scanr1 :: Vector v a => (a -> a -> a) -> v a -> v a {-# INLINE scanr1 #-} -scanr1 f = unstreamR . inplace (MStream.scanl1 (flip f)) . streamR +scanr1 f = unstreamR . inplace (S.scanl1 (flip f)) id . streamR -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict -- accumulator scanr1' :: Vector v a => (a -> a -> a) -> v a -> v a {-# INLINE scanr1' #-} -scanr1' f = unstreamR . inplace (MStream.scanl1' (flip f)) . streamR +scanr1' f = unstreamR . inplace (S.scanl1' (flip f)) id . streamR -- Conversions - Lists -- ------------------------ @@ -1735,12 +1737,12 @@ -- | /O(n)/ Convert a vector to a list toList :: Vector v a => v a -> [a] {-# INLINE toList #-} -toList = Stream.toList . stream +toList = Bundle.toList . stream -- | /O(n)/ Convert a list to a vector fromList :: Vector v a => [a] -> v a {-# INLINE fromList #-} -fromList = unstream . Stream.fromList +fromList = unstream . Bundle.fromList -- | /O(n)/ Convert the first @n@ elements of a list to a vector -- @@ -1749,7 +1751,7 @@ -- @ fromListN :: Vector v a => Int -> [a] -> v a {-# INLINE fromListN #-} -fromListN n = unstream . Stream.fromListN n +fromListN n = unstream . Bundle.fromListN n -- Conversions - Immutable vectors -- ------------------------------- @@ -1757,7 +1759,7 @@ -- | /O(n)/ Convert different vector types convert :: (Vector v a, Vector w a) => v a -> w a {-# INLINE convert #-} -convert = unstream . stream +convert = unstream . Bundle.reVector . stream -- Conversions - Mutable vectors -- ----------------------------- @@ -1777,12 +1779,12 @@ -- | /O(1)/ Unsafely convert an immutable vector to a mutable one without -- copying. The immutable vector may not be used after this operation. unsafeThaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a) -{-# INLINE_STREAM unsafeThaw #-} +{-# INLINE_FUSED unsafeThaw #-} unsafeThaw = basicUnsafeThaw -- | /O(n)/ Yield a mutable copy of the immutable vector. thaw :: (PrimMonad m, Vector v a) => v a -> m (Mutable v (PrimState m) a) -{-# INLINE_STREAM thaw #-} +{-# INLINE_FUSED thaw #-} thaw v = do mv <- M.unsafeNew (length v) unsafeCopy mv v @@ -1802,7 +1804,7 @@ -- | /O(n)/ Yield a mutable vector containing copies of each vector in the -- list. thawMany :: (PrimMonad m, Vector v a) => [v a] -> m (Mutable v (PrimState m) a) -{-# INLINE_STREAM thawMany #-} +{-# INLINE_FUSED thawMany #-} -- FIXME: add rule for (stream (new (New.create (thawMany vs)))) -- NOTE: We don't try to consume the list lazily as this wouldn't significantly -- change the space requirements anyway. @@ -1839,13 +1841,16 @@ (M.length dst == length src) $ (dst `seq` src `seq` basicUnsafeCopy dst src) --- Conversions to/from Streams +-- Conversions to/from Bundles -- --------------------------- --- | /O(1)/ Convert a vector to a 'Stream' -stream :: Vector v a => v a -> Stream a -{-# INLINE_STREAM stream #-} -stream v = v `seq` n `seq` (Stream.unfoldr get 0 `Stream.sized` Exact n) +-- | /O(1)/ Convert a vector to a 'Bundle' +stream :: Vector v a => v a -> Bundle v a +{-# INLINE_FUSED stream #-} +stream v = Bundle.fromVector v + +{- +stream v = v `seq` n `seq` (Bundle.unfoldr get 0 `Bundle.sized` Exact n) where n = length v @@ -1854,9 +1859,10 @@ {-# INLINE get #-} get i | i >= n = Nothing | otherwise = case basicUnsafeIndexM v i of Box x -> Just (x, i+1) +-} --- | /O(n)/ Construct a vector from a 'Stream' -unstream :: Vector v a => Stream a -> v a +-- | /O(n)/ Construct a vector from a 'Bundle' +unstream :: Vector v a => Bundle v a -> v a {-# INLINE unstream #-} unstream s = new (New.unstream s) @@ -1872,19 +1878,19 @@ clone (new p) = p "inplace [Vector]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) m. - New.unstream (inplace f (stream (new m))) = New.transform f m + forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m. + New.unstream (inplace f g (stream (new m))) = New.transform f g m "uninplace [Vector]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) m. - stream (new (New.transform f m)) = inplace f (stream (new m)) + forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m. + stream (new (New.transform f g m)) = inplace f g (stream (new m)) #-} --- | /O(1)/ Convert a vector to a 'Stream', proceeding from right to left -streamR :: Vector v a => v a -> Stream a -{-# INLINE_STREAM streamR #-} -streamR v = v `seq` n `seq` (Stream.unfoldr get n `Stream.sized` Exact n) +-- | /O(1)/ Convert a vector to a 'Bundle', proceeding from right to left +streamR :: Vector v a => v a -> Bundle u a +{-# INLINE_FUSED streamR #-} +streamR v = v `seq` n `seq` (Bundle.unfoldr get n `Bundle.sized` Exact n) where n = length v @@ -1894,8 +1900,8 @@ in case basicUnsafeIndexM v i' of Box x -> Just (x, i') --- | /O(n)/ Construct a vector from a 'Stream', proceeding from right to left -unstreamR :: Vector v a => Stream a -> v a +-- | /O(n)/ Construct a vector from a 'Bundle', proceeding from right to left +unstreamR :: Vector v a => Bundle v a -> v a {-# INLINE unstreamR #-} unstreamR s = new (New.unstreamR s) @@ -1914,31 +1920,31 @@ New.unstreamR (stream (new p)) = New.modify M.reverse p "inplace right [Vector]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) m. - New.unstreamR (inplace f (streamR (new m))) = New.transformR f m + forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m. + New.unstreamR (inplace f g (streamR (new m))) = New.transformR f g m "uninplace right [Vector]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) m. - streamR (new (New.transformR f m)) = inplace f (streamR (new m)) + forall (f :: forall m. Monad m => Stream m a -> Stream m a) g m. + streamR (new (New.transformR f g m)) = inplace f g (streamR (new m)) #-} -unstreamM :: (Monad m, Vector v a) => MStream m a -> m (v a) -{-# INLINE_STREAM unstreamM #-} +unstreamM :: (Monad m, Vector v a) => MBundle m u a -> m (v a) +{-# INLINE_FUSED unstreamM #-} unstreamM s = do - xs <- MStream.toList s - return $ unstream $ Stream.unsafeFromList (MStream.size s) xs + xs <- MBundle.toList s + return $ unstream $ Bundle.unsafeFromList (MBundle.size s) xs -unstreamPrimM :: (PrimMonad m, Vector v a) => MStream m a -> m (v a) -{-# INLINE_STREAM unstreamPrimM #-} +unstreamPrimM :: (PrimMonad m, Vector v a) => MBundle m u a -> m (v a) +{-# INLINE_FUSED unstreamPrimM #-} unstreamPrimM s = M.munstream s >>= unsafeFreeze -- FIXME: the next two functions are only necessary for the specialisations -unstreamPrimM_IO :: Vector v a => MStream IO a -> IO (v a) +unstreamPrimM_IO :: Vector v a => MBundle IO u a -> IO (v a) {-# INLINE unstreamPrimM_IO #-} unstreamPrimM_IO = unstreamPrimM -unstreamPrimM_ST :: Vector v a => MStream (ST s) a -> ST s (v a) +unstreamPrimM_ST :: Vector v a => MBundle (ST s) u a -> ST s (v a) {-# INLINE unstreamPrimM_ST #-} unstreamPrimM_ST = unstreamPrimM @@ -1955,13 +1961,13 @@ -- | Construct a vector from a monadic initialiser. new :: Vector v a => New v a -> v a -{-# INLINE_STREAM new #-} +{-# INLINE_FUSED new #-} new m = m `seq` runST (unsafeFreeze =<< New.run m) -- | Convert a vector to an initialiser which, when run, produces a copy of -- the vector. clone :: Vector v a => v a -> New v a -{-# INLINE_STREAM clone #-} +{-# INLINE_FUSED clone #-} clone v = v `seq` New.create ( do mv <- M.new (length v) @@ -2020,7 +2026,11 @@ {-# INLINE mkType #-} mkType = mkNoRepType +#if __GLASGOW_HASKELL__ >= 707 +dataCast :: (Vector v a, Data a, Typeable v, Typeable t) +#else dataCast :: (Vector v a, Data a, Typeable1 v, Typeable1 t) +#endif => (forall d. Data d => c (t d)) -> Maybe (c (v a)) {-# INLINE dataCast #-} dataCast f = gcast1 f diff --git a/Data/Vector/Generic/Base.hs b/Data/Vector/Generic/Base.hs --- a/Data/Vector/Generic/Base.hs +++ b/Data/Vector/Generic/Base.hs @@ -18,8 +18,8 @@ Vector(..), Mutable ) where -import Data.Vector.Generic.Mutable ( MVector ) -import qualified Data.Vector.Generic.Mutable as M +import Data.Vector.Generic.Mutable.Base ( MVector ) +import qualified Data.Vector.Generic.Mutable.Base as M import Control.Monad.Primitive diff --git a/Data/Vector/Generic/Mutable.hs b/Data/Vector/Generic/Mutable.hs --- a/Data/Vector/Generic/Mutable.hs +++ b/Data/Vector/Generic/Mutable.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE MultiParamTypeClasses, BangPatterns, ScopedTypeVariables #-} +{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, BangPatterns, TypeFamilies, ScopedTypeVariables #-} -- | -- Module : Data.Vector.Generic.Mutable -- Copyright : (c) Roman Leshchinskiy 2008-2010 @@ -49,18 +49,23 @@ -- * Internal operations mstream, mstreamR, - unstream, unstreamR, + unstream, unstreamR, vunstream, munstream, munstreamR, transform, transformR, fill, fillR, unsafeAccum, accum, unsafeUpdate, update, reverse, - unstablePartition, unstablePartitionStream, partitionStream + unstablePartition, unstablePartitionBundle, partitionBundle ) where -import qualified Data.Vector.Fusion.Stream as Stream -import Data.Vector.Fusion.Stream ( Stream, MStream ) -import qualified Data.Vector.Fusion.Stream.Monadic as MStream -import Data.Vector.Fusion.Stream.Size +import Data.Vector.Generic.Mutable.Base +import qualified Data.Vector.Generic.Base as V + +import qualified Data.Vector.Fusion.Bundle as Bundle +import Data.Vector.Fusion.Bundle ( Bundle, MBundle, Chunk(..) ) +import qualified Data.Vector.Fusion.Bundle.Monadic as MBundle +import Data.Vector.Fusion.Stream.Monadic ( Stream ) +import qualified Data.Vector.Fusion.Stream.Monadic as Stream +import Data.Vector.Fusion.Bundle.Size import Data.Vector.Fusion.Util ( delay_inline ) import Control.Monad.Primitive ( PrimMonad, PrimState ) @@ -70,23 +75,12 @@ #include "vector.h" +{- +type family Immutable (v :: * -> * -> *) :: * -> * + -- | Class of mutable vectors parametrised with a primitive state token. -- --- Minimum complete implementation: --- --- * 'basicLength' --- --- * 'basicUnsafeSlice' --- --- * 'basicOverlaps' --- --- * 'basicUnsafeNew' --- --- * 'basicUnsafeRead' --- --- * 'basicUnsafeWrite' --- -class MVector v a where +class MBundle.Pointer u a => MVector v a where -- | Length of the mutable vector. This method should not be -- called directly, use 'length' instead. basicLength :: v s a -> Int @@ -128,6 +122,10 @@ -- not be called directly, use 'set' instead. basicSet :: PrimMonad m => v (PrimState m) a -> a -> m () + basicUnsafeCopyPointer :: PrimMonad m => v (PrimState m) a + -> Immutable v a + -> m () + -- | Copy a vector. The two vectors may not overlap. This method should not -- be called directly, use 'unsafeCopy' instead. basicUnsafeCopy :: PrimMonad m => v (PrimState m) a -- ^ target @@ -170,6 +168,14 @@ | otherwise = basicUnsafeCopy (basicUnsafeSlice i (n-i) v) (basicUnsafeSlice 0 (n-i) v) + {-# INLINE basicUnsafeCopyPointer #-} + basicUnsafeCopyPointer !dst !src = do_copy 0 src + where + do_copy !i p | Just (x,q) <- MBundle.pget p = do + basicUnsafeWrite dst i x + do_copy (i+1) q + | otherwise = return () + {-# INLINE basicUnsafeCopy #-} basicUnsafeCopy !dst !src = do_copy 0 where @@ -196,7 +202,8 @@ return v' where n = basicLength v - +-} + -- ------------------ -- Internal functions -- ------------------ @@ -233,9 +240,9 @@ $ unsafeWrite v' i' x return (v', i') -mstream :: (PrimMonad m, MVector v a) => v (PrimState m) a -> MStream m a +mstream :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a {-# INLINE mstream #-} -mstream v = v `seq` n `seq` (MStream.unfoldrM get 0 `MStream.sized` Exact n) +mstream v = v `seq` n `seq` (Stream.unfoldrM get 0) where n = length v @@ -245,10 +252,10 @@ | otherwise = return $ Nothing fill :: (PrimMonad m, MVector v a) - => v (PrimState m) a -> MStream m a -> m (v (PrimState m) a) + => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) {-# INLINE fill #-} fill v s = v `seq` do - n' <- MStream.foldM put 0 s + n' <- Stream.foldM put 0 s return $ unsafeSlice 0 n' v where {-# INLINE_INNER put #-} @@ -257,14 +264,15 @@ $ unsafeWrite v i x return (i+1) -transform :: (PrimMonad m, MVector v a) - => (MStream m a -> MStream m a) -> v (PrimState m) a -> m (v (PrimState m) a) -{-# INLINE_STREAM transform #-} +transform + :: (PrimMonad m, MVector v a) + => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) +{-# INLINE_FUSED transform #-} transform f v = fill v (f (mstream v)) -mstreamR :: (PrimMonad m, MVector v a) => v (PrimState m) a -> MStream m a +mstreamR :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Stream m a {-# INLINE mstreamR #-} -mstreamR v = v `seq` n `seq` (MStream.unfoldrM get n `MStream.sized` Exact n) +mstreamR v = v `seq` n `seq` (Stream.unfoldrM get n) where n = length v @@ -276,10 +284,10 @@ j = i-1 fillR :: (PrimMonad m, MVector v a) - => v (PrimState m) a -> MStream m a -> m (v (PrimState m) a) + => v (PrimState m) a -> Stream m a -> m (v (PrimState m) a) {-# INLINE fillR #-} fillR v s = v `seq` do - i <- MStream.foldM put n s + i <- Stream.foldM put n s return $ unsafeSlice i (n-i) v where n = length v @@ -291,25 +299,28 @@ where j = i-1 -transformR :: (PrimMonad m, MVector v a) - => (MStream m a -> MStream m a) -> v (PrimState m) a -> m (v (PrimState m) a) -{-# INLINE_STREAM transformR #-} +transformR + :: (PrimMonad m, MVector v a) + => (Stream m a -> Stream m a) -> v (PrimState m) a -> m (v (PrimState m) a) +{-# INLINE_FUSED transformR #-} transformR f v = fillR v (f (mstreamR v)) --- | Create a new mutable vector and fill it with elements from the 'Stream'. --- The vector will grow exponentially if the maximum size of the 'Stream' is +-- | Create a new mutable vector and fill it with elements from the 'Bundle'. +-- The vector will grow exponentially if the maximum size of the 'Bundle' is -- unknown. -unstream :: (PrimMonad m, MVector v a) => Stream a -> m (v (PrimState m) a) --- NOTE: replace INLINE_STREAM by INLINE? (also in unstreamR) -{-# INLINE_STREAM unstream #-} -unstream s = munstream (Stream.liftStream s) +unstream :: (PrimMonad m, MVector v a) + => Bundle u a -> m (v (PrimState m) a) +-- NOTE: replace INLINE_FUSED by INLINE? (also in unstreamR) +{-# INLINE_FUSED unstream #-} +unstream s = munstream (Bundle.lift s) -- | Create a new mutable vector and fill it with elements from the monadic -- stream. The vector will grow exponentially if the maximum size of the stream -- is unknown. -munstream :: (PrimMonad m, MVector v a) => MStream m a -> m (v (PrimState m) a) -{-# INLINE_STREAM munstream #-} -munstream s = case upperBound (MStream.size s) of +munstream :: (PrimMonad m, MVector v a) + => MBundle m u a -> m (v (PrimState m) a) +{-# INLINE_FUSED munstream #-} +munstream s = case upperBound (MBundle.size s) of Just n -> munstreamMax s n Nothing -> munstreamUnknown s @@ -319,12 +330,12 @@ -- the shape of the vector) and one for when the vector has grown. To see the -- problem simply compile this: -- --- fromList = Data.Vector.Unboxed.unstream . Stream.fromList +-- fromList = Data.Vector.Unboxed.unstream . Bundle.fromList -- -- I'm not sure this still applies (19/04/2010) -munstreamMax - :: (PrimMonad m, MVector v a) => MStream m a -> Int -> m (v (PrimState m) a) +munstreamMax :: (PrimMonad m, MVector v a) + => MBundle m u a -> Int -> m (v (PrimState m) a) {-# INLINE munstreamMax #-} munstreamMax s n = do @@ -334,17 +345,17 @@ INTERNAL_CHECK(checkIndex) "munstreamMax" i n $ unsafeWrite v i x return (i+1) - n' <- MStream.foldM' put 0 s + n' <- MBundle.foldM' put 0 s return $ INTERNAL_CHECK(checkSlice) "munstreamMax" 0 n' n $ unsafeSlice 0 n' v -munstreamUnknown - :: (PrimMonad m, MVector v a) => MStream m a -> m (v (PrimState m) a) +munstreamUnknown :: (PrimMonad m, MVector v a) + => MBundle m u a -> m (v (PrimState m) a) {-# INLINE munstreamUnknown #-} munstreamUnknown s = do v <- unsafeNew 0 - (v', n) <- MStream.foldM put (v, 0) s + (v', n) <- MBundle.foldM put (v, 0) s return $ INTERNAL_CHECK(checkSlice) "munstreamUnknown" 0 n (length v') $ unsafeSlice 0 n v' where @@ -353,25 +364,103 @@ v' <- unsafeAppend1 v i x return (v',i+1) --- | Create a new mutable vector and fill it with elements from the 'Stream' + + + + + + +-- | Create a new mutable vector and fill it with elements from the 'Bundle'. +-- The vector will grow exponentially if the maximum size of the 'Bundle' is +-- unknown. +vunstream :: (PrimMonad m, V.Vector v a) + => Bundle v a -> m (V.Mutable v (PrimState m) a) +-- NOTE: replace INLINE_FUSED by INLINE? (also in unstreamR) +{-# INLINE_FUSED vunstream #-} +vunstream s = vmunstream (Bundle.lift s) + +-- | Create a new mutable vector and fill it with elements from the monadic +-- stream. The vector will grow exponentially if the maximum size of the stream +-- is unknown. +vmunstream :: (PrimMonad m, V.Vector v a) + => MBundle m v a -> m (V.Mutable v (PrimState m) a) +{-# INLINE_FUSED vmunstream #-} +vmunstream s = case upperBound (MBundle.size s) of + Just n -> vmunstreamMax s n + Nothing -> vmunstreamUnknown s + +-- FIXME: I can't think of how to prevent GHC from floating out +-- unstreamUnknown. That is bad because SpecConstr then generates two +-- specialisations: one for when it is called from unstream (it doesn't know +-- the shape of the vector) and one for when the vector has grown. To see the +-- problem simply compile this: +-- +-- fromList = Data.Vector.Unboxed.unstream . Bundle.fromList +-- +-- I'm not sure this still applies (19/04/2010) + +vmunstreamMax :: (PrimMonad m, V.Vector v a) + => MBundle m v a -> Int -> m (V.Mutable v (PrimState m) a) +{-# INLINE vmunstreamMax #-} +vmunstreamMax s n + = do + v <- INTERNAL_CHECK(checkLength) "munstreamMax" n + $ unsafeNew n + let {-# INLINE_INNER copy #-} + copy i (Chunk n f) = + INTERNAL_CHECK(checkSlice) "munstreamMax.copy" i n (length v) $ do + f (basicUnsafeSlice i n v) + return (i+n) + + n' <- Stream.foldlM' copy 0 (MBundle.chunks s) + return $ INTERNAL_CHECK(checkSlice) "munstreamMax" 0 n' n + $ unsafeSlice 0 n' v + +vmunstreamUnknown :: (PrimMonad m, V.Vector v a) + => MBundle m v a -> m (V.Mutable v (PrimState m) a) +{-# INLINE vmunstreamUnknown #-} +vmunstreamUnknown s + = do + v <- unsafeNew 0 + (v', n) <- Stream.foldlM copy (v,0) (MBundle.chunks s) + return $ INTERNAL_CHECK(checkSlice) "munstreamUnknown" 0 n (length v') + $ unsafeSlice 0 n v' + where + {-# INLINE_INNER copy #-} + copy (v,i) (Chunk n f) + = do + let j = i+n + v' <- if basicLength v < j + then unsafeGrow v (delay_inline max (enlarge_delta v) (j - basicLength v)) + else return v + INTERNAL_CHECK(checkSlice) "munstreamUnknown.copy" i n (length v') + $ f (basicUnsafeSlice i n v') + return (v',j) + + + + +-- | Create a new mutable vector and fill it with elements from the 'Bundle' -- from right to left. The vector will grow exponentially if the maximum size --- of the 'Stream' is unknown. -unstreamR :: (PrimMonad m, MVector v a) => Stream a -> m (v (PrimState m) a) --- NOTE: replace INLINE_STREAM by INLINE? (also in unstream) -{-# INLINE_STREAM unstreamR #-} -unstreamR s = munstreamR (Stream.liftStream s) +-- of the 'Bundle' is unknown. +unstreamR :: (PrimMonad m, MVector v a) + => Bundle u a -> m (v (PrimState m) a) +-- NOTE: replace INLINE_FUSED by INLINE? (also in unstream) +{-# INLINE_FUSED unstreamR #-} +unstreamR s = munstreamR (Bundle.lift s) -- | Create a new mutable vector and fill it with elements from the monadic -- stream from right to left. The vector will grow exponentially if the maximum -- size of the stream is unknown. -munstreamR :: (PrimMonad m, MVector v a) => MStream m a -> m (v (PrimState m) a) -{-# INLINE_STREAM munstreamR #-} -munstreamR s = case upperBound (MStream.size s) of +munstreamR :: (PrimMonad m, MVector v a) + => MBundle m u a -> m (v (PrimState m) a) +{-# INLINE_FUSED munstreamR #-} +munstreamR s = case upperBound (MBundle.size s) of Just n -> munstreamRMax s n Nothing -> munstreamRUnknown s -munstreamRMax - :: (PrimMonad m, MVector v a) => MStream m a -> Int -> m (v (PrimState m) a) +munstreamRMax :: (PrimMonad m, MVector v a) + => MBundle m u a -> Int -> m (v (PrimState m) a) {-# INLINE munstreamRMax #-} munstreamRMax s n = do @@ -382,17 +471,17 @@ INTERNAL_CHECK(checkIndex) "munstreamRMax" i' n $ unsafeWrite v i' x return i' - i <- MStream.foldM' put n s + i <- MBundle.foldM' put n s return $ INTERNAL_CHECK(checkSlice) "munstreamRMax" i (n-i) n $ unsafeSlice i (n-i) v -munstreamRUnknown - :: (PrimMonad m, MVector v a) => MStream m a -> m (v (PrimState m) a) +munstreamRUnknown :: (PrimMonad m, MVector v a) + => MBundle m u a -> m (v (PrimState m) a) {-# INLINE munstreamRUnknown #-} munstreamRUnknown s = do v <- unsafeNew 0 - (v', i) <- MStream.foldM put (v, 0) s + (v', i) <- MBundle.foldM put (v, 0) s let n = length v' return $ INTERNAL_CHECK(checkSlice) "unstreamRUnknown" i (n-i) n $ unsafeSlice i (n-i) v' @@ -510,7 +599,7 @@ -- and fill it with values produced by repeatedly executing the monadic action. replicateM :: (PrimMonad m, MVector v a) => Int -> m a -> m (v (PrimState m) a) {-# INLINE replicateM #-} -replicateM n m = munstream (MStream.replicateM n m) +replicateM n m = munstream (MBundle.replicateM n m) -- | Create a copy of a mutable vector. clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) @@ -709,9 +798,9 @@ -- ------------ accum :: (PrimMonad m, MVector v a) - => (a -> b -> a) -> v (PrimState m) a -> Stream (Int, b) -> m () + => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () {-# INLINE accum #-} -accum f !v s = Stream.mapM_ upd s +accum f !v s = Bundle.mapM_ upd s where {-# INLINE_INNER upd #-} upd (i,b) = do @@ -722,9 +811,9 @@ !n = length v update :: (PrimMonad m, MVector v a) - => v (PrimState m) a -> Stream (Int, a) -> m () + => v (PrimState m) a -> Bundle u (Int, a) -> m () {-# INLINE update #-} -update !v s = Stream.mapM_ upd s +update !v s = Bundle.mapM_ upd s where {-# INLINE_INNER upd #-} upd (i,b) = BOUNDS_CHECK(checkIndex) "update" i n @@ -733,9 +822,9 @@ !n = length v unsafeAccum :: (PrimMonad m, MVector v a) - => (a -> b -> a) -> v (PrimState m) a -> Stream (Int, b) -> m () + => (a -> b -> a) -> v (PrimState m) a -> Bundle u (Int, b) -> m () {-# INLINE unsafeAccum #-} -unsafeAccum f !v s = Stream.mapM_ upd s +unsafeAccum f !v s = Bundle.mapM_ upd s where {-# INLINE_INNER upd #-} upd (i,b) = do @@ -746,9 +835,9 @@ !n = length v unsafeUpdate :: (PrimMonad m, MVector v a) - => v (PrimState m) a -> Stream (Int, a) -> m () + => v (PrimState m) a -> Bundle u (Int, a) -> m () {-# INLINE unsafeUpdate #-} -unsafeUpdate !v s = Stream.mapM_ upd s +unsafeUpdate !v s = Bundle.mapM_ upd s where {-# INLINE_INNER upd #-} upd (i,b) = UNSAFE_CHECK(checkIndex) "accum" i n @@ -794,16 +883,16 @@ from_left (i+1) j else from_right i (j-1) -unstablePartitionStream :: (PrimMonad m, MVector v a) - => (a -> Bool) -> Stream a -> m (v (PrimState m) a, v (PrimState m) a) -{-# INLINE unstablePartitionStream #-} -unstablePartitionStream f s - = case upperBound (Stream.size s) of +unstablePartitionBundle :: (PrimMonad m, MVector v a) + => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) +{-# INLINE unstablePartitionBundle #-} +unstablePartitionBundle f s + = case upperBound (Bundle.size s) of Just n -> unstablePartitionMax f s n Nothing -> partitionUnknown f s unstablePartitionMax :: (PrimMonad m, MVector v a) - => (a -> Bool) -> Stream a -> Int + => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE unstablePartitionMax #-} unstablePartitionMax f s n @@ -819,19 +908,19 @@ unsafeWrite v (j-1) x return (i, j-1) - (i,j) <- Stream.foldM' put (0, n) s + (i,j) <- Bundle.foldM' put (0, n) s return (unsafeSlice 0 i v, unsafeSlice j (n-j) v) -partitionStream :: (PrimMonad m, MVector v a) - => (a -> Bool) -> Stream a -> m (v (PrimState m) a, v (PrimState m) a) -{-# INLINE partitionStream #-} -partitionStream f s - = case upperBound (Stream.size s) of +partitionBundle :: (PrimMonad m, MVector v a) + => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) +{-# INLINE partitionBundle #-} +partitionBundle f s + = case upperBound (Bundle.size s) of Just n -> partitionMax f s n Nothing -> partitionUnknown f s partitionMax :: (PrimMonad m, MVector v a) - => (a -> Bool) -> Stream a -> Int -> m (v (PrimState m) a, v (PrimState m) a) + => (a -> Bool) -> Bundle u a -> Int -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE partitionMax #-} partitionMax f s n = do @@ -849,7 +938,7 @@ unsafeWrite v j' x return (i,j') - (i,j) <- Stream.foldM' put (0,n) s + (i,j) <- Bundle.foldM' put (0,n) s INTERNAL_CHECK(check) "partitionMax" "invalid indices" (i <= j) $ return () let l = unsafeSlice 0 i v @@ -858,13 +947,13 @@ return (l,r) partitionUnknown :: (PrimMonad m, MVector v a) - => (a -> Bool) -> Stream a -> m (v (PrimState m) a, v (PrimState m) a) + => (a -> Bool) -> Bundle u a -> m (v (PrimState m) a, v (PrimState m) a) {-# INLINE partitionUnknown #-} partitionUnknown f s = do v1 <- unsafeNew 0 v2 <- unsafeNew 0 - (v1', n1, v2', n2) <- Stream.foldM' put (v1, 0, v2, 0) s + (v1', n1, v2', n2) <- Bundle.foldM' put (v1, 0, v2, 0) s INTERNAL_CHECK(checkSlice) "partitionUnknown" 0 n1 (length v1') $ INTERNAL_CHECK(checkSlice) "partitionUnknown" 0 n2 (length v2') $ return (unsafeSlice 0 n1 v1', unsafeSlice 0 n2 v2') diff --git a/Data/Vector/Generic/Mutable/Base.hs b/Data/Vector/Generic/Mutable/Base.hs new file mode 100644 --- /dev/null +++ b/Data/Vector/Generic/Mutable/Base.hs @@ -0,0 +1,135 @@ +{-# LANGUAGE MultiParamTypeClasses, BangPatterns #-} +-- | +-- Module : Data.Vector.Generic.Mutable.Base +-- Copyright : (c) Roman Leshchinskiy 2008-2011 +-- License : BSD-style +-- +-- Maintainer : Roman Leshchinskiy +-- Stability : experimental +-- Portability : non-portable +-- +-- Class of mutable vectors +-- + +module Data.Vector.Generic.Mutable.Base ( + MVector(..) +) where + +import Control.Monad.Primitive ( PrimMonad, PrimState ) + +#include "vector.h" + +-- | Class of mutable vectors parametrised with a primitive state token. +-- +class MVector v a where + -- | Length of the mutable vector. This method should not be + -- called directly, use 'length' instead. + basicLength :: v s a -> Int + + -- | Yield a part of the mutable vector without copying it. This method + -- should not be called directly, use 'unsafeSlice' instead. + basicUnsafeSlice :: Int -- ^ starting index + -> Int -- ^ length of the slice + -> v s a + -> v s a + + -- Check whether two vectors overlap. This method should not be + -- called directly, use 'overlaps' instead. + basicOverlaps :: v s a -> v s a -> Bool + + -- | Create a mutable vector of the given length. This method should not be + -- called directly, use 'unsafeNew' instead. + basicUnsafeNew :: PrimMonad m => Int -> m (v (PrimState m) a) + + -- | Create a mutable vector of the given length and fill it with an + -- initial value. This method should not be called directly, use + -- 'replicate' instead. + basicUnsafeReplicate :: PrimMonad m => Int -> a -> m (v (PrimState m) a) + + -- | Yield the element at the given position. This method should not be + -- called directly, use 'unsafeRead' instead. + basicUnsafeRead :: PrimMonad m => v (PrimState m) a -> Int -> m a + + -- | Replace the element at the given position. This method should not be + -- called directly, use 'unsafeWrite' instead. + basicUnsafeWrite :: PrimMonad m => v (PrimState m) a -> Int -> a -> m () + + -- | Reset all elements of the vector to some undefined value, clearing all + -- references to external objects. This is usually a noop for unboxed + -- vectors. This method should not be called directly, use 'clear' instead. + basicClear :: PrimMonad m => v (PrimState m) a -> m () + + -- | Set all elements of the vector to the given value. This method should + -- not be called directly, use 'set' instead. + basicSet :: PrimMonad m => v (PrimState m) a -> a -> m () + + -- | Copy a vector. The two vectors may not overlap. This method should not + -- be called directly, use 'unsafeCopy' instead. + basicUnsafeCopy :: PrimMonad m => v (PrimState m) a -- ^ target + -> v (PrimState m) a -- ^ source + -> m () + + -- | Move the contents of a vector. The two vectors may overlap. This method + -- should not be called directly, use 'unsafeMove' instead. + basicUnsafeMove :: PrimMonad m => v (PrimState m) a -- ^ target + -> v (PrimState m) a -- ^ source + -> m () + + -- | Grow a vector by the given number of elements. This method should not be + -- called directly, use 'unsafeGrow' instead. + basicUnsafeGrow :: PrimMonad m => v (PrimState m) a -> Int + -> m (v (PrimState m) a) + + {-# INLINE basicUnsafeReplicate #-} + basicUnsafeReplicate n x + = do + v <- basicUnsafeNew n + basicSet v x + return v + + {-# INLINE basicClear #-} + basicClear _ = return () + + {-# INLINE basicSet #-} + basicSet !v x + | n == 0 = return () + | otherwise = do + basicUnsafeWrite v 0 x + do_set 1 + where + !n = basicLength v + + do_set i | 2*i < n = do basicUnsafeCopy (basicUnsafeSlice i i v) + (basicUnsafeSlice 0 i v) + do_set (2*i) + | otherwise = basicUnsafeCopy (basicUnsafeSlice i (n-i) v) + (basicUnsafeSlice 0 (n-i) v) + + {-# INLINE basicUnsafeCopy #-} + basicUnsafeCopy !dst !src = do_copy 0 + where + !n = basicLength src + + do_copy i | i < n = do + x <- basicUnsafeRead src i + basicUnsafeWrite dst i x + do_copy (i+1) + | otherwise = return () + + {-# INLINE basicUnsafeMove #-} + basicUnsafeMove !dst !src + | basicOverlaps dst src = do + srcCopy <- basicUnsafeNew (basicLength src) + basicUnsafeCopy srcCopy src + basicUnsafeCopy dst srcCopy + | otherwise = basicUnsafeCopy dst src + + {-# INLINE basicUnsafeGrow #-} + basicUnsafeGrow v by + = do + v' <- basicUnsafeNew (n+by) + basicUnsafeCopy (basicUnsafeSlice 0 n v') v + return v' + where + n = basicLength v + diff --git a/Data/Vector/Generic/New.hs b/Data/Vector/Generic/New.hs --- a/Data/Vector/Generic/New.hs +++ b/Data/Vector/Generic/New.hs @@ -13,7 +13,7 @@ -- module Data.Vector.Generic.New ( - New(..), create, run, runPrim, apply, modify, modifyWithStream, + New(..), create, run, runPrim, apply, modify, modifyWithBundle, unstream, transform, unstreamR, transformR, slice, init, tail, take, drop, unsafeSlice, unsafeInit, unsafeTail @@ -24,8 +24,10 @@ import Data.Vector.Generic.Base ( Vector, Mutable ) -import Data.Vector.Fusion.Stream ( Stream, MStream ) -import qualified Data.Vector.Fusion.Stream as Stream +import Data.Vector.Fusion.Bundle ( Bundle, MBundle ) +import qualified Data.Vector.Fusion.Bundle as Bundle +import Data.Vector.Fusion.Stream.Monadic ( Stream ) +import Data.Vector.Fusion.Bundle.Size import Control.Monad.Primitive import Control.Monad.ST ( ST ) @@ -56,117 +58,120 @@ {-# INLINE modify #-} modify f (New p) = New (do { v <- p; f v; return v }) -modifyWithStream :: (forall s. Mutable v s a -> Stream b -> ST s ()) - -> New v a -> Stream b -> New v a -{-# INLINE_STREAM modifyWithStream #-} -modifyWithStream f (New p) s = s `seq` New (do { v <- p; f v s; return v }) +modifyWithBundle :: (forall s. Mutable v s a -> Bundle u b -> ST s ()) + -> New v a -> Bundle u b -> New v a +{-# INLINE_FUSED modifyWithBundle #-} +modifyWithBundle f (New p) s = s `seq` New (do { v <- p; f v s; return v }) -unstream :: Vector v a => Stream a -> New v a -{-# INLINE_STREAM unstream #-} -unstream s = s `seq` New (MVector.unstream s) +unstream :: Vector v a => Bundle v a -> New v a +{-# INLINE_FUSED unstream #-} +unstream s = s `seq` New (MVector.vunstream s) -transform :: Vector v a => - (forall m. Monad m => MStream m a -> MStream m a) -> New v a -> New v a -{-# INLINE_STREAM transform #-} -transform f (New p) = New (MVector.transform f =<< p) +transform + :: Vector v a => (forall m. Monad m => Stream m a -> Stream m a) + -> (Size -> Size) -> New v a -> New v a +{-# INLINE_FUSED transform #-} +transform f g (New p) = New (MVector.transform f =<< p) {-# RULES "transform/transform [New]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) - (g :: forall m. Monad m => MStream m a -> MStream m a) - p . - transform f (transform g p) = transform (f . g) p + forall (f1 :: forall m. Monad m => Stream m a -> Stream m a) + (f2 :: forall m. Monad m => Stream m a -> Stream m a) + g1 g2 p . + transform f1 g1 (transform f2 g2 p) = transform (f1 . f2) (g1 . g2) p "transform/unstream [New]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) - s. - transform f (unstream s) = unstream (f s) + forall (f :: forall m. Monad m => Stream m a -> Stream m a) + g s. + transform f g (unstream s) = unstream (Bundle.inplace f g s) #-} -unstreamR :: Vector v a => Stream a -> New v a -{-# INLINE_STREAM unstreamR #-} +unstreamR :: Vector v a => Bundle v a -> New v a +{-# INLINE_FUSED unstreamR #-} unstreamR s = s `seq` New (MVector.unstreamR s) -transformR :: Vector v a => - (forall m. Monad m => MStream m a -> MStream m a) -> New v a -> New v a -{-# INLINE_STREAM transformR #-} -transformR f (New p) = New (MVector.transformR f =<< p) +transformR + :: Vector v a => (forall m. Monad m => Stream m a -> Stream m a) + -> (Size -> Size) -> New v a -> New v a +{-# INLINE_FUSED transformR #-} +transformR f g (New p) = New (MVector.transformR f =<< p) {-# RULES "transformR/transformR [New]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) - (g :: forall m. Monad m => MStream m a -> MStream m a) + forall (f1 :: forall m. Monad m => Stream m a -> Stream m a) + (f2 :: forall m. Monad m => Stream m a -> Stream m a) + g1 g2 p . - transformR f (transformR g p) = transformR (f . g) p + transformR f1 g1 (transformR f2 g2 p) = transformR (f1 . f2) (g1 . g2) p "transformR/unstreamR [New]" - forall (f :: forall m. Monad m => MStream m a -> MStream m a) - s. - transformR f (unstreamR s) = unstreamR (f s) + forall (f :: forall m. Monad m => Stream m a -> Stream m a) + g s. + transformR f g (unstreamR s) = unstreamR (Bundle.inplace f g s) #-} slice :: Vector v a => Int -> Int -> New v a -> New v a -{-# INLINE_STREAM slice #-} +{-# INLINE_FUSED slice #-} slice i n m = apply (MVector.slice i n) m init :: Vector v a => New v a -> New v a -{-# INLINE_STREAM init #-} +{-# INLINE_FUSED init #-} init m = apply MVector.init m tail :: Vector v a => New v a -> New v a -{-# INLINE_STREAM tail #-} +{-# INLINE_FUSED tail #-} tail m = apply MVector.tail m take :: Vector v a => Int -> New v a -> New v a -{-# INLINE_STREAM take #-} +{-# INLINE_FUSED take #-} take n m = apply (MVector.take n) m drop :: Vector v a => Int -> New v a -> New v a -{-# INLINE_STREAM drop #-} +{-# INLINE_FUSED drop #-} drop n m = apply (MVector.drop n) m unsafeSlice :: Vector v a => Int -> Int -> New v a -> New v a -{-# INLINE_STREAM unsafeSlice #-} +{-# INLINE_FUSED unsafeSlice #-} unsafeSlice i n m = apply (MVector.unsafeSlice i n) m unsafeInit :: Vector v a => New v a -> New v a -{-# INLINE_STREAM unsafeInit #-} +{-# INLINE_FUSED unsafeInit #-} unsafeInit m = apply MVector.unsafeInit m unsafeTail :: Vector v a => New v a -> New v a -{-# INLINE_STREAM unsafeTail #-} +{-# INLINE_FUSED unsafeTail #-} unsafeTail m = apply MVector.unsafeTail m {-# RULES "slice/unstream [New]" forall i n s. - slice i n (unstream s) = unstream (Stream.slice i n s) + slice i n (unstream s) = unstream (Bundle.slice i n s) "init/unstream [New]" forall s. - init (unstream s) = unstream (Stream.init s) + init (unstream s) = unstream (Bundle.init s) "tail/unstream [New]" forall s. - tail (unstream s) = unstream (Stream.tail s) + tail (unstream s) = unstream (Bundle.tail s) "take/unstream [New]" forall n s. - take n (unstream s) = unstream (Stream.take n s) + take n (unstream s) = unstream (Bundle.take n s) "drop/unstream [New]" forall n s. - drop n (unstream s) = unstream (Stream.drop n s) + drop n (unstream s) = unstream (Bundle.drop n s) "unsafeSlice/unstream [New]" forall i n s. - unsafeSlice i n (unstream s) = unstream (Stream.slice i n s) + unsafeSlice i n (unstream s) = unstream (Bundle.slice i n s) "unsafeInit/unstream [New]" forall s. - unsafeInit (unstream s) = unstream (Stream.init s) + unsafeInit (unstream s) = unstream (Bundle.init s) "unsafeTail/unstream [New]" forall s. - unsafeTail (unstream s) = unstream (Stream.tail s) + unsafeTail (unstream s) = unstream (Bundle.tail s) #-} diff --git a/Data/Vector/Primitive.hs b/Data/Vector/Primitive.hs --- a/Data/Vector/Primitive.hs +++ b/Data/Vector/Primitive.hs @@ -136,7 +136,7 @@ import qualified Data.Vector.Generic as G import Data.Vector.Primitive.Mutable ( MVector(..) ) -import qualified Data.Vector.Fusion.Stream as Stream +import qualified Data.Vector.Fusion.Bundle as Bundle import Data.Primitive.ByteArray import Data.Primitive ( Prim, sizeOf ) @@ -223,27 +223,27 @@ -- See http://trac.haskell.org/vector/ticket/12 instance (Prim a, Eq a) => Eq (Vector a) where {-# INLINE (==) #-} - xs == ys = Stream.eq (G.stream xs) (G.stream ys) + xs == ys = Bundle.eq (G.stream xs) (G.stream ys) {-# INLINE (/=) #-} - xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys)) + xs /= ys = not (Bundle.eq (G.stream xs) (G.stream ys)) -- See http://trac.haskell.org/vector/ticket/12 instance (Prim a, Ord a) => Ord (Vector a) where {-# INLINE compare #-} - compare xs ys = Stream.cmp (G.stream xs) (G.stream ys) + compare xs ys = Bundle.cmp (G.stream xs) (G.stream ys) {-# INLINE (<) #-} - xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT + xs < ys = Bundle.cmp (G.stream xs) (G.stream ys) == LT {-# INLINE (<=) #-} - xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT + xs <= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= GT {-# INLINE (>) #-} - xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT + xs > ys = Bundle.cmp (G.stream xs) (G.stream ys) == GT {-# INLINE (>=) #-} - xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT + xs >= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= LT instance Prim a => Monoid (Vector a) where {-# INLINE mempty #-} diff --git a/Data/Vector/Storable.hs b/Data/Vector/Storable.hs --- a/Data/Vector/Storable.hs +++ b/Data/Vector/Storable.hs @@ -139,7 +139,7 @@ import qualified Data.Vector.Generic as G import Data.Vector.Storable.Mutable ( MVector(..) ) import Data.Vector.Storable.Internal -import qualified Data.Vector.Fusion.Stream as Stream +import qualified Data.Vector.Fusion.Bundle as Bundle import Foreign.Storable import Foreign.ForeignPtr @@ -230,27 +230,27 @@ -- See http://trac.haskell.org/vector/ticket/12 instance (Storable a, Eq a) => Eq (Vector a) where {-# INLINE (==) #-} - xs == ys = Stream.eq (G.stream xs) (G.stream ys) + xs == ys = Bundle.eq (G.stream xs) (G.stream ys) {-# INLINE (/=) #-} - xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys)) + xs /= ys = not (Bundle.eq (G.stream xs) (G.stream ys)) -- See http://trac.haskell.org/vector/ticket/12 instance (Storable a, Ord a) => Ord (Vector a) where {-# INLINE compare #-} - compare xs ys = Stream.cmp (G.stream xs) (G.stream ys) + compare xs ys = Bundle.cmp (G.stream xs) (G.stream ys) {-# INLINE (<) #-} - xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT + xs < ys = Bundle.cmp (G.stream xs) (G.stream ys) == LT {-# INLINE (<=) #-} - xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT + xs <= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= GT {-# INLINE (>) #-} - xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT + xs > ys = Bundle.cmp (G.stream xs) (G.stream ys) == GT {-# INLINE (>=) #-} - xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT + xs >= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= LT instance Storable a => Monoid (Vector a) where {-# INLINE mempty #-} diff --git a/Data/Vector/Unboxed.hs b/Data/Vector/Unboxed.hs --- a/Data/Vector/Unboxed.hs +++ b/Data/Vector/Unboxed.hs @@ -163,7 +163,7 @@ import Data.Vector.Unboxed.Base import qualified Data.Vector.Generic as G -import qualified Data.Vector.Fusion.Stream as Stream +import qualified Data.Vector.Fusion.Bundle as Bundle import Data.Vector.Fusion.Util ( delayed_min ) import Control.Monad.ST ( ST ) @@ -193,27 +193,27 @@ -- See http://trac.haskell.org/vector/ticket/12 instance (Unbox a, Eq a) => Eq (Vector a) where {-# INLINE (==) #-} - xs == ys = Stream.eq (G.stream xs) (G.stream ys) + xs == ys = Bundle.eq (G.stream xs) (G.stream ys) {-# INLINE (/=) #-} - xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys)) + xs /= ys = not (Bundle.eq (G.stream xs) (G.stream ys)) -- See http://trac.haskell.org/vector/ticket/12 instance (Unbox a, Ord a) => Ord (Vector a) where {-# INLINE compare #-} - compare xs ys = Stream.cmp (G.stream xs) (G.stream ys) + compare xs ys = Bundle.cmp (G.stream xs) (G.stream ys) {-# INLINE (<) #-} - xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT + xs < ys = Bundle.cmp (G.stream xs) (G.stream ys) == LT {-# INLINE (<=) #-} - xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT + xs <= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= GT {-# INLINE (>) #-} - xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT + xs > ys = Bundle.cmp (G.stream xs) (G.stream ys) == GT {-# INLINE (>=) #-} - xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT + xs >= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= LT instance Unbox a => Monoid (Vector a) where {-# INLINE mempty #-} diff --git a/Data/Vector/Unboxed/Base.hs b/Data/Vector/Unboxed/Base.hs --- a/Data/Vector/Unboxed/Base.hs +++ b/Data/Vector/Unboxed/Base.hs @@ -1,4 +1,7 @@ {-# LANGUAGE MultiParamTypeClasses, TypeFamilies, FlexibleContexts #-} +#if __GLASGOW_HASKELL__ >= 707 +{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-} +#endif {-# OPTIONS_HADDOCK hide #-} -- | @@ -31,6 +34,9 @@ import Data.Int ( Int8, Int16, Int32, Int64 ) import Data.Complex +#if __GLASGOW_HASKELL__ >= 707 +import Data.Typeable ( Typeable ) +#else import Data.Typeable ( Typeable1(..), Typeable2(..), mkTyConApp, #if MIN_VERSION_base(4,4,0) mkTyCon3 @@ -38,6 +44,8 @@ mkTyCon #endif ) +#endif + import Data.Data ( Data(..) ) #include "vector.h" @@ -58,7 +66,10 @@ -- ----------------- -- Data and Typeable -- ----------------- - +#if __GLASGOW_HASKELL__ >= 707 +deriving instance Typeable Vector +deriving instance Typeable MVector +#else #if MIN_VERSION_base(4,4,0) vectorTyCon = mkTyCon3 "vector" #else @@ -70,6 +81,7 @@ instance Typeable2 MVector where typeOf2 _ = mkTyConApp (vectorTyCon "Data.Vector.Unboxed.Mutable" "MVector") [] +#endif instance (Data a, Unbox a) => Data (Vector a) where gfoldl = G.gfoldl diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# The vector package + +An efficient implementation of Int-indexed arrays (both mutable and +immutable), with a powerful loop optimisation framework. diff --git a/benchmarks/vector-benchmarks.cabal b/benchmarks/vector-benchmarks.cabal --- a/benchmarks/vector-benchmarks.cabal +++ b/benchmarks/vector-benchmarks.cabal @@ -1,5 +1,5 @@ Name: vector-benchmarks -Version: 0.10.0.1 +Version: 0.10.9 License: BSD3 License-File: LICENSE Author: Roman Leshchinskiy @@ -14,7 +14,7 @@ Build-Depends: base >= 2 && < 5, array, criterion >= 0.5 && < 0.7, mwc-random >= 0.5 && < 0.13, - vector == 0.10.0.1 + vector == 0.10.9 if impl(ghc<6.13) Ghc-Options: -finline-if-enough-args -fno-method-sharing diff --git a/include/vector.h b/include/vector.h --- a/include/vector.h +++ b/include/vector.h @@ -1,8 +1,8 @@ -#define PHASE_STREAM [1] -#define PHASE_INNER [0] +#define PHASE_FUSED [1] +#define PHASE_INNER [0] -#define INLINE_STREAM INLINE PHASE_STREAM -#define INLINE_INNER INLINE PHASE_INNER +#define INLINE_FUSED INLINE PHASE_FUSED +#define INLINE_INNER INLINE PHASE_INNER #ifndef NOT_VECTOR_MODULE import qualified Data.Vector.Internal.Check as Ck @@ -16,4 +16,6 @@ #define UNSAFE_CHECK(f) (CHECK(f) Ck.Unsafe) #define INTERNAL_CHECK(f) (CHECK(f) Ck.Internal) +#define PHASE_STREAM Please use "PHASE_FUSED" instead +#define INLINE_STREAM Please use "INLINE_FUSED" instead diff --git a/internal/GenUnboxTuple.hs b/internal/GenUnboxTuple.hs --- a/internal/GenUnboxTuple.hs +++ b/internal/GenUnboxTuple.hs @@ -59,7 +59,7 @@ <+> sep (punctuate (text " ->") [text ty <+> v | v <- vars]) <+> text "->" <+> text ty <+> tuple vars - ,text "{-# INLINE_STREAM" <+> name <+> text "#-}" + ,text "{-# INLINE_FUSED" <+> name <+> text "#-}" ,name <+> sep varss <+> text "=" <+> con c @@ -84,7 +84,7 @@ 2 $ text "G.stream" <+> parens (name "zip" <+> sep varss) <+> char '=' - <+> text "Stream." <> name "zipWith" <+> tuple (replicate n empty) + <+> text "Bundle." <> name "zipWith" <+> tuple (replicate n empty) <+> sep [parens $ text "G.stream" <+> vs | vs <- varss] $$ text "#-}" where diff --git a/internal/unbox-tuple-instances b/internal/unbox-tuple-instances --- a/internal/unbox-tuple-instances +++ b/internal/unbox-tuple-instances @@ -105,7 +105,7 @@ -- | /O(1)/ Zip 2 vectors zip :: (Unbox a, Unbox b) => MVector s a -> MVector s b -> MVector s (a, b) -{-# INLINE_STREAM zip #-} +{-# INLINE_FUSED zip #-} zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) where len = length as `delayed_min` length bs -- | /O(1)/ Unzip 2 vectors @@ -117,11 +117,11 @@ #ifdef DEFINE_IMMUTABLE -- | /O(1)/ Zip 2 vectors zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b) -{-# INLINE_STREAM zip #-} +{-# INLINE_FUSED zip #-} zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) where len = length as `delayed_min` length bs {-# RULES "stream/zip [Vector.Unboxed]" forall as bs . - G.stream (zip as bs) = Stream.zipWith (,) (G.stream as) + G.stream (zip as bs) = Bundle.zipWith (,) (G.stream as) (G.stream bs) #-} -- | /O(1)/ Unzip 2 vectors @@ -261,7 +261,7 @@ zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a -> MVector s b -> MVector s c -> MVector s (a, b, c) -{-# INLINE_STREAM zip3 #-} +{-# INLINE_FUSED zip3 #-} zip3 as bs cs = MV_3 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -281,14 +281,14 @@ zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a -> Vector b -> Vector c -> Vector (a, b, c) -{-# INLINE_STREAM zip3 #-} +{-# INLINE_FUSED zip3 #-} zip3 as bs cs = V_3 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) where len = length as `delayed_min` length bs `delayed_min` length cs {-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs . - G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as) + G.stream (zip3 as bs cs) = Bundle.zipWith3 (, ,) (G.stream as) (G.stream bs) (G.stream cs) #-} @@ -461,7 +461,7 @@ MVector s b -> MVector s c -> MVector s d -> MVector s (a, b, c, d) -{-# INLINE_STREAM zip4 #-} +{-# INLINE_FUSED zip4 #-} zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -488,7 +488,7 @@ Vector b -> Vector c -> Vector d -> Vector (a, b, c, d) -{-# INLINE_STREAM zip4 #-} +{-# INLINE_FUSED zip4 #-} zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -499,7 +499,7 @@ length cs `delayed_min` length ds {-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds . - G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as) + G.stream (zip4 as bs cs ds) = Bundle.zipWith4 (, , ,) (G.stream as) (G.stream bs) (G.stream cs) (G.stream ds) @@ -714,7 +714,7 @@ MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e) -{-# INLINE_STREAM zip5 #-} +{-# INLINE_FUSED zip5 #-} zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -750,7 +750,7 @@ Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e) -{-# INLINE_STREAM zip5 #-} +{-# INLINE_FUSED zip5 #-} zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -767,7 +767,7 @@ bs cs ds - es) = Stream.zipWith5 (, , , ,) (G.stream as) + es) = Bundle.zipWith5 (, , , ,) (G.stream as) (G.stream bs) (G.stream cs) (G.stream ds) @@ -1013,7 +1013,7 @@ MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f) -{-# INLINE_STREAM zip6 #-} +{-# INLINE_FUSED zip6 #-} zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -1055,7 +1055,7 @@ Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f) -{-# INLINE_STREAM zip6 #-} +{-# INLINE_FUSED zip6 #-} zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs) (unsafeSlice 0 len cs) @@ -1075,7 +1075,7 @@ cs ds es - fs) = Stream.zipWith6 (, , , , ,) (G.stream as) + fs) = Bundle.zipWith6 (, , , , ,) (G.stream as) (G.stream bs) (G.stream cs) (G.stream ds) diff --git a/tests/Main.hs b/tests/Main.hs --- a/tests/Main.hs +++ b/tests/Main.hs @@ -1,12 +1,12 @@ module Main (main) where import qualified Tests.Vector -import qualified Tests.Stream +import qualified Tests.Bundle import qualified Tests.Move import Test.Framework (defaultMain) -main = defaultMain $ Tests.Stream.tests +main = defaultMain $ Tests.Bundle.tests ++ Tests.Vector.tests ++ Tests.Move.tests diff --git a/tests/Tests/Bundle.hs b/tests/Tests/Bundle.hs new file mode 100644 --- /dev/null +++ b/tests/Tests/Bundle.hs @@ -0,0 +1,163 @@ +module Tests.Bundle ( tests ) where + +import Boilerplater +import Utilities + +import qualified Data.Vector.Fusion.Bundle as S + +import Test.QuickCheck + +import Test.Framework +import Test.Framework.Providers.QuickCheck2 + +import Text.Show.Functions () +import Data.List (foldl', foldl1', unfoldr, find, findIndex) +import System.Random (Random) + +#define COMMON_CONTEXT(a) \ + VANILLA_CONTEXT(a) + +#define VANILLA_CONTEXT(a) \ + Eq a, Show a, Arbitrary a, CoArbitrary a, TestData a, Model a ~ a, EqTest a ~ Property + +testSanity :: forall v a. (COMMON_CONTEXT(a)) => S.Bundle v a -> [Test] +testSanity _ = [ + testProperty "fromList.toList == id" prop_fromList_toList, + testProperty "toList.fromList == id" prop_toList_fromList + ] + where + prop_fromList_toList :: P (S.Bundle v a -> S.Bundle v a) + = (S.fromList . S.toList) `eq` id + prop_toList_fromList :: P ([a] -> [a]) + = (S.toList . (S.fromList :: [a] -> S.Bundle v a)) `eq` id + +testPolymorphicFunctions :: forall v a. (COMMON_CONTEXT(a)) => S.Bundle v a -> [Test] +testPolymorphicFunctions _ = $(testProperties [ + 'prop_eq, + + 'prop_length, 'prop_null, + + 'prop_empty, 'prop_singleton, 'prop_replicate, + 'prop_cons, 'prop_snoc, 'prop_append, + + 'prop_head, 'prop_last, 'prop_index, + + 'prop_extract, 'prop_init, 'prop_tail, 'prop_take, 'prop_drop, + + 'prop_map, 'prop_zipWith, 'prop_zipWith3, + 'prop_filter, 'prop_takeWhile, 'prop_dropWhile, + + 'prop_elem, 'prop_notElem, + 'prop_find, 'prop_findIndex, + + 'prop_foldl, 'prop_foldl1, 'prop_foldl', 'prop_foldl1', + 'prop_foldr, 'prop_foldr1, + + 'prop_prescanl, 'prop_prescanl', + 'prop_postscanl, 'prop_postscanl', + 'prop_scanl, 'prop_scanl', 'prop_scanl1, 'prop_scanl1', + + 'prop_concatMap, + 'prop_unfoldr + ]) + where + -- Prelude + prop_eq :: P (S.Bundle v a -> S.Bundle v a -> Bool) = (==) `eq` (==) + + prop_length :: P (S.Bundle v a -> Int) = S.length `eq` length + prop_null :: P (S.Bundle v a -> Bool) = S.null `eq` null + prop_empty :: P (S.Bundle v a) = S.empty `eq` [] + prop_singleton :: P (a -> S.Bundle v a) = S.singleton `eq` singleton + prop_replicate :: P (Int -> a -> S.Bundle v a) + = (\n _ -> n < 1000) ===> S.replicate `eq` replicate + prop_cons :: P (a -> S.Bundle v a -> S.Bundle v a) = S.cons `eq` (:) + prop_snoc :: P (S.Bundle v a -> a -> S.Bundle v a) = S.snoc `eq` snoc + prop_append :: P (S.Bundle v a -> S.Bundle v a -> S.Bundle v a) = (S.++) `eq` (++) + + prop_head :: P (S.Bundle v a -> a) = not . S.null ===> S.head `eq` head + prop_last :: P (S.Bundle v a -> a) = not . S.null ===> S.last `eq` last + prop_index = \xs -> + not (S.null xs) ==> + forAll (choose (0, S.length xs-1)) $ \i -> + unP prop xs i + where + prop :: P (S.Bundle v a -> Int -> a) = (S.!!) `eq` (!!) + + prop_extract = \xs -> + forAll (choose (0, S.length xs)) $ \i -> + forAll (choose (0, S.length xs - i)) $ \n -> + unP prop i n xs + where + prop :: P (Int -> Int -> S.Bundle v a -> S.Bundle v a) = S.slice `eq` slice + + prop_tail :: P (S.Bundle v a -> S.Bundle v a) = not . S.null ===> S.tail `eq` tail + prop_init :: P (S.Bundle v a -> S.Bundle v a) = not . S.null ===> S.init `eq` init + prop_take :: P (Int -> S.Bundle v a -> S.Bundle v a) = S.take `eq` take + prop_drop :: P (Int -> S.Bundle v a -> S.Bundle v a) = S.drop `eq` drop + + prop_map :: P ((a -> a) -> S.Bundle v a -> S.Bundle v a) = S.map `eq` map + prop_zipWith :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a) = S.zipWith `eq` zipWith + prop_zipWith3 :: P ((a -> a -> a -> a) -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a) + = S.zipWith3 `eq` zipWith3 + + prop_filter :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.filter `eq` filter + prop_takeWhile :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.takeWhile `eq` takeWhile + prop_dropWhile :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.dropWhile `eq` dropWhile + + prop_elem :: P (a -> S.Bundle v a -> Bool) = S.elem `eq` elem + prop_notElem :: P (a -> S.Bundle v a -> Bool) = S.notElem `eq` notElem + prop_find :: P ((a -> Bool) -> S.Bundle v a -> Maybe a) = S.find `eq` find + prop_findIndex :: P ((a -> Bool) -> S.Bundle v a -> Maybe Int) + = S.findIndex `eq` findIndex + + prop_foldl :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldl `eq` foldl + prop_foldl1 :: P ((a -> a -> a) -> S.Bundle v a -> a) = notNullS2 ===> + S.foldl1 `eq` foldl1 + prop_foldl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldl' `eq` foldl' + prop_foldl1' :: P ((a -> a -> a) -> S.Bundle v a -> a) = notNullS2 ===> + S.foldl1' `eq` foldl1' + prop_foldr :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldr `eq` foldr + prop_foldr1 :: P ((a -> a -> a) -> S.Bundle v a -> a) = notNullS2 ===> + S.foldr1 `eq` foldr1 + + prop_prescanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.prescanl `eq` prescanl + prop_prescanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.prescanl' `eq` prescanl + prop_postscanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.postscanl `eq` postscanl + prop_postscanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.postscanl' `eq` postscanl + prop_scanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.scanl `eq` scanl + prop_scanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a) + = S.scanl' `eq` scanl + prop_scanl1 :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a) = notNullS2 ===> + S.scanl1 `eq` scanl1 + prop_scanl1' :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a) = notNullS2 ===> + S.scanl1' `eq` scanl1 + + prop_concatMap = forAll arbitrary $ \xs -> + forAll (sized (\n -> resize (n `div` S.length xs) arbitrary)) $ \f -> unP prop f xs + where + prop :: P ((a -> S.Bundle v a) -> S.Bundle v a -> S.Bundle v a) = S.concatMap `eq` concatMap + + limitUnfolds f (theirs, ours) | ours >= 0 + , Just (out, theirs') <- f theirs = Just (out, (theirs', ours - 1)) + | otherwise = Nothing + prop_unfoldr :: P (Int -> (Int -> Maybe (a,Int)) -> Int -> S.Bundle v a) + = (\n f a -> S.unfoldr (limitUnfolds f) (a, n)) + `eq` (\n f a -> unfoldr (limitUnfolds f) (a, n)) + +testBoolFunctions :: forall v. S.Bundle v Bool -> [Test] +testBoolFunctions _ = $(testProperties ['prop_and, 'prop_or ]) + where + prop_and :: P (S.Bundle v Bool -> Bool) = S.and `eq` and + prop_or :: P (S.Bundle v Bool -> Bool) = S.or `eq` or + +testBundleFunctions = testSanity (undefined :: S.Bundle v Int) + ++ testPolymorphicFunctions (undefined :: S.Bundle v Int) + ++ testBoolFunctions (undefined :: S.Bundle v Bool) + +tests = [ testGroup "Data.Vector.Fusion.Bundle" testBundleFunctions ] + diff --git a/tests/Tests/Stream.hs b/tests/Tests/Stream.hs deleted file mode 100644 --- a/tests/Tests/Stream.hs +++ /dev/null @@ -1,163 +0,0 @@ -module Tests.Stream ( tests ) where - -import Boilerplater -import Utilities - -import qualified Data.Vector.Fusion.Stream as S - -import Test.QuickCheck - -import Test.Framework -import Test.Framework.Providers.QuickCheck2 - -import Text.Show.Functions () -import Data.List (foldl', foldl1', unfoldr, find, findIndex) -import System.Random (Random) - -#define COMMON_CONTEXT(a) \ - VANILLA_CONTEXT(a) - -#define VANILLA_CONTEXT(a) \ - Eq a, Show a, Arbitrary a, CoArbitrary a, TestData a, Model a ~ a, EqTest a ~ Property - -testSanity :: forall a. (COMMON_CONTEXT(a)) => S.Stream a -> [Test] -testSanity _ = [ - testProperty "fromList.toList == id" prop_fromList_toList, - testProperty "toList.fromList == id" prop_toList_fromList - ] - where - prop_fromList_toList :: P (S.Stream a -> S.Stream a) - = (S.fromList . S.toList) `eq` id - prop_toList_fromList :: P ([a] -> [a]) - = (S.toList . (S.fromList :: [a] -> S.Stream a)) `eq` id - -testPolymorphicFunctions :: forall a. (COMMON_CONTEXT(a)) => S.Stream a -> [Test] -testPolymorphicFunctions _ = $(testProperties [ - 'prop_eq, - - 'prop_length, 'prop_null, - - 'prop_empty, 'prop_singleton, 'prop_replicate, - 'prop_cons, 'prop_snoc, 'prop_append, - - 'prop_head, 'prop_last, 'prop_index, - - 'prop_extract, 'prop_init, 'prop_tail, 'prop_take, 'prop_drop, - - 'prop_map, 'prop_zipWith, 'prop_zipWith3, - 'prop_filter, 'prop_takeWhile, 'prop_dropWhile, - - 'prop_elem, 'prop_notElem, - 'prop_find, 'prop_findIndex, - - 'prop_foldl, 'prop_foldl1, 'prop_foldl', 'prop_foldl1', - 'prop_foldr, 'prop_foldr1, - - 'prop_prescanl, 'prop_prescanl', - 'prop_postscanl, 'prop_postscanl', - 'prop_scanl, 'prop_scanl', 'prop_scanl1, 'prop_scanl1', - - 'prop_concatMap, - 'prop_unfoldr - ]) - where - -- Prelude - prop_eq :: P (S.Stream a -> S.Stream a -> Bool) = (==) `eq` (==) - - prop_length :: P (S.Stream a -> Int) = S.length `eq` length - prop_null :: P (S.Stream a -> Bool) = S.null `eq` null - prop_empty :: P (S.Stream a) = S.empty `eq` [] - prop_singleton :: P (a -> S.Stream a) = S.singleton `eq` singleton - prop_replicate :: P (Int -> a -> S.Stream a) - = (\n _ -> n < 1000) ===> S.replicate `eq` replicate - prop_cons :: P (a -> S.Stream a -> S.Stream a) = S.cons `eq` (:) - prop_snoc :: P (S.Stream a -> a -> S.Stream a) = S.snoc `eq` snoc - prop_append :: P (S.Stream a -> S.Stream a -> S.Stream a) = (S.++) `eq` (++) - - prop_head :: P (S.Stream a -> a) = not . S.null ===> S.head `eq` head - prop_last :: P (S.Stream a -> a) = not . S.null ===> S.last `eq` last - prop_index = \xs -> - not (S.null xs) ==> - forAll (choose (0, S.length xs-1)) $ \i -> - unP prop xs i - where - prop :: P (S.Stream a -> Int -> a) = (S.!!) `eq` (!!) - - prop_extract = \xs -> - forAll (choose (0, S.length xs)) $ \i -> - forAll (choose (0, S.length xs - i)) $ \n -> - unP prop i n xs - where - prop :: P (Int -> Int -> S.Stream a -> S.Stream a) = S.slice `eq` slice - - prop_tail :: P (S.Stream a -> S.Stream a) = not . S.null ===> S.tail `eq` tail - prop_init :: P (S.Stream a -> S.Stream a) = not . S.null ===> S.init `eq` init - prop_take :: P (Int -> S.Stream a -> S.Stream a) = S.take `eq` take - prop_drop :: P (Int -> S.Stream a -> S.Stream a) = S.drop `eq` drop - - prop_map :: P ((a -> a) -> S.Stream a -> S.Stream a) = S.map `eq` map - prop_zipWith :: P ((a -> a -> a) -> S.Stream a -> S.Stream a -> S.Stream a) = S.zipWith `eq` zipWith - prop_zipWith3 :: P ((a -> a -> a -> a) -> S.Stream a -> S.Stream a -> S.Stream a -> S.Stream a) - = S.zipWith3 `eq` zipWith3 - - prop_filter :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.filter `eq` filter - prop_takeWhile :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.takeWhile `eq` takeWhile - prop_dropWhile :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.dropWhile `eq` dropWhile - - prop_elem :: P (a -> S.Stream a -> Bool) = S.elem `eq` elem - prop_notElem :: P (a -> S.Stream a -> Bool) = S.notElem `eq` notElem - prop_find :: P ((a -> Bool) -> S.Stream a -> Maybe a) = S.find `eq` find - prop_findIndex :: P ((a -> Bool) -> S.Stream a -> Maybe Int) - = S.findIndex `eq` findIndex - - prop_foldl :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldl `eq` foldl - prop_foldl1 :: P ((a -> a -> a) -> S.Stream a -> a) = notNullS2 ===> - S.foldl1 `eq` foldl1 - prop_foldl' :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldl' `eq` foldl' - prop_foldl1' :: P ((a -> a -> a) -> S.Stream a -> a) = notNullS2 ===> - S.foldl1' `eq` foldl1' - prop_foldr :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldr `eq` foldr - prop_foldr1 :: P ((a -> a -> a) -> S.Stream a -> a) = notNullS2 ===> - S.foldr1 `eq` foldr1 - - prop_prescanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.prescanl `eq` prescanl - prop_prescanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.prescanl' `eq` prescanl - prop_postscanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.postscanl `eq` postscanl - prop_postscanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.postscanl' `eq` postscanl - prop_scanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.scanl `eq` scanl - prop_scanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a) - = S.scanl' `eq` scanl - prop_scanl1 :: P ((a -> a -> a) -> S.Stream a -> S.Stream a) = notNullS2 ===> - S.scanl1 `eq` scanl1 - prop_scanl1' :: P ((a -> a -> a) -> S.Stream a -> S.Stream a) = notNullS2 ===> - S.scanl1' `eq` scanl1 - - prop_concatMap = forAll arbitrary $ \xs -> - forAll (sized (\n -> resize (n `div` S.length xs) arbitrary)) $ \f -> unP prop f xs - where - prop :: P ((a -> S.Stream a) -> S.Stream a -> S.Stream a) = S.concatMap `eq` concatMap - - limitUnfolds f (theirs, ours) | ours >= 0 - , Just (out, theirs') <- f theirs = Just (out, (theirs', ours - 1)) - | otherwise = Nothing - prop_unfoldr :: P (Int -> (Int -> Maybe (a,Int)) -> Int -> S.Stream a) - = (\n f a -> S.unfoldr (limitUnfolds f) (a, n)) - `eq` (\n f a -> unfoldr (limitUnfolds f) (a, n)) - -testBoolFunctions :: [Test] -testBoolFunctions = $(testProperties ['prop_and, 'prop_or]) - where - prop_and :: P (S.Stream Bool -> Bool) = S.and `eq` and - prop_or :: P (S.Stream Bool -> Bool) = S.or `eq` or - -testStreamFunctions = testSanity (undefined :: S.Stream Int) - ++ testPolymorphicFunctions (undefined :: S.Stream Int) - ++ testBoolFunctions - -tests = [ testGroup "Data.Vector.Fusion.Stream" testStreamFunctions ] - diff --git a/tests/Tests/Vector.hs b/tests/Tests/Vector.hs --- a/tests/Tests/Vector.hs +++ b/tests/Tests/Vector.hs @@ -8,7 +8,7 @@ import qualified Data.Vector.Primitive import qualified Data.Vector.Storable import qualified Data.Vector.Unboxed -import qualified Data.Vector.Fusion.Stream as S +import qualified Data.Vector.Fusion.Bundle as S import Test.QuickCheck @@ -74,7 +74,7 @@ prop_fromList_toList (v :: v a) = (V.fromList . V.toList) v == v prop_toList_fromList (l :: [a]) = ((V.toList :: v a -> [a]) . V.fromList) l == l prop_unstream_stream (v :: v a) = (V.unstream . V.stream) v == v - prop_stream_unstream (s :: S.Stream a) = ((V.stream :: v a -> S.Stream a) . V.unstream) s == s + prop_stream_unstream (s :: S.Bundle v a) = ((V.stream :: v a -> S.Bundle v a) . V.unstream) s == s testPolymorphicFunctions :: forall a v. (COMMON_CONTEXT(a, v), VECTOR_CONTEXT(Int, v)) => v a -> [Test] testPolymorphicFunctions _ = $(testProperties [ diff --git a/tests/Utilities.hs b/tests/Utilities.hs --- a/tests/Utilities.hs +++ b/tests/Utilities.hs @@ -8,13 +8,13 @@ import qualified Data.Vector.Primitive as DVP import qualified Data.Vector.Storable as DVS import qualified Data.Vector.Unboxed as DVU -import qualified Data.Vector.Fusion.Stream as S +import qualified Data.Vector.Fusion.Bundle as S import Data.List ( sortBy ) -instance Show a => Show (S.Stream a) where - show s = "Data.Vector.Fusion.Stream.fromList " ++ show (S.toList s) +instance Show a => Show (S.Bundle v a) where + show s = "Data.Vector.Fusion.Bundle.fromList " ++ show (S.toList s) instance Arbitrary a => Arbitrary (DV.Vector a) where @@ -41,10 +41,10 @@ instance (CoArbitrary a, DVU.Unbox a) => CoArbitrary (DVU.Vector a) where coarbitrary = coarbitrary . DVU.toList -instance Arbitrary a => Arbitrary (S.Stream a) where +instance Arbitrary a => Arbitrary (S.Bundle v a) where arbitrary = fmap S.fromList arbitrary -instance CoArbitrary a => CoArbitrary (S.Stream a) where +instance CoArbitrary a => CoArbitrary (S.Bundle v a) where coarbitrary = coarbitrary . S.toList class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where @@ -55,12 +55,12 @@ type EqTest a equal :: a -> a -> EqTest a -instance Eq a => TestData (S.Stream a) where - type Model (S.Stream a) = [a] +instance Eq a => TestData (S.Bundle v a) where + type Model (S.Bundle v a) = [a] model = S.toList unmodel = S.fromList - type EqTest (S.Stream a) = Property + type EqTest (S.Bundle v a) = Property equal x y = property (x == y) instance Eq a => TestData (DV.Vector a) where diff --git a/tests/vector-tests.cabal b/tests/vector-tests.cabal --- a/tests/vector-tests.cabal +++ b/tests/vector-tests.cabal @@ -1,5 +1,5 @@ Name: vector-tests -Version: 0.10.0.1 +Version: 0.10.9 License: BSD3 License-File: LICENSE Author: Max Bolingbroke, Roman Leshchinskiy @@ -11,14 +11,14 @@ Description: Tests for the vector package -Cabal-Version: >= 1.2 +Cabal-Version: >= 1.6 Build-Type: Simple Executable "vector-tests-O0" Main-Is: Main.hs - Build-Depends: base >= 4 && < 5, template-haskell, vector == 0.10.0.1, + Build-Depends: base >= 4 && < 5, template-haskell, vector == 0.10.9.0, random, QuickCheck >= 2, test-framework, test-framework-quickcheck2 @@ -38,7 +38,7 @@ Executable "vector-tests-O2" Main-Is: Main.hs - Build-Depends: base >= 4 && < 5, template-haskell, vector == 0.10.0.1, + Build-Depends: base >= 4 && < 5, template-haskell, vector == 0.10.9.0, random, QuickCheck >= 2, test-framework, test-framework-quickcheck2 diff --git a/vector.cabal b/vector.cabal --- a/vector.cabal +++ b/vector.cabal @@ -1,12 +1,12 @@ Name: vector -Version: 0.10.0.1 +Version: 0.10.9.0 License: BSD3 License-File: LICENSE Author: Roman Leshchinskiy Maintainer: Roman Leshchinskiy Copyright: (c) Roman Leshchinskiy 2008-2012 -Homepage: http://code.haskell.org/vector -Bug-Reports: http://trac.haskell.org/vector +Homepage: https://github.com/haskell/vector +Bug-Reports: https://github.com/haskell/vector/issues Category: Data, Data Structures Synopsis: Efficient Arrays Description: @@ -33,11 +33,6 @@ . * . - Please use the project trac to submit bug reports and feature - requests. - . - * - . Changes in version 0.10.0.1 . * Require @primitive@ to include workaround for a GHC array copying bug @@ -51,10 +46,11 @@ * Safe Haskell support removed . -Cabal-Version: >= 1.2.3 +Cabal-Version: >= 1.6 Build-Type: Simple Extra-Source-Files: + README.md tests/vector-tests.cabal tests/LICENSE tests/Setup.hs @@ -62,7 +58,7 @@ tests/Boilerplater.hs tests/Utilities.hs tests/Tests/Move.hs - tests/Tests/Stream.hs + tests/Tests/Bundle.hs tests/Tests/Vector.hs benchmarks/vector-benchmarks.cabal benchmarks/LICENSE @@ -103,10 +99,12 @@ Data.Vector.Internal.Check Data.Vector.Fusion.Util - Data.Vector.Fusion.Stream.Size Data.Vector.Fusion.Stream.Monadic - Data.Vector.Fusion.Stream + Data.Vector.Fusion.Bundle.Size + Data.Vector.Fusion.Bundle.Monadic + Data.Vector.Fusion.Bundle + Data.Vector.Generic.Mutable.Base Data.Vector.Generic.Mutable Data.Vector.Generic.Base Data.Vector.Generic.New @@ -151,3 +149,6 @@ if flag(InternalChecks) cpp-options: -DVECTOR_INTERNAL_CHECKS +source-repository head + type: git + location: https://github.com/haskell/vector