Fix signatures of right-to-left scans
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 10 Dec 2009 06:21:44 +0000 (06:21 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 10 Dec 2009 06:21:44 +0000 (06:21 +0000)
Data/Vector.hs
Data/Vector/Generic.hs
Data/Vector/Primitive.hs
Data/Vector/Storable.hs
Data/Vector/Unboxed.hs

index 1be476e..ec1fb73 100644 (file)
@@ -739,32 +739,32 @@ scanl1' = G.scanl1'
 
 
 -- | Prefix right-to-left scan
-prescanr :: (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
 -- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
 -- | Suffix right-to-left scan
-postscanr :: (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
 -- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
 -- | Haskell-style right-to-left scan
-scanr :: (a -> b -> a) -> a -> Vector b -> Vector a
+scanr :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
 -- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (a -> b -> a) -> a -> Vector b -> Vector a
+scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
index 0ac3e7a..bdcb73a 100644 (file)
@@ -1140,44 +1140,44 @@ scanl1' f = unstream . inplace (MStream.scanl1' f) . stream
 
 
 -- | Prefix right-to-left scan
-prescanr :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+prescanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE prescanr #-}
-prescanr f z = unstreamR . inplace (MStream.prescanl f z) . streamR
+prescanr f z = unstreamR . inplace (MStream.prescanl (flip f) z) . streamR
 
 -- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+prescanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE prescanr' #-}
-prescanr' f z = unstreamR . inplace (MStream.prescanl' f z) . streamR
+prescanr' f z = unstreamR . inplace (MStream.prescanl' (flip f) z) . streamR
 
 -- | Suffix right-to-left scan
-postscanr :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+postscanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE postscanr #-}
-postscanr f z = unstreamR . inplace (MStream.postscanl f z) . streamR
+postscanr f z = unstreamR . inplace (MStream.postscanl (flip f) z) . streamR
 
 -- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+postscanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE postscanr' #-}
-postscanr' f z = unstreamR . inplace (MStream.postscanl' f z) . streamR
+postscanr' f z = unstreamR . inplace (MStream.postscanl' (flip f) z) . streamR
 
 -- | Haskell-style right-to-left scan
-scanr :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+scanr :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE scanr #-}
-scanr f z = unstreamR . Stream.scanl f z . streamR
+scanr f z = unstreamR . Stream.scanl (flip f) z . streamR
 
 -- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (Vector v a, Vector v b) => (a -> b -> a) -> a -> v b -> v a
+scanr' :: (Vector v a, Vector v b) => (a -> b -> b) -> b -> v a -> v b
 {-# INLINE scanr' #-}
-scanr' f z = unstreamR . Stream.scanl' f z . streamR
+scanr' f z = unstreamR . Stream.scanl' (flip f) z . streamR
 
 -- | 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 f) . streamR
+scanr1 f = unstreamR . inplace (MStream.scanl1 (flip f)) . streamR
 
 -- | 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' f) . streamR
+scanr1' f = unstreamR . inplace (MStream.scanl1' (flip f)) . streamR
 
 -- Enumeration
 -- -----------
index 85a5cd0..ecdc46e 100644 (file)
@@ -682,32 +682,32 @@ scanl1' = G.scanl1'
 
 
 -- | Prefix right-to-left scan
-prescanr :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
 -- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
 -- | Suffix right-to-left scan
-postscanr :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
 -- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
 -- | Haskell-style right-to-left scan
-scanr :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
 -- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr' :: (Prim a, Prim b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
index f15e0ae..31aa67d 100644 (file)
@@ -727,35 +727,35 @@ scanl1' = G.scanl1'
 
 -- | Prefix right-to-left scan
 prescanr
-  :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
 -- | Prefix right-to-left scan with strict accumulator
 prescanr'
-  :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
 -- | Suffix right-to-left scan
 postscanr
-  :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
 -- | Suffix right-to-left scan with strict accumulator
 postscanr'
-  :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+  :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
 -- | Haskell-style right-to-left scan
-scanr :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
 -- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'
 
index 29d43d3..93cc540 100644 (file)
@@ -680,32 +680,32 @@ scanl1' = G.scanl1'
 
 
 -- | Prefix right-to-left scan
-prescanr :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr #-}
 prescanr = G.prescanr
 
 -- | Prefix right-to-left scan with strict accumulator
-prescanr' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE prescanr' #-}
 prescanr' = G.prescanr'
 
 -- | Suffix right-to-left scan
-postscanr :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr #-}
 postscanr = G.postscanr
 
 -- | Suffix right-to-left scan with strict accumulator
-postscanr' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE postscanr' #-}
 postscanr' = G.postscanr'
 
 -- | Haskell-style right-to-left scan
-scanr :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr #-}
 scanr = G.scanr
 
 -- | Haskell-style right-to-left scan with strict accumulator
-scanr' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector a -> Vector b
 {-# INLINE scanr' #-}
 scanr' = G.scanr'