Implement conversion between strict and lazy vectors

Author: Shimuuar

vector/src/Data/Vector/Strict.hs

@@ -162,7 +162,8 @@ module Data.Vector.Strict (
 
   -- ** Lists
   toList, Data.Vector.Strict.fromList, Data.Vector.Strict.fromListN,
-
+  -- ** Lazy vectors
+  toLazy, fromLazy, lazyFromLazy,
   -- ** Arrays
   toArray, fromArray, lazyFromArray, toArraySlice, unsafeFromArraySlice, unsafeLazyFromArraySlice,
 
@@ -2463,6 +2464,24 @@ fromListN :: Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
+-- Conversions - Lazy vectors
+-- -----------------------------
+
+-- | /O(1)/ Convert strict array to lazy array
+toLazy :: Vector a -> V.Vector a
+toLazy (Vector v) = v
+
+-- | /O(n)/ Convert lazy array to strict array. This function reduces
+-- each element of vector to WHNF.
+fromLazy :: V.Vector a -> Vector a
+fromLazy vec = liftRnf (`seq` ()) v `seq` v where v = Vector vec
+
+-- | /O(1)/ Convert lazy array to strict array. This function does not
+-- evaluate vector elements.
+lazyFromLazy :: V.Vector a -> Vector a
+lazyFromLazy = Vector
+
+
 -- Conversions - Arrays
 -- -----------------------------
 

vector/src/Data/Vector/Strict/Mutable.hs

@@ -66,7 +66,8 @@ module Data.Vector.Strict.Mutable (
 
   -- ** Filling and copying
   set, copy, move, unsafeCopy, unsafeMove,
-
+  -- ** Lazy arrays
+  toLazy, fromLazy, lazyFromLazy,
   -- ** Arrays
   fromMutableArray, toMutableArray,
 
@@ -707,6 +708,31 @@ ifoldrM' :: (PrimMonad m) => (Int -> a -> b -> m b) -> b -> MVector (PrimState m
 {-# INLINE ifoldrM' #-}
 ifoldrM' = G.ifoldrM'
 
+-- Conversions - Lazy vectors
+-- -----------------------------
+
+-- | /O(1)/ Convert strict mutable vector to lazy mutable
+-- vector. Vectors will share mutable buffer
+toLazy :: MVector s a -> MV.MVector s a
+{-# INLINE toLazy #-}
+toLazy (MVector vec) = vec
+
+-- | /O(1)/ Convert lazy mutable vector to strict mutable
+-- vector. Vectors will share mutable buffer. This function does not
+-- evaluate vector elements to WHNF.
+lazyFromLazy :: MV.MVector s a -> MVector s a
+{-# INLINE lazyFromLazy #-}
+lazyFromLazy = MVector
+
+-- | /O(1)/ Convert lazy mutable vector to strict mutable
+-- vector. Vectors will share mutable buffer. This function evaluates
+-- vector elements to WHNF.
+fromLazy :: PrimMonad m => MV.MVector (PrimState m) a -> m (MVector (PrimState m) a)
+fromLazy mvec = stToPrim $ do
+  G.foldM' (\_ !_ -> return ()) () mvec
+  return $ MVector mvec
+
+
 -- Conversions - Arrays
 -- -----------------------------