Add basicUnsafeThaw
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 24 May 2010 07:17:00 +0000 (07:17 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 24 May 2010 07:17:00 +0000 (07:17 +0000)
Data/Vector.hs
Data/Vector/Generic/Base.hs
Data/Vector/Primitive.hs
Data/Vector/Storable.hs
Data/Vector/Unboxed/Base.hs
internal/GenUnboxTuple.hs
internal/unbox-tuple-instances

index 4ddee95..7e24f3c 100644 (file)
@@ -196,6 +196,10 @@ instance G.Vector Vector a where
   basicUnsafeFreeze (MVector i n marr)
     = Vector i n `liftM` unsafeFreezeArray marr
 
+  {-# INLINE basicUnsafeThaw #-}
+  basicUnsafeThaw (Vector i n arr)
+    = MVector i n `liftM` unsafeThawArray arr
+
   {-# INLINE basicLength #-}
   basicLength (Vector _ n _) = n
 
index eea391f..7b6ece3 100644 (file)
@@ -37,6 +37,8 @@ type family Mutable (v :: * -> *) :: * -> * -> *
 --
 --   * 'basicUnsafeFreeze'
 --
+--   * 'basicUnsafeThaw'
+--
 --   * 'basicLength'
 --
 --   * 'basicUnsafeSlice'
@@ -53,6 +55,12 @@ class MVector (Mutable v) a => Vector v a where
 
   -- | /Assumed complexity: O(1)/
   --
+  -- Unsafely convert an immutable vector to its mutable version without
+  -- copying. The immutable vector may not be used after this operation.
+  basicUnsafeThaw :: PrimMonad m => v a -> m (Mutable v (PrimState m) a)
+
+  -- | /Assumed complexity: O(1)/
+  --
   -- Yield the length of the vector.
   basicLength      :: v a -> Int
 
index b9fbe11..d9a9398 100644 (file)
@@ -187,6 +187,10 @@ instance Prim a => G.Vector Vector a where
   basicUnsafeFreeze (MVector i n marr)
     = Vector i n `liftM` unsafeFreezeByteArray marr
 
+  {-# INLINE basicUnsafeThaw #-}
+  basicUnsafeThaw (Vector i n arr)
+    = MVector i n `liftM` unsafeThawByteArray arr
+
   {-# INLINE basicLength #-}
   basicLength (Vector _ n _) = n
 
index 577f99a..ae4a096 100644 (file)
@@ -193,6 +193,9 @@ instance Storable a => G.Vector Vector a where
   {-# INLINE basicUnsafeFreeze #-}
   basicUnsafeFreeze (MVector p n fp) = return $ Vector p n fp
 
+  {-# INLINE basicUnsafeThaw #-}
+  basicUnsafeThaw (Vector p n fp) = return $ MVector p n fp
+
   {-# INLINE basicLength #-}
   basicLength (Vector _ n _) = n
 
index 7d4fbb7..b62406c 100644 (file)
@@ -109,6 +109,9 @@ instance G.Vector Vector () where
   {-# INLINE basicUnsafeFreeze #-}
   basicUnsafeFreeze (MV_Unit n) = return $ V_Unit n
 
+  {-# INLINE basicUnsafeThaw #-}
+  basicUnsafeThaw (V_Unit n) = return $ MV_Unit n
+
   {-# INLINE basicLength #-}
   basicLength (V_Unit n) = n
 
@@ -157,11 +160,13 @@ instance M.MVector MVector ty where {                                   \
 #define primVector(ty,con,mcon)                                         \
 instance G.Vector Vector ty where {                                     \
   {-# INLINE basicUnsafeFreeze #-}                                      \
+; {-# INLINE basicUnsafeThaw #-}                                        \
 ; {-# INLINE basicLength #-}                                            \
 ; {-# INLINE basicUnsafeSlice #-}                                       \
 ; {-# INLINE basicUnsafeIndexM #-}                                      \
 ; {-# INLINE elemseq #-}                                                \
 ; basicUnsafeFreeze (mcon v) = con `liftM` G.basicUnsafeFreeze v        \
+; basicUnsafeThaw (con v) = mcon `liftM` G.basicUnsafeThaw v            \
 ; basicLength (con v) = G.basicLength v                                 \
 ; basicUnsafeSlice i n (con v) = con $ G.basicUnsafeSlice i n v         \
 ; basicUnsafeIndexM (con v) i = G.basicUnsafeIndexM v i                 \
@@ -294,11 +299,13 @@ instance M.MVector MVector Bool where
 
 instance G.Vector Vector Bool where
   {-# INLINE basicUnsafeFreeze #-}
+  {-# INLINE basicUnsafeThaw #-}
   {-# INLINE basicLength #-}
   {-# INLINE basicUnsafeSlice #-}
   {-# INLINE basicUnsafeIndexM #-}
   {-# INLINE elemseq #-}
   basicUnsafeFreeze (MV_Bool v) = V_Bool `liftM` G.basicUnsafeFreeze v
+  basicUnsafeThaw (V_Bool v) = MV_Bool `liftM` G.basicUnsafeThaw v
   basicLength (V_Bool v) = G.basicLength v
   basicUnsafeSlice i n (V_Bool v) = V_Bool $ G.basicUnsafeSlice i n v
   basicUnsafeIndexM (V_Bool v) i = toBool `liftM` G.basicUnsafeIndexM v i
@@ -340,11 +347,13 @@ instance (RealFloat a, Unbox a) => M.MVector MVector (Complex a) where
 
 instance (RealFloat a, Unbox a) => G.Vector Vector (Complex a) where
   {-# INLINE basicUnsafeFreeze #-}
+  {-# INLINE basicUnsafeThaw #-}
   {-# INLINE basicLength #-}
   {-# INLINE basicUnsafeSlice #-}
   {-# INLINE basicUnsafeIndexM #-}
   {-# INLINE elemseq #-}
   basicUnsafeFreeze (MV_Complex v) = V_Complex `liftM` G.basicUnsafeFreeze v
+  basicUnsafeThaw (V_Complex v) = MV_Complex `liftM` G.basicUnsafeThaw v
   basicLength (V_Complex v) = G.basicLength v
   basicUnsafeSlice i n (V_Complex v) = V_Complex $ G.basicUnsafeSlice i n v
   basicUnsafeIndexM (V_Complex v) i
index 08cb1ce..8433adb 100644 (file)
@@ -178,6 +178,12 @@ generate n =
                $ text "return $" <+> con "V" <+> var 'n'
                                  <+> sep [vs <> char '\'' | vs <- varss])
 
+    gen_unsafeThaw rec
+      = (pat "V",
+         mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss]
+               $ text "return $" <+> con "MV" <+> var 'n'
+                                 <+> sep [vs <> char '\'' | vs <- varss])
+
     gen_basicUnsafeIndexM rec
       = (pat "V" <+> var 'i',
          mk_do [v <+> text "<-" <+> qG rec <+> vs <+> var 'i'
@@ -215,6 +221,7 @@ generate n =
                       ,("basicUnsafeGrow",        gen_unsafeGrow)]
 
     methods_Vector  = [("basicUnsafeFreeze",      gen_unsafeFreeze)
+                      ,("basicUnsafeThaw",        gen_unsafeThaw)
                       ,("basicLength",            gen_length "V")
                       ,("basicUnsafeSlice",       gen_unsafeSlice "G" "V")
                       ,("basicUnsafeIndexM",      gen_basicUnsafeIndexM)
index 2fbfcc9..0e40a7c 100644 (file)
@@ -68,6 +68,12 @@ instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
           as' <- G.basicUnsafeFreeze as
           bs' <- G.basicUnsafeFreeze bs
           return $ V_2 n_ as' bs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_2 n_ as bs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          return $ MV_2 n_ as' bs'
   {-# INLINE basicLength  #-}
   basicLength (V_2 n_ as bs) = n_
   {-# INLINE basicUnsafeSlice  #-}
@@ -206,6 +212,13 @@ instance (Unbox a,
           bs' <- G.basicUnsafeFreeze bs
           cs' <- G.basicUnsafeFreeze cs
           return $ V_3 n_ as' bs' cs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_3 n_ as bs cs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          return $ MV_3 n_ as' bs' cs'
   {-# INLINE basicLength  #-}
   basicLength (V_3 n_ as bs cs) = n_
   {-# INLINE basicUnsafeSlice  #-}
@@ -378,6 +391,14 @@ instance (Unbox a,
           cs' <- G.basicUnsafeFreeze cs
           ds' <- G.basicUnsafeFreeze ds
           return $ V_4 n_ as' bs' cs' ds'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_4 n_ as bs cs ds)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          return $ MV_4 n_ as' bs' cs' ds'
   {-# INLINE basicLength  #-}
   basicLength (V_4 n_ as bs cs ds) = n_
   {-# INLINE basicUnsafeSlice  #-}
@@ -594,6 +615,15 @@ instance (Unbox a,
           ds' <- G.basicUnsafeFreeze ds
           es' <- G.basicUnsafeFreeze es
           return $ V_5 n_ as' bs' cs' ds' es'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_5 n_ as bs cs ds es)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          return $ MV_5 n_ as' bs' cs' ds' es'
   {-# INLINE basicLength  #-}
   basicLength (V_5 n_ as bs cs ds es) = n_
   {-# INLINE basicUnsafeSlice  #-}
@@ -862,6 +892,16 @@ instance (Unbox a,
           es' <- G.basicUnsafeFreeze es
           fs' <- G.basicUnsafeFreeze fs
           return $ V_6 n_ as' bs' cs' ds' es' fs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          fs' <- G.basicUnsafeThaw fs
+          return $ MV_6 n_ as' bs' cs' ds' es' fs'
   {-# INLINE basicLength  #-}
   basicLength (V_6 n_ as bs cs ds es fs) = n_
   {-# INLINE basicUnsafeSlice  #-}