1fb51c4 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Replace Unboxed with Unbox and remove the Unboxed type alias

1fb51c4Adithya Kumar4 years ago

benchmark/Streamly/Benchmark/Data/Array/Stream/Unboxed.hs+3−3

compare with master

unifiedsplit

@@ -51,7 +51,7 @@ import Streamly.Benchmark.Common.Handle

51import Control.Monad.IO.Class (MonadIO)

53#ifdef INSPECTION

54−import Streamly.Internal.Data.Unboxed (Unboxed)

54+import Streamly.Internal.Data.Unboxed (Unbox)

55import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))

56import Test.Inspection

57#endif

@@ -188,7 +188,7 @@ copyChunksSplitInterposeSuffix inh outh =

188 $ Handle.readChunks inh

189

190#ifdef INSPECTION

191−inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterposeSuffix [''Unboxed]

191+inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterposeSuffix [''Unbox]

192inspect $ 'copyChunksSplitInterposeSuffix `hasNoType` ''Step

193#endif

194

@@ -203,7 +203,7 @@ copyChunksSplitInterpose inh outh =

203 $ Handle.readChunks inh

204

205#ifdef INSPECTION

206−inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterpose [''Unboxed]

206+inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterpose [''Unbox]

207inspect $ 'copyChunksSplitInterpose `hasNoType` ''Step

208#endif

209

benchmark/Streamly/Benchmark/Unicode/Stream.hs+2−2

@@ -36,7 +36,7 @@ import Streamly.Benchmark.Common

36import Streamly.Benchmark.Common.Handle

38#ifdef INSPECTION

39−import Streamly.Internal.Data.Unboxed (Unboxed)

39+import Streamly.Internal.Data.Unboxed (Unbox)

40import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))

41import qualified Streamly.Internal.Data.Fold.Type as Fold

42import qualified Streamly.Internal.Data.Tuple.Strict as Strict

@@ -106,7 +106,7 @@ linesUnlinesArrayCharCopy inh outh =

106 $ Stream.unfold Handle.reader inh

107

108#ifdef INSPECTION

109−inspect $ hasNoTypeClassesExcept 'linesUnlinesArrayCharCopy [''Unboxed]

109+inspect $ hasNoTypeClassesExcept 'linesUnlinesArrayCharCopy [''Unbox]

110-- inspect $ 'linesUnlinesArrayCharCopy `hasNoType` ''Step

111#endif

112

core/src/Streamly/Internal/Data/Array/Unboxed.hs+20−20

@@ -126,7 +126,7 @@ import Data.Word (Word8)

126import Foreign.C.String (CString)

127import Foreign.Ptr (castPtr)

128import Streamly.Internal.Data.Unboxed

129− ( Unboxed

129+ ( Unbox

130 , castContents

131 , peekWith

132 , sizeOf

@@ -165,7 +165,7 @@ import qualified Streamly.Internal.Data.Unfold as Unfold

165--

166-- /Pre-release/

167{-# INLINE fromStreamN #-}

168−fromStreamN :: (MonadIO m, Unboxed a) => Int -> Stream m a -> m (Array a)

168+fromStreamN :: (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)

169fromStreamN n m = do

170 when (n < 0) $ error "writeN: negative write count specified"

171 A.fromStreamDN n $ Stream.toStreamD m

@@ -180,7 +180,7 @@ fromStreamN n m = do

180--

181-- /Pre-release/

182{-# INLINE fromStream #-}

183−fromStream :: (MonadIO m, Unboxed a) => Stream m a -> m (Array a)

183+fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (Array a)

184fromStream m = P.fold A.write $ Stream.toStreamK m

185-- write m = A.fromStreamD $ D.fromStreamK m

186

@@ -189,7 +189,7 @@ fromStream m = P.fold A.write $ Stream.toStreamK m

189-------------------------------------------------------------------------------

190

191{-# INLINE_NORMAL producer #-}

192−producer :: forall m a. (Monad m, Unboxed a) => Producer m (Array a) a

192+producer :: forall m a. (Monad m, Unbox a) => Producer m (Array a) a

193producer =

194 Producer.translate A.unsafeThaw A.unsafeFreeze

195 $ MA.producerWith (return . unsafeInlineIO)

@@ -197,7 +197,7 @@ producer =

197-- | Unfold an array into a stream.

198--

199{-# INLINE_NORMAL reader #-}

200−reader :: forall m a. (Monad m, Unboxed a) => Unfold m (Array a) a

200+reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a

201reader = Producer.simplify producer

202

203-- | Unfold an array into a stream, does not check the end of the array, the

@@ -212,7 +212,7 @@ reader = Producer.simplify producer

212-- /Pre-release/

213--

214{-# INLINE_NORMAL readerUnsafe #-}

215−readerUnsafe :: forall m a. (Monad m, Unboxed a) => Unfold m (Array a) a

215+readerUnsafe :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a

216readerUnsafe = Unfold step inject

217 where

218

@@ -245,7 +245,7 @@ null arr = A.byteLength arr == 0

245--

246-- /Pre-release/

247{-# INLINE getIndexRev #-}

248−getIndexRev :: forall a. Unboxed a => Int -> Array a -> Maybe a

248+getIndexRev :: forall a. Unbox a => Int -> Array a -> Maybe a

249getIndexRev i arr =

250 unsafeInlineIO

251 $ do

@@ -261,7 +261,7 @@ getIndexRev i arr =

261--

262-- /Pre-release/

263{-# INLINE last #-}

264−last :: Unboxed a => Array a -> Maybe a

264+last :: Unbox a => Array a -> Maybe a

265last = getIndexRev 0

266

267-------------------------------------------------------------------------------

@@ -273,7 +273,7 @@ last = getIndexRev 0

273--

274{-# INLINE writeLastN #-}

275writeLastN ::

276− (Unboxed a, MonadIO m) => Int -> Fold m a (Array a)

276+ (Unbox a, MonadIO m) => Int -> Fold m a (Array a)

277writeLastN n

278 | n <= 0 = fmap (const mempty) FL.drain

279 | otherwise = A.unsafeFreeze <$> Fold step initial done

@@ -353,7 +353,7 @@ find = Unfold.fold Fold.null . Stream.unfold (findIndicesOf p)

353-- /Pre-release/

354{-# INLINE getSliceUnsafe #-}

355getSliceUnsafe ::

356− forall a. Unboxed a

356+ forall a. Unbox a

357 => Int -- ^ starting index

358 -> Int -- ^ length of the slice

359 -> Array a

@@ -369,7 +369,7 @@ getSliceUnsafe index len (Array contents start e) =

369--

370-- /Pre-release/

371{-# INLINE splitOn #-}

372−splitOn :: (Monad m, Unboxed a) =>

372+splitOn :: (Monad m, Unbox a) =>

373 (a -> Bool) -> Array a -> Stream m (Array a)

374splitOn predicate arr =

375 Stream.fromStreamD

@@ -377,7 +377,7 @@ splitOn predicate arr =

377 $ D.sliceOnSuffix predicate (A.toStreamD arr)

378

379{-# INLINE genSlicesFromLen #-}

380−genSlicesFromLen :: forall m a. (Monad m, Unboxed a)

380+genSlicesFromLen :: forall m a. (Monad m, Unbox a)

381 => Int -- ^ from index

382 -> Int -- ^ length of the slice

383 -> Unfold m (Array a) (Int, Int)

@@ -390,7 +390,7 @@ genSlicesFromLen from len =

390--

391-- /Pre-release//

392{-# INLINE getSlicesFromLen #-}

393−getSlicesFromLen :: forall m a. (Monad m, Unboxed a)

393+getSlicesFromLen :: forall m a. (Monad m, Unbox a)

394 => Int -- ^ from index

395 -> Int -- ^ length of the slice

396 -> Unfold m (Array a) (Array a)

@@ -408,7 +408,7 @@ getSlicesFromLen from len =

408-- | /O(1)/ Lookup the element at the given index. Index starts from 0.

409--

410{-# INLINE getIndex #-}

411−getIndex :: forall a. Unboxed a => Int -> Array a -> Maybe a

411+getIndex :: forall a. Unbox a => Int -> Array a -> Maybe a

412getIndex i arr =

413 unsafeInlineIO

414 $ do

@@ -435,7 +435,7 @@ getIndex i arr =

435--

436-- /Pre-release/

437{-# INLINE getIndices #-}

438−getIndices :: (Monad m, Unboxed a) => Stream m Int -> Unfold m (Array a) a

438+getIndices :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a

439getIndices m =

440 let unf = MA.getIndicesD (return . unsafeInlineIO) $ D.fromStreamK $ Stream.toStreamK m

441 in Unfold.lmap A.unsafeThaw unf

@@ -471,7 +471,7 @@ getIndicesFromThenTo = undefined

471-- operation.

472--

473{-# INLINE runPipe #-}

474−runPipe :: (MonadIO m, Unboxed a, Unboxed b)

474+runPipe :: (MonadIO m, Unbox a, Unbox b)

475 => Pipe m a b -> Array a -> m (Array b)

476runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)

477-}

@@ -484,7 +484,7 @@ runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)

484--

485-- /Pre-release/

486{-# INLINE streamTransform #-}

487−streamTransform :: forall m a b. (MonadIO m, Unboxed a, Unboxed b)

487+streamTransform :: forall m a b. (MonadIO m, Unbox a, Unbox b)

488 => (Stream m a -> Stream m b) -> Array a -> m (Array b)

489streamTransform f arr =

490 P.fold (A.writeWith (length arr)) $ Stream.toStreamK $ f (A.read arr)

@@ -519,7 +519,7 @@ asBytes = castUnsafe

519-- target element otherwise 'Nothing' is returned.

520--

521--

522−cast :: forall a b. (Unboxed b) => Array a -> Maybe (Array b)

522+cast :: forall a b. (Unbox b) => Array a -> Maybe (Array b)

523cast arr =

524 let len = A.byteLength arr

525 r = len `mod` SIZE_OF(b)

@@ -551,12 +551,12 @@ asCStringUnsafe arr act = do

551--

552-- /Pre-release/

553{-# INLINE fold #-}

554−fold :: forall m a b. (Monad m, Unboxed a) => Fold m a b -> Array a -> m b

554+fold :: forall m a b. (Monad m, Unbox a) => Fold m a b -> Array a -> m b

555fold f arr = P.fold f (Stream.toStreamK (A.read arr))

556

557-- | Fold an array using a stream fold operation.

558--

559-- /Pre-release/

560{-# INLINE streamFold #-}

561−streamFold :: (Monad m, Unboxed a) => (Stream m a -> m b) -> Array a -> m b

561+streamFold :: (Monad m, Unbox a) => (Stream m a -> m b) -> Array a -> m b

562streamFold f arr = f (A.read arr)

core/src/Streamly/Internal/Data/Array/Unboxed/Fold.hs+5−5

@@ -61,7 +61,7 @@ import Control.Exception (assert)

61import Control.Monad.Catch (MonadThrow)

62import Control.Monad.IO.Class (MonadIO(..))

63import Data.Bifunctor (first)

64−import Streamly.Internal.Data.Unboxed (peekWith, sizeOf, Unboxed)

64+import Streamly.Internal.Data.Unboxed (peekWith, sizeOf, Unbox)

65import GHC.Types (SPEC(..))

66import Streamly.Internal.Data.Array.Unboxed.Mut.Type (touch)

67import Streamly.Internal.Data.Array.Unboxed.Type (Array(..))

@@ -101,7 +101,7 @@ newtype ArrayFold m a b = ArrayFold (ParserD.Parser m (Array a) b)

101#ifdef DEVBUILD

102fromFold :: forall m a b. (MonadIO m) =>

103#else

104−fromFold :: forall m a b. (MonadIO m, Unboxed a) =>

104+fromFold :: forall m a b. (MonadIO m, Unbox a) =>

105#endif

106 Fold.Fold m a b -> ArrayFold m a b

107fromFold (Fold.Fold fstep finitial fextract) =

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

143#ifdef DEVBUILD

144fromParserD :: forall m a b. (MonadIO m) =>

145#else

146−fromParserD :: forall m a b. (MonadIO m, Unboxed a) =>

146+fromParserD :: forall m a b. (MonadIO m, Unbox a) =>

147#endif

148 ParserD.Parser m a b -> ArrayFold m a b

149fromParserD (ParserD.Parser step1 initial1 extract1) =

@@ -189,7 +189,7 @@ fromParserD (ParserD.Parser step1 initial1 extract1) =

189#ifdef DEVBUILD

190fromParser :: forall m a b. (MonadThrow m, MonadIO m) =>

191#else

192−fromParser :: forall m a b. (MonadThrow m, MonadIO m, Unboxed a) =>

192+fromParser :: forall m a b. (MonadThrow m, MonadIO m, Unbox a) =>

193#endif

194 Parser.Parser m a b -> ArrayFold m a b

195fromParser = fromParserD . ParserD.fromParserK

@@ -314,7 +314,7 @@ instance MonadThrow m => Monad (ArrayFold m a) where

314

315-- | Take @n@ array elements (@a@) from a stream of arrays (@Array a@).

316{-# INLINE take #-}

317−take :: forall m a b. (Monad m, Unboxed a) =>

317+take :: forall m a b. (Monad m, Unbox a) =>

318 Int -> ArrayFold m a b -> ArrayFold m a b

319take n (ArrayFold (ParserD.Parser step1 initial1 extract1)) =

320 ArrayFold $ ParserD.Parser step initial extract

core/src/Streamly/Internal/Data/Array/Unboxed/Mut.hs+5−5

@@ -33,7 +33,7 @@ module Streamly.Internal.Data.Array.Unboxed.Mut

33where

35import Control.Monad.IO.Class (MonadIO(..))

36−import Streamly.Internal.Data.Unboxed (Unboxed)

36+import Streamly.Internal.Data.Unboxed (Unbox)

37import Streamly.Internal.Data.Stream (Stream)

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

@@ -50,7 +50,7 @@ import Streamly.Internal.Data.Array.Unboxed.Mut.Type

50--

51-- /Pre-release/

52{-# INLINE splitOn #-}

53−splitOn :: (MonadIO m, Unboxed a) =>

53+splitOn :: (MonadIO m, Unbox a) =>

54 (a -> Bool) -> Array a -> Stream m (Array a)

55splitOn predicate arr =

56 Stream.fromStreamD

@@ -63,7 +63,7 @@ splitOn predicate arr =

63--

64-- /Pre-release/

65{-# INLINE genSlicesFromLen #-}

66−genSlicesFromLen :: forall m a. (Monad m, Unboxed a)

66+genSlicesFromLen :: forall m a. (Monad m, Unbox a)

67 => Int -- ^ from index

68 -> Int -- ^ length of the slice

69 -> Unfold m (Array a) (Int, Int)

@@ -80,7 +80,7 @@ genSlicesFromLen from len =

80--

81-- /Pre-release/

82{-# INLINE getSlicesFromLen #-}

83−getSlicesFromLen :: forall m a. (Monad m, Unboxed a)

83+getSlicesFromLen :: forall m a. (Monad m, Unbox a)

84 => Int -- ^ from index

85 -> Int -- ^ length of the slice

86 -> Unfold m (Array a) (Array a)

@@ -98,6 +98,6 @@ getSlicesFromLen from len =

98--

99-- /Pre-release/

100{-# INLINE fromStream #-}

101−fromStream :: (MonadIO m, Unboxed a) => Stream m a -> m (Array a)

101+fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (Array a)

102fromStream = fromStreamD . Stream.toStreamD

103-- fromStream (Stream m) = P.fold write m

core/src/Streamly/Internal/Data/Array/Unboxed/Mut/Stream.hs+10−10

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

31import Control.Monad (when)

32import Control.Monad.Catch (MonadThrow)

33import Data.Bifunctor (first)

34−import Streamly.Internal.Data.Unboxed (Unboxed, sizeOf)

34+import Streamly.Internal.Data.Unboxed (Unbox, sizeOf)

35import Streamly.Internal.Data.Array.Unboxed.Mut.Type (Array(..))

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

37import Streamly.Internal.Data.Stream.Type (Stream)

@@ -52,7 +52,7 @@ import qualified Streamly.Internal.Data.Stream.Type as Stream

52--

53-- /Pre-release/

54{-# INLINE arraysOf #-}

55−arraysOf :: (MonadIO m, Unboxed a)

55+arraysOf :: (MonadIO m, Unbox a)

56 => Int -> Stream m a -> Stream m (Array a)

57arraysOf n = Stream.fromStreamD . MArray.arraysOf n . Stream.toStreamD

@@ -81,7 +81,7 @@ data SpliceState s arr

81--

82-- @since 0.7.0

83{-# INLINE_NORMAL packArraysChunksOf #-}

84−packArraysChunksOf :: (MonadIO m, Unboxed a)

84+packArraysChunksOf :: (MonadIO m, Unbox a)

85 => Int -> D.Stream m (Array a) -> D.Stream m (Array a)

86packArraysChunksOf n (D.Stream step state) =

87 D.Stream step' (SpliceInitial state)

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

129-- lpackArraysChunksOf = Fold.many compactLEFold

130--

131{-# INLINE_NORMAL lpackArraysChunksOf #-}

132−lpackArraysChunksOf :: (MonadIO m, Unboxed a)

132+lpackArraysChunksOf :: (MonadIO m, Unbox a)

133 => Int -> Fold m (Array a) () -> Fold m (Array a) ()

134lpackArraysChunksOf n (Fold step1 initial1 extract1) =

135 Fold step initial extract

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

191--

192-- /Internal/

193{-# INLINE compact #-}

194−compact :: (MonadIO m, Unboxed a)

194+compact :: (MonadIO m, Unbox a)

195 => Int -> Stream m (Array a) -> Stream m (Array a)

196compact n = Stream.fromStreamD . packArraysChunksOf n . Stream.toStreamD

197

@@ -204,7 +204,7 @@ compact n = Stream.fromStreamD . packArraysChunksOf n . Stream.toStreamD

204-- /Internal/

205{-# INLINE_NORMAL compactLEParserD #-}

206compactLEParserD ::

207− forall m a. (MonadThrow m, MonadIO m, Unboxed a)

207+ forall m a. (MonadThrow m, MonadIO m, Unbox a)

208 => Int -> ParserD.Parser m (Array a) (Array a)

209compactLEParserD n = ParserD.Parser step initial extract

210

@@ -254,7 +254,7 @@ compactLEParserD n = ParserD.Parser step initial extract

254-- /Internal/

255{-# INLINE_NORMAL compactGEFold #-}

256compactGEFold ::

257− forall m a. (MonadIO m, Unboxed a)

257+ forall m a. (MonadIO m, Unbox a)

258 => Int -> FL.Fold m (Array a) (Array a)

259compactGEFold n = Fold step initial extract

260

@@ -298,7 +298,7 @@ compactGEFold n = Fold step initial extract

298-- maximum specified size in bytes.

299--

300-- /Internal/

301−compactLE :: (MonadThrow m, MonadIO m, Unboxed a) =>

301+compactLE :: (MonadThrow m, MonadIO m, Unbox a) =>

302 Int -> Stream m (Array a) -> Stream m (Array a)

303compactLE n =

304 Stream.fromStreamD . D.parseMany (compactLEParserD n) . Stream.toStreamD

@@ -308,7 +308,7 @@ compactLE n =

308--

309-- /Unimplemented/

310{-# INLINE compactEQ #-}

311−compactEQ :: -- (MonadIO m, Unboxed a) =>

311+compactEQ :: -- (MonadIO m, Unbox a) =>

312 Int -> Stream m (Array a) -> Stream m (Array a)

313compactEQ _n _xs = undefined

314 -- IsStream.fromStreamD $ D.foldMany (compactEQFold n) (IsStream.toStreamD xs)

@@ -319,7 +319,7 @@ compactEQ _n _xs = undefined

319-- /Internal/

320{-# INLINE compactGE #-}

321compactGE ::

322− (MonadIO m, Unboxed a)

322+ (MonadIO m, Unbox a)

323 => Int -> Stream m (Array a) -> Stream m (Array a)

324compactGE n =

325 Stream.fromStreamD . D.foldMany (compactGEFold n) . Stream.toStreamD

core/src/Streamly/Internal/Data/Array/Unboxed/Mut/Type.hs+98−98

@@ -223,7 +223,7 @@ import Foreign.C.Types (CSize(..), CInt(..))

223import Foreign.Ptr (plusPtr, minusPtr, nullPtr)

224import Streamly.Internal.Data.Unboxed

225 ( MutableByteArray(..)

226− , Unboxed

226+ , Unbox

227 , alignment

228 , castContents

229 , getMutableByteArray#

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

286-- how many elements of that type will completely fit in those bytes.

287--

288{-# INLINE bytesToElemCount #-}

289−bytesToElemCount :: forall a. Unboxed a => a -> Int -> Int

289+bytesToElemCount :: forall a. Unbox a => a -> Int -> Int

290bytesToElemCount _ n = n `div` SIZE_OF(a)

291

292-- XXX we are converting Int to CSize

@@ -333,7 +333,7 @@ memcmp p1 p2 len = do

333--

334data Array a =

335#ifdef DEVBUILD

336− Unboxed a =>

336+ Unbox a =>

337#endif

338 -- The array is a range into arrContents. arrContents may be a superset of

339 -- the slice represented by the array. All offsets are in bytes.

@@ -389,7 +389,7 @@ unpin arr@Array{..} = do

389--

390-- /Pre-release/

391{-# INLINE newArrayWith #-}

392−newArrayWith :: forall m a. (MonadIO m, Unboxed a)

392+newArrayWith :: forall m a. (MonadIO m, Unbox a)

393 => (Int -> Int -> m (MutableByteArray a)) -> Int -> Int -> m (Array a)

394newArrayWith alloc alignSize count = do

395 let size = max (count * SIZE_OF(a)) 0

@@ -403,7 +403,7 @@ newArrayWith alloc alignSize count = do

403

404nil ::

405#ifdef DEVBUILD

406− Unboxed a =>

406+ Unbox a =>

407#endif

408 Array a

409nil = Array Unboxed.nil 0 0 0

@@ -415,7 +415,7 @@ nil = Array Unboxed.nil 0 0 0

415--

416-- /Pre-release/

417{-# INLINE newPinnedBytes #-}

418−newPinnedBytes :: forall m a. (MonadIO m, Unboxed a) => Int -> m (Array a)

418+newPinnedBytes :: forall m a. (MonadIO m, Unbox a) => Int -> m (Array a)

419newPinnedBytes bytes = do

420 contents <-

421 liftIO

@@ -432,7 +432,7 @@ newPinnedBytes bytes = do

432--

433-- /Internal/

434{-# INLINE newAlignedPinned #-}

435−newAlignedPinned :: (MonadIO m, Unboxed a) => Int -> Int -> m (Array a)

435+newAlignedPinned :: (MonadIO m, Unbox a) => Int -> Int -> m (Array a)

436newAlignedPinned =

437 newArrayWith (\s a -> liftIO $ Unboxed.newAlignedPinnedBytes s a)

438

@@ -443,14 +443,14 @@ newAlignedPinned =

443-- instance of the type.

444--

445{-# INLINE newPinned #-}

446−newPinned :: forall m a. (MonadIO m, Unboxed a) => Int -> m (Array a)

446+newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (Array a)

447newPinned = newAlignedPinned (alignment (undefined :: a))

448

449-- | Allocates an empty unpinned array that can hold 'count' items. The memory

450-- of the array is uninitialized.

451--

452{-# INLINE new #-}

453−new :: (MonadIO m, Unboxed a) => Int -> m (Array a)

453+new :: (MonadIO m, Unbox a) => Int -> m (Array a)

454new =

455 newArrayWith

456 (\s _ -> liftIO $ Unboxed.newUnpinnedBytes s)

@@ -462,7 +462,7 @@ new =

462-- /Internal/

463{-# INLINE withNewArrayUnsafe #-}

464withNewArrayUnsafe ::

465− (MonadIO m, Unboxed a) => Int -> (Ptr a -> m ()) -> m (Array a)

465+ (MonadIO m, Unbox a) => Int -> (Ptr a -> m ()) -> m (Array a)

466withNewArrayUnsafe count f = do

467 arr <- newPinned count

468 asPtrUnsafe arr

@@ -477,7 +477,7 @@ withNewArrayUnsafe count f = do

477--

478-- /Pre-release/

479{-# INLINE putIndexUnsafe #-}

480−putIndexUnsafe :: forall m a. (MonadIO m, Unboxed a)

480+putIndexUnsafe :: forall m a. (MonadIO m, Unbox a)

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

482putIndexUnsafe i x Array{..} = do

483 let index = INDEX_OF(arrStart, i, a)

@@ -496,7 +496,7 @@ invalidIndex label i =

496-- >>> putIndex ix val arr = Stream.fold (f arr) (Stream.fromPure (ix, val))

497--

498{-# INLINE putIndex #-}

499−putIndex :: forall m a. (MonadIO m, Unboxed a) => Int -> a -> Array a -> m ()

499+putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> a -> Array a -> m ()

500putIndex i x Array{..} = do

501 let index = INDEX_OF(arrStart,i,a)

502 if i >= 0 && INDEX_VALID(index,arrEnd,a)

@@ -508,7 +508,7 @@ putIndex i x Array{..} = do

508--

509-- /Pre-release/

510{-# INLINE putIndices #-}

511−putIndices :: forall m a. (MonadIO m, Unboxed a)

511+putIndices :: forall m a. (MonadIO m, Unbox a)

512 => Array a -> Fold m (Int, a) ()

513putIndices arr = FL.foldlM' step (return ())

514

@@ -519,7 +519,7 @@ putIndices arr = FL.foldlM' step (return ())

519-- | Modify a given index of an array using a modifier function.

520--

521-- /Pre-release/

522−modifyIndexUnsafe :: forall m a b. (MonadIO m, Unboxed a) =>

522+modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) =>

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

524modifyIndexUnsafe i f Array{..} = liftIO $ do

525 let index = INDEX_OF(arrStart,i,a)

@@ -532,7 +532,7 @@ modifyIndexUnsafe i f Array{..} = liftIO $ do

532-- | Modify a given index of an array using a modifier function.

533--

534-- /Pre-release/

535−modifyIndex :: forall m a b. (MonadIO m, Unboxed a) =>

535+modifyIndex :: forall m a b. (MonadIO m, Unbox a) =>

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

537modifyIndex i f Array{..} = do

538 let index = INDEX_OF(arrStart,i,a)

@@ -549,7 +549,7 @@ modifyIndex i f Array{..} = do

549--

550-- /Pre-release/

551{-# INLINE modifyIndices #-}

552−modifyIndices :: forall m a . (MonadIO m, Unboxed a)

552+modifyIndices :: forall m a . (MonadIO m, Unbox a)

553 => (Int -> a -> a) -> Array a -> Fold m Int ()

554modifyIndices f arr = FL.foldlM' step initial

555

@@ -564,7 +564,7 @@ modifyIndices f arr = FL.foldlM' step initial

564-- | Modify each element of an array using the supplied modifier function.

565--

566-- /Pre-release/

567−modify :: forall m a. (MonadIO m, Unboxed a)

567+modify :: forall m a. (MonadIO m, Unbox a)

568 => (a -> a) -> Array a -> m ()

569modify f Array{..} = liftIO $

570 go arrStart

@@ -578,7 +578,7 @@ modify f Array{..} = liftIO $

578 go (INDEX_NEXT(i,a))

579

580{-# INLINE swapArrayByteIndices #-}

581−swapArrayByteIndices :: Unboxed a => MutableByteArray a -> Int -> Int -> IO ()

581+swapArrayByteIndices :: Unbox a => MutableByteArray a -> Int -> Int -> IO ()

582swapArrayByteIndices arrContents i1 i2 = do

583 r1 <- peekWith arrContents i1

584 r2 <- peekWith arrContents i2

@@ -591,7 +591,7 @@ swapArrayByteIndices arrContents i1 i2 = do

591--

592-- /Pre-release/

593{-# INLINE unsafeSwapIndices #-}

594−unsafeSwapIndices :: forall m a. (MonadIO m, Unboxed a)

594+unsafeSwapIndices :: forall m a. (MonadIO m, Unbox a)

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

596unsafeSwapIndices i1 i2 Array{..} = liftIO $ do

597 let t1 = INDEX_OF(arrStart,i1,a)

@@ -601,7 +601,7 @@ unsafeSwapIndices i1 i2 Array{..} = liftIO $ do

601-- | Swap the elements at two indices.

602--

603-- /Pre-release/

604−swapIndices :: forall m a. (MonadIO m, Unboxed a)

604+swapIndices :: forall m a. (MonadIO m, Unbox a)

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

606swapIndices i1 i2 Array{..} = liftIO $ do

607 let t1 = INDEX_OF(arrStart,i1,a)

@@ -672,7 +672,7 @@ roundUpToPower2 n =

672-- case it returns one element's size.

673--

674{-# INLINE allocBytesToBytes #-}

675−allocBytesToBytes :: forall a. Unboxed a => a -> Int -> Int

675+allocBytesToBytes :: forall a. Unbox a => a -> Int -> Int

676allocBytesToBytes _ n = max (arrayPayloadSize n) (SIZE_OF(a))

677

678-- | Given an 'Unboxed' type (unused first arg) and real allocation size

@@ -680,7 +680,7 @@ allocBytesToBytes _ n = max (arrayPayloadSize n) (SIZE_OF(a))

680-- fit in it, returns at least 1.

681--

682{-# INLINE allocBytesToElemCount #-}

683−allocBytesToElemCount :: Unboxed a => a -> Int -> Int

683+allocBytesToElemCount :: Unbox a => a -> Int -> Int

684allocBytesToElemCount x bytes =

685 let n = bytesToElemCount x (allocBytesToBytes x bytes)

686 in assert (n >= 1) n

@@ -745,14 +745,14 @@ reallocAligned elemSize alignSize newCapacityInBytes Array{..} = do

745-- 'largeObjectThreshold' then it is rounded up to the block size (4K).

746--

747{-# INLINABLE realloc #-}

748−realloc :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m (Array a)

748+realloc :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m (Array a)

749realloc bytes arr =

750 liftIO $ reallocAligned (SIZE_OF(a)) (alignment (undefined :: a)) bytes arr

751

752-- | @reallocWith label capSizer minIncrBytes array@. The label is used

753-- in error messages and the capSizer is used to determine the capacity of the

754-- new array in bytes given the current byte length of the array.

755−reallocWith :: forall m a. (MonadIO m , Unboxed a) =>

755+reallocWith :: forall m a. (MonadIO m , Unbox a) =>

756 String

757 -> (Int -> Int)

758 -> Int

@@ -786,7 +786,7 @@ reallocWith label capSizer minIncrBytes arr = do

786--

787-- /Pre-release/

788{-# INLINE resize #-}

789−resize :: forall m a. (MonadIO m, Unboxed a) =>

789+resize :: forall m a. (MonadIO m, Unbox a) =>

790 Int -> Array a -> m (Array a)

791resize nElems arr@Array{..} = do

792 let req = SIZE_OF(a) * nElems

@@ -800,7 +800,7 @@ resize nElems arr@Array{..} = do

800--

801-- /Pre-release/

802{-# INLINE resizeExp #-}

803−resizeExp :: forall m a. (MonadIO m, Unboxed a) =>

803+resizeExp :: forall m a. (MonadIO m, Unbox a) =>

804 Int -> Array a -> m (Array a)

805resizeExp nElems arr@Array{..} = do

806 let req = roundUpLargeArray (SIZE_OF(a) * nElems)

@@ -822,7 +822,7 @@ resizeExp nElems arr@Array{..} = do

822--

823-- /Pre-release/

824{-# INLINE rightSize #-}

825−rightSize :: forall m a. (MonadIO m, Unboxed a) => Array a -> m (Array a)

825+rightSize :: forall m a. (MonadIO m, Unbox a) => Array a -> m (Array a)

826rightSize arr@Array{..} = do

827 assert (arrEnd <= arrBound) (return ())

828 let start = arrStart

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

854--

855-- /Internal/

856{-# INLINE snocNewEnd #-}

857−snocNewEnd :: (MonadIO m, Unboxed a) => Int -> Array a -> a -> m (Array a)

857+snocNewEnd :: (MonadIO m, Unbox a) => Int -> Array a -> a -> m (Array a)

858snocNewEnd newEnd arr@Array{..} x = liftIO $ do

859 assert (newEnd <= arrBound) (return ())

860 pokeWith arrContents arrEnd x

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

866--

867-- /Internal/

868{-# INLINE snocUnsafe #-}

869−snocUnsafe :: forall m a. (MonadIO m, Unboxed a) =>

869+snocUnsafe :: forall m a. (MonadIO m, Unbox a) =>

870 Array a -> a -> m (Array a)

871snocUnsafe arr@Array{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr

872

@@ -875,7 +875,7 @@ snocUnsafe arr@Array{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr

875--

876-- /Internal/

877{-# INLINE snocMay #-}

878−snocMay :: forall m a. (MonadIO m, Unboxed a) =>

878+snocMay :: forall m a. (MonadIO m, Unbox a) =>

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

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

881 let newEnd = INDEX_NEXT(arrEnd,a)

@@ -885,7 +885,7 @@ snocMay arr@Array{..} x = liftIO $ do

885

886-- NOINLINE to move it out of the way and not pollute the instruction cache.

887{-# NOINLINE snocWithRealloc #-}

888−snocWithRealloc :: forall m a. (MonadIO m, Unboxed a) =>

888+snocWithRealloc :: forall m a. (MonadIO m, Unbox a) =>

889 (Int -> Int)

890 -> Array a

891 -> a

@@ -908,7 +908,7 @@ snocWithRealloc sizer arr x = do

908--

909-- /Pre-release/

910{-# INLINE snocWith #-}

911−snocWith :: forall m a. (MonadIO m, Unboxed a) =>

911+snocWith :: forall m a. (MonadIO m, Unbox a) =>

912 (Int -> Int)

913 -> Array a

914 -> a

@@ -930,7 +930,7 @@ snocWith allocSize arr x = liftIO $ do

930--

931-- /Pre-release/

932{-# INLINE snocLinear #-}

933−snocLinear :: forall m a. (MonadIO m, Unboxed a) => Array a -> a -> m (Array a)

933+snocLinear :: forall m a. (MonadIO m, Unbox a) => Array a -> a -> m (Array a)

934snocLinear = snocWith (+ allocBytesToBytes (undefined :: a) arrayChunkBytes)

935

936-- | The array is mutated to append an additional element to it. If there is no

@@ -947,7 +947,7 @@ snocLinear = snocWith (+ allocBytesToBytes (undefined :: a) arrayChunkBytes)

947-- Performs O(n * log n) copies to grow, but is liberal with memory allocation.

948--

949{-# INLINE snoc #-}

950−snoc :: forall m a. (MonadIO m, Unboxed a) => Array a -> a -> m (Array a)

950+snoc :: forall m a. (MonadIO m, Unbox a) => Array a -> a -> m (Array a)

951snoc = snocWith f

952

953 where

@@ -967,7 +967,7 @@ snoc = snocWith f

967--

968-- Unsafe because it does not check the bounds of the array.

969{-# INLINE_NORMAL getIndexUnsafe #-}

970−getIndexUnsafe :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a

970+getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a

971getIndexUnsafe i Array{..} = do

972 let index = INDEX_OF(arrStart,i,a)

973 assert (i >= 0 && INDEX_VALID(index,arrEnd,a)) (return ())

@@ -976,7 +976,7 @@ getIndexUnsafe i Array{..} = do

976-- | /O(1)/ Lookup the element at the given index. Index starts from 0.

977--

978{-# INLINE getIndex #-}

979−getIndex :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a

979+getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a

980getIndex i Array{..} = do

981 let index = INDEX_OF(arrStart,i,a)

982 if i >= 0 && INDEX_VALID(index,arrEnd,a)

@@ -989,7 +989,7 @@ getIndex i Array{..} = do

989-- Slightly faster than computing the forward index and using getIndex.

990--

991{-# INLINE getIndexRev #-}

992−getIndexRev :: forall m a. (MonadIO m, Unboxed a) => Int -> Array a -> m a

992+getIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> Array a -> m a

993getIndexRev i Array{..} = do

994 let index = RINDEX_OF(arrEnd,i,a)

995 if i >= 0 && index >= arrStart

@@ -1005,7 +1005,7 @@ data GetIndicesState contents start end st =

1005--

1006-- /Pre-release/

1007{-# INLINE getIndicesD #-}

1008−getIndicesD :: (Monad m, Unboxed a) =>

1008+getIndicesD :: (Monad m, Unbox a) =>

1009 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (Array a) a

1010getIndicesD liftio (D.Stream stepi sti) = Unfold step inject

1011

@@ -1025,7 +1025,7 @@ getIndicesD liftio (D.Stream stepi sti) = Unfold step inject

1025 D.Stop -> return D.Stop

1026

1027{-# INLINE getIndices #-}

1028−getIndices :: (MonadIO m, Unboxed a) => Stream m Int -> Unfold m (Array a) a

1028+getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (Array a) a

1029getIndices = getIndicesD liftIO . Stream.toStreamD

1030

1031-------------------------------------------------------------------------------

@@ -1042,7 +1042,7 @@ getIndices = getIndicesD liftIO . Stream.toStreamD

1042--

1043-- /Pre-release/

1044{-# INLINE getSliceUnsafe #-}

1045−getSliceUnsafe :: forall a. Unboxed a

1045+getSliceUnsafe :: forall a. Unbox a

1046 => Int -- ^ from index

1047 -> Int -- ^ length of the slice

1048 -> Array a

@@ -1061,7 +1061,7 @@ getSliceUnsafe index len (Array contents start e _) =

1061--

1062-- /Pre-release/

1063{-# INLINE getSlice #-}

1064−getSlice :: forall a. Unboxed a =>

1064+getSlice :: forall a. Unbox a =>

1065 Int -- ^ from index

1066 -> Int -- ^ length of the slice

1067 -> Array a

@@ -1089,7 +1089,7 @@ getSlice index len (Array contents start e _) =

1089-- of cache locality and when you do not want to allocate additional memory.

1090--

1091{-# INLINE reverse #-}

1092−reverse :: forall m a. (MonadIO m, Unboxed a) => Array a -> m ()

1092+reverse :: forall m a. (MonadIO m, Unbox a) => Array a -> m ()

1093reverse Array{..} = liftIO $ do

1094 let l = arrStart

1095 h = INDEX_PREV(arrEnd,a)

@@ -1116,7 +1116,7 @@ permute = undefined

1116--

1117-- /Pre-release/

1118{-# INLINE partitionBy #-}

1119−partitionBy :: forall m a. (MonadIO m, Unboxed a)

1119+partitionBy :: forall m a. (MonadIO m, Unbox a)

1120 => (a -> Bool) -> Array a -> m (Array a, Array a)

1121partitionBy f arr@Array{..} = liftIO $ do

1122 if arrStart >= arrEnd

@@ -1238,7 +1238,7 @@ byteLength Array{..} =

1238-- involves a costly division operation.

1239--

1240{-# INLINE length #-}

1241−length :: forall a. Unboxed a => Array a -> Int

1241+length :: forall a. Unbox a => Array a -> Int

1242length arr =

1243 let elemSize = SIZE_OF(a)

1244 blen = byteLength arr

@@ -1282,7 +1282,7 @@ data GroupState s contents start end bound

1282--

1283-- /Pre-release/

1284{-# INLINE_NORMAL arraysOf #-}

1285−arraysOf :: forall m a. (MonadIO m, Unboxed a)

1285+arraysOf :: forall m a. (MonadIO m, Unbox a)

1286 => Int -> D.Stream m a -> D.Stream m (Array a)

1287-- XXX the idiomatic implementation leads to large regression in the D.reverse'

1288-- benchmark. It seems it has difficulty producing optimized code when

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

1329-- XXX buffer to a list instead?

1330-- | Buffer the stream into arrays in memory.

1331{-# INLINE arrayStreamKFromStreamD #-}

1332−arrayStreamKFromStreamD :: forall m a. (MonadIO m, Unboxed a) =>

1332+arrayStreamKFromStreamD :: forall m a. (MonadIO m, Unbox a) =>

1333 D.Stream m a -> m (K.Stream m (Array a))

1334arrayStreamKFromStreamD =

1335 let n = allocBytesToElemCount (undefined :: a) defaultChunkSize

@@ -1350,7 +1350,7 @@ data FlattenState s contents a =

1350-- We can try this if there are any fusion issues in the unfold.

1351--

1352{-# INLINE_NORMAL flattenArrays #-}

1353−flattenArrays :: forall m a. (MonadIO m, Unboxed a)

1353+flattenArrays :: forall m a. (MonadIO m, Unbox a)

1354 => D.Stream m (Array a) -> D.Stream m a

1355flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)

1356

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

1379-- We can try this if there are any fusion issues in the unfold.

1380--

1381{-# INLINE_NORMAL flattenArraysRev #-}

1382−flattenArraysRev :: forall m a. (MonadIO m, Unboxed a)

1382+flattenArraysRev :: forall m a. (MonadIO m, Unbox a)

1383 => D.Stream m (Array a) -> D.Stream m a

1384flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)

1385

@@ -1417,7 +1417,7 @@ toArrayUnsafe (Array contents start end _) = ArrayUnsafe contents start end

1417

1418fromArrayUnsafe ::

1419#ifdef DEVBUILD

1420− Unboxed a =>

1420+ Unbox a =>

1421#endif

1422 ArrayUnsafe a -> Array a

1423fromArrayUnsafe (ArrayUnsafe contents start end) =

@@ -1425,7 +1425,7 @@ fromArrayUnsafe (ArrayUnsafe contents start end) =

1425

1426{-# INLINE_NORMAL producerWith #-}

1427producerWith ::

1428− forall m a. (Monad m, Unboxed a)

1428+ forall m a. (Monad m, Unbox a)

1429 => (forall b. IO b -> m b) -> Producer m (Array a) a

1430producerWith liftio = Producer step (return . toArrayUnsafe) extract

1431 where

@@ -1446,18 +1446,18 @@ producerWith liftio = Producer step (return . toArrayUnsafe) extract

1446-- | Resumable unfold of an array.

1447--

1448{-# INLINE_NORMAL producer #-}

1449−producer :: forall m a. (MonadIO m, Unboxed a) => Producer m (Array a) a

1449+producer :: forall m a. (MonadIO m, Unbox a) => Producer m (Array a) a

1450producer = producerWith liftIO

1451

1452-- | Unfold an array into a stream.

1453--

1454{-# INLINE_NORMAL reader #-}

1455−reader :: forall m a. (MonadIO m, Unboxed a) => Unfold m (Array a) a

1455+reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (Array a) a

1456reader = Producer.simplify producer

1457

1458{-# INLINE_NORMAL readerRevWith #-}

1459readerRevWith ::

1460− forall m a. (Monad m, Unboxed a)

1460+ forall m a. (Monad m, Unbox a)

1461 => (forall b. IO b -> m b) -> Unfold m (Array a) a

1462readerRevWith liftio = Unfold step inject

1463 where

@@ -1475,7 +1475,7 @@ readerRevWith liftio = Unfold step inject

1475-- | Unfold an array into a stream in reverse order.

1476--

1477{-# INLINE_NORMAL readerRev #-}

1478−readerRev :: forall m a. (MonadIO m, Unboxed a) => Unfold m (Array a) a

1478+readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (Array a) a

1479readerRev = readerRevWith liftIO

1480

1481-------------------------------------------------------------------------------

@@ -1486,7 +1486,7 @@ readerRev = readerRevWith liftIO

1486-- Use foldr/build fusion to fuse with list consumers

1487-- This can be useful when using the IsList instance

1488{-# INLINE_LATE toListFB #-}

1489−toListFB :: forall a b. Unboxed a => (a -> b -> b) -> b -> Array a -> b

1489+toListFB :: forall a b. Unbox a => (a -> b -> b) -> b -> Array a -> b

1490toListFB c n Array{..} = go arrStart

1491 where

1492

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

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

1511--

1512{-# INLINE toList #-}

1513−toList :: forall m a. (MonadIO m, Unboxed a) => Array a -> m [a]

1513+toList :: forall m a. (MonadIO m, Unbox a) => Array a -> m [a]

1514toList Array{..} = liftIO $ go arrStart

1515 where

1516

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

1521

1522{-# INLINE_NORMAL toStreamDWith #-}

1523toStreamDWith ::

1524− forall m a. (Monad m, Unboxed a)

1524+ forall m a. (Monad m, Unbox a)

1525 => (forall b. IO b -> m b) -> Array a -> D.Stream m a

1526toStreamDWith liftio Array{..} = D.Stream step arrStart

1527

@@ -1539,12 +1539,12 @@ toStreamDWith liftio Array{..} = D.Stream step arrStart

1539--

1540-- We can try this if the unfold has any performance issues.

1541{-# INLINE_NORMAL toStreamD #-}

1542−toStreamD :: forall m a. (MonadIO m, Unboxed a) => Array a -> D.Stream m a

1542+toStreamD :: forall m a. (MonadIO m, Unbox a) => Array a -> D.Stream m a

1543toStreamD = toStreamDWith liftIO

1544

1545{-# INLINE toStreamKWith #-}

1546toStreamKWith ::

1547− forall m a. (Monad m, Unboxed a)

1547+ forall m a. (Monad m, Unbox a)

1548 => (forall b. IO b -> m b) -> Array a -> K.Stream m a

1549toStreamKWith liftio Array{..} = go arrStart

1550

@@ -1556,12 +1556,12 @@ toStreamKWith liftio Array{..} = go arrStart

1556 in liftio elemM `K.consM` go (INDEX_NEXT(p,a))

1557

1558{-# INLINE toStreamK #-}

1559−toStreamK :: forall m a. (MonadIO m, Unboxed a) => Array a -> K.Stream m a

1559+toStreamK :: forall m a. (MonadIO m, Unbox a) => Array a -> K.Stream m a

1560toStreamK = toStreamKWith liftIO

1561

1562{-# INLINE_NORMAL toStreamDRevWith #-}

1563toStreamDRevWith ::

1564− forall m a. (Monad m, Unboxed a)

1564+ forall m a. (Monad m, Unbox a)

1565 => (forall b. IO b -> m b) -> Array a -> D.Stream m a

1566toStreamDRevWith liftio Array{..} =

1567 let p = INDEX_PREV(arrEnd,a)

@@ -1581,12 +1581,12 @@ toStreamDRevWith liftio Array{..} =

1581--

1582-- We can try this if the unfold has any perf issues.

1583{-# INLINE_NORMAL toStreamDRev #-}

1584−toStreamDRev :: forall m a. (MonadIO m, Unboxed a) => Array a -> D.Stream m a

1584+toStreamDRev :: forall m a. (MonadIO m, Unbox a) => Array a -> D.Stream m a

1585toStreamDRev = toStreamDRevWith liftIO

1586

1587{-# INLINE toStreamKRevWith #-}

1588toStreamKRevWith ::

1589− forall m a. (Monad m, Unboxed a)

1589+ forall m a. (Monad m, Unbox a)

1590 => (forall b. IO b -> m b) -> Array a -> K.Stream m a

1591toStreamKRevWith liftio Array {..} =

1592 let p = INDEX_PREV(arrEnd,a)

@@ -1600,7 +1600,7 @@ toStreamKRevWith liftio Array {..} =

1600 in liftio elemM `K.consM` go (INDEX_PREV(p,a))

1601

1602{-# INLINE toStreamKRev #-}

1603−toStreamKRev :: forall m a. (MonadIO m, Unboxed a) => Array a -> K.Stream m a

1603+toStreamKRev :: forall m a. (MonadIO m, Unbox a) => Array a -> K.Stream m a

1604toStreamKRev = toStreamKRevWith liftIO

1605

1606-------------------------------------------------------------------------------

@@ -1612,12 +1612,12 @@ toStreamKRev = toStreamKRevWith liftIO

1612--

1613-- | Strict left fold of an array.

1614{-# INLINE_NORMAL foldl' #-}

1615−foldl' :: (MonadIO m, Unboxed a) => (b -> a -> b) -> b -> Array a -> m b

1615+foldl' :: (MonadIO m, Unbox a) => (b -> a -> b) -> b -> Array a -> m b

1616foldl' f z arr = D.foldl' f z $ toStreamD arr

1617

1618-- | Right fold of an array.

1619{-# INLINE_NORMAL foldr #-}

1620−foldr :: (MonadIO m, Unboxed a) => (a -> b -> b) -> b -> Array a -> m b

1620+foldr :: (MonadIO m, Unbox a) => (a -> b -> b) -> b -> Array a -> m b

1621foldr f z arr = D.foldr f z $ toStreamD arr

1622

1623-------------------------------------------------------------------------------

@@ -1641,7 +1641,7 @@ foldr f z arr = D.foldr f z $ toStreamD arr

1641--

1642-- /Internal/

1643{-# INLINE_NORMAL appendNUnsafe #-}

1644−appendNUnsafe :: forall m a. (MonadIO m, Unboxed a) =>

1644+appendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>

1645 m (Array a)

1646 -> Int

1647 -> Fold m a (Array a)

@@ -1673,7 +1673,7 @@ appendNUnsafe action n =

1673-- >>> appendN initial n = Fold.take n (Array.appendNUnsafe initial n)

1674--

1675{-# INLINE_NORMAL appendN #-}

1676−appendN :: forall m a. (MonadIO m, Unboxed a) =>

1676+appendN :: forall m a. (MonadIO m, Unbox a) =>

1677 m (Array a) -> Int -> Fold m a (Array a)

1678appendN initial n = FL.take n (appendNUnsafe initial n)

1679

@@ -1688,7 +1688,7 @@ appendN initial n = FL.take n (appendNUnsafe initial n)

1688--

1689-- /Pre-release/

1690{-# INLINE appendWith #-}

1691−appendWith :: forall m a. (MonadIO m, Unboxed a) =>

1691+appendWith :: forall m a. (MonadIO m, Unbox a) =>

1692 (Int -> Int) -> m (Array a) -> Fold m a (Array a)

1693appendWith sizer = FL.foldlM' (snocWith sizer)

1694

@@ -1701,7 +1701,7 @@ appendWith sizer = FL.foldlM' (snocWith sizer)

1701-- >>> append = Array.appendWith (* 2)

1702--

1703{-# INLINE append #-}

1704−append :: forall m a. (MonadIO m, Unboxed a) =>

1704+append :: forall m a. (MonadIO m, Unbox a) =>

1705 m (Array a) -> Fold m a (Array a)

1706append = appendWith (* 2)

1707

@@ -1715,7 +1715,7 @@ append = appendWith (* 2)

1715--

1716-- /Pre-release/

1717{-# INLINE_NORMAL writeNWithUnsafe #-}

1718−writeNWithUnsafe :: forall m a. (MonadIO m, Unboxed a)

1718+writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)

1719 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)

1720writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial

1721

@@ -1737,7 +1737,7 @@ writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial

1737-- >>> writeNUnsafe = Array.writeNWithUnsafe Array.newPinned

1738--

1739{-# INLINE_NORMAL writeNUnsafe #-}

1740−writeNUnsafe :: forall m a. (MonadIO m, Unboxed a)

1740+writeNUnsafe :: forall m a. (MonadIO m, Unbox a)

1741 => Int -> Fold m a (Array a)

1742writeNUnsafe = writeNWithUnsafe newPinned

1743

@@ -1748,7 +1748,7 @@ writeNUnsafe = writeNWithUnsafe newPinned

1748-- >>> writeNWith alloc n = Array.appendN (alloc n) n

1749--

1750{-# INLINE_NORMAL writeNWith #-}

1751−writeNWith :: forall m a. (MonadIO m, Unboxed a)

1751+writeNWith :: forall m a. (MonadIO m, Unbox a)

1752 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)

1753writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)

1754

@@ -1760,14 +1760,14 @@ writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)

1760-- >>> writeN n = Array.appendN (Array.newPinned n) n

1761--

1762{-# INLINE_NORMAL writeN #-}

1763−writeN :: forall m a. (MonadIO m, Unboxed a) => Int -> Fold m a (Array a)

1763+writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)

1764writeN = writeNWith newPinned

1765

1766-- | Like writeNWithUnsafe but writes the array in reverse order.

1767--

1768-- /Internal/

1769{-# INLINE_NORMAL writeRevNWithUnsafe #-}

1770−writeRevNWithUnsafe :: forall m a. (MonadIO m, Unboxed a)

1770+writeRevNWithUnsafe :: forall m a. (MonadIO m, Unbox a)

1771 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)

1772writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial

1773

@@ -1788,7 +1788,7 @@ writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial

1788--

1789-- /Internal/

1790{-# INLINE_NORMAL writeRevNWith #-}

1791−writeRevNWith :: forall m a. (MonadIO m, Unboxed a)

1791+writeRevNWith :: forall m a. (MonadIO m, Unbox a)

1792 => (Int -> m (Array a)) -> Int -> Fold m a (Array a)

1793writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)

1794

@@ -1796,7 +1796,7 @@ writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)

1796--

1797-- /Pre-release/

1798{-# INLINE_NORMAL writeRevN #-}

1799−writeRevN :: forall m a. (MonadIO m, Unboxed a) => Int -> Fold m a (Array a)

1799+writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)

1800writeRevN = writeRevNWith newPinned

1801

1802-- | @writeNAligned align n@ folds a maximum of @n@ elements from the input

@@ -1808,7 +1808,7 @@ writeRevN = writeRevNWith newPinned

1808-- /Pre-release/

1809--

1810{-# INLINE_NORMAL writeNAligned #-}

1811−writeNAligned :: forall m a. (MonadIO m, Unboxed a)

1811+writeNAligned :: forall m a. (MonadIO m, Unbox a)

1812 => Int -> Int -> Fold m a (Array a)

1813writeNAligned align = writeNWith (newAlignedPinned align)

1814

@@ -1826,7 +1826,7 @@ writeNAligned align = writeNWith (newAlignedPinned align)

1826-- /Unimplemented/

1827--

1828{-# INLINE_NORMAL writeChunks #-}

1829−writeChunks :: (MonadIO m, Unboxed a) =>

1829+writeChunks :: (MonadIO m, Unbox a) =>

1830 Int -> Fold m a (K.Stream n (Array a))

1831writeChunks n = FL.many (writeN n) FL.toStreamK

1832

@@ -1859,7 +1859,7 @@ writeChunks n = FL.many (writeN n) FL.toStreamK

1859--

1860-- /Pre-release/

1861{-# INLINE_NORMAL writeWith #-}

1862−writeWith :: forall m a. (MonadIO m, Unboxed a)

1862+writeWith :: forall m a. (MonadIO m, Unbox a)

1863 => Int -> Fold m a (Array a)

1864-- writeWith n = FL.rmapM rightSize $ appendWith (* 2) (newPinned n)

1865writeWith elemCount =

@@ -1897,7 +1897,7 @@ writeWith elemCount =

1897-- /Caution! Do not use this on infinite streams./

1898--

1899{-# INLINE write #-}

1900−write :: forall m a. (MonadIO m, Unboxed a) => Fold m a (Array a)

1900+write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)

1901write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)

1902

1903-------------------------------------------------------------------------------

@@ -1909,7 +1909,7 @@ write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)

1909-- >>> fromStreamDN n = StreamD.fold (Array.writeN n)

1910--

1911{-# INLINE_NORMAL fromStreamDN #-}

1912−fromStreamDN :: forall m a. (MonadIO m, Unboxed a)

1912+fromStreamDN :: forall m a. (MonadIO m, Unbox a)

1913 => Int -> D.Stream m a -> m (Array a)

1914-- fromStreamDN n = D.fold (writeN n)

1915fromStreamDN limit str = do

@@ -1928,14 +1928,14 @@ fromStreamDN limit str = do

1928-- array may hold less than N elements.

1929--

1930{-# INLINABLE fromListN #-}

1931−fromListN :: (MonadIO m, Unboxed a) => Int -> [a] -> m (Array a)

1931+fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (Array a)

1932fromListN n xs = fromStreamDN n $ D.fromList xs

1933

1934-- | Like fromListN but writes the array in reverse order.

1935--

1936-- /Pre-release/

1937{-# INLINE fromListRevN #-}

1938−fromListRevN :: (MonadIO m, Unboxed a) => Int -> [a] -> m (Array a)

1938+fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (Array a)

1939fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs

1940

1941-------------------------------------------------------------------------------

@@ -1943,14 +1943,14 @@ fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs

1943-------------------------------------------------------------------------------

1944

1945{-# INLINE arrayStreamKLength #-}

1946−arrayStreamKLength :: (Monad m, Unboxed a) => K.Stream m (Array a) -> m Int

1946+arrayStreamKLength :: (Monad m, Unbox a) => K.Stream m (Array a) -> m Int

1947arrayStreamKLength as = K.foldl' (+) 0 (K.map length as)

1948

1949-- | Convert an array stream to an array. Note that this requires peak memory

1950-- that is double the size of the array stream.

1951--

1952{-# INLINE fromArrayStreamK #-}

1953−fromArrayStreamK :: (Unboxed a, MonadIO m) =>

1953+fromArrayStreamK :: (Unbox a, MonadIO m) =>

1954 K.Stream m (Array a) -> m (Array a)

1955fromArrayStreamK as = do

1956 len <- arrayStreamKLength as

@@ -1970,13 +1970,13 @@ fromArrayStreamK as = do

1970-- >>> fromStreamD = StreamD.fold Array.write

1971--

1972{-# INLINE fromStreamD #-}

1973−fromStreamD :: (MonadIO m, Unboxed a) => D.Stream m a -> m (Array a)

1973+fromStreamD :: (MonadIO m, Unbox a) => D.Stream m a -> m (Array a)

1974fromStreamD m = arrayStreamKFromStreamD m >>= fromArrayStreamK

1975

1976-- | Create an 'Array' from a list. The list must be of finite size.

1977--

1978{-# INLINE fromList #-}

1979−fromList :: (MonadIO m, Unboxed a) => [a] -> m (Array a)

1979+fromList :: (MonadIO m, Unbox a) => [a] -> m (Array a)

1980fromList xs = fromStreamD $ D.fromList xs

1981

1982-- XXX We are materializing the whole list first for getting the length. Check

@@ -1984,7 +1984,7 @@ fromList xs = fromStreamD $ D.fromList xs

1984

1985-- | Like 'fromList' but writes the contents of the list in reverse order.

1986{-# INLINE fromListRev #-}

1987−fromListRev :: (MonadIO m, Unboxed a) => [a] -> m (Array a)

1987+fromListRev :: (MonadIO m, Unbox a) => [a] -> m (Array a)

1988fromListRev xs = fromListRevN (Prelude.length xs) xs

1989

1990-------------------------------------------------------------------------------

@@ -2009,7 +2009,7 @@ putSliceUnsafe src srcStartBytes dst dstStartBytes lenBytes = liftIO $ do

2009

2010-- | Copy two arrays into a newly allocated array.

2011{-# INLINE spliceCopy #-}

2012−spliceCopy :: forall m a. (MonadIO m, Unboxed a) =>

2012+spliceCopy :: forall m a. (MonadIO m, Unbox a) =>

2013 Array a -> Array a -> m (Array a)

2014spliceCopy arr1 arr2 = liftIO $ do

2015 let start1 = arrStart arr1

@@ -2051,7 +2051,7 @@ spliceUnsafe dst src =

2051--

2052-- /Pre-release/

2053{-# INLINE spliceWith #-}

2054−spliceWith :: forall m a. (MonadIO m, Unboxed a) =>

2054+spliceWith :: forall m a. (MonadIO m, Unbox a) =>

2055 (Int -> Int -> Int) -> Array a -> Array a -> m (Array a)

2056spliceWith sizer dst@(Array _ start end bound) src = do

2057{-

@@ -2085,7 +2085,7 @@ spliceWith sizer dst@(Array _ start end bound) src = do

2085--

2086-- /Pre-release/

2087{-# INLINE splice #-}

2088−splice :: (MonadIO m, Unboxed a) => Array a -> Array a -> m (Array a)

2088+splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)

2089splice = spliceWith (+)

2090

2091-- | Like 'append' but the growth of the array is exponential. Whenever a new

@@ -2099,7 +2099,7 @@ splice = spliceWith (+)

2099--

2100-- /Pre-release/

2101{-# INLINE spliceExp #-}

2102−spliceExp :: (MonadIO m, Unboxed a) => Array a -> Array a -> m (Array a)

2102+spliceExp :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)

2103spliceExp = spliceWith (\l1 l2 -> max (l1 * 2) (l1 + l2))

2104

2105-------------------------------------------------------------------------------

@@ -2137,7 +2137,7 @@ breakOn sep arr@Array{..} = asPtrUnsafe arr $ \p -> liftIO $ do

2137-- | Create two slices of an array without copying the original array. The

2138-- specified index @i@ is the first index of the second slice.

2139--

2140−splitAt :: forall a. Unboxed a => Int -> Array a -> (Array a, Array a)

2140+splitAt :: forall a. Unbox a => Int -> Array a -> (Array a, Array a)

2141splitAt i arr@Array{..} =

2142 let maxIndex = length arr - 1

2143 in if i < 0

@@ -2189,7 +2189,7 @@ asBytes = castUnsafe

2189-- type @b@. The length of the array should be a multiple of the size of the

2190-- target element otherwise 'Nothing' is returned.

2191--

2192−cast :: forall a b. Unboxed b => Array a -> Maybe (Array b)

2192+cast :: forall a b. Unbox b => Array a -> Maybe (Array b)

2193cast arr =

2194 let len = byteLength arr

2195 r = len `mod` SIZE_OF(b)

@@ -2278,7 +2278,7 @@ cmp arr1 arr2 =

2278-- NFData

2279-------------------------------------------------------------------------------

2280

2281−-- This is an Unboxed array, we cannot have unevaluated data in it so this is

2281+-- This is an Unbox array, we cannot have unevaluated data in it so this is

2282-- just a no op.

2283instance NFData (Array a) where

2284 {-# INLINE rnf #-}

@@ -2292,7 +2292,7 @@ instance NFData1 Array where

2292--

2293-- /Pre-release/

2294{-# INLINE strip #-}

2295−strip :: forall a m. (Unboxed a, MonadIO m) =>

2295+strip :: forall a m. (Unbox a, MonadIO m) =>

2296 (a -> Bool) -> Array a -> m (Array a)

2297strip eq arr@Array{..} = liftIO $ do

2298 st <- getStart arrStart

@@ -2336,7 +2336,7 @@ strip eq arr@Array{..} = liftIO $ do

2336--

2337-- /Pre-release/

2338{-# INLINE bubble #-}

2339−bubble :: (MonadIO m, Unboxed a) => (a -> a -> Ordering) -> Array a -> m ()

2339+bubble :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Array a -> m ()

2340bubble cmp0 arr =

2341 when (l > 1) $ do

2342 x <- getIndexUnsafe (l - 1) arr

core/src/Streamly/Internal/Data/Array/Unboxed/Stream.hs+32−32

@@ -55,7 +55,7 @@ import Control.Exception (assert)

55import Control.Monad.Catch (MonadThrow, throwM)

56import Control.Monad.IO.Class (MonadIO(..))

57import Data.Word (Word8)

58−import Streamly.Internal.Data.Unboxed (Unboxed, peekWith, sizeOf)

58+import Streamly.Internal.Data.Unboxed (Unbox, peekWith, sizeOf)

59import Fusion.Plugin.Types (Fuse(..))

60import GHC.Exts (SpecConstrAnnotation(..))

61import GHC.Types (SPEC(..))

@@ -107,7 +107,7 @@ import qualified Streamly.Internal.Data.Stream.StreamK.Type as K

107--

108-- /Pre-release/

109{-# INLINE arraysOf #-}

110−arraysOf :: (MonadIO m, Unboxed a)

110+arraysOf :: (MonadIO m, Unbox a)

111 => Int -> Stream m a -> Stream m (Array a)

112arraysOf n str = fromStreamD $ A.arraysOf n (toStreamD str)

113

@@ -127,7 +127,7 @@ arraysOf n str = fromStreamD $ A.arraysOf n (toStreamD str)

127--

128-- @since 0.7.0

129{-# INLINE concat #-}

130−concat :: (Monad m, Unboxed a) => Stream m (Array a) -> Stream m a

130+concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a

131-- concat m = fromStreamD $ A.flattenArrays (toStreamD m)

132-- concat m = fromStreamD $ D.concatMap A.toStreamD (toStreamD m)

133concat m = fromStreamD $ D.unfoldMany A.reader (toStreamD m)

@@ -139,7 +139,7 @@ concat m = fromStreamD $ D.unfoldMany A.reader (toStreamD m)

139--

140-- @since 0.7.0

141{-# INLINE concatRev #-}

142−concatRev :: (Monad m, Unboxed a) => Stream m (Array a) -> Stream m a

142+concatRev :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a

143-- concatRev m = fromStreamD $ A.flattenArraysRev (toStreamD m)

144concatRev m = fromStreamD $ D.unfoldMany A.readerRev (toStreamD m)

145

@@ -152,11 +152,11 @@ concatRev m = fromStreamD $ D.unfoldMany A.readerRev (toStreamD m)

152--

153-- /Pre-release/

154{-# INLINE interpose #-}

155−interpose :: (Monad m, Unboxed a) => a -> Stream m (Array a) -> Stream m a

155+interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a

156interpose x = S.interpose x A.reader

157

158{-# INLINE intercalateSuffix #-}

159−intercalateSuffix :: (Monad m, Unboxed a)

159+intercalateSuffix :: (Monad m, Unbox a)

160 => Array a -> Stream m (Array a) -> Stream m a

161intercalateSuffix = S.intercalateSuffix A.reader

162

@@ -165,7 +165,7 @@ intercalateSuffix = S.intercalateSuffix A.reader

165--

166-- @since 0.7.0

167{-# INLINE interposeSuffix #-}

168−interposeSuffix :: (Monad m, Unboxed a)

168+interposeSuffix :: (Monad m, Unbox a)

169 => a -> Stream m (Array a) -> Stream m a

170-- interposeSuffix x = fromStreamD . A.unlines x . toStreamD

171interposeSuffix x = S.interposeSuffix x A.reader

@@ -176,7 +176,7 @@ data FlattenState s a =

176

177-- XXX Remove monadIO constraint

178{-# INLINE_NORMAL unlines #-}

179−unlines :: forall m a. (MonadIO m, Unboxed a)

179+unlines :: forall m a. (MonadIO m, Unbox a)

180 => a -> D.Stream m (Array a) -> D.Stream m a

181unlines sep (D.Stream step state) = D.Stream step' (OuterLoop state)

182 where

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

204-- module Streamly.Internal.Data.Array.Unboxed.Mut.Stream

205--

206{-# INLINE_NORMAL packArraysChunksOf #-}

207−packArraysChunksOf :: (MonadIO m, Unboxed a)

207+packArraysChunksOf :: (MonadIO m, Unbox a)

208 => Int -> D.Stream m (Array a) -> D.Stream m (Array a)

209packArraysChunksOf n str =

210 D.map A.unsafeFreeze $ AS.packArraysChunksOf n $ D.map A.unsafeThaw str

@@ -212,7 +212,7 @@ packArraysChunksOf n str =

212-- XXX instead of writing two different versions of this operation, we should

213-- write it as a pipe.

214{-# INLINE_NORMAL lpackArraysChunksOf #-}

215−lpackArraysChunksOf :: (MonadIO m, Unboxed a)

215+lpackArraysChunksOf :: (MonadIO m, Unbox a)

216 => Int -> Fold m (Array a) () -> Fold m (Array a) ()

217lpackArraysChunksOf n fld =

218 FL.lmap A.unsafeThaw $ AS.lpackArraysChunksOf n (FL.lmap A.unsafeFreeze fld)

@@ -222,7 +222,7 @@ lpackArraysChunksOf n fld =

222--

223-- @since 0.7.0

224{-# INLINE compact #-}

225−compact :: (MonadIO m, Unboxed a)

225+compact :: (MonadIO m, Unbox a)

226 => Int -> Stream m (Array a) -> Stream m (Array a)

227compact n xs = fromStreamD $ packArraysChunksOf n (toStreamD xs)

228

@@ -319,7 +319,7 @@ splitOnSuffix byte s =

319-- to the number of times it can be called on the same stream.

320--

321{-# INLINE_NORMAL foldBreakD #-}

322−foldBreakD :: forall m a b. (MonadIO m, Unboxed a) =>

322+foldBreakD :: forall m a b. (MonadIO m, Unbox a) =>

323 Fold m a b -> D.Stream m (Array a) -> m (b, D.Stream m (Array a))

324foldBreakD (FL.Fold fstep initial extract) stream@(D.Stream step state) = do

325 res <- initial

@@ -355,7 +355,7 @@ foldBreakD (FL.Fold fstep initial extract) stream@(D.Stream step state) = do

355 FL.Partial fs1 -> goArray SPEC st fp next fs1

356

357{-# INLINE_NORMAL foldBreakK #-}

358−foldBreakK :: forall m a b. (MonadIO m, Unboxed a) =>

358+foldBreakK :: forall m a b. (MonadIO m, Unbox a) =>

359 Fold m a b -> K.Stream m (Array a) -> m (b, K.Stream m (Array a))

360foldBreakK (FL.Fold fstep initial extract) stream = do

361 res <- initial

@@ -396,7 +396,7 @@ foldBreakK (FL.Fold fstep initial extract) stream = do

396--

397{-# INLINE_NORMAL foldBreak #-}

398foldBreak ::

399− (MonadIO m, Unboxed a)

399+ (MonadIO m, Unbox a)

400 => Fold m a b

401 -> Stream m (A.Array a)

402 -> m (b, Stream m (A.Array a))

@@ -415,7 +415,7 @@ foldBreak f =

415

416-- When we have to take an array partially, take the last part of the array.

417{-# INLINE takeArrayListRev #-}

418−takeArrayListRev :: forall a. Unboxed a => Int -> [Array a] -> [Array a]

418+takeArrayListRev :: forall a. Unbox a => Int -> [Array a] -> [Array a]

419takeArrayListRev = go

420

421 where

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

436-- the first split.

437{-# INLINE splitAtArrayListRev #-}

438splitAtArrayListRev ::

439− forall a. Unboxed a => Int -> [Array a] -> ([Array a],[Array a])

439+ forall a. Unbox a => Int -> [Array a] -> ([Array a],[Array a])

440splitAtArrayListRev n ls

441 | n <= 0 = ([], ls)

442 | otherwise = go n ls

@@ -470,14 +470,14 @@ foldlM' step begin = D.foldlM' step begin . S.toStreamD

470-- CAUTION! length must more than equal to lengths of all the arrays in the

471-- stream.

472{-# INLINE spliceArraysLenUnsafe #-}

473−spliceArraysLenUnsafe :: (MonadIO m, Unboxed a)

473+spliceArraysLenUnsafe :: (MonadIO m, Unbox a)

474 => Int -> Stream m (MA.Array a) -> m (MA.Array a)

475spliceArraysLenUnsafe len buffered = do

476 arr <- liftIO $ MA.newPinned len

477 foldlM' MA.spliceUnsafe (return arr) buffered

478

479{-# INLINE _spliceArrays #-}

480−_spliceArrays :: (MonadIO m, Unboxed a)

480+_spliceArrays :: (MonadIO m, Unbox a)

481 => Stream m (Array a) -> m (Array a)

482_spliceArrays s = do

483 buffered <- S.foldr S.cons S.nil s

@@ -491,7 +491,7 @@ _spliceArrays s = do

491 writeArr dst arr = MA.spliceUnsafe dst (A.unsafeThaw arr)

492

493{-# INLINE _spliceArraysBuffered #-}

494−_spliceArraysBuffered :: (MonadIO m, Unboxed a)

494+_spliceArraysBuffered :: (MonadIO m, Unbox a)

495 => Stream m (Array a) -> m (Array a)

496_spliceArraysBuffered s = do

497 buffered <- S.foldr S.cons S.nil s

@@ -499,7 +499,7 @@ _spliceArraysBuffered s = do

499 A.unsafeFreeze <$> spliceArraysLenUnsafe len (fmap A.unsafeThaw s)

500

501{-# INLINE spliceArraysRealloced #-}

502−spliceArraysRealloced :: forall m a. (MonadIO m, Unboxed a)

502+spliceArraysRealloced :: forall m a. (MonadIO m, Unbox a)

503 => Stream m (Array a) -> m (Array a)

504spliceArraysRealloced s = do

505 let n = allocBytesToElemCount (undefined :: a) (4 * 1024)

@@ -515,7 +515,7 @@ spliceArraysRealloced s = do

515--

516-- @since 0.7.0

517{-# INLINE toArray #-}

518−toArray :: (MonadIO m, Unboxed a) => Stream m (Array a) -> m (Array a)

518+toArray :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)

519toArray = spliceArraysRealloced

520-- spliceArrays = _spliceArraysBuffered

521

@@ -526,7 +526,7 @@ toArray = spliceArraysRealloced

526--

527{-

528{-# INLINE toArraysInRange #-}

529−toArraysInRange :: (MonadIO m, Unboxed a)

529+toArraysInRange :: (MonadIO m, Unbox a)

530 => Int -> Int -> Fold m (Array a) b -> Fold m a b

531toArraysInRange low high (Fold step initial extract) =

532-}

@@ -534,7 +534,7 @@ toArraysInRange low high (Fold step initial extract) =

534{-

535-- | Fold the input to a pure buffered stream (List) of arrays.

536{-# INLINE _toArraysOf #-}

537−_toArraysOf :: (MonadIO m, Unboxed a)

537+_toArraysOf :: (MonadIO m, Unbox a)

538 => Int -> Fold m a (Stream Identity (Array a))

539_toArraysOf n = FL.chunksOf n (A.writeNF n) FL.toStream

540-}

@@ -556,7 +556,7 @@ newtype List a = List {getList :: [a]}

556-- to the number of times it can be called on the same stream.

557{-# INLINE_NORMAL parseBreakD #-}

558parseBreakD ::

559− forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

559+ forall m a b. (MonadIO m, MonadThrow m, Unbox a)

560 => PRD.Parser m a b

561 -> D.Stream m (Array.Array a)

562 -> m (b, D.Stream m (Array.Array a))

@@ -637,7 +637,7 @@ parseBreakD

637

638{-# INLINE_NORMAL parseBreakK #-}

639parseBreakK ::

640− forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

640+ forall m a b. (MonadIO m, MonadThrow m, Unbox a)

641 => PRD.Parser m a b

642 -> K.Stream m (Array.Array a)

643 -> m (b, K.Stream m (Array.Array a))

@@ -772,7 +772,7 @@ parseBreakK (PRD.Parser pstep initial extract) stream = do

772--

773{-# INLINE_NORMAL parseBreak #-}

774parseBreak ::

775− (MonadIO m, MonadThrow m, Unboxed a)

775+ (MonadIO m, MonadThrow m, Unbox a)

776 => PR.Parser m a b

777 -> Stream m (A.Array a)

778 -> m (b, Stream m (A.Array a))

@@ -798,7 +798,7 @@ parseBreak p =

798--

799{-# INLINE_NORMAL runArrayParserDBreak #-}

800runArrayParserDBreak ::

801− forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

801+ forall m a b. (MonadIO m, MonadThrow m, Unbox a)

802 => PRD.Parser m (Array a) b

803 -> D.Stream m (Array.Array a)

804 -> m (b, D.Stream m (Array.Array a))

@@ -927,7 +927,7 @@ runArrayParserDBreak

927--

928{-# INLINE parseArr #-}

929parseArr ::

930− (MonadIO m, MonadThrow m, Unboxed a)

930+ (MonadIO m, MonadThrow m, Unbox a)

931 => ASF.Parser m a b

932 -> Stream m (A.Array a)

933 -> m (b, Stream m (A.Array a))

@@ -939,7 +939,7 @@ parseArr p s = fmap fromStreamD <$> parseBreakD p (toStreamD s)

939-- /Pre-release/

940--

941{-# INLINE runArrayFold #-}

942−runArrayFold :: (MonadIO m, MonadThrow m, Unboxed a) =>

942+runArrayFold :: (MonadIO m, MonadThrow m, Unbox a) =>

943 ArrayFold m a b -> Stream m (A.Array a) -> m b

944runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

945

@@ -948,7 +948,7 @@ runArrayFold (ArrayFold p) s = fst <$> runArrayParserDBreak p (toStreamD s)

948-- /Pre-release/

949--

950{-# INLINE runArrayFoldBreak #-}

951−runArrayFoldBreak :: (MonadIO m, MonadThrow m, Unboxed a) =>

951+runArrayFoldBreak :: (MonadIO m, MonadThrow m, Unbox a) =>

952 ArrayFold m a b -> Stream m (A.Array a) -> m (b, Stream m (A.Array a))

953runArrayFoldBreak (ArrayFold p) s =

954 second fromStreamD <$> runArrayParserDBreak p (toStreamD s)

@@ -966,7 +966,7 @@ data ParseChunksState x inpBuf st pst =

966

967{-# INLINE_NORMAL runArrayFoldManyD #-}

968runArrayFoldManyD

969− :: (MonadThrow m, Unboxed a)

969+ :: (MonadThrow m, Unbox a)

970 => ArrayFold m a b

971 -> D.Stream m (Array a)

972 -> D.Stream m b

@@ -1151,7 +1151,7 @@ runArrayFoldManyD

1151-- /Pre-release/

1152{-# INLINE runArrayFoldMany #-}

1153runArrayFoldMany

1154− :: (MonadThrow m, Unboxed a)

1154+ :: (MonadThrow m, Unbox a)

1155 => ArrayFold m a b

1156 -> Stream m (Array a)

1157 -> Stream m b

core/src/Streamly/Internal/Data/Array/Unboxed/Type.hs+45−45

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

90import Streamly.Internal.Data.Array.Unboxed.Mut.Type (MutableByteArray)

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

92import Streamly.Internal.Data.Stream.Type (Stream)

93−import Streamly.Internal.Data.Unboxed (Unboxed, peekWith, sizeOf)

93+import Streamly.Internal.Data.Unboxed (Unbox, peekWith, sizeOf)

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

95import Text.Read (readPrec, readListPrec, readListPrecDefault)

@@ -128,7 +128,7 @@ import Streamly.Internal.System.IO (unsafeInlineIO, defaultChunkSize)

128--

129data Array a =

130#ifdef DEVBUILD

131− Unboxed a =>

131+ Unbox a =>

132#endif

133 -- All offsets are in terms of bytes from the start of arraycontents

134 Array

@@ -176,7 +176,7 @@ unsafeFreeze (MA.Array ac as ae _) = Array ac as ae

176-- | Similar to 'unsafeFreeze' but uses 'MA.rightSize' on the mutable array

177-- first.

178{-# INLINE unsafeFreezeWithShrink #-}

179−unsafeFreezeWithShrink :: Unboxed a => MA.Array a -> Array a

179+unsafeFreezeWithShrink :: Unbox a => MA.Array a -> Array a

180unsafeFreezeWithShrink arr = unsafePerformIO $ do

181 MA.Array ac as ae _ <- MA.rightSize arr

182 return $ Array ac as ae

@@ -211,7 +211,7 @@ unpin = fmap unsafeFreeze . MA.unpin . unsafeThaw

211

212-- Splice two immutable arrays creating a new array.

213{-# INLINE splice #-}

214−splice :: (MonadIO m, Unboxed a) => Array a -> Array a -> m (Array a)

214+splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)

215splice arr1 arr2 =

216 unsafeFreeze <$> MA.splice (unsafeThaw arr1) (unsafeThaw arr2)

217

@@ -220,7 +220,7 @@ splice arr1 arr2 =

220-- array may hold less than N elements.

221--

222{-# INLINABLE fromListN #-}

223−fromListN :: Unboxed a => Int -> [a] -> Array a

223+fromListN :: Unbox a => Int -> [a] -> Array a

224fromListN n xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListN n xs

225

226-- | Create an 'Array' from the first N elements of a list in reverse order.

@@ -229,13 +229,13 @@ fromListN n xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListN n xs

229--

230-- /Pre-release/

231{-# INLINABLE fromListRevN #-}

232−fromListRevN :: Unboxed a => Int -> [a] -> Array a

232+fromListRevN :: Unbox a => Int -> [a] -> Array a

233fromListRevN n xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListRevN n xs

234

235-- | Create an 'Array' from a list. The list must be of finite size.

236--

237{-# INLINE fromList #-}

238−fromList :: Unboxed a => [a] -> Array a

238+fromList :: Unbox a => [a] -> Array a

239fromList xs = unsafePerformIO $ unsafeFreeze <$> MA.fromList xs

240

241-- | Create an 'Array' from a list in reverse order. The list must be of finite

@@ -243,16 +243,16 @@ fromList xs = unsafePerformIO $ unsafeFreeze <$> MA.fromList xs

243--

244-- /Pre-release/

245{-# INLINABLE fromListRev #-}

246−fromListRev :: Unboxed a => [a] -> Array a

246+fromListRev :: Unbox a => [a] -> Array a

247fromListRev xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListRev xs

248

249{-# INLINE_NORMAL fromStreamDN #-}

250−fromStreamDN :: forall m a. (MonadIO m, Unboxed a)

250+fromStreamDN :: forall m a. (MonadIO m, Unbox a)

251 => Int -> D.Stream m a -> m (Array a)

252fromStreamDN limit str = unsafeFreeze <$> MA.fromStreamDN limit str

253

254{-# INLINE_NORMAL fromStreamD #-}

255−fromStreamD :: forall m a. (MonadIO m, Unboxed a)

255+fromStreamD :: forall m a. (MonadIO m, Unbox a)

256 => D.Stream m a -> m (Array a)

257fromStreamD str = unsafeFreeze <$> MA.fromStreamD str

258

@@ -261,14 +261,14 @@ fromStreamD str = unsafeFreeze <$> MA.fromStreamD str

261-------------------------------------------------------------------------------

262

263{-# INLINE bufferChunks #-}

264−bufferChunks :: (MonadIO m, Unboxed a) =>

264+bufferChunks :: (MonadIO m, Unbox a) =>

265 D.Stream m a -> m (K.Stream m (Array a))

266bufferChunks m = D.foldr K.cons K.nil $ arraysOf defaultChunkSize m

267

268-- | @arraysOf n stream@ groups the input stream into a stream of

269-- arrays of size n.

270{-# INLINE_NORMAL arraysOf #-}

271−arraysOf :: forall m a. (MonadIO m, Unboxed a)

271+arraysOf :: forall m a. (MonadIO m, Unbox a)

272 => Int -> D.Stream m a -> D.Stream m (Array a)

273arraysOf n str = D.map unsafeFreeze $ MA.arraysOf n str

274

@@ -279,7 +279,7 @@ arraysOf n str = D.map unsafeFreeze $ MA.arraysOf n str

279-- We can try this if there are any fusion issues in the unfold.

280--

281{-# INLINE_NORMAL flattenArrays #-}

282−flattenArrays :: forall m a. (MonadIO m, Unboxed a)

282+flattenArrays :: forall m a. (MonadIO m, Unbox a)

283 => D.Stream m (Array a) -> D.Stream m a

284flattenArrays = MA.flattenArrays . D.map unsafeThaw

285

@@ -290,7 +290,7 @@ flattenArrays = MA.flattenArrays . D.map unsafeThaw

290-- We can try this if there are any fusion issues in the unfold.

291--

292{-# INLINE_NORMAL flattenArraysRev #-}

293−flattenArraysRev :: forall m a. (MonadIO m, Unboxed a)

293+flattenArraysRev :: forall m a. (MonadIO m, Unbox a)

294 => D.Stream m (Array a) -> D.Stream m a

295flattenArraysRev = MA.flattenArraysRev . D.map unsafeThaw

296

@@ -310,12 +310,12 @@ breakOn sep arr = do

310--

311-- Unsafe because it does not check the bounds of the array.

312{-# INLINE_NORMAL unsafeIndexIO #-}

313−unsafeIndexIO :: forall a. Unboxed a => Int -> Array a -> IO a

313+unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a

314unsafeIndexIO i arr = MA.getIndexUnsafe i (unsafeThaw arr)

315

316-- | Return element at the specified index without checking the bounds.

317{-# INLINE_NORMAL unsafeIndex #-}

318−unsafeIndex :: forall a. Unboxed a => Int -> Array a -> a

318+unsafeIndex :: forall a. Unbox a => Int -> Array a -> a

319unsafeIndex i arr = let !r = unsafeInlineIO $ unsafeIndexIO i arr in r

320

321-- | /O(1)/ Get the byte length of the array.

@@ -328,30 +328,30 @@ byteLength = MA.byteLength . unsafeThaw

328-- array.

329--

330{-# INLINE length #-}

331−length :: Unboxed a => Array a -> Int

331+length :: Unbox a => Array a -> Int

332length arr = MA.length (unsafeThaw arr)

333

334-- | Unfold an array into a stream in reverse order.

335--

336{-# INLINE_NORMAL readerRev #-}

337−readerRev :: forall m a. (Monad m, Unboxed a) => Unfold m (Array a) a

337+readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a

338readerRev = Unfold.lmap unsafeThaw $ MA.readerRevWith (return . unsafeInlineIO)

339

340{-# INLINE_NORMAL toStreamD #-}

341−toStreamD :: forall m a. (Monad m, Unboxed a) => Array a -> D.Stream m a

341+toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> D.Stream m a

342toStreamD arr = MA.toStreamDWith (return . unsafeInlineIO) (unsafeThaw arr)

343

344{-# INLINE toStreamK #-}

345−toStreamK :: forall m a. (Monad m, Unboxed a) => Array a -> K.Stream m a

345+toStreamK :: forall m a. (Monad m, Unbox a) => Array a -> K.Stream m a

346toStreamK arr = MA.toStreamKWith (return . unsafeInlineIO) (unsafeThaw arr)

347

348{-# INLINE_NORMAL toStreamDRev #-}

349−toStreamDRev :: forall m a. (Monad m, Unboxed a) => Array a -> D.Stream m a

349+toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> D.Stream m a

350toStreamDRev arr =

351 MA.toStreamDRevWith (return . unsafeInlineIO) (unsafeThaw arr)

352

353{-# INLINE toStreamKRev #-}

354−toStreamKRev :: forall m a. (Monad m, Unboxed a) => Array a -> K.Stream m a

354+toStreamKRev :: forall m a. (Monad m, Unbox a) => Array a -> K.Stream m a

355toStreamKRev arr =

356 MA.toStreamKRevWith (return . unsafeInlineIO) (unsafeThaw arr)

357

@@ -359,14 +359,14 @@ toStreamKRev arr =

359--

360-- /Pre-release/

361{-# INLINE_EARLY read #-}

362−read :: (Monad m, Unboxed a) => Array a -> Stream m a

362+read :: (Monad m, Unbox a) => Array a -> Stream m a

363read = Stream.fromStreamD . toStreamD

364

365-- | Same as 'read'

366--

367{-# DEPRECATED toStream "Please use 'read' instead." #-}

368{-# INLINE_EARLY toStream #-}

369−toStream :: (Monad m, Unboxed a) => Array a -> Stream m a

369+toStream :: (Monad m, Unbox a) => Array a -> Stream m a

370toStream = read

371-- XXX add fallback to StreamK rule

372-- {-# RULES "Streamly.Array.read fallback to StreamK" [1]

@@ -376,14 +376,14 @@ toStream = read

376--

377-- /Pre-release/

378{-# INLINE_EARLY readRev #-}

379−readRev :: (Monad m, Unboxed a) => Array a -> Stream m a

379+readRev :: (Monad m, Unbox a) => Array a -> Stream m a

380readRev = Stream.fromStreamD . toStreamDRev

381

382-- | Same as 'readRev'

383--

384{-# DEPRECATED toStreamRev "Please use 'readRev' instead." #-}

385{-# INLINE_EARLY toStreamRev #-}

386−toStreamRev :: (Monad m, Unboxed a) => Array a -> Stream m a

386+toStreamRev :: (Monad m, Unbox a) => Array a -> Stream m a

387toStreamRev = readRev

388

389-- XXX add fallback to StreamK rule

@@ -391,17 +391,17 @@ toStreamRev = readRev

391-- forall a. S.toStreamK (readRev a) = K.revFromArray a #-}

392

393{-# INLINE_NORMAL foldl' #-}

394−foldl' :: forall a b. Unboxed a => (b -> a -> b) -> b -> Array a -> b

394+foldl' :: forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b

395foldl' f z arr = runIdentity $ D.foldl' f z $ toStreamD arr

396

397{-# INLINE_NORMAL foldr #-}

398−foldr :: Unboxed a => (a -> b -> b) -> b -> Array a -> b

398+foldr :: Unbox a => (a -> b -> b) -> b -> Array a -> b

399foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr

400

401-- | Create two slices of an array without copying the original array. The

402-- specified index @i@ is the first index of the second slice.

403--

404−splitAt :: Unboxed a => Int -> Array a -> (Array a, Array a)

404+splitAt :: Unbox a => Int -> Array a -> (Array a, Array a)

405splitAt i arr = (unsafeFreeze a, unsafeFreeze b)

406 where

407 (a, b) = MA.splitAt i (unsafeThaw arr)

@@ -409,7 +409,7 @@ splitAt i arr = (unsafeFreeze a, unsafeFreeze b)

409-- Use foldr/build fusion to fuse with list consumers

410-- This can be useful when using the IsList instance

411{-# INLINE_LATE toListFB #-}

412−toListFB :: forall a b. Unboxed a => (a -> b -> b) -> b -> Array a -> b

412+toListFB :: forall a b. Unbox a => (a -> b -> b) -> b -> Array a -> b

413toListFB c n Array{..} = go arrStart

414 where

415

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

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

428--

429{-# INLINE toList #-}

430−toList :: Unboxed a => Array a -> [a]

430+toList :: Unbox a => Array a -> [a]

431toList s = build (\c n -> toListFB c n s)

432

433-------------------------------------------------------------------------------

@@ -438,7 +438,7 @@ toList s = build (\c n -> toListFB c n s)

438-- 'Array'.

439--

440{-# INLINE_NORMAL writeN #-}

441−writeN :: forall m a. (MonadIO m, Unboxed a) => Int -> Fold m a (Array a)

441+writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)

442writeN = fmap unsafeFreeze . MA.writeN

443

444-- | @writeNAligned alignment n@ folds a maximum of @n@ elements from the input

@@ -447,7 +447,7 @@ writeN = fmap unsafeFreeze . MA.writeN

447-- /Pre-release/

448--

449{-# INLINE_NORMAL writeNAligned #-}

450−writeNAligned :: forall m a. (MonadIO m, Unboxed a)

450+writeNAligned :: forall m a. (MonadIO m, Unbox a)

451 => Int -> Int -> Fold m a (Array a)

452writeNAligned alignSize = fmap unsafeFreeze . MA.writeNAligned alignSize

453

@@ -458,12 +458,12 @@ writeNAligned alignSize = fmap unsafeFreeze . MA.writeNAligned alignSize

458-- slowdown.

459--

460{-# INLINE_NORMAL writeNUnsafe #-}

461−writeNUnsafe :: forall m a. (MonadIO m, Unboxed a)

461+writeNUnsafe :: forall m a. (MonadIO m, Unbox a)

462 => Int -> Fold m a (Array a)

463writeNUnsafe n = unsafeFreeze <$> MA.writeNUnsafe n

464

465{-# INLINE_NORMAL writeWith #-}

466−writeWith :: forall m a. (MonadIO m, Unboxed a)

466+writeWith :: forall m a. (MonadIO m, Unbox a)

467 => Int -> Fold m a (Array a)

468-- writeWith n = FL.rmapM spliceArrays $ toArraysOf n

469writeWith elemCount = unsafeFreeze <$> MA.writeWith elemCount

@@ -473,18 +473,18 @@ writeWith elemCount = unsafeFreeze <$> MA.writeWith elemCount

473-- /Caution! Do not use this on infinite streams./

474--

475{-# INLINE write #-}

476−write :: forall m a. (MonadIO m, Unboxed a) => Fold m a (Array a)

476+write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)

477write = fmap unsafeFreeze MA.write

478

479-------------------------------------------------------------------------------

480-- Instances

481-------------------------------------------------------------------------------

482

483−instance (Show a, Unboxed a) => Show (Array a) where

483+instance (Show a, Unbox a) => Show (Array a) where

484 {-# INLINE showsPrec #-}

485 showsPrec _ = shows . toList

486

487−instance (Unboxed a, Read a, Show a) => Read (Array a) where

487+instance (Unbox a, Read a, Show a) => Read (Array a) where

488 {-# INLINE readPrec #-}

489 readPrec = fromList <$> readPrec

490 readListPrec = readListPrecDefault

@@ -494,7 +494,7 @@ instance (a ~ Char) => IsString (Array a) where

494 fromString = fromList

495

496-- GHC versions 8.0 and below cannot derive IsList

497−instance Unboxed a => IsList (Array a) where

497+instance Unbox a => IsList (Array a) where

498 type (Item (Array a)) = a

499 {-# INLINE fromList #-}

500 fromList = fromList

@@ -505,12 +505,12 @@ instance Unboxed a => IsList (Array a) where

505

506-- XXX we are assuming that Unboxed equality means element equality. This may

507-- or may not be correct? arrcmp is 40% faster compared to stream equality.

508−instance (Unboxed a, Eq a) => Eq (Array a) where

508+instance (Unbox a, Eq a) => Eq (Array a) where

509 {-# INLINE (==) #-}

510 arr1 == arr2 =

511 (==) EQ $ unsafeInlineIO $! unsafeThaw arr1 `MA.cmp` unsafeThaw arr2

512

513−-- Since this is an Unboxed array we cannot have unevaluated data in it so

513+-- Since this is an Unbox array we cannot have unevaluated data in it so

514-- this is just a no op.

515instance NFData (Array a) where

516 {-# INLINE rnf #-}

@@ -519,7 +519,7 @@ instance NFData (Array a) where

519instance NFData1 Array where

520 liftRnf _ Array{} = ()

521

522−instance (Unboxed a, Ord a) => Ord (Array a) where

522+instance (Unbox a, Ord a) => Ord (Array a) where

523 {-# INLINE compare #-}

524 compare arr1 arr2 = runIdentity $

525 D.cmpBy compare (toStreamD arr1) (toStreamD arr2)

@@ -582,16 +582,16 @@ instance Foldable Array where

582-- Semigroup and Monoid

583-------------------------------------------------------------------------------

584

585−instance Unboxed a => Semigroup (Array a) where

585+instance Unbox a => Semigroup (Array a) where

586 arr1 <> arr2 = unsafePerformIO $ splice arr1 arr2

587

588nil ::

589#ifdef DEVBUILD

590− Unboxed a =>

590+ Unbox a =>

591#endif

592 Array a

593nil = Array Unboxed.nil 0 0

594

595−instance Unboxed a => Monoid (Array a) where

595+instance Unbox a => Monoid (Array a) where

596 mempty = nil

597 mappend = (<>)

core/src/Streamly/Internal/Data/Fold.hs+6−6

@@ -343,7 +343,7 @@ import Foreign.Storable (peek, sizeOf)

343import Streamly.Internal.Data.IsMap (IsMap(..))

344import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)

345import Streamly.Internal.Data.Pipe.Type (Pipe (..), PipeState(..))

346−import Streamly.Internal.Data.Unboxed (Unboxed)

346+import Streamly.Internal.Data.Unboxed (Unbox)

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

348import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

349import Streamly.Internal.Data.Stream.Type (Stream)

@@ -1625,7 +1625,7 @@ data SplitOnSeqState acc a rb rh w ck =

1625--

1626-- /Pre-release/

1627{-# INLINE takeEndBySeq #-}

1628−takeEndBySeq :: forall m a b. (MonadIO m, Unboxed a, Enum a, Eq a) =>

1628+takeEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) =>

1629 Array.Array a

1630 -> Fold m a b

1631 -> Fold m a b

@@ -1761,7 +1761,7 @@ takeEndBySeq patArr (Fold fstep finitial fextract) =

1761-- /Pre-release/

1762--

1763{-# INLINE takeEndBySeq_ #-}

1764−takeEndBySeq_ :: forall m a b. (MonadIO m, Unboxed a, Enum a, Eq a) =>

1764+takeEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) =>

1765 Array.Array a

1766 -> Fold m a b

1767 -> Fold m a b

@@ -2757,7 +2757,7 @@ unfoldMany (Unfold ustep inject) (Fold fstep initial extract) =

2757 consume s a = inject a >>= produce s

2758

2759{-# INLINE topBy #-}

2760−topBy :: (MonadIO m, Unboxed a) =>

2760+topBy :: (MonadIO m, Unbox a) =>

2761 (a -> a -> Ordering)

2762 -> Int

2763 -> Fold m a (MA.Array a)

@@ -2796,7 +2796,7 @@ topBy cmp n = Fold step initial extract

2796--

2797-- /Pre-release/

2798{-# INLINE top #-}

2799−top :: (MonadIO m, Unboxed a, Ord a) => Int -> Fold m a (MA.Array a)

2799+top :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MA.Array a)

2800top = topBy $ flip compare

2801

2802-- | Fold the input stream to bottom n elements.

@@ -2807,5 +2807,5 @@ top = topBy $ flip compare

2807--

2808-- /Pre-release/

2809{-# INLINE bottom #-}

2810−bottom :: (MonadIO m, Unboxed a, Ord a) => Int -> Fold m a (MA.Array a)

2810+bottom :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MA.Array a)

2811bottom = topBy compare

core/src/Streamly/Internal/Data/IORef/Unboxed.hs+7−7

@@ -41,7 +41,7 @@ where

41import Control.Monad.IO.Class (MonadIO(..))

42import Streamly.Internal.Data.Unboxed

43 ( MutableByteArray(..)

44− , Unboxed

44+ , Unbox

45 , sizeOf

46 , peekWith

47 , pokeWith

@@ -50,14 +50,14 @@ import Streamly.Internal.Data.Unboxed

51import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

53−-- | An 'IORef' holds a single 'Unboxed' value.

53+-- | An 'IORef' holds a single 'Unbox'-able value.

54newtype IORef a = IORef (MutableByteArray a)

56-- | Create a new 'IORef'.

57--

58-- /Pre-release/

59{-# INLINE newIORef #-}

60−newIORef :: forall a. Unboxed a => a -> IO (IORef a)

60+newIORef :: forall a. Unbox a => a -> IO (IORef a)

61newIORef x = do

62 var <- newUnpinnedBytes (sizeOf (undefined :: a))

63 pokeWith var 0 x

@@ -67,21 +67,21 @@ newIORef x = do

67--

68-- /Pre-release/

69{-# INLINE writeIORef #-}

70−writeIORef :: Unboxed a => IORef a -> a -> IO ()

70+writeIORef :: Unbox a => IORef a -> a -> IO ()

71writeIORef (IORef var) = pokeWith var 0

73-- | Read a value from an 'IORef'.

74--

75-- /Pre-release/

76{-# INLINE readIORef #-}

77−readIORef :: Unboxed a => IORef a -> IO a

77+readIORef :: Unbox a => IORef a -> IO a

78readIORef (IORef var) = peekWith var 0

80-- | Modify the value of an 'IORef' using a function with strict application.

81--

82-- /Pre-release/

83{-# INLINE modifyIORef' #-}

84−modifyIORef' :: Unboxed a => IORef a -> (a -> a) -> IO ()

84+modifyIORef' :: Unbox a => IORef a -> (a -> a) -> IO ()

85modifyIORef' var g = do

86 x <- readIORef var

87 writeIORef var (g x)

@@ -90,7 +90,7 @@ modifyIORef' var g = do

90--

91-- /Pre-release/

92{-# INLINE_NORMAL toStreamD #-}

93−toStreamD :: (MonadIO m, Unboxed a) => IORef a -> D.Stream m a

93+toStreamD :: (MonadIO m, Unbox a) => IORef a -> D.Stream m a

94toStreamD var = D.Stream step ()

96 where

core/src/Streamly/Internal/Data/Ring/Unboxed.hs+3−3

@@ -81,7 +81,7 @@ import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)

81import Foreign.Ptr (plusPtr, minusPtr, castPtr)

82import Streamly.Internal.Data.Unboxed as Unboxed

83 ( MutableByteArray

84− , Unboxed

84+ , Unbox

85 , castContents

86 , peekWith

87 )

@@ -561,7 +561,7 @@ data Tuple4' a b c d = Tuple4' !a !b !c !d deriving Show

561-- a))@ action depends on when it is executed. It does not capture the sanpshot

562-- of the ring at a particular time.

563{-# INLINE slidingWindowWith #-}

564−slidingWindowWith :: forall m a b. (MonadIO m, Unboxed a)

564+slidingWindowWith :: forall m a b. (MonadIO m, Unbox a)

565 => Int -> Fold m ((a, Maybe a), m (Array a)) b -> Fold m a b

566slidingWindowWith n (Fold step1 initial1 extract1) = Fold step initial extract

567

@@ -615,6 +615,6 @@ slidingWindowWith n (Fold step1 initial1 extract1) = Fold step initial extract

615-- there is no old element.

616--

617{-# INLINE slidingWindow #-}

618−slidingWindow :: forall m a b. (MonadIO m, Unboxed a)

618+slidingWindow :: forall m a b. (MonadIO m, Unbox a)

619 => Int -> Fold m (a, Maybe a) b -> Fold m a b

620slidingWindow n f = slidingWindowWith n (lmap fst f)

core/src/Streamly/Internal/Data/Stream/Bottom.hs+2−2

@@ -63,7 +63,7 @@ where

63import Control.Monad.IO.Class (MonadIO(..))

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

65import Streamly.Internal.Data.Time.Units (AbsTime, RelTime64, addToAbsTime64)

66−import Streamly.Internal.Data.Unboxed (Unboxed)

66+import Streamly.Internal.Data.Unboxed (Unbox)

67import Streamly.Internal.System.IO (defaultChunkSize)

69import qualified Streamly.Internal.Data.Array.Unboxed.Type as A

@@ -418,7 +418,7 @@ reverse s = fromStreamD $ D.reverse $ toStreamD s

418--

419-- /Pre-release/

420{-# INLINE reverse' #-}

421−reverse' :: (MonadIO m, Unboxed a) => Stream m a -> Stream m a

421+reverse' :: (MonadIO m, Unbox a) => Stream m a -> Stream m a

422-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s

423reverse' =

424 fromStreamD

core/src/Streamly/Internal/Data/Stream/Eliminate.hs+2−2

@@ -75,7 +75,7 @@ import Control.Monad.Catch (MonadThrow)

75import Control.Monad.IO.Class (MonadIO(..))

76import Control.Monad.Trans.Class (MonadTrans(..))

77import Streamly.Internal.Data.Parser (Parser (..))

78−import Streamly.Internal.Data.Unboxed (Unboxed)

78+import Streamly.Internal.Data.Unboxed (Unbox)

80import qualified Streamly.Internal.Data.Array.Unboxed.Type as Array

81import qualified Streamly.Internal.Data.Fold as Fold

@@ -291,7 +291,7 @@ isPrefixOf m1 m2 = D.isPrefixOf (toStreamD m1) (toStreamD m2)

291-- /Requires 'Storable' constraint/

292--

293{-# INLINE isInfixOf #-}

294−isInfixOf :: (MonadIO m, Eq a, Enum a, Unboxed a)

294+isInfixOf :: (MonadIO m, Eq a, Enum a, Unbox a)

295 => Stream m a -> Stream m a -> m Bool

296isInfixOf infx stream = do

297 arr <- fold Array.write infx

core/src/Streamly/Internal/Data/Stream/Generate.hs+2−2

@@ -79,7 +79,7 @@ import Streamly.Internal.Data.Stream.Enumerate

79import Streamly.Internal.Data.Stream.Type

80 (Stream, fromStreamD, fromStreamK, toStreamK)

81import Streamly.Internal.Data.Time.Units (AbsTime, RelTime64, addToAbsTime64)

82−import Streamly.Internal.Data.Unboxed (Unboxed)

82+import Streamly.Internal.Data.Unboxed (Unbox)

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

85import qualified Streamly.Internal.Data.IORef.Unboxed as Unboxed

@@ -458,5 +458,5 @@ fromByteStr# addr =

458-- /Pre-release/

459--

460{-# INLINE fromUnboxedIORef #-}

461−fromUnboxedIORef :: (MonadIO m, Unboxed a) => Unboxed.IORef a -> Stream m a

461+fromUnboxedIORef :: (MonadIO m, Unbox a) => Unboxed.IORef a -> Stream m a

462fromUnboxedIORef = fromStreamD . Unboxed.toStreamD

core/src/Streamly/Internal/Data/Stream/Reduce.hs+2−2

@@ -64,7 +64,7 @@ import Streamly.Internal.Data.Parser (Parser (..))

64import Streamly.Internal.Data.Refold.Type (Refold (..))

65import Streamly.Internal.Data.Stream.Bottom (foldManyPost)

66import Streamly.Internal.Data.Stream.Type (Stream, fromStreamD, toStreamD)

67−import Streamly.Internal.Data.Unboxed (Unboxed)

67+import Streamly.Internal.Data.Unboxed (Unbox)

69import qualified Streamly.Internal.Data.Array.Unboxed.Type as Array

70import qualified Streamly.Internal.Data.Parser.ParserD as ParserD

@@ -427,6 +427,6 @@ parseIterate f i m = fromStreamD $

427--

428-- /Pre-release/

429{-# INLINE arraysOf #-}

430−arraysOf :: (MonadIO m, Unboxed a)

430+arraysOf :: (MonadIO m, Unbox a)

431 => Int -> Stream m a -> Stream m (Array a)

432arraysOf n = fromStreamD . Array.arraysOf n . toStreamD

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

@@ -166,7 +166,7 @@ import Streamly.Internal.Data.Parser (ParseError(..))

166import Streamly.Internal.Data.Refold.Type (Refold(..))

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

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

169−import Streamly.Internal.Data.Unboxed (Unboxed)

169+import Streamly.Internal.Data.Unboxed (Unbox)

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

171

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

@@ -1823,7 +1823,7 @@ data SplitOnSeqState rb rh ck w fs s b x =

1823

1824{-# INLINE_NORMAL splitOnSeq #-}

1825splitOnSeq

1826− :: forall m a b. (MonadIO m, Unboxed a, Enum a, Eq a)

1826+ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a)

1827 => Array a

1828 -> Fold m a b

1829 -> Stream m a

@@ -2136,7 +2136,7 @@ data SplitOnSuffixSeqState rb rh ck w fs s b x =

2136

2137{-# INLINE_NORMAL splitOnSuffixSeq #-}

2138splitOnSuffixSeq

2139− :: forall m a b. (MonadIO m, Unboxed a, Enum a, Eq a)

2139+ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a)

2140 => Bool

2141 -> Array a

2142 -> Fold m a b

core/src/Streamly/Internal/Data/Unboxed.hs+6−9

@@ -2,8 +2,7 @@

2{-# LANGUAGE UnboxedTuples #-}

4module Streamly.Internal.Data.Unboxed

5− ( Unboxed

6− , Unbox(..)

5+ ( Unbox(..)

7 , alignment

6 , alignment

8 , peekWith

7 , peekWith

9 , pokeWith

8 , pokeWith

@@ -137,7 +136,7 @@ unpin arr@(MutableByteArray marr#) =

137 (# s1#, marr1# #) -> (# s1#, MutableByteArray marr1# #)

136 (# s1#, marr1# #) -> (# s1#, MutableByteArray marr1# #)

138

137

139--------------------------------------------------------------------------------

138--------------------------------------------------------------------------------

140−-- The Unboxed type class

139+-- The Unbox type class

141--------------------------------------------------------------------------------

140--------------------------------------------------------------------------------

142

141

143-- In theory we could convert a type to and from a byte stream and use that

142-- In theory we could convert a type to and from a byte stream and use that

@@ -188,8 +187,6 @@ class Storable a => Unbox a where

188 -- index.

187 -- index.

189 unbox :: MutableByteArray a -> Int -> a -> IO ()

188 unbox :: MutableByteArray a -> Int -> a -> IO ()

190

189

191−type Unboxed a = Unbox a

192−

193#define DERIVE_UNBOXED(_type, _constructor, _readArray, _writeArray) \

190#define DERIVE_UNBOXED(_type, _constructor, _readArray, _writeArray) \

194instance Unbox _type where { \

191instance Unbox _type where { \

195; {-# INLINE box #-} \

192; {-# INLINE box #-} \

@@ -310,8 +307,8 @@ DERIVE_WRAPPED_UNBOX(Unbox a =>,(Identity a),Identity)

310DERIVE_WRAPPED_UNBOX(Unbox a =>,(Down a),Down)

307DERIVE_WRAPPED_UNBOX(Unbox a =>,(Down a),Down)

311#endif

308#endif

312DERIVE_WRAPPED_UNBOX(Unbox a =>,(Const a b),Const)

309DERIVE_WRAPPED_UNBOX(Unbox a =>,(Const a b),Const)

313−DERIVE_BINARY_UNBOX(forall a. Unboxed a =>,(Complex a),(:+),a)

310+DERIVE_BINARY_UNBOX(forall a. Unbox a =>,(Complex a),(:+),a)

314−DERIVE_BINARY_UNBOX(forall a. (Integral a, Unboxed a) =>,(Ratio a),(:%),a)

311+DERIVE_BINARY_UNBOX(forall a. (Integral a, Unbox a) =>,(Ratio a),(:%),a)

315DERIVE_BINARY_UNBOX(,Fingerprint,Fingerprint,Word64)

312DERIVE_BINARY_UNBOX(,Fingerprint,Fingerprint,Word64)

316

313

317instance Unbox () where

314instance Unbox () where

@@ -350,9 +347,9 @@ instance Unbox Bool where

350--------------------------------------------------------------------------------

347--------------------------------------------------------------------------------

351

348

352{-# INLINE peekWith #-}

349{-# INLINE peekWith #-}

353−peekWith :: Unboxed a => MutableByteArray a -> Int -> IO a

350+peekWith :: Unbox a => MutableByteArray a -> Int -> IO a

354peekWith = box

351peekWith = box

355

352

356{-# INLINE pokeWith #-}

353{-# INLINE pokeWith #-}

357−pokeWith :: Unboxed a => MutableByteArray a -> Int -> a -> IO ()

354+pokeWith :: Unbox a => MutableByteArray a -> Int -> a -> IO ()

358pokeWith = unbox

355pokeWith = unbox

core/src/Streamly/Internal/FileSystem/Handle.hs+4−4

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

115import Data.Function ((&))

116import Data.Maybe (isNothing, fromJust)

117import Data.Word (Word8)

118−import Streamly.Internal.Data.Unboxed (Unboxed)

118+import Streamly.Internal.Data.Unboxed (Unbox)

119import System.IO (Handle, SeekMode(..), hGetBufSome, hPutBuf, hSeek)

120import Prelude hiding (read)

121

@@ -417,7 +417,7 @@ putChunks h = S.fold (FL.drainBy (putChunk h))

417-- we do not split the arrays to fit exactly to the specified size.

418--

419{-# INLINE putChunksWith #-}

420−putChunksWith :: (MonadIO m, Unboxed a)

420+putChunksWith :: (MonadIO m, Unbox a)

421 => Int -> Handle -> Stream m (Array a) -> m ()

422putChunksWith n h xs = putChunks h $ AS.compact n xs

423

@@ -470,7 +470,7 @@ chunkWriter = Refold.drainBy putChunk

470-- remains below the specified size.

471--

472{-# INLINE writeChunksWith #-}

473−writeChunksWith :: (MonadIO m, Unboxed a)

473+writeChunksWith :: (MonadIO m, Unbox a)

474 => Int -> Handle -> Fold m (Array a) ()

475writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

476

@@ -478,7 +478,7 @@ writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

478--

479{-# DEPRECATED writeChunksWithBufferOf "Please use writeChunksWith instead." #-}

480{-# INLINE writeChunksWithBufferOf #-}

481−writeChunksWithBufferOf :: (MonadIO m, Unboxed a)

481+writeChunksWithBufferOf :: (MonadIO m, Unbox a)

482 => Int -> Handle -> Fold m (Array a) ()

483writeChunksWithBufferOf = writeChunksWith

484

src/Streamly/Internal/Data/Stream/IsStream/Common.hs+3−3

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

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

80import Streamly.Internal.Data.Time.Units (AbsTime, RelTime64, addToAbsTime64)

81import Streamly.Internal.System.IO (defaultChunkSize)

82−import Streamly.Internal.Data.Unboxed (Unboxed)

82+import Streamly.Internal.Data.Unboxed (Unbox)

84import qualified Streamly.Data.Stream as Stream (fold, foldBreak)

85import qualified Streamly.Internal.Data.Array.Unboxed.Type as A

@@ -500,7 +500,7 @@ reverse s = fromStreamD $ D.reverse $ toStreamD s

500--

501-- /Pre-release/

502{-# INLINE reverse' #-}

503−reverse' :: (IsStream t, MonadIO m, Unboxed a) => t m a -> t m a

503+reverse' :: (IsStream t, MonadIO m, Unbox a) => t m a -> t m a

504-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s

505reverse' =

506 fromStreamD

@@ -679,7 +679,7 @@ foldManyPost f m = fromStreamD $ D.foldManyPost f (toStreamD m)

679-- that we can search files in files for example.

680{-# INLINE splitOnSeq #-}

681splitOnSeq

682− :: (IsStream t, MonadIO m, Unboxed a, Enum a, Eq a)

682+ :: (IsStream t, MonadIO m, Unbox a, Enum a, Eq a)

683 => Array a -> Fold m a b -> t m a -> t m b

684splitOnSeq patt f m =

685 IsStream.fromStreamD $ D.splitOnSeq patt f (IsStream.toStreamD m)

src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+2−2

@@ -166,7 +166,7 @@ import Streamly.Internal.Data.Stream.IsStream.Common

166import Streamly.Internal.Data.Stream.IsStream.Type

167 (IsStream, toStreamD, fromStreamD, toStreamD)

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

169−import Streamly.Internal.Data.Unboxed (Unboxed)

169+import Streamly.Internal.Data.Unboxed (Unbox)

170

171import qualified Streamly.Data.Array.Unboxed as A

172import qualified Streamly.Data.Stream as Stream

@@ -849,7 +849,7 @@ isPrefixOf m1 m2 = D.isPrefixOf (toStreamD m1) (toStreamD m2)

849-- /Requires 'Storable' constraint/

850--

851{-# INLINE isInfixOf #-}

852−isInfixOf :: (MonadIO m, Eq a, Enum a, Unboxed a)

852+isInfixOf :: (MonadIO m, Eq a, Enum a, Unbox a)

853 => SerialT m a -> SerialT m a -> m Bool

854isInfixOf infx stream = do

855 arr <- fold A.write infx

src/Streamly/Internal/Data/Stream/IsStream/Generate.hs+2−2

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

104import Streamly.Internal.Data.Stream.Serial (SerialT, WSerialT)

105import Streamly.Internal.Data.Stream.Zip (ZipSerialM)

106import Streamly.Internal.Data.Time.Units (AbsTime , RelTime64, addToAbsTime64)

107−import Streamly.Internal.Data.Unboxed (Unboxed)

107+import Streamly.Internal.Data.Unboxed (Unbox)

108

109import qualified Streamly.Internal.Data.IORef.Unboxed as Unboxed

110 (toStreamD, IORef)

@@ -661,5 +661,5 @@ fromCallback setCallback = concatM $ do

661-- /Pre-release/

662--

663{-# INLINE fromPrimIORef #-}

664−fromPrimIORef :: (IsStream t, MonadIO m, Unboxed a) => Unboxed.IORef a -> t m a

664+fromPrimIORef :: (IsStream t, MonadIO m, Unbox a) => Unboxed.IORef a -> t m a

665fromPrimIORef = fromStreamD . Unboxed.toStreamD

src/Streamly/Internal/Data/Stream/IsStream/Reduce.hs+10−10

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

179import Streamly.Internal.Data.Time.Units

180 ( AbsTime, MilliSecond64(..), addToAbsTime, toRelTime

181 , toAbsTime)

182−import Streamly.Internal.Data.Unboxed (Unboxed)

182+import Streamly.Internal.Data.Unboxed (Unbox)

183

184import qualified Data.Heap as H

185import qualified Streamly.Data.Unfold as Unfold

@@ -798,7 +798,7 @@ splitWithSuffix predicate f = foldMany (FL.takeEndBy predicate f)

798-- /Unimplemented/

799--

800{-# INLINE splitOnAny #-}

801−splitOnAny :: -- (IsStream t, Monad m, Unboxed a, Integral a) =>

801+splitOnAny :: -- (IsStream t, Monad m, Unbox a, Integral a) =>

802 [Array a] -> Fold m a b -> t m a -> t m b

803splitOnAny _subseq _f _m =

804 undefined -- D.fromStreamD $ D.splitOnAny f subseq (D.toStreamD m)

@@ -843,7 +843,7 @@ splitOnAny _subseq _f _m =

843-- /Pre-release/

844{-# INLINE splitBySeq #-}

845splitBySeq

846− :: (IsStream t, MonadAsync m, Unboxed a, Enum a, Eq a)

846+ :: (IsStream t, MonadAsync m, Unbox a, Enum a, Eq a)

847 => Array a -> Fold m a b -> t m a -> t m b

848splitBySeq patt f m =

849 intersperseM (fold f (A.read patt)) $ splitOnSeq patt f m

@@ -894,7 +894,7 @@ splitBySeq patt f m =

894-- /Pre-release/

895{-# INLINE splitOnSuffixSeq #-}

896splitOnSuffixSeq

897− :: (IsStream t, MonadIO m, Unboxed a, Enum a, Eq a)

897+ :: (IsStream t, MonadIO m, Unbox a, Enum a, Eq a)

898 => Array a -> Fold m a b -> t m a -> t m b

899splitOnSuffixSeq patt f m =

900 fromStreamD $ D.splitOnSuffixSeq False patt f (toStreamD m)

@@ -908,7 +908,7 @@ splitOnSuffixSeq patt f m =

908--

909-- /Unimplemented/

910{-# INLINE wordsOn #-}

911−wordsOn :: -- (IsStream t, Monad m, Unboxed a, Eq a) =>

911+wordsOn :: -- (IsStream t, Monad m, Unbox a, Eq a) =>

912 Array a -> Fold m a b -> t m a -> t m b

913wordsOn _subseq _f _m =

914 undefined -- D.fromStreamD $ D.wordsOn f subseq (D.toStreamD m)

@@ -946,7 +946,7 @@ wordsOn _subseq _f _m =

946-- /Pre-release/

947{-# INLINE splitWithSuffixSeq #-}

948splitWithSuffixSeq

949− :: (IsStream t, MonadIO m, Unboxed a, Enum a, Eq a)

949+ :: (IsStream t, MonadIO m, Unbox a, Enum a, Eq a)

950 => Array a -> Fold m a b -> t m a -> t m b

951splitWithSuffixSeq patt f m =

952 fromStreamD $ D.splitOnSuffixSeq True patt f (toStreamD m)

@@ -958,7 +958,7 @@ splitWithSuffixSeq patt f m =

958--

959-- /Unimplemented/

960{-# INLINE splitOnSuffixSeqAny #-}

961−splitOnSuffixSeqAny :: -- (IsStream t, Monad m, Unboxed a, Integral a) =>

961+splitOnSuffixSeqAny :: -- (IsStream t, Monad m, Unbox a, Integral a) =>

962 [Array a] -> Fold m a b -> t m a -> t m b

963splitOnSuffixSeqAny _subseq _f _m = undefined

964 -- D.fromStreamD $ D.splitPostAny f subseq (D.toStreamD m)

@@ -994,7 +994,7 @@ chunksOf n f = fromStreamD . D.chunksOf n f . toStreamD

994--

995-- /Pre-release/

996{-# INLINE arraysOf #-}

997−arraysOf :: (IsStream t, MonadIO m, Unboxed a)

997+arraysOf :: (IsStream t, MonadIO m, Unbox a)

998 => Int -> t m a -> t m (Array a)

999arraysOf n = fromStreamD . A.arraysOf n . toStreamD

1000

@@ -1100,7 +1100,7 @@ classifySlidingSessions tick interval slide (Fold step initial extract) str

1100-- insert the new elements, and apply an incremental fold on the sliding

1101-- window, supplying the outgoing elements, the new ring buffer as arguments.

1102slidingChunkBuffer

1103− :: (IsStream t, Monad m, Ord a, Unboxed a)

1103+ :: (IsStream t, Monad m, Ord a, Unbox a)

1104 => Int -- window size

1105 -> Int -- window slide

1106 -> Fold m (Ring a, Array a) b

@@ -1113,7 +1113,7 @@ slidingChunkBuffer = undefined

1113-- an incremental fold on the sliding window, supplying the outgoing elements,

1114-- and the new radix tree buffer as arguments.

1115slidingSessionBuffer

1116− :: (IsStream t, Monad m, Ord a, Unboxed a)

1116+ :: (IsStream t, Monad m, Ord a, Unbox a)

1117 => Int -- window size

1118 -> Int -- tick size

1119 -> Fold m (RTree a, Array a) b

src/Streamly/Internal/FileSystem/FD.hs+5−5

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

120import Data.Word (Word8)

121-- import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)

122import Foreign.Ptr (castPtr)

123−import Streamly.Internal.Data.Unboxed (Unboxed)

123+import Streamly.Internal.Data.Unboxed (Unbox)

124-- import System.IO (Handle, hGetBufSome, hPutBuf)

125import System.IO (IOMode)

126import Prelude hiding (read)

@@ -240,7 +240,7 @@ readArrayUpto size (Handle fd) = do

240--

241-- @since 0.7.0

242{-# INLINABLE writeArray #-}

243−writeArray :: Unboxed a => Handle -> Array a -> IO ()

243+writeArray :: Unbox a => Handle -> Array a -> IO ()

244writeArray _ arr | A.length arr == 0 = return ()

245writeArray (Handle fd) arr =

246 asPtrUnsafe arr $ \p ->

@@ -337,7 +337,7 @@ readInChunksOf :: (MonadIO m) => Int -> Handle -> Stream m Word8

337readInChunksOf chunkSize h = AS.concat $ readArraysOfUpto chunkSize h

338

339-- TODO

340−-- read :: (MonadIO m, Unboxed a) => Handle -> Stream m a

340+-- read :: (MonadIO m, Unbox a) => Handle -> Stream m a

341--

342-- > read = 'readByChunks' A.defaultChunkSize

343-- | Generate a stream of elements of the given type from a file 'Handle'. The

@@ -356,7 +356,7 @@ read = AS.concat . readArrays

356--

357-- @since 0.7.0

358{-# INLINE writeArrays #-}

359−writeArrays :: (MonadIO m, Unboxed a) => Handle -> Stream m (Array a) -> m ()

359+writeArrays :: (MonadIO m, Unbox a) => Handle -> Stream m (Array a) -> m ()

360writeArrays h = S.fold (FL.drainBy (liftIO . writeArray h))

361

362-- | Write a stream of arrays to a handle after coalescing them in chunks of

@@ -366,7 +366,7 @@ writeArrays h = S.fold (FL.drainBy (liftIO . writeArray h))

366--

367-- @since 0.7.0

368{-# INLINE writeArraysPackedUpto #-}

369−writeArraysPackedUpto :: (MonadIO m, Unboxed a)

369+writeArraysPackedUpto :: (MonadIO m, Unbox a)

370 => Int -> Handle -> Stream m (Array a) -> m ()

371writeArraysPackedUpto n h xs = writeArrays h $ AS.compact n xs

372

src/Streamly/Internal/Network/Socket.hs+7−7

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

72import Data.Maybe (isNothing, fromJust)

73import Data.Word (Word8)

74import Foreign.Ptr (plusPtr, Ptr, castPtr)

75−import Streamly.Internal.Data.Unboxed (Unboxed)

75+import Streamly.Internal.Data.Unboxed (Unbox)

76import Network.Socket

77 (Socket, SocketOption(..), Family(..), SockAddr(..),

78 ProtocolNumber, withSocketsDo, SocketType(..), socket, bind,

@@ -303,7 +303,7 @@ sendAll s p len = do

303 when (sent >= 0) $ sendAll s (p `plusPtr` sent) (len - sent)

304

305{-# INLINABLE writeArrayWith #-}

306−writeArrayWith :: Unboxed a

306+writeArrayWith :: Unbox a

307 => (h -> Ptr Word8 -> Int -> IO ())

308 -> h

309 -> Array a

@@ -318,7 +318,7 @@ writeArrayWith f h arr = A.asPtrUnsafe arr $ \ptr -> f h (castPtr ptr) aLen

318-- | Write an Array to a file handle.

319--

320{-# INLINABLE putChunk #-}

321−putChunk :: Unboxed a => Socket -> Array a -> IO ()

321+putChunk :: Unbox a => Socket -> Array a -> IO ()

322putChunk = writeArrayWith sendAll

323

324-------------------------------------------------------------------------------

@@ -448,7 +448,7 @@ reader = UF.first defaultChunkSize readerWith

448-- | Write a stream of arrays to a handle.

449--

450{-# INLINE putChunks #-}

451−putChunks :: (MonadIO m, Unboxed a)

451+putChunks :: (MonadIO m, Unbox a)

452 => Socket -> Stream m (Array a) -> m ()

453putChunks h = S.fold (FL.drainBy (liftIO . putChunk h))

454

@@ -456,7 +456,7 @@ putChunks h = S.fold (FL.drainBy (liftIO . putChunk h))

456-- to the socket as a separate IO request.

457--

458{-# INLINE writeChunks #-}

459−writeChunks :: (MonadIO m, Unboxed a) => Socket -> Fold m (Array a) ()

459+writeChunks :: (MonadIO m, Unbox a) => Socket -> Fold m (Array a) ()

460writeChunks h = FL.drainBy (liftIO . putChunk h)

461

462-- | @writeChunksWith bufsize socket@ writes a stream of arrays to

@@ -466,7 +466,7 @@ writeChunks h = FL.drainBy (liftIO . putChunk h)

466-- the specified size it emitted as it is.

467--

468{-# INLINE writeChunksWith #-}

469−writeChunksWith :: (MonadIO m, Unboxed a)

469+writeChunksWith :: (MonadIO m, Unbox a)

470 => Int -> Socket -> Fold m (Array a) ()

471writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

472

@@ -474,7 +474,7 @@ writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

474--

475{-# DEPRECATED writeChunksWithBufferOf "Please use 'writeChunksWith' instead" #-}

476{-# INLINE writeChunksWithBufferOf #-}

477−writeChunksWithBufferOf :: (MonadIO m, Unboxed a)

477+writeChunksWithBufferOf :: (MonadIO m, Unbox a)

478 => Int -> Socket -> Fold m (Array a) ()

479writeChunksWithBufferOf = writeChunksWith

480

test/Streamly/Test/Data/Array/Unboxed.hs+2−2

@@ -15,7 +15,7 @@ import Foreign.Storable (peek)

15import GHC.Ptr (plusPtr)

16import Streamly.Data.Fold (Fold)

17import Streamly.Internal.Data.Stream (Stream)

18−import Streamly.Internal.Data.Unboxed (Unboxed, sizeOf)

18+import Streamly.Internal.Data.Unboxed (Unbox, sizeOf)

19import Streamly.Test.Common (listEquals)

21import qualified Streamly.Data.Fold as Fold

@@ -164,7 +164,7 @@ testBubbleAsc = testBubbleWith True

164testBubbleDesc :: Property

165testBubbleDesc = testBubbleWith False

166

167−testByteLengthWithMA :: forall a. Unboxed a => a -> IO ()

167+testByteLengthWithMA :: forall a. Unbox a => a -> IO ()

168testByteLengthWithMA _ = do

169 arrA <- MA.newPinned 100 :: IO (MA.Array a)

170 let arrW8 = MA.castUnsafe arrA :: MA.Array Word8

test/Streamly/Test/Data/Array/Unboxed/Mut.hs+2−2

@@ -13,7 +13,7 @@ import GHC.Int (Int16(..), Int32(..), Int64(..), Int8(..))

13import GHC.Real (Ratio(..))

14import GHC.Stable (StablePtr(..))

15import GHC.Word (Word16(..), Word32(..), Word64(..), Word8(..))

16−import Streamly.Internal.Data.Unboxed (Unboxed)

16+import Streamly.Internal.Data.Unboxed (Unbox)

17import Streamly.Test.Common (chooseInt)

18import Test.Hspec (hspec, describe, it)

19import Test.Hspec.QuickCheck

@@ -138,7 +138,7 @@ testUnboxInstanceExistance = do

138 TEST_IE(Const Int Int)

139 where

140

141− testIE :: Unboxed a => [a] -> IO ()

141+ testIE :: Unbox a => [a] -> IO ()

142 testIE lst = void $ MArray.fromList lst

143

144main :: IO ()

test/Streamly/Test/Prelude/Serial.hs+2−2

@@ -20,7 +20,7 @@ import Data.List (sort, group, intercalate)

20import Data.Maybe ( isJust, fromJust )

21import Data.Word (Word8)

22import Data.Semigroup (Sum(..), getSum)

23−import Streamly.Internal.Data.Unboxed (Unboxed)

23+import Streamly.Internal.Data.Unboxed (Unbox)

24import Test.Hspec.QuickCheck

25import Test.QuickCheck

26 ( Gen

@@ -111,7 +111,7 @@ splitOnSuffixSeq = do

111 $ IS.splitOnSuffixSeq (A.fromList pat) FL.toList (S.fromList xs)

112

113splitterProperties ::

114− forall a. (Arbitrary a, Eq a, Show a, Unboxed a, Enum a)

114+ forall a. (Arbitrary a, Eq a, Show a, Unbox a, Enum a)

115 => a

116 -> String

117 -> Spec