91e4160 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Fix A.fromList crashes on empty list of type [()]

91e4160Ranjeet Kumar Ranjan5 years ago

src/Streamly/Internal/Data/Array/Foreign.hs+8−7

compare with master

unifiedsplit

@@ -130,7 +130,8 @@ import Prelude hiding (length, null, last, map, (!!), read, concat)

130

131import GHC.Ptr (Ptr(..))

132

133−import Streamly.Internal.Data.Array.Foreign.Mut.Type (ReadUState(..), touch)

133+import Streamly.Internal.Data.Array.Foreign.Mut.Type

134+ (ReadUState(..), sizeOfElem, touch)

134import Streamly.Internal.Data.Array.Foreign.Type (Array(..), length)

135import Streamly.Internal.Data.Array.Foreign.Type (Array(..), length)

135import Streamly.Internal.Data.Fold.Type (Fold(..))

136import Streamly.Internal.Data.Fold.Type (Fold(..))

136import Streamly.Internal.Data.Producer.Type (Producer(..))

137import Streamly.Internal.Data.Producer.Type (Producer(..))

@@ -204,7 +205,7 @@ producer = Producer step inject extract

204 -- This should be safe as the array contents are guaranteed to be

205 -- This should be safe as the array contents are guaranteed to be

205 -- evaluated/written to before we peek at them.

206 -- evaluated/written to before we peek at them.

206 let !x = unsafeInlineIO $ peek cur

207 let !x = unsafeInlineIO $ peek cur

207− cur1 = cur `plusPtr` sizeOf (undefined :: a)

208+ cur1 = cur `plusPtr` sizeOfElem (undefined :: a)

208 return $ D.Yield x (ReadUState contents end cur1)

209 return $ D.Yield x (ReadUState contents end cur1)

209

210

210 extract (ReadUState contents end cur) = return $ Array contents cur end

211 extract (ReadUState contents end cur) = return $ Array contents cur end

@@ -249,7 +250,7 @@ unsafeRead = Unfold step inject

249 r <- peek p

250 r <- peek p

250 touch contents

251 touch contents

251 return r

252 return r

252− let !p1 = p `plusPtr` sizeOf (undefined :: a)

253+ let !p1 = p `plusPtr` sizeOfElem (undefined :: a)

253 return $ D.Yield x (ReadUState contents end p1)

254 return $ D.Yield x (ReadUState contents end p1)

254

255

255-- |

256-- |

@@ -271,7 +272,7 @@ getIndexRev arr i =

271 unsafeInlineIO

272 unsafeInlineIO

272 $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

273 $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

273 $ \ptr -> do

274 $ \ptr -> do

274− let elemSize = sizeOf (undefined :: a)

275+ let elemSize = sizeOfElem (undefined :: a)

275 elemPtr = aEnd arr `plusPtr` negate (elemSize * (i + 1))

276 elemPtr = aEnd arr `plusPtr` negate (elemSize * (i + 1))

276 if i >= 0 && elemPtr >= ptr

277 if i >= 0 && elemPtr >= ptr

277 then Just <$> peek elemPtr

278 then Just <$> peek elemPtr

@@ -382,7 +383,7 @@ getSliceUnsafe ::

382 -> Array a

383 -> Array a

384 -> Array a

384getSliceUnsafe index len (Array contents start e) =

385getSliceUnsafe index len (Array contents start e) =

385− let size = sizeOf (undefined :: a)

386+ let size = sizeOfElem (undefined :: a)

386 fp1 = start `plusPtr` (index * size)

387 fp1 = start `plusPtr` (index * size)

387 end = fp1 `plusPtr` (len * size)

388 end = fp1 `plusPtr` (len * size)

388 in assert (end <= e) (Array contents fp1 end)

389 in assert (end <= e) (Array contents fp1 end)

@@ -437,7 +438,7 @@ getIndex arr i =

437 unsafeInlineIO

438 unsafeInlineIO

438 $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

439 $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

439 $ \ptr -> do

440 $ \ptr -> do

440− let elemSize = sizeOf (undefined :: a)

441+ let elemSize = sizeOfElem (undefined :: a)

441 elemPtr = ptr `plusPtr` (elemSize * i)

442 elemPtr = ptr `plusPtr` (elemSize * i)

442 if i >= 0 && elemPtr `plusPtr` elemSize <= aEnd arr

443 if i >= 0 && elemPtr `plusPtr` elemSize <= aEnd arr

443 then Just <$> peek elemPtr

444 then Just <$> peek elemPtr

@@ -549,7 +550,7 @@ asBytes = unsafeCast

549cast :: forall a b. (Storable b) => Array a -> Maybe (Array b)

550cast :: forall a b. (Storable b) => Array a -> Maybe (Array b)

550cast arr =

551cast arr =

551 let len = A.byteLength arr

552 let len = A.byteLength arr

552− r = len `mod` sizeOf (undefined :: b)

553+ r = len `mod` sizeOfElem (undefined :: b)

553 in if r /= 0

554 in if r /= 0

554 then Nothing

555 then Nothing

555 else Just $ unsafeCast arr

556 else Just $ unsafeCast arr

src/Streamly/Internal/Data/Array/Foreign/Mut/Type.hs+52−43

@@ -200,6 +200,7 @@ module Streamly.Internal.Data.Array.Foreign.Mut.Type

200 , memcpy

201 , memcmp

202 , c_memchr

203+ , sizeOfElem

203 )

204 )

204where

205where

205

206

@@ -275,6 +276,14 @@ import Prelude hiding

275-- >>> import qualified Streamly.Internal.Data.Fold as Fold

276-- >>> import qualified Streamly.Internal.Data.Fold as Fold

276-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold

277-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold

277

278

279+-------------------------------------------------------------------------------

280+-- Utilities

281+-------------------------------------------------------------------------------

282+

283+{-# INLINE sizeOfElem #-}

284+sizeOfElem :: forall a . (Storable a) => a -> Int

285+sizeOfElem _ = max 1 $ sizeOf (undefined :: a)

286+

278-------------------------------------------------------------------------------

287-------------------------------------------------------------------------------

279-- Foreign helpers

288-- Foreign helpers

280-------------------------------------------------------------------------------

289-------------------------------------------------------------------------------

@@ -294,7 +303,7 @@ foreign import ccall unsafe "string.h memcmp" c_memcmp

294{-# INLINE bytesToElemCount #-}

303{-# INLINE bytesToElemCount #-}

295bytesToElemCount :: Storable a => a -> Int -> Int

304bytesToElemCount :: Storable a => a -> Int -> Int

296bytesToElemCount x n =

305bytesToElemCount x n =

297− let elemSize = sizeOf x

306+ let elemSize = sizeOfElem x

298 in n `div` elemSize

307 in n `div` elemSize

299

308

300-- XXX we are converting Int to CSize

309-- XXX we are converting Int to CSize

@@ -447,7 +456,7 @@ fromForeignPtrUnsafe fp@(ForeignPtr start contents) end bound =

447newArrayWith :: forall m a. (MonadIO m, Storable a)

456newArrayWith :: forall m a. (MonadIO m, Storable a)

448 => (Int -> Int -> m (ArrayContents, Ptr a)) -> Int -> Int -> m (Array a)

457 => (Int -> Int -> m (ArrayContents, Ptr a)) -> Int -> Int -> m (Array a)

449newArrayWith alloc alignSize count = do

458newArrayWith alloc alignSize count = do

450− let size = max (count * sizeOf (undefined :: a)) 0

459+ let size = max (count * sizeOfElem (undefined :: a)) 0

451 (contents, p) <- alloc size alignSize

460 (contents, p) <- alloc size alignSize

452 return $ Array

461 return $ Array

453 { arrContents = contents

462 { arrContents = contents

@@ -502,7 +511,7 @@ newArrayAlignedUnmanaged = do

502 return (ArrayContents contents, Ptr addr)

511 return (ArrayContents contents, Ptr addr)

503#else

512#else

504newArrayAlignedUnmanaged _align count = do

513newArrayAlignedUnmanaged _align count = do

505− let size = max (count * sizeOf (undefined :: a)) 0

514+ let size = max (count * sizeOfElem (undefined :: a)) 0

506 p <- liftIO $ mallocBytes size

515 p <- liftIO $ mallocBytes size

507 return $ Array

516 return $ Array

508 { arrContents = nilArrayContents

517 { arrContents = nilArrayContents

@@ -556,7 +565,7 @@ putIndexUnsafe :: forall m a. (MonadIO m, Storable a)

556 => Array a -> Int -> a -> m ()

565 => Array a -> Int -> a -> m ()

557putIndexUnsafe Array{..} i x =

566putIndexUnsafe Array{..} i x =

558 unsafeWithArrayContents arrContents arrStart $ \ptr -> do

567 unsafeWithArrayContents arrContents arrStart $ \ptr -> do

559− let elemSize = sizeOf (undefined :: a)

568+ let elemSize = sizeOfElem (undefined :: a)

560 elemPtr = ptr `plusPtr` (elemSize * i)

569 elemPtr = ptr `plusPtr` (elemSize * i)

561 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

570 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

562 liftIO $ poke elemPtr x

571 liftIO $ poke elemPtr x

@@ -569,7 +578,7 @@ invalidIndex label i =

569putIndexPtr :: forall m a. (MonadIO m, Storable a) =>

578putIndexPtr :: forall m a. (MonadIO m, Storable a) =>

570 Ptr a -> Ptr a -> Int -> a -> m ()

579 Ptr a -> Ptr a -> Int -> a -> m ()

571putIndexPtr start end i x = do

580putIndexPtr start end i x = do

572− let elemSize = sizeOf (undefined :: a)

581+ let elemSize = sizeOfElem (undefined :: a)

573 elemPtr = start `plusPtr` (elemSize * i)

582 elemPtr = start `plusPtr` (elemSize * i)

574 if i >= 0 && elemPtr `plusPtr` elemSize <= end

583 if i >= 0 && elemPtr `plusPtr` elemSize <= end

575 then liftIO $ poke elemPtr x

584 then liftIO $ poke elemPtr x

@@ -613,7 +622,7 @@ modifyIndexUnsafe :: forall m a b. (MonadIO m, Storable a) =>

613 Array a -> Int -> (a -> (a, b)) -> m b

622 Array a -> Int -> (a -> (a, b)) -> m b

614modifyIndexUnsafe Array{..} i f = do

623modifyIndexUnsafe Array{..} i f = do

615 liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do

624 liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do

616− let elemSize = sizeOf (undefined :: a)

625+ let elemSize = sizeOfElem (undefined :: a)

617 elemPtr = ptr `plusPtr` (elemSize * i)

626 elemPtr = ptr `plusPtr` (elemSize * i)

618 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

627 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

619 r <- peek elemPtr

628 r <- peek elemPtr

@@ -769,7 +778,7 @@ roundUpToPower2 x =

769{-# INLINE allocBytesToBytes #-}

778{-# INLINE allocBytesToBytes #-}

770allocBytesToBytes :: forall a. Storable a => a -> Int -> Int

779allocBytesToBytes :: forall a. Storable a => a -> Int -> Int

771allocBytesToBytes _ n =

780allocBytesToBytes _ n =

772− max (arrayPayloadSize n) (sizeOf (undefined :: a))

781+ max (arrayPayloadSize n) (sizeOfElem (undefined :: a))

773

782

774-- | Given a 'Storable' type (unused first arg) and real allocation size

783-- | Given a 'Storable' type (unused first arg) and real allocation size

775-- (including overhead), return how many elements of that type will completely

784-- (including overhead), return how many elements of that type will completely

@@ -819,7 +828,7 @@ snocNewEnd newEnd arr@Array{..} x = liftIO $ do

819snocUnsafe :: forall m a. (MonadIO m, Storable a) =>

828snocUnsafe :: forall m a. (MonadIO m, Storable a) =>

820 Array a -> a -> m (Array a)

829 Array a -> a -> m (Array a)

821snocUnsafe arr@Array{..} =

830snocUnsafe arr@Array{..} =

822− snocNewEnd (aEnd `plusPtr` sizeOf (undefined :: a)) arr

831+ snocNewEnd (aEnd `plusPtr` sizeOfElem (undefined :: a)) arr

823

832

824-- | Like 'snoc' but does not reallocate when pre-allocated array capacity

833-- | Like 'snoc' but does not reallocate when pre-allocated array capacity

825-- becomes full.

834-- becomes full.

@@ -829,7 +838,7 @@ snocUnsafe arr@Array{..} =

829snocMay :: forall m a. (MonadIO m, Storable a) =>

838snocMay :: forall m a. (MonadIO m, Storable a) =>

830 Array a -> a -> m (Maybe (Array a))

839 Array a -> a -> m (Maybe (Array a))

831snocMay arr@Array{..} x = liftIO $ do

840snocMay arr@Array{..} x = liftIO $ do

832− let newEnd = aEnd `plusPtr` sizeOf (undefined :: a)

841+ let newEnd = aEnd `plusPtr` sizeOfElem (undefined :: a)

833 if newEnd <= aBound

842 if newEnd <= aBound

834 then Just <$> snocNewEnd newEnd arr x

843 then Just <$> snocNewEnd newEnd arr x

835 else return Nothing

844 else return Nothing

@@ -866,7 +875,7 @@ snocWithRealloc :: forall m a. (MonadIO m, Storable a) =>

866 -> a

875 -> a

867 -> m (Array a)

876 -> m (Array a)

868snocWithRealloc sizer arr x = do

877snocWithRealloc sizer arr x = do

869− let elemSize = sizeOf (undefined :: a)

878+ let elemSize = sizeOfElem (undefined :: a)

870 arr1 <- liftIO $ reallocWith "snocWith" sizer elemSize arr

879 arr1 <- liftIO $ reallocWith "snocWith" sizer elemSize arr

871 snocUnsafe arr1 x

880 snocUnsafe arr1 x

872

881

@@ -890,7 +899,7 @@ snocWith :: forall m a. (MonadIO m, Storable a) =>

890 -> a

899 -> a

891 -> m (Array a)

900 -> m (Array a)

892snocWith allocSize arr x = liftIO $ do

901snocWith allocSize arr x = liftIO $ do

893− let newEnd = aEnd arr `plusPtr` sizeOf (undefined :: a)

902+ let newEnd = aEnd arr `plusPtr` sizeOfElem (undefined :: a)

894 if newEnd <= aBound arr

903 if newEnd <= aBound arr

895 then snocNewEnd newEnd arr x

904 then snocNewEnd newEnd arr x

896 else snocWithRealloc allocSize arr x

905 else snocWithRealloc allocSize arr x

@@ -963,7 +972,7 @@ realloc :: forall m a. (MonadIO m, Storable a) => Int -> Array a -> m (Array a)

963realloc i arr =

972realloc i arr =

964 liftIO

973 liftIO

965 $ reallocAligned

974 $ reallocAligned

966− (sizeOf (undefined :: a)) (alignment (undefined :: a)) i arr

975+ (sizeOfElem (undefined :: a)) (alignment (undefined :: a)) i arr

967

976

968-- | Change the reserved memory of the array so that it is enough to hold the

977-- | Change the reserved memory of the array so that it is enough to hold the

969-- specified number of elements. Nothing is done if the specified capacity is

978-- specified number of elements. Nothing is done if the specified capacity is

@@ -1005,7 +1014,7 @@ rightSize arr@Array{..} = do

1005 target = roundUpLargeArray len

1014 target = roundUpLargeArray len

1006 waste = aBound `minusPtr` aEnd

1015 waste = aBound `minusPtr` aEnd

1007 assert (target >= len) (return ())

1016 assert (target >= len) (return ())

1008− assert (len `mod` sizeOf (undefined :: a) == 0) (return ())

1017+ assert (len `mod` sizeOfElem (undefined :: a) == 0) (return ())

1009 -- We trade off some wastage (25%) to avoid reallocations and copying.

1018 -- We trade off some wastage (25%) to avoid reallocations and copying.

1010 if target < capacity && len < 3 * waste

1019 if target < capacity && len < 3 * waste

1011 then realloc target arr

1020 then realloc target arr

@@ -1056,7 +1065,7 @@ truncateExp = undefined

1056getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Array a -> Int -> m a

1065getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Array a -> Int -> m a

1057getIndexUnsafe Array {..} i =

1066getIndexUnsafe Array {..} i =

1058 unsafeWithArrayContents arrContents arrStart $ \ptr -> do

1067 unsafeWithArrayContents arrContents arrStart $ \ptr -> do

1059− let elemSize = sizeOf (undefined :: a)

1068+ let elemSize = sizeOfElem (undefined :: a)

1060 elemPtr = ptr `plusPtr` (elemSize * i)

1069 elemPtr = ptr `plusPtr` (elemSize * i)

1061 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

1070 assert (i >= 0 && elemPtr `plusPtr` elemSize <= aEnd) (return ())

1062 liftIO $ peek elemPtr

1071 liftIO $ peek elemPtr

@@ -1065,7 +1074,7 @@ getIndexUnsafe Array {..} i =

1065getIndexPtr :: forall m a. (MonadIO m, Storable a) =>

1074getIndexPtr :: forall m a. (MonadIO m, Storable a) =>

1066 Ptr a -> Ptr a -> Int -> m a

1075 Ptr a -> Ptr a -> Int -> m a

1067getIndexPtr ptr end i = do

1076getIndexPtr ptr end i = do

1068− let elemSize = sizeOf (undefined :: a)

1077+ let elemSize = sizeOfElem (undefined :: a)

1069 elemPtr = ptr `plusPtr` (elemSize * i)

1078 elemPtr = ptr `plusPtr` (elemSize * i)

1070 if i >= 0 && elemPtr `plusPtr` elemSize <= end

1079 if i >= 0 && elemPtr `plusPtr` elemSize <= end

1071 then liftIO $ peek elemPtr

1080 then liftIO $ peek elemPtr

@@ -1083,7 +1092,7 @@ getIndex arr i =

1083getIndexPtrRev :: forall m a. (MonadIO m, Storable a) =>

1092getIndexPtrRev :: forall m a. (MonadIO m, Storable a) =>

1084 Ptr a -> Ptr a -> Int -> m a

1093 Ptr a -> Ptr a -> Int -> m a

1085getIndexPtrRev ptr end i = do

1094getIndexPtrRev ptr end i = do

1086− let elemSize = sizeOf (undefined :: a)

1095+ let elemSize = sizeOfElem (undefined :: a)

1087 elemPtr = end `plusPtr` negate (elemSize * (i + 1))

1096 elemPtr = end `plusPtr` negate (elemSize * (i + 1))

1088 if i >= 0 && elemPtr >= ptr

1097 if i >= 0 && elemPtr >= ptr

1089 then liftIO $ peek elemPtr

1098 then liftIO $ peek elemPtr

@@ -1151,7 +1160,7 @@ getSliceUnsafe :: forall a. Storable a

1151 -> Array a

1160 -> Array a

1152 -> Array a

1161 -> Array a

1153getSliceUnsafe index len (Array contents start e _) =

1162getSliceUnsafe index len (Array contents start e _) =

1154− let size = sizeOf (undefined :: a)

1163+ let size = sizeOfElem (undefined :: a)

1155 fp1 = start `plusPtr` (index * size)

1164 fp1 = start `plusPtr` (index * size)

1156 end = fp1 `plusPtr` (len * size)

1165 end = fp1 `plusPtr` (len * size)

1157 in assert

1166 in assert

@@ -1169,7 +1178,7 @@ getSlice :: forall a. Storable a =>

1169 -> Array a

1178 -> Array a

1170 -> Array a

1179 -> Array a

1171getSlice index len (Array contents start e _) =

1180getSlice index len (Array contents start e _) =

1172− let size = sizeOf (undefined :: a)

1181+ let size = sizeOfElem (undefined :: a)

1173 fp1 = start `plusPtr` (index * size)

1182 fp1 = start `plusPtr` (index * size)

1174 end = fp1 `plusPtr` (len * size)

1183 end = fp1 `plusPtr` (len * size)

1175 in if index >= 0 && len >= 0 && end <= e

1184 in if index >= 0 && len >= 0 && end <= e

@@ -1288,7 +1297,7 @@ byteLength Array{..} =

1288{-# INLINE length #-}

1297{-# INLINE length #-}

1289length :: forall a. Storable a => Array a -> Int

1298length :: forall a. Storable a => Array a -> Int

1290length arr =

1299length arr =

1291− let elemSize = sizeOf (undefined :: a)

1300+ let elemSize = sizeOfElem (undefined :: a)

1292 blen = byteLength arr

1301 blen = byteLength arr

1293 in assert (blen `mod` elemSize == 0) (blen `div` elemSize)

1302 in assert (blen `mod` elemSize == 0) (blen `div` elemSize)

1294

1303

@@ -1356,7 +1365,7 @@ arraysOf n (D.Stream step state) =

1356 case r of

1365 case r of

1357 D.Yield x s -> do

1366 D.Yield x s -> do

1358 liftIO $ poke end x >> touch contents

1367 liftIO $ poke end x >> touch contents

1359− let end' = end `plusPtr` sizeOf (undefined :: a)

1368+ let end' = end `plusPtr` sizeOfElem (undefined :: a)

1360 return $

1369 return $

1361 if end' >= bound

1370 if end' >= bound

1362 then D.Skip

1371 then D.Skip

@@ -1422,7 +1431,7 @@ flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)

1422 touch contents

1431 touch contents

1423 return r

1432 return r

1424 return $ D.Yield x (InnerLoop st contents

1433 return $ D.Yield x (InnerLoop st contents

1425− (p `plusPtr` sizeOf (undefined :: a)) end)

1434+ (p `plusPtr` sizeOfElem (undefined :: a)) end)

1426

1435

1427-- | Use the "readRev" unfold instead.

1436-- | Use the "readRev" unfold instead.

1428--

1437--

@@ -1442,7 +1451,7 @@ flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)

1442 r <- step (adaptState gst) st

1451 r <- step (adaptState gst) st

1443 return $ case r of

1452 return $ case r of

1444 D.Yield Array{..} s ->

1453 D.Yield Array{..} s ->

1445− let p = aEnd `plusPtr` negate (sizeOf (undefined :: a))

1454+ let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))

1446 in D.Skip (InnerLoop s arrContents p arrStart)

1455 in D.Skip (InnerLoop s arrContents p arrStart)

1447 D.Skip s -> D.Skip (OuterLoop s)

1456 D.Skip s -> D.Skip (OuterLoop s)

1448 D.Stop -> D.Stop

1457 D.Stop -> D.Stop

@@ -1455,7 +1464,7 @@ flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)

1455 r <- peek p

1464 r <- peek p

1456 touch contents

1465 touch contents

1457 return r

1466 return r

1458− let cur = p `plusPtr` negate (sizeOf (undefined :: a))

1467+ let cur = p `plusPtr` negate (sizeOfElem (undefined :: a))

1459 return $ D.Yield x (InnerLoop st contents cur start)

1468 return $ D.Yield x (InnerLoop st contents cur start)

1460

1469

1461-------------------------------------------------------------------------------

1470-------------------------------------------------------------------------------

@@ -1484,7 +1493,7 @@ producer = Producer step (return . toReadUState) extract

1484 return D.Stop

1493 return D.Stop

1485 step (ReadUState contents end cur) = do

1494 step (ReadUState contents end cur) = do

1486 !x <- liftIO $ peek cur

1495 !x <- liftIO $ peek cur

1487− let cur1 = cur `plusPtr` sizeOf (undefined :: a)

1496+ let cur1 = cur `plusPtr` sizeOfElem (undefined :: a)

1488 return $ D.Yield x (ReadUState contents end cur1)

1497 return $ D.Yield x (ReadUState contents end cur1)

1489

1498

1490 extract (ReadUState contents end cur) = return $ Array contents cur end end

1499 extract (ReadUState contents end cur) = return $ Array contents cur end end

@@ -1505,7 +1514,7 @@ readRev = Unfold step inject

1505 where

1514 where

1506

1515

1507 inject (Array contents start end _) =

1516 inject (Array contents start end _) =

1508− let p = end `plusPtr` negate (sizeOf (undefined :: a))

1517+ let p = end `plusPtr` negate (sizeOfElem (undefined :: a))

1509 in return $ ReadUState contents start p

1518 in return $ ReadUState contents start p

1510

1519

1511 {-# INLINE_LATE step #-}

1520 {-# INLINE_LATE step #-}

@@ -1514,7 +1523,7 @@ readRev = Unfold step inject

1514 return D.Stop

1523 return D.Stop

1515 step (ReadUState contents start p) = do

1524 step (ReadUState contents start p) = do

1516 x <- liftIO $ peek p

1525 x <- liftIO $ peek p

1517− let cur = p `plusPtr` negate (sizeOf (undefined :: a))

1526+ let cur = p `plusPtr` negate (sizeOfElem (undefined :: a))

1518 return $ D.Yield x (ReadUState contents start cur)

1527 return $ D.Yield x (ReadUState contents start cur)

1519

1528

1520-------------------------------------------------------------------------------

1529-------------------------------------------------------------------------------

@@ -1542,7 +1551,7 @@ toListFB c n Array{..} = go arrStart

1542 r <- peek p

1551 r <- peek p

1543 touch arrContents

1552 touch arrContents

1544 return r

1553 return r

1545− in c x (go (p `plusPtr` sizeOf (undefined :: a)))

1554+ in c x (go (p `plusPtr` sizeOfElem (undefined :: a)))

1546-}

1555-}

1547

1556

1548-- XXX Monadic foldr/build fusion?

1557-- XXX Monadic foldr/build fusion?

@@ -1559,7 +1568,7 @@ toList Array{..} = liftIO $ go arrStart

1559 go p = do

1568 go p = do

1560 x <- peek p

1569 x <- peek p

1561 touch arrContents

1570 touch arrContents

1562− (:) x <$> go (p `plusPtr` sizeOf (undefined :: a))

1571+ (:) x <$> go (p `plusPtr` sizeOfElem (undefined :: a))

1563

1572

1564-- | Use the 'read' unfold instead.

1573-- | Use the 'read' unfold instead.

1565--

1574--

@@ -1577,7 +1586,7 @@ toStreamD Array{..} = D.Stream step arrStart

1577 step _ p = liftIO $ do

1586 step _ p = liftIO $ do

1578 r <- peek p

1587 r <- peek p

1579 touch arrContents

1588 touch arrContents

1580− return $ D.Yield r (p `plusPtr` sizeOf (undefined :: a))

1589+ return $ D.Yield r (p `plusPtr` sizeOfElem (undefined :: a))

1581

1590

1582{-# INLINE toStreamK #-}

1591{-# INLINE toStreamK #-}

1583toStreamK :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a

1592toStreamK :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a

@@ -1591,7 +1600,7 @@ toStreamK Array{..} = go arrStart

1591 r <- peek p

1600 r <- peek p

1592 touch arrContents

1601 touch arrContents

1593 return r

1602 return r

1594− in liftIO elemM `K.consM` go (p `plusPtr` sizeOf (undefined :: a))

1603+ in liftIO elemM `K.consM` go (p `plusPtr` sizeOfElem (undefined :: a))

1595

1604

1596-- | Use the 'readRev' unfold instead.

1605-- | Use the 'readRev' unfold instead.

1597--

1606--

@@ -1601,7 +1610,7 @@ toStreamK Array{..} = go arrStart

1601{-# INLINE_NORMAL toStreamDRev #-}

1610{-# INLINE_NORMAL toStreamDRev #-}

1602toStreamDRev :: forall m a. (MonadIO m, Storable a) => Array a -> D.Stream m a

1611toStreamDRev :: forall m a. (MonadIO m, Storable a) => Array a -> D.Stream m a

1603toStreamDRev Array{..} =

1612toStreamDRev Array{..} =

1604− let p = aEnd `plusPtr` negate (sizeOf (undefined :: a))

1613+ let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))

1605 in D.Stream step p

1614 in D.Stream step p

1606

1615

1607 where

1616 where

@@ -1611,12 +1620,12 @@ toStreamDRev Array{..} =

1611 step _ p = liftIO $ do

1620 step _ p = liftIO $ do

1612 r <- peek p

1621 r <- peek p

1613 touch arrContents

1622 touch arrContents

1614− return $ D.Yield r (p `plusPtr` negate (sizeOf (undefined :: a)))

1623+ return $ D.Yield r (p `plusPtr` negate (sizeOfElem (undefined :: a)))

1615

1624

1616{-# INLINE toStreamKRev #-}

1625{-# INLINE toStreamKRev #-}

1617toStreamKRev :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a

1626toStreamKRev :: forall m a. (MonadIO m, Storable a) => Array a -> K.Stream m a

1618toStreamKRev Array {..} =

1627toStreamKRev Array {..} =

1619− let p = aEnd `plusPtr` negate (sizeOf (undefined :: a))

1628+ let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))

1620 in go p

1629 in go p

1621

1630

1622 where

1631 where

@@ -1627,7 +1636,7 @@ toStreamKRev Array {..} =

1627 r <- peek p

1636 r <- peek p

1628 touch arrContents

1637 touch arrContents

1629 return r

1638 return r

1630− in liftIO elemM `K.consM` go (p `plusPtr` negate (sizeOf (undefined :: a)))

1639+ in liftIO elemM `K.consM` go (p `plusPtr` negate (sizeOfElem (undefined :: a)))

1631

1640

1632-------------------------------------------------------------------------------

1641-------------------------------------------------------------------------------

1633-- Folding

1642-- Folding

@@ -1696,7 +1705,7 @@ appendNUnsafe action n =

1696 assert (n >= 0) (return ())

1705 assert (n >= 0) (return ())

1697 arr@(Array _ _ end bound) <- action

1706 arr@(Array _ _ end bound) <- action

1698 let free = bound `minusPtr` end

1707 let free = bound `minusPtr` end

1699− elemSize = sizeOf (undefined :: a)

1708+ elemSize = sizeOfElem (undefined :: a)

1700 needed = n * elemSize

1709 needed = n * elemSize

1701 -- XXX We can also reallocate if the array has too much free space,

1710 -- XXX We can also reallocate if the array has too much free space,

1702 -- otherwise we lose that space.

1711 -- otherwise we lose that space.

@@ -1708,7 +1717,7 @@ appendNUnsafe action n =

1708

1717

1709 step (ArrayUnsafe contents start end) x = do

1718 step (ArrayUnsafe contents start end) x = do

1710 liftIO $ poke end x >> touch contents

1719 liftIO $ poke end x >> touch contents

1711− let end1 = end `plusPtr` sizeOf (undefined :: a)

1720+ let end1 = end `plusPtr` sizeOfElem (undefined :: a)

1712 return $ ArrayUnsafe contents start end1

1721 return $ ArrayUnsafe contents start end1

1713

1722

1714-- | Append @n@ elements to an existing array. Any free space left in the array

1723-- | Append @n@ elements to an existing array. Any free space left in the array

@@ -1826,7 +1835,7 @@ writeNWithUnsafe alloc n = Fold step initial (return . fromArrayUnsafe)

1826 liftIO $ poke end x >> touch contents

1835 liftIO $ poke end x >> touch contents

1827 return

1836 return

1828 $ FL.Partial

1837 $ FL.Partial

1829− $ ArrayUnsafe contents start (end `plusPtr` sizeOf (undefined :: a))

1838+ $ ArrayUnsafe contents start (end `plusPtr` sizeOfElem (undefined :: a))

1830

1839

1831-- | Like 'writeN' but does not check the array bounds when writing. The fold

1840-- | Like 'writeN' but does not check the array bounds when writing. The fold

1832-- driver must not call the step function more than 'n' times otherwise it will

1841-- driver must not call the step function more than 'n' times otherwise it will

@@ -1899,20 +1908,20 @@ writeWith elemCount =

1899

1908

1900 insertElem (Array contents start end bound) x = do

1909 insertElem (Array contents start end bound) x = do

1901 liftIO $ poke end x

1910 liftIO $ poke end x

1902− let end1 = end `plusPtr` sizeOf (undefined :: a)

1911+ let end1 = end `plusPtr` sizeOfElem (undefined :: a)

1903 return $ Array contents start end1 bound

1912 return $ Array contents start end1 bound

1904

1913

1905 initial = do

1914 initial = do

1906 when (elemCount < 0) $ error "writeWith: elemCount is negative"

1915 when (elemCount < 0) $ error "writeWith: elemCount is negative"

1907 liftIO $ newArrayAligned (alignment (undefined :: a)) elemCount

1916 liftIO $ newArrayAligned (alignment (undefined :: a)) elemCount

1908 step arr@(Array _ start end bound) x

1917 step arr@(Array _ start end bound) x

1909− | end `plusPtr` sizeOf (undefined :: a) > bound = do

1918+ | end `plusPtr` sizeOfElem (undefined :: a) > bound = do

1910 let oldSize = end `minusPtr` start

1919 let oldSize = end `minusPtr` start

1911 newSize = max (oldSize * 2) 1

1920 newSize = max (oldSize * 2) 1

1912 arr1 <-

1921 arr1 <-

1913 liftIO

1922 liftIO

1914 $ reallocAligned

1923 $ reallocAligned

1915− (sizeOf (undefined :: a))

1924+ (sizeOfElem (undefined :: a))

1916 (alignment (undefined :: a))

1925 (alignment (undefined :: a))

1917 newSize

1926 newSize

1918 arr

1927 arr

@@ -1953,7 +1962,7 @@ fromStreamDN limit str = do

1953

1962

1954 fwrite ptr x = do

1963 fwrite ptr x = do

1955 liftIO $ poke ptr x

1964 liftIO $ poke ptr x

1956− return $ ptr `plusPtr` sizeOf (undefined :: a)

1965+ return $ ptr `plusPtr` sizeOfElem (undefined :: a)

1957

1966

1958-- | Create an 'Array' from the first N elements of a list. The array is

1967-- | Create an 'Array' from the first N elements of a list. The array is

1959-- allocated to size N, if the list terminates before N elements then the

1968-- allocated to size N, if the list terminates before N elements then the

@@ -2147,7 +2156,7 @@ splitAt i arr@Array{..} =

2147 else if i > maxIndex

2156 else if i > maxIndex

2148 then error $ "sliceAt: specified array index " ++ show i

2157 then error $ "sliceAt: specified array index " ++ show i

2149 ++ " is beyond the maximum index " ++ show maxIndex

2158 ++ " is beyond the maximum index " ++ show maxIndex

2150− else let off = i * sizeOf (undefined :: a)

2159+ else let off = i * sizeOfElem (undefined :: a)

2151 p = arrStart `plusPtr` off

2160 p = arrStart `plusPtr` off

2152 in ( Array

2161 in ( Array

2153 { arrContents = arrContents

2162 { arrContents = arrContents

@@ -2198,7 +2207,7 @@ asBytes = castUnsafe

2198cast :: forall a b. Storable b => Array a -> Maybe (Array b)

2207cast :: forall a b. Storable b => Array a -> Maybe (Array b)

2199cast arr =

2208cast arr =

2200 let len = byteLength arr

2209 let len = byteLength arr

2201− r = len `mod` sizeOf (undefined :: b)

2210+ r = len `mod` sizeOfElem (undefined :: b)

2202 in if r /= 0

2211 in if r /= 0

2203 then Nothing

2212 then Nothing

2204 else Just $ castUnsafe arr

2213 else Just $ castUnsafe arr

src/Streamly/Internal/Data/Array/Foreign/Type.hs+11−11

@@ -90,7 +90,7 @@ import GHC.ForeignPtr (ForeignPtr)

90import GHC.IO (unsafePerformIO)

91import GHC.Ptr (Ptr(..))

92import Streamly.Internal.Data.Array.Foreign.Mut.Type

93− (ArrayContents, ReadUState(..), touch)

93+ (ArrayContents, ReadUState(..), sizeOfElem, touch)

94import Streamly.Internal.Data.Fold.Type (Fold(..))

95import Streamly.Internal.Data.Stream.Serial (SerialT(..))

96import Streamly.Internal.Data.Unfold.Type (Unfold(..))

@@ -466,7 +466,7 @@ readRev = Unfold step inject

466 where

467

468 inject (Array contents start end) =

469− let p = end `plusPtr` negate (sizeOf (undefined :: a))

469+ let p = end `plusPtr` negate (sizeOfElem (undefined :: a))

470 in return $ ReadUState contents start p

471

472 {-# INLINE_LATE step #-}

@@ -481,7 +481,7 @@ readRev = Unfold step inject

481 -- This should be safe as the array contents are guaranteed to be

482 -- evaluated/written to before we peek at them.

483 let !x = unsafeInlineIO $ peek p

484− let cur = p `plusPtr` negate (sizeOf (undefined :: a))

484+ let cur = p `plusPtr` negate (sizeOfElem (undefined :: a))

485 return $ D.Yield x (ReadUState contents start cur)

486

487

@@ -505,7 +505,7 @@ toStreamD Array{..} = D.Stream step arrStart

505 r <- peek p

506 touch arrContents

507 return r

508− return $ D.Yield x (p `plusPtr` sizeOf (undefined :: a))

508+ return $ D.Yield x (p `plusPtr` sizeOfElem (undefined :: a))

509

510{-# INLINE toStreamK #-}

511toStreamK :: forall m a. Storable a => Array a -> K.Stream m a

@@ -520,12 +520,12 @@ toStreamK Array{..} = go arrStart

520 r <- peek p

521 touch arrContents

522 return r

523− in x `K.cons` go (p `plusPtr` sizeOf (undefined :: a))

523+ in x `K.cons` go (p `plusPtr` sizeOfElem (undefined :: a))

524

525{-# INLINE_NORMAL toStreamDRev #-}

526toStreamDRev :: forall m a. (Monad m, Storable a) => Array a -> D.Stream m a

527toStreamDRev Array{..} =

528− let p = aEnd `plusPtr` negate (sizeOf (undefined :: a))

528+ let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))

529 in D.Stream step p

530

531 where

@@ -538,12 +538,12 @@ toStreamDRev Array{..} =

538 r <- peek p

539 touch arrContents

540 return r

541− return $ D.Yield x (p `plusPtr` negate (sizeOf (undefined :: a)))

541+ return $ D.Yield x (p `plusPtr` negate (sizeOfElem (undefined :: a)))

542

543{-# INLINE toStreamKRev #-}

544toStreamKRev :: forall m a. Storable a => Array a -> K.Stream m a

545toStreamKRev Array {..} =

546− let p = aEnd `plusPtr` negate (sizeOf (undefined :: a))

546+ let p = aEnd `plusPtr` negate (sizeOfElem (undefined :: a))

547 in go p

548

549 where

@@ -554,7 +554,7 @@ toStreamKRev Array {..} =

554 r <- peek p

555 touch arrContents

556 return r

557− in x `K.cons` go (p `plusPtr` negate (sizeOf (undefined :: a)))

557+ in x `K.cons` go (p `plusPtr` negate (sizeOfElem (undefined :: a)))

558

559-- | Convert an 'Array' into a stream.

560--

@@ -613,7 +613,7 @@ toListFB c n Array{..} = go arrStart

613 r <- peek p

614 touch arrContents

615 return r

616− in c x (go (p `plusPtr` sizeOf (undefined :: a)))

616+ in c x (go (p `plusPtr` sizeOfElem (undefined :: a)))

617

618-- | Convert an 'Array' into a list.

619--

@@ -781,7 +781,7 @@ contraint.

781{-# INLINE_NORMAL _foldr #-}

782_foldr :: forall a b. (a -> b -> b) -> b -> Array a -> b

783_foldr f z arr =

784− let !n = sizeOf (undefined :: a)

784+ let !n = sizeOfElem (undefined :: a)

785 in unsafePerformIO $ D.foldr f z $ toStreamD_ n arr

786

787-- | Note that the 'Foldable' instance is 7x slower than the direct

src/Streamly/Internal/Data/Array/Prim/MutTypesInclude.hs+1−1

@@ -83,7 +83,7 @@ length ::

83length arr =

84 liftIO $ do

85 blen <- byteLength arr

86− return $ blen `quot` (sizeOf (undefined :: a))

86+ return $ blen `quot` (max 1 $ sizeOf (undefined :: a))

88-------------------------------------------------------------------------------

89-- Random Access

src/Streamly/Internal/Data/Array/Prim/TypesInclude.hs+6−3

@@ -128,10 +128,13 @@ defaultChunkSize = mkChunkSizeKB 32

128-- Length

129-------------------------------------------------------------------------------

130

131+sizeOfPrimElem :: forall a . (Prim a) => a -> Int

132+sizeOfPrimElem _ = max 1 $ sizeOf (undefined :: a)

133+

131-- XXX rename to byteCount?

134-- XXX rename to byteCount?

132{-# INLINE byteLength #-}

135{-# INLINE byteLength #-}

133byteLength :: forall a. Prim a => Array a -> Int

136byteLength :: forall a. Prim a => Array a -> Int

134−byteLength (Array _ _ len) = len * sizeOf (undefined :: a)

137+byteLength (Array _ _ len) = len * sizeOfPrimElem (undefined :: a)

135

138

136-- XXX Also, rename to elemCount

139-- XXX Also, rename to elemCount

137-- XXX I would prefer length to keep the API consistent

140-- XXX I would prefer length to keep the API consistent

@@ -546,7 +549,7 @@ packArraysChunksOf n (D.Stream step state) =

546

549

547 where

550 where

548

551

549− nElem = n `quot` sizeOf (undefined :: a)

552+ nElem = n `quot` sizeOfPrimElem (undefined :: a)

550

553

551 {-# INLINE_LATE step' #-}

554 {-# INLINE_LATE step' #-}

552 step' gst (SpliceInitial st) = do

555 step' gst (SpliceInitial st) = do

@@ -597,7 +600,7 @@ lpackArraysChunksOf n (Fold step1 initial1 extract1) =

597

600

598 where

601 where

599

602

600− nElem = n `quot` sizeOf (undefined :: a)

603+ nElem = n `quot` sizeOfPrimElem (undefined :: a)

601

604

602 initial = do

605 initial = do

603 when (n <= 0) $

606 when (n <= 0) $

src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hs+4−4

@@ -58,7 +58,7 @@ import Control.Monad.IO.Class (MonadIO(..))

58import Foreign.Ptr (minusPtr, plusPtr)

59import Foreign.Storable (Storable(..))

60import GHC.Types (SPEC(..))

61−import Streamly.Internal.Data.Array.Foreign.Mut.Type (touch)

61+import Streamly.Internal.Data.Array.Foreign.Mut.Type (sizeOfElem, touch)

62import Streamly.Internal.Data.Array.Foreign.Type (Array(..))

63import Streamly.Internal.Data.Parser.ParserD (Initial(..), Step(..))

64import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

@@ -118,7 +118,7 @@ fromFold (Fold.Fold fstep finitial fextract) =

118 goArray !_ !cur !fs = do

119 x <- liftIO $ peek cur

120 res <- fstep fs x

121− let elemSize = sizeOf (undefined :: a)

121+ let elemSize = sizeOfElem (undefined :: a)

122 next = cur `plusPtr` elemSize

123 case res of

124 Fold.Done b ->

@@ -156,7 +156,7 @@ fromParser (ParserD.Parser step1 initial1 extract1) =

156 x <- liftIO $ peek cur

157 liftIO $ touch contents

158 res <- step1 fs x

159− let elemSize = sizeOf (undefined :: a)

159+ let elemSize = sizeOfElem (undefined :: a)

160 next = cur `plusPtr` elemSize

161 arrRem = (end `minusPtr` next) `div` elemSize

162 case res of

@@ -320,7 +320,7 @@ take n (Fold (ParserD.Parser step1 initial1 extract1)) =

320 Error err -> return $ Error err

321 else do

322 let !(Array contents start _) = arr

323− sz = sizeOf (undefined :: a)

323+ sz = sizeOfElem (undefined :: a)

324 end = start `plusPtr` (i * sz)

325 arr1 = Array contents start end

326 remaining = negate i1

src/Streamly/Internal/Data/Array/Stream/Foreign.hs+6−6

@@ -76,7 +76,7 @@ import Streamly.Internal.Data.Stream.IsStream.Type

76 (IsStream, fromStreamD, toStreamD)

77import Streamly.Internal.Data.SVar (adaptState, defState)

78import Streamly.Internal.Data.Array.Foreign.Mut.Type

79− (memcpy, allocBytesToElemCount)

79+ (memcpy, allocBytesToElemCount, sizeOfElem)

81import qualified Streamly.Internal.Data.Array.Foreign as A

82import qualified Streamly.Internal.Data.Array.Foreign as Array

@@ -195,7 +195,7 @@ unlines sep (D.Stream step state) = D.Stream step' (OuterLoop state)

195 touch contents

196 return r

197 return $ D.Yield x (InnerLoop st contents

198− (p `plusPtr` sizeOf (undefined :: a)) end)

198+ (p `plusPtr` sizeOfElem (undefined :: a)) end)

199

200-------------------------------------------------------------------------------

201-- Compact

@@ -349,7 +349,7 @@ foldD (Fold fstep initial extract) stream@(D.Stream step state) = do

349 goArray !_ st fp@(ForeignPtr end contents) !cur !fs = do

350 x <- liftIO $ peek cur

351 res <- fstep fs x

352− let elemSize = sizeOf (undefined :: a)

352+ let elemSize = sizeOfElem (undefined :: a)

353 next = cur `plusPtr` elemSize

354 case res of

355 FL.Done b -> do

@@ -390,7 +390,7 @@ takeArrayListRev = go

390 else if n == len

391 then [x]

392 else let !(Array contents _ end) = x

393− sz = sizeOf (undefined :: a)

393+ sz = sizeOfElem (undefined :: a)

394 !start = end `plusPtr` negate (n * sz)

395 in [Array contents start end]

396

@@ -413,7 +413,7 @@ splitAtArrayListRev n ls

413 else if m == len

414 then ([x],xs)

415 else let !(Array contents start end) = x

416− sz = sizeOf (undefined :: a)

416+ sz = sizeOfElem (undefined :: a)

417 end1 = end `plusPtr` negate (m * sz)

418 arr2 = Array contents start end1

419 arr1 = Array contents end1 end

@@ -568,7 +568,7 @@ parseD (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do

568 gobuf !_ s backBuf fp@(ForeignPtr end contents) !cur !pst = do

569 x <- liftIO $ peek cur

570 pRes <- pstep pst x

571− let elemSize = sizeOf (undefined :: a)

571+ let elemSize = sizeOfElem (undefined :: a)

572 next = cur `plusPtr` elemSize

573 case pRes of

574 PR.Partial 0 pst1 ->

src/Streamly/Internal/Data/Ring/Foreign.hs+8−7

@@ -79,7 +79,8 @@ import Foreign.Ptr (plusPtr, minusPtr, castPtr)

79import Foreign.Storable (Storable(..))

80import GHC.ForeignPtr (mallocPlainForeignPtrAlignedBytes)

81import GHC.Ptr (Ptr(..))

82−import Streamly.Internal.Data.Array.Foreign.Mut.Type (Array, memcmp)

82+import Streamly.Internal.Data.Array.Foreign.Mut.Type

83+ (Array, memcmp, sizeOfElem)

83import Streamly.Internal.Data.Fold.Type (Fold(..), Step(..))

84import Streamly.Internal.Data.Fold.Type (Fold(..), Step(..))

84import Streamly.Internal.Data.Stream.Serial (SerialT(..))

85import Streamly.Internal.Data.Stream.Serial (SerialT(..))

85import Streamly.Internal.Data.Unfold.Type (Unfold(..))

86import Streamly.Internal.Data.Unfold.Type (Unfold(..))

@@ -123,7 +124,7 @@ startOf = unsafeForeignPtrToPtr . ringStart

123{-# INLINE new #-}

124{-# INLINE new #-}

124new :: forall a. Storable a => Int -> IO (Ring a, Ptr a)

125new :: forall a. Storable a => Int -> IO (Ring a, Ptr a)

125new count = do

126new count = do

126− let size = count * sizeOf (undefined :: a)

127+ let size = count * sizeOfElem (undefined :: a)

127 fptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: a))

128 fptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: a))

128 let p = unsafeForeignPtrToPtr fptr

129 let p = unsafeForeignPtrToPtr fptr

129 return (Ring

130 return (Ring

@@ -147,7 +148,7 @@ newRing = undefined

147{-# INLINE advance #-}

148{-# INLINE advance #-}

148advance :: forall a. Storable a => Ring a -> Ptr a -> Ptr a

149advance :: forall a. Storable a => Ring a -> Ptr a -> Ptr a

149advance Ring{..} ringHead =

150advance Ring{..} ringHead =

150− let ptr = ringHead `plusPtr` sizeOf (undefined :: a)

151+ let ptr = ringHead `plusPtr` sizeOfElem (undefined :: a)

151 in if ptr < ringBound

152 in if ptr < ringBound

152 then ptr

153 then ptr

153 else unsafeForeignPtrToPtr ringStart

154 else unsafeForeignPtrToPtr ringStart

@@ -161,7 +162,7 @@ moveBy by Ring {..} ringHead = ringStartPtr `plusPtr` advanceFromHead

161

162

162 where

163 where

163

164

164− elemSize = sizeOf (undefined :: a)

165+ elemSize = sizeOfElem (undefined :: a)

165 ringStartPtr = unsafeForeignPtrToPtr ringStart

166 ringStartPtr = unsafeForeignPtrToPtr ringStart

166 lenInBytes = ringBound `minusPtr` ringStartPtr

167 lenInBytes = ringBound `minusPtr` ringStartPtr

167 offInBytes = ringHead `minusPtr` ringStartPtr

168 offInBytes = ringHead `minusPtr` ringStartPtr

@@ -361,7 +362,7 @@ asBytes = castUnsafe

361cast :: forall a b. Storable b => Ring a -> Maybe (Ring b)

362cast :: forall a b. Storable b => Ring a -> Maybe (Ring b)

362cast arr =

363cast arr =

363 let len = byteLength arr

364 let len = byteLength arr

364− r = len `mod` sizeOf (undefined :: b)

365+ r = len `mod` sizeOfElem (undefined :: b)

365 in if r /= 0

366 in if r /= 0

366 then Nothing

367 then Nothing

367 else Just $ castUnsafe arr

368 else Just $ castUnsafe arr

@@ -443,7 +444,7 @@ unsafeFoldRing ptr f z Ring{..} =

443 | p == q = return acc

444 | p == q = return acc

444 | otherwise = do

445 | otherwise = do

445 x <- peek p

446 x <- peek p

446− go (f acc x) (p `plusPtr` sizeOf (undefined :: a)) q

447+ go (f acc x) (p `plusPtr` sizeOfElem (undefined :: a)) q

447

448

448-- XXX Can we remove MonadIO here?

449-- XXX Can we remove MonadIO here?

449withForeignPtrM :: MonadIO m => ForeignPtr a -> (Ptr a -> m b) -> m b

450withForeignPtrM :: MonadIO m => ForeignPtr a -> (Ptr a -> m b) -> m b

@@ -464,7 +465,7 @@ unsafeFoldRingM ptr f z Ring {..} =

464 | otherwise = do

465 | otherwise = do

465 let !x = unsafeInlineIO $ peek start

466 let !x = unsafeInlineIO $ peek start

466 acc' <- f acc x

467 acc' <- f acc x

467− go acc' (start `plusPtr` sizeOf (undefined :: a)) end

468+ go acc' (start `plusPtr` sizeOfElem (undefined :: a)) end

468

469

469-- | Fold the entire length of a ring buffer starting at the supplied ringHead

470-- | Fold the entire length of a ring buffer starting at the supplied ringHead

470-- pointer. Assuming the supplied ringHead pointer points to the oldest item,

471-- pointer. Assuming the supplied ringHead pointer points to the oldest item,

src/Streamly/Internal/Data/Stream/StreamD/Nesting.hs+3−2

@@ -167,6 +167,7 @@ import Streamly.Internal.Data.Refold.Type (Refold(..))

167import Streamly.Internal.Data.SVar.Type (adaptState)

168import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

169import Streamly.Internal.Data.Unfold.Type (Unfold(..))

170+import Streamly.Internal.Data.Array.Foreign.Mut.Type (sizeOfElem)

170

171

171import qualified Streamly.Internal.Data.Array.Foreign.Type as A

172import qualified Streamly.Internal.Data.Array.Foreign.Type as A

172import qualified Streamly.Internal.Data.Fold as FL

173import qualified Streamly.Internal.Data.Fold as FL

@@ -1671,7 +1672,7 @@ splitOnSeq patArr (Fold fstep initial done) (Stream step state) =

1671

1672

1672 patLen = A.length patArr

1673 patLen = A.length patArr

1673 maxIndex = patLen - 1

1674 maxIndex = patLen - 1

1674− elemBits = sizeOf (undefined :: a) * 8

1675+ elemBits = sizeOfElem (undefined :: a) * 8

1675

1676

1676 -- For word pattern case

1677 -- For word pattern case

1677 wordMask :: Word

1678 wordMask :: Word

@@ -1985,7 +1986,7 @@ splitOnSuffixSeq withSep patArr (Fold fstep initial done) (Stream step state) =

1985

1986

1986 patLen = A.length patArr

1987 patLen = A.length patArr

1987 maxIndex = patLen - 1

1988 maxIndex = patLen - 1

1988− elemBits = sizeOf (undefined :: a) * 8

1989+ elemBits = sizeOfElem (undefined :: a) * 8

1989

1990

1990 -- For word pattern case

1991 -- For word pattern case

1991 wordMask :: Word

1992 wordMask :: Word

src/Streamly/Internal/Data/Stream/StreamD/Transform.hs+3−2

@@ -1109,12 +1109,13 @@ reverse' :: forall m a. (MonadIO m, Storable a) => Stream m a -> Stream m a

1109import Foreign.ForeignPtr (touchForeignPtr)

1110import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)

1111import Foreign.Ptr (Ptr, plusPtr)

1112+import Streamly.Internal.Data.Array.Foreign.Mut.Type (sizeOfElem)

1112reverse' m = Stream step Nothing

1113reverse' m = Stream step Nothing

1113 where

1114 where

1114 {-# INLINE_LATE step #-}

1115 {-# INLINE_LATE step #-}

1115 step _ Nothing = do

1116 step _ Nothing = do

1116 arr <- A.fromStreamD m

1117 arr <- A.fromStreamD m

1117− let p = A.aEnd arr `plusPtr` negate (sizeOf (undefined :: a))

1118+ let p = A.aEnd arr `plusPtr` negate (sizeOfElem (undefined :: a))

1118 return $ Skip $ Just (A.aStart arr, p)

1119 return $ Skip $ Just (A.aStart arr, p)

1119

1120

1120 step _ (Just (start, p)) | p < unsafeForeignPtrToPtr start = return Stop

1121 step _ (Just (start, p)) | p < unsafeForeignPtrToPtr start = return Stop

@@ -1124,7 +1125,7 @@ reverse' m = Stream step Nothing

1124 r <- peek p

1125 r <- peek p

1125 touchForeignPtr start

1126 touchForeignPtr start

1126 return r

1127 return r

1127− next = p `plusPtr` negate (sizeOf (undefined :: a))

1128+ next = p `plusPtr` negate (sizeOfElem (undefined :: a))

1128 return $ Yield x (Just (start, next))

1129 return $ Yield x (Just (start, next))

1129-}

1130-}

1130

1131