Add accessors for Vector/MVector fields

Co-authored-by: Alexey Kuleshevich <alexey@kuleshevi.ch>

Author: Shimuuar

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

@@ -31,12 +31,13 @@ import Prelude
 type role MVector nominal representational
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
-data MVector s a = MVector { _offset :: {-# UNPACK #-} !Int
+data MVector s a = MVector { unsafeOffset :: {-# UNPACK #-} !Int
                            -- ^ Offset in underlying array
-                           , _size   :: {-# UNPACK #-} !Int
+                           , unsafeSize   :: {-# UNPACK #-} !Int
                            -- ^ Size of slice
-                           , _array  :: {-# UNPACK #-} !(MutableArray s a)
-                           -- ^ Underlying array
+                           , unsafeMutableArray  :: {-# UNPACK #-} !(MutableArray s a)
+                           -- ^ Underlying mutable array
+                           }
                            }
 
 

vector/src/Data/Vector/Primitive/Mutable/Unsafe.hs

@@ -43,9 +43,13 @@ import Unsafe.Coerce
 type role MVector nominal nominal
 
 -- | Mutable vectors of primitive types.
-data MVector s a = MVector {-# UNPACK #-} !Int                  -- ^ offset
-                           {-# UNPACK #-} !Int                  -- ^ length
-                           {-# UNPACK #-} !(MutableByteArray s) -- ^ underlying mutable byte array
+data MVector s a = MVector { unsafeOffset :: {-# UNPACK #-} !Int
+                             -- ^ Offset into the `unsafeMutableByteArray` in number of elements, not bytes
+                           , unsafeSize :: {-# UNPACK #-} !Int
+                             -- ^ Size of the mutable vector in number of elements, not bytes
+                           , unsafeMutableByteArray :: {-# UNPACK #-} !(MutableByteArray s)
+                             -- ^ Underlying mutable byte array
+                           }
 
 -- | /O(1)/ Unsafely coerce a mutable vector from one element type to another,
 -- representationally equal type. The operation just changes the type of the

vector/src/Data/Vector/Primitive/Unsafe.hs

@@ -48,9 +48,13 @@ import Data.Vector.Primitive.Mutable.Unsafe (MVector(..))
 type role Vector nominal
 
 -- | Unboxed vectors of primitive types.
-data Vector a = Vector {-# UNPACK #-} !Int       -- ^ offset
-                       {-# UNPACK #-} !Int       -- ^ length
-                       {-# UNPACK #-} !ByteArray -- ^ underlying byte array
+data Vector a = Vector { unsafeOffset :: {-# UNPACK #-} !Int
+                         -- ^ Offset into `unsafeByteArray` in number of elements, not bytes
+                       , unsafeSize :: {-# UNPACK #-} !Int
+                         -- ^ Number of elements in number of elements, not bytes
+                       , unsafeByteArray :: {-# UNPACK #-} !ByteArray
+                         -- ^ Underlying byte array
+                       }
 
 type instance G.Mutable Vector = MVector
 

vector/src/Data/Vector/Storable/Mutable/Unsafe.hs

@@ -58,8 +58,11 @@ import Unsafe.Coerce
 type role MVector nominal nominal
 
 -- | Mutable 'Storable'-based vectors.
-data MVector s a = MVector {-# UNPACK #-} !Int
-                           {-# UNPACK #-} !(ForeignPtr a)
+data MVector s a = MVector { unsafeSize :: {-# UNPACK #-} !Int
+                           -- ^ Number of elements in a mutable vector
+                           , unsafeForeignPtr :: {-# UNPACK #-} !(ForeignPtr a)
+                           -- ^ Underlying buffer as a `ForeignPtr`, which is allowed to be mutated
+                           }
 
 type IOVector = MVector RealWorld
 type STVector s = MVector s

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

@@ -28,7 +28,7 @@ import Prelude ( Monad(..), return )
 type role MVector nominal representational
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
-newtype MVector s a = MVector (MV.MVector s a)
+newtype MVector s a = MVector { unsafeLazyMVector :: MV.MVector s a }
 
 instance G.MVector MVector a where
   {-# INLINE basicLength #-}

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

@@ -54,7 +54,7 @@ import qualified Data.Traversable as Traversable
 import qualified GHC.Exts as Exts (IsList(..))
 
 -- | Strict boxed vectors, supporting efficient slicing.
-newtype Vector a = Vector (V.Vector a)
+newtype Vector a = Vector { unsafeLazyVector :: V.Vector a }
   deriving (Foldable.Foldable, Semigroup, Monoid)
 
 -- NOTE: [GND for strict vector]