@@ -200,11 +200,11 @@ module Streamly.Internal.Data.Array.Foreign.Mut.Type
200200 , memcpy
201201 , memcmp
202202 , c_memchr
203− , sizeOfElem
204203 )
205204where
206205
207206#include "inline.hs"
207+#include "ArrayMacros.h"
208208#include "MachDeps.h"
209209
210210#ifdef USE_C_MALLOC
@@ -276,14 +276,6 @@ import Prelude hiding
276276-- >>> import qualified Streamly.Internal.Data.Fold as Fold
277277-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold
278278
279−-------------------------------------------------------------------------------
280−-- Utilities
281−-------------------------------------------------------------------------------
282−
283−{-# INLINE sizeOfElem #-}
284−sizeOfElem :: forall a . (Storable a) => a -> Int
285−sizeOfElem _ = max 1 $ sizeOf (undefined :: a)
286−
287279-------------------------------------------------------------------------------
288280-- Foreign helpers
289281-------------------------------------------------------------------------------
@@ -301,10 +293,8 @@ foreign import ccall unsafe "string.h memcmp" c_memcmp
301293-- how many elements of that type will completely fit in those bytes.
302294--
303295{-# INLINE bytesToElemCount #-}
304−bytesToElemCount :: Storable a => a -> Int -> Int
305−bytesToElemCount x n =
306− let elemSize = sizeOfElem x
307− in n `div` elemSize
296+bytesToElemCount :: forall a. Storable a => a -> Int -> Int
297+bytesToElemCount _ n = n `div` SIZE_OF(a)
308298
309299-- XXX we are converting Int to CSize
310300memcpy :: Ptr Word8 -> Ptr Word8 -> Int -> IO ()
@@ -456,7 +446,7 @@ fromForeignPtrUnsafe fp@(ForeignPtr start contents) end bound =
456446newArrayWith :: forall m a. (MonadIO m, Storable a)
457447 => (Int -> Int -> m (ArrayContents, Ptr a)) -> Int -> Int -> m (Array a)
458448newArrayWith alloc alignSize count = do
459− let size = max (count * sizeOfElem (undefined :: a)) 0
449+ let size = max (count * SIZE_OF(a)) 0
460450 (contents, p) <- alloc size alignSize
461451 return $ Array
462452 { arrContents = contents
@@ -511,7 +501,7 @@ newArrayAlignedUnmanaged = do
511501 return (ArrayContents contents, Ptr addr)
512502#else
513503newArrayAlignedUnmanaged _align count = do
514− let size = max (count * sizeOfElem (undefined :: a)) 0
504+ let size = max (count * SIZE_OF(a)) 0
515505 p <- liftIO $ mallocBytes size
516506 return $ Array
517507 { arrContents = nilArrayContents
@@ -565,9 +555,8 @@ putIndexUnsafe :: forall m a. (MonadIO m, Storable a)
565555 => Array a -> Int -> a -> m ()
566556putIndexUnsafe Array{..} i x =
567557 unsafeWithArrayContents arrContents arrStart $ \ptr -> do
568− let elemSize = sizeOfElem (undefined :: a)
569− elemPtr = ptr `plusPtr` (elemSize * i)
570− assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())
558+ let elemPtr = PTR_INDEX(ptr,i,a)
559+ assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())
571560 liftIO $ poke elemPtr x
572561
573562invalidIndex :: String -> Int -> a
@@ -578,9 +567,8 @@ invalidIndex label i =
578567putIndexPtr :: forall m a. (MonadIO m, Storable a) =>
579568 Ptr a -> Ptr a -> Int -> a -> m ()
580569putIndexPtr start end i x = do
581− let elemSize = sizeOfElem (undefined :: a)
582− elemPtr = start `plusPtr` (elemSize * i)
583− if i >= 0 && elemPtr `plusPtr` elemSize <= end
570+ let elemPtr = PTR_INDEX(start,i,a)
571+ if i >= 0 && PTR_VALID(elemPtr,end,a)
584572 then liftIO $ poke elemPtr x
585573 else invalidIndex "putIndexPtr" i
586574
@@ -622,9 +610,8 @@ modifyIndexUnsafe :: forall m a b. (MonadIO m, Storable a) =>
622610 Array a -> Int -> (a -> (a, b)) -> m b
623611modifyIndexUnsafe Array{..} i f = do
624612 liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do
625− let elemSize = sizeOfElem (undefined :: a)
626− elemPtr = ptr `plusPtr` (elemSize * i)
627− assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())
613+ let elemPtr = PTR_INDEX(ptr,i,a)
614+ assert (i >= 0 && PTR_NEXT(elemPtr,a) <= aEnd) (return ())
628615 r <- peek elemPtr
629616 let (x, res) = f r
630617 poke elemPtr x
@@ -634,9 +621,8 @@ modifyIndexUnsafe Array{..} i f = do
634621modifyIndexPtr :: forall m a b. (MonadIO m, Storable a) =>
635622 Int -> (a -> (a, b)) -> Ptr a -> Ptr a -> m b
636623modifyIndexPtr i f start end = liftIO $ do
637− let elemSize = sizeOfElem (undefined :: a)
638− elemPtr = start `plusPtr` (elemSize * i)
639− if i >= 0 && elemPtr `plusPtr` elemSize <= end
624+ let elemPtr = PTR_INDEX(start,i,a)
625+ if i >= 0 && PTR_VALID(elemPtr,end,a)
640626 then do
641627 r <- peek elemPtr
642628 let (x, res) = f r
@@ -681,12 +667,11 @@ modify Array{..} f = liftIO $
681667
682668 where
683669
684− go ptr = do
685− let elemSize = sizeOfElem (undefined :: a)
686− when (ptr `plusPtr` elemSize <= aEnd) $ do
670+ go ptr =
671+ when (PTR_VALID(ptr,aEnd,a)) $ do
687672 r <- peek ptr
688673 poke ptr (f r)
689− go (ptr `plusPtr` elemSize)
674+ go (PTR_NEXT(ptr,a))
690675
691676{-# INLINE swapPtrs #-}
692677swapPtrs :: Storable a => Ptr a -> Ptr a -> IO ()
@@ -706,9 +691,8 @@ unsafeSwapIndices :: forall m a. (MonadIO m, Storable a)
706691 => Array a -> Int -> Int -> m ()
707692unsafeSwapIndices Array{..} i1 i2 = liftIO $ do
708693 unsafeWithArrayContents arrContents arrStart $ \ptr -> do
709− let elemSize = sizeOfElem (undefined :: a)
710− ptr1 = ptr `plusPtr` (elemSize * i1)
711− ptr2 = ptr `plusPtr` (elemSize * i2)
694+ let ptr1 = PTR_INDEX(ptr,i1,a)
695+ ptr2 = PTR_INDEX(ptr,i2,a)
712696 swapPtrs ptr1 (ptr2 :: Ptr a)
713697
714698-- | Swap the elements at two indices.
@@ -717,11 +701,12 @@ unsafeSwapIndices Array{..} i1 i2 = liftIO $ do
717701swapIndices :: forall m a. (MonadIO m, Storable a)
718702 => Array a -> Int -> Int -> m ()
719703swapIndices Array{..} i1 i2 = liftIO $ do
720− let elemSize = sizeOfElem (undefined :: a)
721− ptr1 = arrStart `plusPtr` (elemSize * i1)
722− ptr2 = arrStart `plusPtr` (elemSize * i2)
723− when (i1 < 0 || ptr1 >= aEnd ) $ invalidIndex "swapIndices" i1
724− when (i2 < 0 || ptr2 >= aEnd ) $ invalidIndex "swapIndices" i2
704+ let ptr1 = PTR_INDEX(arrStart,i1,a)
705+ ptr2 = PTR_INDEX(arrStart,i2,a)
706+ when (i1 < 0 || PTR_INVALID(ptr1,aEnd,a))
707+ $ invalidIndex "swapIndices" i1
708+ when (i2 < 0 || PTR_INVALID(ptr2,aEnd,a))
709+ $ invalidIndex "swapIndices" i2
725710 swapPtrs ptr1 (ptr2 :: Ptr a)
726711
727712-------------------------------------------------------------------------------
@@ -777,8 +762,7 @@ roundUpToPower2 x =
777762--
778763{-# INLINE allocBytesToBytes #-}
779764allocBytesToBytes :: forall a. Storable a => a -> Int -> Int
780−allocBytesToBytes _ n =
781− max (arrayPayloadSize n) (sizeOfElem (undefined :: a))
765+allocBytesToBytes _ n = max (arrayPayloadSize n) (SIZE_OF(a))
782766
783767-- | Given a 'Storable' type (unused first arg) and real allocation size
784768-- (including overhead), return how many elements of that type will completely
@@ -827,8 +811,7 @@ snocNewEnd newEnd arr@Array{..} x = liftIO $ do
827811{-# INLINE snocUnsafe #-}
828812snocUnsafe :: forall m a. (MonadIO m, Storable a) =>
829813 Array a -> a -> m (Array a)
830−snocUnsafe arr@Array{..} =
831− snocNewEnd (aEnd `plusPtr` sizeOfElem (undefined :: a)) arr
814+snocUnsafe arr@Array{..} = snocNewEnd (PTR_NEXT(aEnd,a)) arr
832815
833816-- | Like 'snoc' but does not reallocate when pre-allocated array capacity
834817-- becomes full.
@@ -838,7 +821,7 @@ snocUnsafe arr@Array{..} =
838821snocMay :: forall m a. (MonadIO m, Storable a) =>
839822 Array a -> a -> m (Maybe (Array a))
840823snocMay arr@Array{..} x = liftIO $ do
841− let newEnd = aEnd `plusPtr` sizeOfElem (undefined :: a)
824+ let newEnd = PTR_NEXT(aEnd,a)
842825 if newEnd <= aBound
843826 then Just <$> snocNewEnd newEnd arr x
844827 else return Nothing
@@ -875,8 +858,7 @@ snocWithRealloc :: forall m a. (MonadIO m, Storable a) =>
875858 -> a
876859 -> m (Array a)
877860snocWithRealloc sizer arr x = do
878− let elemSize = sizeOfElem (undefined :: a)
879− arr1 <- liftIO $ reallocWith "snocWith" sizer elemSize arr
861+ arr1 <- liftIO $ reallocWith "snocWith" sizer (SIZE_OF(a)) arr
880862 snocUnsafe arr1 x
881863
882864-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
@@ -899,7 +881,7 @@ snocWith :: forall m a. (MonadIO m, Storable a) =>
899881 -> a
900882 -> m (Array a)
901883snocWith allocSize arr x = liftIO $ do
902− let newEnd = aEnd arr `plusPtr` sizeOfElem (undefined :: a)
884+ let newEnd = PTR_NEXT(aEnd arr,a)
903885 if newEnd <= aBound arr
904886 then snocNewEnd newEnd arr x
905887 else snocWithRealloc allocSize arr x
@@ -970,9 +952,7 @@ reallocAligned elemSize alignSize newSize Array{..} = do
970952{-# INLINABLE realloc #-}
971953realloc :: forall m a. (MonadIO m, Storable a) => Int -> Array a -> m (Array a)
972954realloc i arr =
973− liftIO
974− $ reallocAligned
975− (sizeOfElem (undefined :: a)) (alignment (undefined :: a)) i arr
955+ liftIO $ reallocAligned (SIZE_OF(a)) (alignment (undefined :: a)) i arr
976956
977957-- | Change the reserved memory of the array so that it is enough to hold the
978958-- specified number of elements. Nothing is done if the specified capacity is
@@ -1014,7 +994,7 @@ rightSize arr@Array{..} = do
1014994 target = roundUpLargeArray len
1015995 waste = aBound `minusPtr` aEnd
1016996 assert (target >= len) (return ())
1017− assert (len `mod` sizeOfElem (undefined :: a) == 0) (return ())
997+ assert (len `mod` SIZE_OF(a) == 0) (return ())
1018998 -- We trade off some wastage (25%) to avoid reallocations and copying.
1019999 if target < capacity && len < 3 * waste
10201000 then realloc target arr
@@ -1065,18 +1045,16 @@ truncateExp = undefined
10651045getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Array a -> Int -> m a
10661046getIndexUnsafe Array {..} i =
10671047 unsafeWithArrayContents arrContents arrStart $ \ptr -> do
1068− let elemSize = sizeOfElem (undefined :: a)
1069− elemPtr = ptr `plusPtr` (elemSize * i)
1070− assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())
1048+ let elemPtr = PTR_INDEX(ptr,i,a)
1049+ assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())
10711050 liftIO $ peek elemPtr
10721051
10731052{-# INLINE getIndexPtr #-}
10741053getIndexPtr :: forall m a. (MonadIO m, Storable a) =>
10751054 Ptr a -> Ptr a -> Int -> m a
1076−getIndexPtr ptr end i = do
1077− let elemSize = sizeOfElem (undefined :: a)
1078− elemPtr = ptr `plusPtr` (elemSize * i)
1079− if i >= 0 && elemPtr `plusPtr` elemSize <= end
1055+getIndexPtr start end i = do
1056+ let elemPtr = PTR_INDEX(start,i,a)
1057+ if i >= 0 && PTR_VALID(elemPtr,end,a)
10801058 then liftIO $ peek elemPtr
10811059 else invalidIndex "getIndexPtr" i
10821060
@@ -1091,10 +1069,9 @@ getIndex arr i =
10911069{-# INLINE getIndexPtrRev #-}
10921070getIndexPtrRev :: forall m a. (MonadIO m, Storable a) =>
10931071 Ptr a -> Ptr a -> Int -> m a
1094−getIndexPtrRev ptr end i = do
1095− let elemSize = sizeOfElem (undefined :: a)
1096− elemPtr = end `plusPtr` negate (elemSize * (i + 1))
1097− if i >= 0 && elemPtr >= ptr
1072+getIndexPtrRev start end i = do
1073+ let elemPtr = PTR_RINDEX(end,i,a)
1074+ if i >= 0 && elemPtr >= start
10981075 then liftIO $ peek elemPtr
10991076 else invalidIndex "getIndexPtrRev" i
11001077
@@ -1160,9 +1137,8 @@ getSliceUnsafe :: forall a. Storable a
11601137 -> Array a
11611138 -> Array a
11621139getSliceUnsafe index len (Array contents start e _) =
1163− let size = sizeOfElem (undefined :: a)
1164− fp1 = start `plusPtr` (index * size)
1165− end = fp1 `plusPtr` (len * size)
1140+ let fp1 = PTR_INDEX(start,index,a)
1141+ end = fp1 `plusPtr` (len * SIZE_OF(a))
11661142 in assert
11671143 (index >= 0 && len >= 0 && end <= e)
11681144 (Array contents fp1 end end)
@@ -1178,9 +1154,8 @@ getSlice :: forall a. Storable a =>
11781154 -> Array a
11791155 -> Array a
11801156getSlice index len (Array contents start e _) =
1181− let size = sizeOfElem (undefined :: a)
1182− fp1 = start `plusPtr` (index * size)
1183− end = fp1 `plusPtr` (len * size)
1157+ let fp1 = PTR_INDEX(start,index,a)
1158+ end = fp1 `plusPtr` (len * SIZE_OF(a))
11841159 in if index >= 0 && len >= 0 && end <= e
11851160 then Array contents fp1 end end
11861161 else error
@@ -1203,17 +1178,15 @@ getSlice index len (Array contents start e _) =
12031178reverse :: forall m a. (MonadIO m, Storable a) => Array a -> m ()
12041179reverse Array{..} = liftIO $ do
12051180 let l = arrStart
1206− h = aEnd `plusPtr` (- elemSize)
1181+ h = PTR_PREV(aEnd,a)
12071182 in swap l h
12081183
12091184 where
12101185
1211− elemSize = sizeOfElem (undefined :: a)
1212−
12131186 swap l h = do
12141187 when (l < h) $ do
12151188 swapPtrs l h
1216− swap (l `plusPtr` elemSize) (h `plusPtr` (- elemSize))
1189+ swap (PTR_NEXT(l,a)) (PTR_PREV(h,a))
12171190
12181191-- | Generate the next permutation of the sequence, returns False if this is
12191192-- the last permutation.
@@ -1297,7 +1270,7 @@ byteLength Array{..} =
12971270{-# INLINE length #-}
12981271length :: forall a. Storable a => Array a -> Int
12991272length arr =
1300− let elemSize = sizeOfElem (undefined :: a)
1273+ let elemSize = SIZE_OF(a)
13011274 blen = byteLength arr
13021275 in assert (blen `mod` elemSize == 0) (blen `div` elemSize)
13031276
@@ -1365,13 +1338,13 @@ arraysOf n (D.Stream step state) =
13651338 case r of
13661339 D.Yield x s -> do
13671340 liftIO $ poke end x >> touch contents
1368− let end' = end `plusPtr` sizeOfElem (undefined :: a)
1341+ let end1 = PTR_NEXT(end,a)
13691342 return $
1370− if end' >= bound
1343+ if end1 >= bound
13711344 then D.Skip
13721345 (GroupYield
1373− contents start end' bound (GroupStart s))
1374− else D.Skip (GroupBuffer s contents start end' bound)
1346+ contents start end1 bound (GroupStart s))
1347+ else D.Skip (GroupBuffer s contents start end1 bound)
13751348 D.Skip s ->
13761349 return $ D.Skip (GroupBuffer s contents start end bound)
13771350 D.Stop ->
@@ -1430,8 +1403,7 @@ flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)
14301403 r <- peek p
14311404 touch contents
14321405 return r
1433− return $ D.Yield x (InnerLoop st contents
1434− (p `plusPtr` sizeOfElem (undefined :: a)) end)
1406+ return $ D.Yield x (InnerLoop st contents (PTR_NEXT(p,a)) end)
14351407
14361408-- | Use the "readRev" unfold instead.
14371409--
@@ -1451,7 +1423,7 @@ flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)
14511423 r <- step (adaptState gst) st
14521424 return $ case r of
14531425 D.Yield Array{..} s ->
1454− let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))
1426+ let p = PTR_PREV(aEnd,a)
14551427 in D.Skip (InnerLoop s arrContents p arrStart)
14561428 D.Skip s -> D.Skip (OuterLoop s)
14571429 D.Stop -> D.Stop
@@ -1464,7 +1436,7 @@ flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)
14641436 r <- peek p
14651437 touch contents
14661438 return r
1467− let cur = p `plusPtr` negate (sizeOfElem (undefined :: a))
1439+ let cur = PTR_PREV(p,a)
14681440 return $ D.Yield x (InnerLoop st contents cur start)
14691441
14701442-------------------------------------------------------------------------------
@@ -1493,8 +1465,7 @@ producer = Producer step (return . toReadUState) extract
14931465 return D.Stop
14941466 step (ReadUState contents end cur) = do
14951467 !x <- liftIO $ peek cur
1496− let cur1 = cur `plusPtr` sizeOfElem (undefined :: a)
1497− return $ D.Yield x (ReadUState contents end cur1)
1468+ return $ D.Yield x (ReadUState contents end (PTR_NEXT(cur,a)))
14981469
14991470 extract (ReadUState contents end cur) = return $ Array contents cur end end
15001471
@@ -1514,7 +1485,7 @@ readRev = Unfold step inject
15141485 where
15151486
15161487 inject (Array contents start end _) =
1517− let p = end `plusPtr` negate (sizeOfElem (undefined :: a))
1488+ let p = PTR_PREV(end,a)
15181489 in return $ ReadUState contents start p
15191490
15201491 {-# INLINE_LATE step #-}
@@ -1522,9 +1493,8 @@ readRev = Unfold step inject
15221493 liftIO $ touch contents
15231494 return D.Stop
15241495 step (ReadUState contents start p) = do
1525− x <- liftIO $ peek p
1526− let cur = p `plusPtr` negate (sizeOfElem (undefined :: a))
1527− return $ D.Yield x (ReadUState contents start cur)
1496+ x <- liftIO $ peek p
1497+ return $ D.Yield x (ReadUState contents start (PTR_PREV(p,a)))
15281498
15291499-------------------------------------------------------------------------------
15301500-- to Lists and streams
@@ -1551,7 +1521,7 @@ toListFB c n Array{..} = go arrStart
15511521 r <- peek p
15521522 touch arrContents
15531523 return r
1554− in c x (go (p `plusPtr` sizeOfElem (undefined :: a)))
1524+ in c x (go (PTR_NEXT(p,a)))
15551525-}
15561526
15571527-- XXX Monadic foldr/build fusion?
@@ -1568,7 +1538,7 @@ toList Array{..} = liftIO $ go arrStart
15681538 go p = do
15691539 x <- peek p
15701540 touch arrContents
1571− (:) x <$> go (p `plusPtr` sizeOfElem (undefined :: a))
1541+ (:) x <$> go (PTR_NEXT(p,a))
15721542
15731543-- | Use the 'read' unfold instead.
15741544--
@@ -1586,7 +1556,7 @@ toStreamD Array{..} = D.Stream step arrStart
15861556 step _ p = liftIO $ do
15871557 r <- peek p
15881558 touch arrContents
1589− return $ D.Yield r (p `plusPtr` sizeOfElem (undefined :: a))
1559+ return $ D.Yield r (PTR_NEXT(p,a))
15901560
15911561{-# INLINE toStreamK #-}
15921562toStreamK :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a
@@ -1600,7 +1570,7 @@ toStreamK Array{..} = go arrStart
16001570 r <- peek p
16011571 touch arrContents
16021572 return r
1603− in liftIO elemM `K.consM` go (p `plusPtr` sizeOfElem (undefined :: a))
1573+ in liftIO elemM `K.consM` go (PTR_NEXT(p,a))
16041574
16051575-- | Use the 'readRev' unfold instead.
16061576--
@@ -1610,7 +1580,7 @@ toStreamK Array{..} = go arrStart
16101580{-# INLINE_NORMAL toStreamDRev #-}
16111581toStreamDRev :: forall m a. (MonadIO m, Storable a) => Array a -> D.Stream m a
16121582toStreamDRev Array{..} =
1613− let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))
1583+ let p = PTR_PREV(aEnd,a)
16141584 in D.Stream step p
16151585
16161586 where
@@ -1620,12 +1590,12 @@ toStreamDRev Array{..} =
16201590 step _ p = liftIO $ do
16211591 r <- peek p
16221592 touch arrContents
1623− return $ D.Yield r (p `plusPtr` negate (sizeOfElem (undefined :: a)))
1593+ return $ D.Yield r (PTR_PREV(p,a))
16241594
16251595{-# INLINE toStreamKRev #-}
16261596toStreamKRev :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a
16271597toStreamKRev Array {..} =
1628− let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))
1598+ let p = PTR_PREV(aEnd,a)
16291599 in go p
16301600
16311601 where
@@ -1636,7 +1606,7 @@ toStreamKRev Array {..} =
16361606 r <- peek p
16371607 touch arrContents
16381608 return r
1639− in liftIO elemM `K.consM` go (p `plusPtr` negate (sizeOfElem (undefined :: a)))
1609+ in liftIO elemM `K.consM` go (PTR_PREV(p,a))
16401610
16411611-------------------------------------------------------------------------------
16421612-- Folding
@@ -1705,8 +1675,7 @@ appendNUnsafe action n =
17051675 assert (n >= 0) (return ())
17061676 arr@(Array _ _ end bound) <- action
17071677 let free = bound `minusPtr` end
1708− elemSize = sizeOfElem (undefined :: a)
1709− needed = n * elemSize
1678+ needed = n * SIZE_OF(a)
17101679 -- XXX We can also reallocate if the array has too much free space,
17111680 -- otherwise we lose that space.
17121681 arr1 <-
@@ -1717,8 +1686,7 @@ appendNUnsafe action n =
17171686
17181687 step (ArrayUnsafe contents start end) x = do
17191688 liftIO $ poke end x >> touch contents
1720− let end1 = end `plusPtr` sizeOfElem (undefined :: a)
1721− return $ ArrayUnsafe contents start end1
1689+ return $ ArrayUnsafe contents start (PTR_NEXT(end,a))
17221690
17231691-- | Append @n@ elements to an existing array. Any free space left in the array
17241692-- after appending @n@ elements is lost.
@@ -1835,7 +1803,7 @@ writeNWithUnsafe alloc n = Fold step initial (return . fromArrayUnsafe)
18351803 liftIO $ poke end x >> touch contents
18361804 return
18371805 $ FL.Partial
1838− $ ArrayUnsafe contents start (end `plusPtr` sizeOfElem (undefined :: a))
1806+ $ ArrayUnsafe contents start (PTR_NEXT(end,a))
18391807
18401808-- | Like 'writeN' but does not check the array bounds when writing. The fold
18411809-- driver must not call the step function more than 'n' times otherwise it will
@@ -1908,20 +1876,19 @@ writeWith elemCount =
19081876
19091877 insertElem (Array contents start end bound) x = do
19101878 liftIO $ poke end x
1911− let end1 = end `plusPtr` sizeOfElem (undefined :: a)
1912− return $ Array contents start end1 bound
1879+ return $ Array contents start (PTR_NEXT(end,a)) bound
19131880
19141881 initial = do
19151882 when (elemCount < 0) $ error "writeWith: elemCount is negative"
19161883 liftIO $ newArrayAligned (alignment (undefined :: a)) elemCount
19171884 step arr@(Array _ start end bound) x
1918− | end `plusPtr` sizeOfElem (undefined :: a) > bound = do
1885+ | PTR_NEXT(end,a) > bound = do
19191886 let oldSize = end `minusPtr` start
19201887 newSize = max (oldSize * 2) 1
19211888 arr1 <-
19221889 liftIO
19231890 $ reallocAligned
1924− (sizeOfElem (undefined :: a))
1891+ (SIZE_OF(a))
19251892 (alignment (undefined :: a))
19261893 newSize
19271894 arr
@@ -1962,7 +1929,7 @@ fromStreamDN limit str = do
19621929
19631930 fwrite ptr x = do
19641931 liftIO $ poke ptr x
1965− return $ ptr `plusPtr` sizeOfElem (undefined :: a)
1932+ return $ PTR_NEXT(ptr,a)
19661933
19671934-- | Create an 'Array' from the first N elements of a list. The array is
19681935-- allocated to size N, if the list terminates before N elements then the
@@ -2156,7 +2123,7 @@ splitAt i arr@Array{..} =
21562123 else if i > maxIndex
21572124 then error $ "sliceAt: specified array index " ++ show i
21582125 ++ " is beyond the maximum index " ++ show maxIndex
2159− else let off = i * sizeOfElem (undefined :: a)
2126+ else let off = i * SIZE_OF(a)
21602127 p = arrStart `plusPtr` off
21612128 in ( Array
21622129 { arrContents = arrContents
@@ -2207,7 +2174,7 @@ asBytes = castUnsafe
22072174cast :: forall a b. Storable b => Array a -> Maybe (Array b)
22082175cast arr =
22092176 let len = byteLength arr
2210− r = len `mod` sizeOfElem (undefined :: b)
2177+ r = len `mod` SIZE_OF(b)
22112178 in if r /= 0
22122179 then Nothing
22132180 else Just $ castUnsafe arr