Rename classes and modules
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 12 Jul 2008 02:33:32 +0000 (02:33 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 12 Jul 2008 02:33:32 +0000 (02:33 +0000)
Data/Vector.hs
Data/Vector/IVector.hs [moved from Data/Vector/Base.hs with 64% similarity]
Data/Vector/MVector.hs [moved from Data/Vector/Base/Mutable.hs with 84% similarity]
Data/Vector/Mutable.hs
Data/Vector/Stream.hs
Data/Vector/Unboxed.hs
Data/Vector/Unboxed/Mutable.hs
vector.cabal

index f1f1ece..41a25e2 100644 (file)
@@ -1,10 +1,10 @@
 {-# LANGUAGE MagicHash, UnboxedTuples, FlexibleInstances, MultiParamTypeClasses #-}
 
 module Data.Vector (
-  Vector(..), module Data.Vector.Base
+  Vector(..), module Data.Vector.IVector
 ) where
 
-import           Data.Vector.Base
+import           Data.Vector.IVector
 import qualified Data.Vector.Mutable as Mut
 
 import Control.Monad.ST ( runST )
@@ -17,7 +17,7 @@ data Vector a = Vector {-# UNPACK #-} !Int
                        {-# UNPACK #-} !Int
                                       (Array# a)
 
-instance Base Vector a where
+instance IVector Vector a where
   {-# INLINE create #-}
   create init = runST (do_create init)
     where
similarity index 64%
rename from Data/Vector/Base.hs
rename to Data/Vector/IVector.hs
index 5637d6f..ee5d655 100644 (file)
@@ -2,10 +2,11 @@
 
 #include "phases.h"
 
-module Data.Vector.Base
+module Data.Vector.IVector
 where
 
-import qualified Data.Vector.Base.Mutable as Mut
+import qualified Data.Vector.MVector as MVector
+import           Data.Vector.MVector ( MVector )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Stream )
@@ -19,15 +20,15 @@ import Prelude hiding ( length,
                         filter, takeWhile, dropWhile,
                         foldl, foldl1, foldr, foldr1 )
 
-class Base v a where
-  create       :: (forall mv m. Mut.Base mv m a => m (mv m a)) -> v a
+class IVector v a where
+  create       :: (forall mv m. MVector mv m a => m (mv m a)) -> v a
 
   length       :: v a -> Int
   unsafeSlice  :: v a -> Int -> Int -> v a
 
   unsafeIndex  :: v a -> Int -> (a -> b) -> b
 
-stream :: Base v a => v a -> Stream a
+stream :: IVector v a => v a -> Stream a
 {-# INLINE_STREAM stream #-}
 stream !v = Stream.unfold get 0 `Stream.sized` Exact n
   where
@@ -37,13 +38,13 @@ stream !v = Stream.unfold get 0 `Stream.sized` Exact n
     get i | i < n     = unsafeIndex v i $ \x -> Just (x, i+1)
           | otherwise = Nothing
 
-unstream :: Base v a => Stream a -> v a
+unstream :: IVector v a => Stream a -> v a
 {-# INLINE_STREAM unstream #-}
-unstream s = create (Mut.unstream s)
+unstream s = create (MVector.unstream s)
 
 {-# RULES
 
-"stream/unstream [Vector.Base]" forall s.
+"stream/unstream [Vector.IVector]" forall s.
   stream (unstream s) = s
 
  #-}
@@ -51,100 +52,100 @@ unstream s = create (Mut.unstream s)
 -- Construction
 -- ------------
 
-empty :: Base v a => v a
+empty :: IVector v a => v a
 {-# INLINE empty #-}
 empty = unstream Stream.empty
 
-singleton :: Base v a => a -> v a
+singleton :: IVector v a => a -> v a
 {-# INLINE singleton #-}
 singleton x = unstream (Stream.singleton x)
 
-replicate :: Base v a => Int -> a -> v a
+replicate :: IVector v a => Int -> a -> v a
 {-# INLINE replicate #-}
 replicate n = unstream . Stream.replicate n
 
-cons :: Base v a => a -> v a -> v a
+cons :: IVector v a => a -> v a -> v a
 {-# INLINE cons #-}
 cons x = unstream . Stream.cons x . stream
 
-snoc :: Base v a => v a -> a -> v a
+snoc :: IVector v a => v a -> a -> v a
 {-# INLINE snoc #-}
 snoc v = unstream . Stream.snoc (stream v)
 
 infixr 5 ++
-(++) :: Base v a => v a -> v a -> v a
+(++) :: IVector v a => v a -> v a -> v a
 {-# INLINE (++) #-}
 v ++ w = unstream (stream v Stream.++ stream w)
 
 -- Subarrays
 -- ---------
 
-take :: Base v a => Int -> v a -> v a
+take :: IVector v a => Int -> v a -> v a
 {-# INLINE take #-}
 take n = unstream . Stream.take n . stream
 
-drop :: Base v a => Int -> v a -> v a
+drop :: IVector v a => Int -> v a -> v a
 {-# INLINE drop #-}
 drop n = unstream . Stream.drop n . stream
 
 -- Mapping/zipping
 -- ---------------
 
-map :: (Base v a, Base v b) => (a -> b) -> v a -> v b
+map :: (IVector v a, IVector v b) => (a -> b) -> v a -> v b
 {-# INLINE map #-}
 map f = unstream . Stream.map f . stream
 
-zipWith :: (Base v a, Base v b, Base v c) => (a -> b -> c) -> v a -> v b -> v c
+zipWith :: (IVector v a, IVector v b, IVector 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))
 
 -- Filtering
 -- ---------
 
-filter :: Base v a => (a -> Bool) -> v a -> v a
+filter :: IVector v a => (a -> Bool) -> v a -> v a
 {-# INLINE filter #-}
 filter f = unstream . Stream.filter f . stream
 
-takeWhile :: Base v a => (a -> Bool) -> v a -> v a
+takeWhile :: IVector v a => (a -> Bool) -> v a -> v a
 {-# INLINE takeWhile #-}
 takeWhile f = unstream . Stream.takeWhile f . stream
 
-dropWhile :: Base v a => (a -> Bool) -> v a -> v a
+dropWhile :: IVector v a => (a -> Bool) -> v a -> v a
 {-# INLINE dropWhile #-}
 dropWhile f = unstream . Stream.dropWhile f . stream
 
 -- Folding
 -- -------
 
-foldl :: Base v b => (a -> b -> a) -> a -> v b -> a
+foldl :: IVector v b => (a -> b -> a) -> a -> v b -> a
 {-# INLINE foldl #-}
 foldl f z = Stream.foldl f z . stream
 
-foldl1 :: Base v a => (a -> a -> a) -> v a -> a
+foldl1 :: IVector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldl1 #-}
 foldl1 f = Stream.foldl1 f . stream
 
-foldl' :: Base v b => (a -> b -> a) -> a -> v b -> a
+foldl' :: IVector v b => (a -> b -> a) -> a -> v b -> a
 {-# INLINE foldl' #-}
 foldl' f z = Stream.foldl' f z . stream
 
-foldl1' :: Base v a => (a -> a -> a) -> v a -> a
+foldl1' :: IVector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldl1' #-}
 foldl1' f = Stream.foldl1' f . stream
 
-foldr :: Base v a => (a -> b -> b) -> b -> v a -> b
+foldr :: IVector v a => (a -> b -> b) -> b -> v a -> b
 {-# INLINE foldr #-}
 foldr f z = Stream.foldr f z . stream
 
-foldr1 :: Base v a => (a -> a -> a) -> v a -> a
+foldr1 :: IVector v a => (a -> a -> a) -> v a -> a
 {-# INLINE foldr1 #-}
 foldr1 f = Stream.foldr1 f . stream
 
-toList :: Base v a => v a -> [a]
+toList :: IVector v a => v a -> [a]
 {-# INLINE toList #-}
 toList = Stream.toList . stream
 
-fromList :: Base v a => [a] -> v a
+fromList :: IVector v a => [a] -> v a
 {-# INLINE fromList #-}
 fromList = unstream . Stream.fromList
 
similarity index 84%
rename from Data/Vector/Base/Mutable.hs
rename to Data/Vector/MVector.hs
index f28490c..32f358f 100644 (file)
@@ -1,6 +1,6 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
-module Data.Vector.Base.Mutable (
-  Base(..),
+module Data.Vector.MVector (
+  MVector(..),
 
   slice, new, newWith, read, write, copy, grow, unstream
 ) where
@@ -21,7 +21,7 @@ import Prelude hiding ( length, read )
 gROWTH_FACTOR :: Double
 gROWTH_FACTOR = 1.5
 
-class Monad m => Base v m a where
+class Monad m => MVector v m a where
   length           :: v m a -> Int
   unsafeSlice      :: v m a -> Int -> Int -> v m a
 
@@ -72,49 +72,49 @@ class Monad m => Base v m a where
     where
       n = length v
 
-inBounds :: Base v m a => v m a -> Int -> Bool
+inBounds :: MVector v m a => v m a -> Int -> Bool
 {-# INLINE inBounds #-}
 inBounds v i = i >= 0 && i < length v
 
-slice :: Base v m a => v m a -> Int -> Int -> v m a
+slice :: MVector v m a => v m a -> Int -> Int -> v m a
 {-# INLINE slice #-}
 slice v i n = assert (i >=0 && n >= 0 && i+n <= length v)
             $ unsafeSlice v i n
 
-new :: Base v m a => Int -> m (v m a)
+new :: MVector v m a => Int -> m (v m a)
 {-# INLINE new #-}
 new n = assert (n >= 0) $ unsafeNew n
 
-newWith :: Base v m a => Int -> a -> m (v m a)
+newWith :: MVector v m a => Int -> a -> m (v m a)
 {-# INLINE newWith #-}
 newWith n x = assert (n >= 0) $ unsafeNewWith n x
 
-read :: Base v m a => v m a -> Int -> m a
+read :: MVector v m a => v m a -> Int -> m a
 {-# INLINE read #-}
 read v i = assert (inBounds v i) $ unsafeRead v i
 
-write :: Base v m a => v m a -> Int -> a -> m ()
+write :: MVector v m a => v m a -> Int -> a -> m ()
 {-# INLINE write #-}
 write v i x = assert (inBounds v i) $ unsafeWrite v i x
 
-copy :: Base v m a => v m a -> v m a -> m ()
+copy :: MVector v m a => v m a -> v m a -> m ()
 {-# INLINE copy #-}
 copy dst src = assert (not (dst `overlaps` src) && length dst == length src)
              $ unsafeCopy dst src
 
-grow :: Base v m a => v m a -> Int -> m (v m a)
+grow :: MVector v m a => v m a -> Int -> m (v m a)
 {-# INLINE grow #-}
 grow v by = assert (by >= 0)
           $ unsafeGrow v by
 
 
-unstream :: Base v m a => Stream a -> m (v m a)
+unstream :: MVector v m a => Stream a -> m (v m a)
 {-# INLINE unstream #-}
 unstream s = case upperBound (Stream.size s) of
                Just n  -> unstreamMax     s n
                Nothing -> unstreamUnknown s
 
-unstreamMax :: Base v m a => Stream a -> Int -> m (v m a)
+unstreamMax :: MVector v m a => Stream a -> Int -> m (v m a)
 {-# INLINE unstreamMax #-}
 unstreamMax s n
   = do
@@ -123,7 +123,7 @@ unstreamMax s n
       n' <- Stream.foldM put 0 s
       return $ slice v 0 n'
 
-unstreamUnknown :: Base v m a => Stream a -> m (v m a)
+unstreamUnknown :: MVector v m a => Stream a -> m (v m a)
 {-# INLINE unstreamUnknown #-}
 unstreamUnknown s
   = do
index 26515f9..5292831 100644 (file)
@@ -3,7 +3,8 @@
 module Data.Vector.Mutable ( Vector(..) )
 where
 
-import qualified Data.Vector.Base.Mutable as Base
+import qualified Data.Vector.MVector as MVector
+import           Data.Vector.MVector ( MVector )
 
 import GHC.Prim ( MutableArray#,
                   newArray#, readArray#, writeArray#, sameMutableArray#, (+#) )
@@ -12,13 +13,17 @@ import GHC.ST   ( ST(..) )
 
 import GHC.Base ( Int(..) )
 
+#ifndef __HADDOCK__
 data Vector m a where
   Vector :: {-# UNPACK #-} !Int
          -> {-# UNPACK #-} !Int
          -> MutableArray# s a
          -> Vector (ST s) a
+#else
+data Vector m a = forall s. Vector !Int !Int (MutableArray# s a)
+#endif
 
-instance Base.Base Vector (ST s) a where
+instance MVector Vector (ST s) a where
   length (Vector _ n _) = n
   unsafeSlice (Vector i _ arr#) j m = Vector (i+j) m arr#
 
index 08c64d8..2dc2437 100644 (file)
@@ -316,12 +316,13 @@ foldl1 f (Stream step s sz) = foldl1_loop s
 
 foldl' :: (a -> b -> a) -> a -> Stream b -> a
 {-# INLINE_STREAM foldl' #-}
-foldl' f !z (Stream step s _) = foldl_go z s
+foldl' f z (Stream step s _) = foldl_go z s
   where
-    foldl_go !z s = case step s of
-                      Yield x s' -> foldl_go (f z x) s'
-                      Skip    s' -> foldl_go z       s'
-                      Done       -> z
+    foldl_go z s = z `seq`
+                   case step s of
+                     Yield x s' -> foldl_go (f z x) s'
+                     Skip    s' -> foldl_go z       s'
+                     Done       -> z
 
 foldl1' :: (a -> a -> a) -> Stream a -> a
 {-# INLINE_STREAM foldl1' #-}
index a6ffcc9..87bf1f6 100644 (file)
@@ -1,10 +1,10 @@
 {-# LANGUAGE MagicHash, UnboxedTuples, FlexibleInstances, MultiParamTypeClasses #-}
 
 module Data.Vector.Unboxed (
-  Vector(..), module Data.Vector.Base
+  Vector(..), module Data.Vector.IVector
 ) where
 
-import           Data.Vector.Base
+import           Data.Vector.IVector
 import qualified Data.Vector.Unboxed.Mutable as Mut
 import           Data.Vector.Unboxed.Unbox
 
@@ -18,7 +18,7 @@ data Vector a = Vector {-# UNPACK #-} !Int
                        {-# UNPACK #-} !Int
                                       ByteArray#
 
-instance Unbox a => Base Vector a where
+instance Unbox a => IVector Vector a where
   {-# INLINE create #-}
   create init = runST (do_create init)
     where
index 434369b..25520bb 100644 (file)
@@ -3,7 +3,8 @@
 module Data.Vector.Unboxed.Mutable ( Vector(..) )
 where
 
-import qualified Data.Vector.Base.Mutable as Base
+import qualified Data.Vector.MVector as MVector
+import           Data.Vector.MVector ( MVector )
 import           Data.Vector.Unboxed.Unbox
 
 import GHC.Prim ( MutableByteArray#,
@@ -13,13 +14,17 @@ import GHC.ST   ( ST(..) )
 
 import GHC.Base ( Int(..) )
 
+#ifndef __HADDOCK__
 data Vector m a where
    Vector :: {-# UNPACK #-} !Int
           -> {-# UNPACK #-} !Int
           -> MutableByteArray# s
           -> Vector (ST s) a
+#else
+data Vector m a = forall s. Vector !Int !Int (MutableByteArray# s)
+#endif
 
-instance Unbox a => Base.Base Vector (ST s) a where
+instance Unbox a => MVector Vector (ST s) a where
   length (Vector _ n _) = n
   unsafeSlice (Vector i _ arr#) j m = Vector (i+j) m arr#
 
index 8740862..79012c3 100644 (file)
@@ -11,12 +11,13 @@ Cabal-Version:  >= 1.2
 Build-Type:     Simple
 
 Library
+  Extensions: CPP
   Exposed-Modules:
         Data.Vector.Stream.Size
         Data.Vector.Stream
 
-        Data.Vector.Base.Mutable
-        Data.Vector.Base
+        Data.Vector.MVector
+        Data.Vector.IVector
 
         Data.Vector.Unboxed.Unbox
         Data.Vector.Unboxed.Mutable