2e21c3a · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Rename Storable constraint to Unboxed

2e21c3aRanjeet Kumar Ranjan4 years ago

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

compare with master

unifiedsplit

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

48import Streamly.Benchmark.Common.Handle

50#ifdef INSPECTION

51−import Streamly.Internal.Data.Unboxed (Storable)

51+import Streamly.Internal.Data.Unboxed (Unboxed)

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

53import Test.Inspection

54#endif

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

185 $ Handle.getChunks inh

186

187#ifdef INSPECTION

188−inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterposeSuffix [''Storable]

188+inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterposeSuffix [''Unboxed]

189inspect $ 'copyChunksSplitInterposeSuffix `hasNoType` ''Step

190#endif

191

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

200 $ Handle.getChunks inh

201

202#ifdef INSPECTION

203−inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterpose [''Storable]

203+inspect $ hasNoTypeClassesExcept 'copyChunksSplitInterpose [''Unboxed]

204inspect $ 'copyChunksSplitInterpose `hasNoType` ''Step

205#endif

206

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

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

35import Streamly.Benchmark.Common.Handle

37#ifdef INSPECTION

38−import Streamly.Internal.Data.Unboxed (Storable)

38+import Streamly.Internal.Data.Unboxed (Unboxed)

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

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

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

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

105 $ Stream.unfold Handle.read inh

106

107#ifdef INSPECTION

108−inspect $ hasNoTypeClassesExcept 'linesUnlinesArrayCharCopy [''Storable]

108+inspect $ hasNoTypeClassesExcept 'linesUnlinesArrayCharCopy [''Unboxed]

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

110#endif

111

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

@@ -60,7 +60,7 @@ import Control.Applicative (liftA2)

60import Control.Exception (assert)

61import Control.Monad.Catch (MonadThrow)

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

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

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

64import GHC.Types (SPEC(..))

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

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

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

97--

98-- /Pre-release/

99{-# INLINE fromFold #-}

100−fromFold :: forall m a b. (MonadIO m, Storable a) =>

100+fromFold :: forall m a b. (MonadIO m, Unboxed a) =>

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

102fromFold (Fold.Fold fstep finitial fextract) =

103 ArrayFold (ParserD.Parser step initial fextract)

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

135--

136-- /Pre-release/

137{-# INLINE fromParserD #-}

138−fromParserD :: forall m a b. (MonadIO m, Storable a) =>

138+fromParserD :: forall m a b. (MonadIO m, Unboxed a) =>

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

140fromParserD (ParserD.Parser step1 initial1 extract1) =

141 ArrayFold (ParserD.Parser step initial1 extract1)

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

177--

178-- /Pre-release/

179{-# INLINE fromParser #-}

180−fromParser :: forall m a b. (MonadThrow m, MonadIO m, Storable a) =>

180+fromParser :: forall m a b. (MonadThrow m, MonadIO m, Unboxed a) =>

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

182fromParser = fromParserD . ParserD.fromParserK

183

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

301

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

303{-# INLINE take #-}

304−take :: forall m a b. (Monad m, Storable a) =>

304+take :: forall m a b. (Monad m, Unboxed a) =>

305 Int -> ArrayFold m a b -> ArrayFold m a b

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

307 ArrayFold $ ParserD.Parser step initial extract

core/src/Streamly/Internal/Data/Array/Stream/Mut/Foreign.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 (Storable, sizeOf)

34+import Streamly.Internal.Data.Unboxed (Unboxed, 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, Storable a)

55+arraysOf :: (MonadIO m, Unboxed 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, Storable a)

84+packArraysChunksOf :: (MonadIO m, Unboxed 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, Storable a)

132+lpackArraysChunksOf :: (MonadIO m, Unboxed 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, Storable a)

194+compact :: (MonadIO m, Unboxed 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, Storable a)

207+ forall m a. (MonadThrow m, MonadIO m, Unboxed 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, Storable a)

257+ forall m a. (MonadIO m, Unboxed 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, Storable a) =>

301+compactLE :: (MonadThrow m, MonadIO m, Unboxed 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, Storable a) =>

311+compactEQ :: -- (MonadIO m, Unboxed 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, Storable a)

322+ (MonadIO m, Unboxed 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.hs+12−12

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

182-------------------------------------------------------------------------------

183

184{-# INLINE_NORMAL producer #-}

185−producer :: forall m a. (Monad m, Storable a) => Producer m (Array a) a

185+producer :: forall m a. (Monad m, Unboxed a) => Producer m (Array a) a

186producer =

187 Producer.translate A.unsafeThaw A.unsafeFreeze

188 $ MA.producerWith (return . unsafeInlineIO)

@@ -193,7 +193,7 @@ producer =

193--

194-- @since 0.8.0

195{-# INLINE_NORMAL read #-}

196−read :: forall m a. (Monad m, Storable a) => Unfold m (Array a) a

196+read :: forall m a. (Monad m, Unboxed a) => Unfold m (Array a) a

197read = Producer.simplify producer

198

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

@@ -208,7 +208,7 @@ read = Producer.simplify producer

208-- /Pre-release/

209--

210{-# INLINE_NORMAL unsafeRead #-}

211−unsafeRead :: forall m a. (Monad m, Storable a) => Unfold m (Array a) a

211+unsafeRead :: forall m a. (Monad m, Unboxed a) => Unfold m (Array a) a

212unsafeRead = Unfold step inject

213 where

214

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

243--

244-- /Pre-release/

245{-# INLINE getIndexRev #-}

246−getIndexRev :: forall a. Storable a => Int -> Array a -> Maybe a

246+getIndexRev :: forall a. Unboxed a => Int -> Array a -> Maybe a

247getIndexRev i arr =

248 unsafeInlineIO

249 $ do

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

259--

260-- /Pre-release/

261{-# INLINE last #-}

262−last :: Storable a => Array a -> Maybe a

262+last :: Unboxed a => Array a -> Maybe a

263last = getIndexRev 0

264

265-------------------------------------------------------------------------------

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

352-- /Pre-release/

353{-# INLINE getSliceUnsafe #-}

354getSliceUnsafe ::

355− forall a. Storable a

355+ forall a. Unboxed a

356 => Int -- ^ starting index

357 -> Int -- ^ length of the slice

358 -> Array a

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

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

377

378{-# INLINE genSlicesFromLen #-}

379−genSlicesFromLen :: forall m a. (Monad m, Storable a)

379+genSlicesFromLen :: forall m a. (Monad m, Unboxed a)

380 => Int -- ^ from index

381 -> Int -- ^ length of the slice

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

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

389--

390-- /Pre-release//

391{-# INLINE getSlicesFromLen #-}

392−getSlicesFromLen :: forall m a. (Monad m, Storable a)

392+getSlicesFromLen :: forall m a. (Monad m, Unboxed a)

393 => Int -- ^ from index

394 -> Int -- ^ length of the slice

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

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

408--

409-- @since 0.8.0

410{-# INLINE getIndex #-}

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

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

412getIndex i arr =

413 unsafeInlineIO

414 $ do

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

472--

473-- @since 0.7.0

474{-# INLINE runPipe #-}

475−runPipe :: (MonadIO m, Storable a, Storable b)

475+runPipe :: (MonadIO m, Unboxed a, Prim b)

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

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

478-}

@@ -503,7 +503,7 @@ streamTransform f arr =

503--

504castUnsafe ::

505#ifdef DEVBUILD

506− Storable b =>

506+ Prim b =>

507#endif

508 Array a -> Array b

509castUnsafe (Array contents start end) =

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

522--

523-- @since 0.8.0

524--

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

525+cast :: forall a b. (Unboxed b) => Array a -> Maybe (Array b)

526cast arr =

527 let len = A.byteLength arr

528 r = len `mod` SIZE_OF(b)

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

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

33where

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

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

36+import Streamly.Internal.Data.Unboxed (Storable, Unboxed)

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

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

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

63--

64-- /Pre-release/

65{-# INLINE genSlicesFromLen #-}

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

66+genSlicesFromLen :: forall m a. (Monad m, Unboxed 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, Storable a)

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

84 => Int -- ^ from index

85 -> Int -- ^ length of the slice

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

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

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

2316-- NFData

2317-------------------------------------------------------------------------------

2318

2319−-- This is a Storable array, we cannot have unevaluated data in it so this is

2319+-- This is a Unboxed array, we cannot have unevaluated data in it so this is

2320-- just a no op.

2321instance NFData (Array a) where

2322 {-# INLINE rnf #-}

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

@@ -524,7 +524,7 @@ instance (Storable a, Eq a) => Eq (Array a) where

524 arr1 == arr2 =

525 (==) EQ $ unsafeInlineIO $! unsafeThaw arr1 `MA.cmp` unsafeThaw arr2

526

527−-- Since this is a Storable array we cannot have unevaluated data in it so

527+-- Since this is a Unboxed array we cannot have unevaluated data in it so

528-- this is just a no op.

529instance NFData (Array a) where

530 {-# INLINE rnf #-}

core/src/Streamly/Internal/Data/Ring/Foreign.hs−1

@@ -604,7 +604,6 @@ slidingWindowWith n (Fold step1 initial1 extract1) = Fold step initial extract

604 Done b -> Done b

605

606 extract (Tuple4' _ _ _ st) = extract1 st

607−

608-- | @slidingWindow collector@ is an incremental sliding window

607-- | @slidingWindow collector@ is an incremental sliding window

609-- fold that does not require all the intermediate elements in a computation.

608-- fold that does not require all the intermediate elements in a computation.

610-- This maintains @n@ elements in the window, when a new element comes it slides

609-- This maintains @n@ elements in the window, when a new element comes it slides

core/src/Streamly/Internal/Data/Stream/Bottom.hs+2−2

@@ -55,7 +55,7 @@ where

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

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

58−import Streamly.Internal.Data.Unboxed (Storable)

58+import Streamly.Internal.Data.Unboxed (Unboxed)

59import Streamly.Internal.System.IO (defaultChunkSize)

61import qualified Streamly.Internal.Data.Array.Unboxed.Type as A

@@ -312,7 +312,7 @@ reverse s = fromStreamD $ D.reverse $ toStreamD s

312--

313-- /Pre-release/

314{-# INLINE reverse' #-}

315−reverse' :: (MonadIO m, Storable a) => Stream m a -> Stream m a

315+reverse' :: (MonadIO m, Unboxed a) => Stream m a -> Stream m a

316-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s

317reverse' =

318 fromStreamD

core/src/Streamly/Internal/Data/Stream/Reduce.hs+2−2

@@ -58,7 +58,7 @@ import Streamly.Internal.Data.Parser (Parser (..))

58import Streamly.Internal.Data.Refold.Type (Refold (..))

59import Streamly.Internal.Data.Stream.Bottom (foldManyPost)

60import Streamly.Internal.Data.Stream.Type (Stream, fromStreamD, toStreamD)

61−import Streamly.Internal.Data.Unboxed (Storable)

61+import Streamly.Internal.Data.Unboxed (Unboxed)

63import qualified Streamly.Internal.Data.Array.Unboxed.Type as Array

64import qualified Streamly.Internal.Data.Parser.ParserD as ParserD

@@ -313,6 +313,6 @@ parseIterate f i m = fromStreamD $

313--

314-- /Pre-release/

315{-# INLINE arraysOf #-}

316−arraysOf :: (MonadIO m, Storable a)

316+arraysOf :: (MonadIO m, Unboxed a)

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

318arraysOf n = fromStreamD . Array.arraysOf n . toStreamD

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

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

58import Data.Semigroup (Semigroup(..))

59#endif

60import Data.Word (Word8)

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

61+import Streamly.Internal.Data.Unboxed (Storable, Unboxed, peekWith, sizeOf)

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

63import GHC.Exts (SpecConstrAnnotation(..))

64import GHC.Types (SPEC(..))

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

105--

106-- /Pre-release/

107{-# INLINE arraysOf #-}

108−arraysOf :: (IsStream t, MonadIO m, Storable a)

108+arraysOf :: (IsStream t, MonadIO m, Unboxed a)

109 => Int -> t m a -> t m (Array a)

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

111

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

125--

126-- @since 0.7.0

127{-# INLINE concat #-}

128−concat :: (IsStream t, Monad m, Storable a) => t m (Array a) -> t m a

128+concat :: (IsStream t, Monad m, Unboxed a) => t m (Array a) -> t m a

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

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

131concat m = fromStreamD $ D.unfoldMany A.read (toStreamD m)

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

137--

138-- @since 0.7.0

139{-# INLINE concatRev #-}

140−concatRev :: (IsStream t, Monad m, Storable a) => t m (Array a) -> t m a

140+concatRev :: (IsStream t, Monad m, Unboxed a) => t m (Array a) -> t m a

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

142concatRev m = fromStreamD $ D.unfoldMany A.readRev (toStreamD m)

143

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

150--

151-- /Pre-release/

152{-# INLINE interpose #-}

153−interpose :: (Monad m, IsStream t, Storable a) => a -> t m (Array a) -> t m a

153+interpose :: (Monad m, IsStream t, Unboxed a) => a -> t m (Array a) -> t m a

154interpose x = S.interpose x A.read

155

156{-# INLINE intercalateSuffix #-}

157−intercalateSuffix :: (Monad m, IsStream t, Storable a)

157+intercalateSuffix :: (Monad m, IsStream t, Unboxed a)

158 => Array a -> t m (Array a) -> t m a

159intercalateSuffix = S.intercalateSuffix A.read

160

@@ -163,7 +163,7 @@ intercalateSuffix = S.intercalateSuffix A.read

163--

164-- @since 0.7.0

165{-# INLINE interposeSuffix #-}

166−interposeSuffix :: (Monad m, IsStream t, Storable a)

166+interposeSuffix :: (Monad m, IsStream t, Unboxed a)

167 => a -> t m (Array a) -> t m a

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

169interposeSuffix x = S.interposeSuffix x A.read

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

174

175-- XXX Remove monadIO constraint

176{-# INLINE_NORMAL unlines #-}

177−unlines :: forall m a. (MonadIO m, Storable a)

177+unlines :: forall m a. (MonadIO m, Unboxed a)

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

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

180 where

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

202-- module Streamly.Internal.Data.Array.Stream.Mut.Foreign

203--

204{-# INLINE_NORMAL packArraysChunksOf #-}

205−packArraysChunksOf :: (MonadIO m, Storable a)

205+packArraysChunksOf :: (MonadIO m, Unboxed a)

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

207packArraysChunksOf n str =

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

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

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

211-- write it as a pipe.

212{-# INLINE_NORMAL lpackArraysChunksOf #-}

213−lpackArraysChunksOf :: (MonadIO m, Storable a)

213+lpackArraysChunksOf :: (MonadIO m, Unboxed a)

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

215lpackArraysChunksOf n fld =

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

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

220--

221-- @since 0.7.0

222{-# INLINE compact #-}

223−compact :: (MonadIO m, Storable a)

223+compact :: (MonadIO m, Unboxed a)

224 => Int -> SerialT m (Array a) -> SerialT m (Array a)

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

226

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

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

318--

319{-# INLINE_NORMAL foldBreakD #-}

320−foldBreakD :: forall m a b. (MonadIO m, Storable a) =>

320+foldBreakD :: forall m a b. (MonadIO m, Unboxed a) =>

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

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

323 res <- initial

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

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

354

355{-# INLINE_NORMAL foldBreakK #-}

356−foldBreakK :: forall m a b. (MonadIO m, Storable a) =>

356+foldBreakK :: forall m a b. (MonadIO m, Unboxed a) =>

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

358foldBreakK (Fold fstep initial extract) stream = do

359 res <- initial

@@ -394,7 +394,7 @@ foldBreakK (Fold fstep initial extract) stream = do

394--

395{-# INLINE_NORMAL foldBreak #-}

396foldBreak ::

397− (MonadIO m, Storable a)

397+ (MonadIO m, Unboxed a)

398 => FL.Fold m a b

399 -> SerialT m (A.Array a)

400 -> m (b, SerialT m (A.Array a))

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

413

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

415{-# INLINE takeArrayListRev #-}

416−takeArrayListRev :: forall a. Storable a => Int -> [Array a] -> [Array a]

416+takeArrayListRev :: forall a. Unboxed a => Int -> [Array a] -> [Array a]

417takeArrayListRev = go

418

419 where

@@ -464,14 +464,14 @@ splitAtArrayListRev n ls

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

465-- stream.

466{-# INLINE spliceArraysLenUnsafe #-}

467−spliceArraysLenUnsafe :: (MonadIO m, Storable a)

467+spliceArraysLenUnsafe :: (MonadIO m, Unboxed a)

468 => Int -> SerialT m (MA.Array a) -> m (MA.Array a)

469spliceArraysLenUnsafe len buffered = do

470 arr <- liftIO $ MA.newArray len

471 S.foldlM' MA.spliceUnsafe (return arr) buffered

472

473{-# INLINE _spliceArrays #-}

474−_spliceArrays :: (MonadIO m, Storable a)

474+_spliceArrays :: (MonadIO m, Unboxed a)

475 => SerialT m (Array a) -> m (Array a)

476_spliceArrays s = do

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

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

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

486

487{-# INLINE _spliceArraysBuffered #-}

488−_spliceArraysBuffered :: (MonadIO m, Storable a)

488+_spliceArraysBuffered :: (MonadIO m, Unboxed a)

489 => SerialT m (Array a) -> m (Array a)

490_spliceArraysBuffered s = do

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

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

493 A.unsafeFreeze <$> spliceArraysLenUnsafe len (S.map A.unsafeThaw s)

494

495{-# INLINE spliceArraysRealloced #-}

496−spliceArraysRealloced :: forall m a. (MonadIO m, Storable a)

496+spliceArraysRealloced :: forall m a. (MonadIO m, Unboxed a)

497 => SerialT m (Array a) -> m (Array a)

498spliceArraysRealloced s = do

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

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

509--

510-- @since 0.7.0

511{-# INLINE toArray #-}

512−toArray :: (MonadIO m, Storable a) => SerialT m (Array a) -> m (Array a)

512+toArray :: (MonadIO m, Unboxed a) => SerialT m (Array a) -> m (Array a)

513toArray = spliceArraysRealloced

514-- spliceArrays = _spliceArraysBuffered

515

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

520--

521{-

522{-# INLINE toArraysInRange #-}

523−toArraysInRange :: (IsStream t, MonadIO m, Storable a)

523+toArraysInRange :: (IsStream t, MonadIO m, Unboxed a)

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

525toArraysInRange low high (Fold step initial extract) =

526-}

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

528{-

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

530{-# INLINE _toArraysOf #-}

531−_toArraysOf :: (MonadIO m, Storable a)

531+_toArraysOf :: (MonadIO m, Unboxed a)

532 => Int -> Fold m a (SerialT Identity (Array a))

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

534-}

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

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

550{-# INLINE_NORMAL parseBreakD #-}

551parseBreakD ::

552− forall m a b. (MonadIO m, MonadThrow m, Storable a)

552+ forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

553 => PRD.Parser m a b

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

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

@@ -629,7 +629,7 @@ parseBreakD

629

630{-# INLINE_NORMAL parseBreakK #-}

631parseBreakK ::

632− forall m a b. (MonadIO m, MonadThrow m, Storable a)

632+ forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

633 => PRD.Parser m a b

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

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

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

708--

709{-# INLINE_NORMAL parseBreak #-}

710parseBreak ::

711− (MonadIO m, MonadThrow m, Storable a)

711+ (MonadIO m, MonadThrow m, Unboxed a)

712 => PR.Parser m a b

713 -> SerialT m (A.Array a)

714 -> m (b, SerialT m (A.Array a))

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

734--

735{-# INLINE_NORMAL runArrayParserDBreak #-}

736runArrayParserDBreak ::

737− forall m a b. (MonadIO m, MonadThrow m, Storable a)

737+ forall m a b. (MonadIO m, MonadThrow m, Unboxed a)

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

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

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

@@ -806,7 +806,7 @@ runArrayParserDBreak

806--

807{-# INLINE parseArr #-}

808parseArr ::

809− (MonadIO m, MonadThrow m, Storable a)

809+ (MonadIO m, MonadThrow m, Unboxed a)

810 => ASF.Parser m a b

811 -> SerialT m (A.Array a)

812 -> m (b, SerialT m (A.Array a))

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

818-- /Pre-release/

819--

820{-# INLINE runArrayFold #-}

821−runArrayFold :: (MonadIO m, MonadThrow m, Storable a) =>

821+runArrayFold :: (MonadIO m, MonadThrow m, Unboxed a) =>

822 ArrayFold m a b -> SerialT m (A.Array a) -> m b

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

824

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

827-- /Pre-release/

828--

829{-# INLINE runArrayFoldBreak #-}

830−runArrayFoldBreak :: (MonadIO m, MonadThrow m, Storable a) =>

830+runArrayFoldBreak :: (MonadIO m, MonadThrow m, Unboxed a) =>

831 ArrayFold m a b -> SerialT m (A.Array a) -> m (b, SerialT m (A.Array a))

832runArrayFoldBreak (ArrayFold p) s =

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

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

842

843{-# INLINE_NORMAL runArrayFoldManyD #-}

844runArrayFoldManyD

845− :: (MonadThrow m, Storable a)

845+ :: (MonadThrow m, Unboxed a)

846 => ArrayFold m a b

847 -> D.Stream m (Array a)

848 -> D.Stream m b

@@ -970,7 +970,7 @@ runArrayFoldManyD

970-- /Pre-release/

971{-# INLINE runArrayFoldMany #-}

972runArrayFoldMany

973− :: (IsStream t, MonadThrow m, Storable a)

973+ :: (IsStream t, MonadThrow m, Unboxed a)

974 => ArrayFold m a b

975 -> t m (Array a)

976 -> t m b

src/Streamly/Internal/Data/Stream/IsStream/Common.hs+2−2

@@ -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 (Storable, Unboxed)

82+import Streamly.Internal.Data.Unboxed (Unboxed)

84import qualified Streamly.Internal.Data.Array.Unboxed.Type as A

85import qualified Streamly.Internal.Data.Stream.Async as Async

@@ -499,7 +499,7 @@ reverse s = fromStreamS $ S.reverse $ toStreamS s

499--

500-- /Pre-release/

501{-# INLINE reverse' #-}

502−reverse' :: (IsStream t, MonadIO m, Storable a) => t m a -> t m a

502+reverse' :: (IsStream t, MonadIO m, Unboxed a) => t m a -> t m a

503-- reverse' s = fromStreamD $ D.reverse' $ toStreamD s

504reverse' =

505 fromStreamD

src/Streamly/Internal/Data/Stream/IsStream/Reduce.hs+7−7

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

178import Streamly.Internal.Data.Time.Units

179 ( AbsTime, MilliSecond64(..), addToAbsTime, toRelTime

180 , toAbsTime)

181−import Streamly.Internal.Data.Unboxed (Storable, Unboxed)

181+import Streamly.Internal.Data.Unboxed (Unboxed)

182

183import qualified Data.Heap as H

184import qualified Streamly.Data.Unfold as Unfold

@@ -779,7 +779,7 @@ splitWithSuffix predicate f = foldMany (FL.takeEndBy predicate f)

779-- /Unimplemented/

780--

781{-# INLINE splitOnAny #-}

782−splitOnAny :: -- (IsStream t, Monad m, Storable a, Integral a) =>

782+splitOnAny :: -- (IsStream t, Monad m, Prim a, Integral a) =>

783 [Array a] -> Fold m a b -> t m a -> t m b

784splitOnAny _subseq _f _m =

785 undefined -- D.fromStreamD $ D.splitOnAny f subseq (D.toStreamD m)

@@ -889,7 +889,7 @@ splitOnSuffixSeq patt f m =

889--

890-- /Unimplemented/

891{-# INLINE wordsOn #-}

892−wordsOn :: -- (IsStream t, Monad m, Storable a, Eq a) =>

892+wordsOn :: -- (IsStream t, Monad m, Prim a, Eq a) =>

893 Array a -> Fold m a b -> t m a -> t m b

894wordsOn _subseq _f _m =

895 undefined -- D.fromStreamD $ D.wordsOn f subseq (D.toStreamD m)

@@ -939,7 +939,7 @@ splitWithSuffixSeq patt f m =

939--

940-- /Unimplemented/

941{-# INLINE splitOnSuffixSeqAny #-}

942−splitOnSuffixSeqAny :: -- (IsStream t, Monad m, Storable a, Integral a) =>

942+splitOnSuffixSeqAny :: -- (IsStream t, Monad m, Prim a, Integral a) =>

943 [Array a] -> Fold m a b -> t m a -> t m b

944splitOnSuffixSeqAny _subseq _f _m = undefined

945 -- D.fromStreamD $ D.splitPostAny f subseq (D.toStreamD m)

@@ -975,7 +975,7 @@ chunksOf n f = fromStreamD . D.chunksOf n f . toStreamD

975--

976-- /Pre-release/

977{-# INLINE arraysOf #-}

978−arraysOf :: (IsStream t, MonadIO m, Storable a)

978+arraysOf :: (IsStream t, MonadIO m, Unboxed a)

979 => Int -> t m a -> t m (Array a)

980arraysOf n = fromStreamD . A.arraysOf n . toStreamD

981

@@ -1081,7 +1081,7 @@ classifySlidingSessions tick interval slide (Fold step initial extract) str

1081-- insert the new elements, and apply an incremental fold on the sliding

1082-- window, supplying the outgoing elements, the new ring buffer as arguments.

1083slidingChunkBuffer

1084− :: (IsStream t, Monad m, Ord a, Storable a)

1084+ :: (IsStream t, Monad m, Ord a, Unboxed a)

1085 => Int -- window size

1086 -> Int -- window slide

1087 -> Fold m (Ring a, Array a) b

@@ -1094,7 +1094,7 @@ slidingChunkBuffer = undefined

1094-- an incremental fold on the sliding window, supplying the outgoing elements,

1095-- and the new radix tree buffer as arguments.

1096slidingSessionBuffer

1097− :: (IsStream t, Monad m, Ord a, Storable a)

1097+ :: (IsStream t, Monad m, Ord a, Unboxed a)

1098 => Int -- window size

1099 -> Int -- tick size

1100 -> Fold m (RTree a, Array a) b

src/Streamly/Internal/FileSystem/FD.hs+12−12

@@ -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 (Storable)

123+import Streamly.Internal.Data.Unboxed (Storable, Unboxed)

124-- import System.IO (Handle, hGetBufSome, hPutBuf)

125import System.IO (IOMode)

126import Prelude hiding (read)

@@ -237,7 +237,7 @@ readArrayUpto size (Handle fd) = do

237--

238-- @since 0.7.0

239{-# INLINABLE writeArray #-}

240−writeArray :: Storable a => Handle -> Array a -> IO ()

240+writeArray :: Unboxed a => Handle -> Array a -> IO ()

241writeArray _ arr | A.length arr == 0 = return ()

242writeArray (Handle fd) arr =

243 asPtrUnsafe arr $ \p ->

@@ -334,7 +334,7 @@ readInChunksOf :: (IsStream t, MonadIO m) => Int -> Handle -> t m Word8

334readInChunksOf chunkSize h = AS.concat $ readArraysOfUpto chunkSize h

335

336-- TODO

337−-- read :: (IsStream t, MonadIO m, Storable a) => Handle -> t m a

337+-- read :: (IsStream t, MonadIO m, Unboxed a) => Handle -> t m a

338--

339-- > read = 'readByChunks' A.defaultChunkSize

340-- | Generate a stream of elements of the given type from a file 'Handle'. The

@@ -481,7 +481,7 @@ readLines h f = foldLines (readUtf8 h) f

481--

482-- @since 0.7.0

483{-# INLINE readFrames #-}

484−readFrames :: (IsStream t, MonadIO m, Storable a)

484+readFrames :: (IsStream t, MonadIO m, Unboxed a)

485 => Array a -> Handle -> Fold m a b -> t m b

486readFrames = undefined -- foldFrames . read

487

@@ -490,7 +490,7 @@ readFrames = undefined -- foldFrames . read

490--

491-- @since 0.7.0

492{-# INLINE writeByFrames #-}

493−writeByFrames :: (IsStream t, MonadIO m, Storable a)

493+writeByFrames :: (IsStream t, MonadIO m, Unboxed a)

494 => Array a -> Handle -> t m a -> m ()

495writeByFrames = undefined

496

@@ -508,7 +508,7 @@ writeByFrames = undefined

508--

509-- @since 0.7.0

510{-# INLINE readIndex #-}

511−readIndex :: Storable a => Handle -> Int -> Maybe a

511+readIndex :: Unboxed a => Handle -> Int -> Maybe a

512readIndex arr i = undefined

513

514-- NOTE: To represent a range to read we have chosen (start, size) instead of

@@ -528,7 +528,7 @@ readIndex arr i = undefined

528-- chunk is aligned with @chunkSize@ from second chunk onwards.

529--

530{-# INLINE readSliceWith #-}

531−readSliceWith :: (IsStream t, MonadIO m, Storable a)

531+readSliceWith :: (IsStream t, MonadIO m, Unboxed a)

532 => Int -> Handle -> Int -> Int -> t m a

533readSliceWith chunkSize h pos len = undefined

534

@@ -538,7 +538,7 @@ readSliceWith chunkSize h pos len = undefined

538--

539-- @since 0.7.0

540{-# INLINE readSlice #-}

541−readSlice :: (IsStream t, MonadIO m, Storable a)

541+readSlice :: (IsStream t, MonadIO m, Unboxed a)

542 => Handle -> Int -> Int -> t m a

543readSlice = readSliceWith defaultChunkSize

544

@@ -548,7 +548,7 @@ readSlice = readSliceWith defaultChunkSize

548--

549-- @since 0.7.0

550{-# INLINE readSliceRev #-}

551−readSliceRev :: (IsStream t, MonadIO m, Storable a)

551+readSliceRev :: (IsStream t, MonadIO m, Unboxed a)

552 => Handle -> Int -> Int -> t m a

553readSliceRev h i count = undefined

554

@@ -556,7 +556,7 @@ readSliceRev h i count = undefined

556--

557-- @since 0.7.0

558{-# INLINE writeIndex #-}

559−writeIndex :: (MonadIO m, Storable a) => Handle -> Int -> a -> m ()

559+writeIndex :: (MonadIO m, Unboxed a) => Handle -> Int -> a -> m ()

560writeIndex h i a = undefined

561

562-- | @writeSlice h i count stream@ writes a stream to the file handle @h@

@@ -565,7 +565,7 @@ writeIndex h i a = undefined

565--

566-- @since 0.7.0

567{-# INLINE writeSlice #-}

568−writeSlice :: (IsStream t, Monad m, Storable a)

568+writeSlice :: (IsStream t, Monad m, Unboxed a)

569 => Handle -> Int -> Int -> t m a -> m ()

570writeSlice h i len s = undefined

571

@@ -575,7 +575,7 @@ writeSlice h i len s = undefined

575--

576-- @since 0.7.0

577{-# INLINE writeSliceRev #-}

578−writeSliceRev :: (IsStream t, Monad m, Storable a)

578+writeSliceRev :: (IsStream t, Monad m, Unboxed a)

579 => Handle -> Int -> Int -> t m a -> m ()

580writeSliceRev arr i len s = undefined

581-}

src/Streamly/Internal/FileSystem/Handle.hs+4−4

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

114import Data.Function ((&))

115import Data.Maybe (isNothing, fromJust)

116import Data.Word (Word8)

117−import Streamly.Internal.Data.Unboxed (Storable)

117+import Streamly.Internal.Data.Unboxed (Storable, Unboxed)

118import System.IO (Handle, SeekMode(..), hGetBufSome, hPutBuf, hSeek)

119import Prelude hiding (read)

120

@@ -365,7 +365,7 @@ getBytesWith size h = AS.concat $ getChunksWith size h

365

366-- TODO

367-- Generate a stream of elements of the given type from a file 'Handle'.

368−-- read :: (IsStream t, MonadIO m, Storable a) => Handle -> t m a

368+-- read :: (IsStream t, MonadIO m, Unboxed a) => Handle -> t m a

369--

370-- | Unfolds a file handle into a byte stream. IO requests to the device are

371-- performed in sizes of

@@ -495,7 +495,7 @@ consumeChunks = Refold.drainBy putChunk

495--

496-- @since 0.9.0

497{-# INLINE writeChunksWith #-}

498−writeChunksWith :: (MonadIO m, Storable a)

498+writeChunksWith :: (MonadIO m, Unboxed a)

499 => Int -> Handle -> Fold m (Array a) ()

500writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

501

@@ -504,7 +504,7 @@ writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

504-- @since 0.7.0

505{-# DEPRECATED writeChunksWithBufferOf "Please use writeChunksWith instead." #-}

506{-# INLINE writeChunksWithBufferOf #-}

507−writeChunksWithBufferOf :: (MonadIO m, Storable a)

507+writeChunksWithBufferOf :: (MonadIO m, Unboxed a)

508 => Int -> Handle -> Fold m (Array a) ()

509writeChunksWithBufferOf = writeChunksWith

510

src/Streamly/Internal/Network/Socket.hs+9−9

@@ -76,7 +76,7 @@ import Control.Monad (forM_, when)

76import Data.Maybe (isNothing, fromJust)

77import Data.Word (Word8)

78import Foreign.Ptr (plusPtr, Ptr, castPtr)

79−import Streamly.Internal.Data.Unboxed (Storable)

79+import Streamly.Internal.Data.Unboxed (Storable, Unboxed)

80import Network.Socket

81 (Socket, SocketOption(..), Family(..), SockAddr(..),

82 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 :: Storable a

306+writeArrayWith :: Unboxed a

307 => (h -> Ptr Word8 -> Int -> IO ())

308 -> h

309 -> Array a

@@ -319,7 +319,7 @@ writeArrayWith f h arr = A.asPtrUnsafe arr $ \ptr -> f h (castPtr ptr) aLen

319--

320-- @since 0.8.0

321{-# INLINABLE writeChunk #-}

322−writeChunk :: Storable a => Socket -> Array a -> IO ()

322+writeChunk :: Unboxed a => Socket -> Array a -> IO ()

323writeChunk = writeArrayWith sendAll

324

325-------------------------------------------------------------------------------

@@ -423,7 +423,7 @@ readWith chunkSize h = A.flattenArrays $ readChunksUpto chunkSize h

423-}

424

425-- TODO

426−-- read :: (IsStream t, MonadIO m, Storable a) => Handle -> t m a

426+-- read :: (IsStream t, MonadIO m, Unboxed a) => Handle -> t m a

427--

428-- > read = 'readByChunks' defaultChunkSize

429-- | Generate a stream of elements of the given type from a socket. The

@@ -476,7 +476,7 @@ putChunks h = S.mapM_ (liftIO . writeChunk h)

476--

477-- @since 0.7.0

478{-# INLINE writeChunks #-}

479−writeChunks :: (MonadIO m, Storable a) => Socket -> Fold m (Array a) ()

479+writeChunks :: (MonadIO m, Unboxed a) => Socket -> Fold m (Array a) ()

480writeChunks h = FL.drainBy (liftIO . writeChunk h)

481

482-- | @writeChunksWith bufsize socket@ writes a stream of arrays to

@@ -487,7 +487,7 @@ writeChunks h = FL.drainBy (liftIO . writeChunk h)

487--

488-- @since 0.9.0

489{-# INLINE writeChunksWith #-}

490−writeChunksWith :: (MonadIO m, Storable a)

490+writeChunksWith :: (MonadIO m, Unboxed a)

491 => Int -> Socket -> Fold m (Array a) ()

492writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

493

@@ -496,7 +496,7 @@ writeChunksWith n h = lpackArraysChunksOf n (writeChunks h)

496-- @since 0.7.0

497{-# DEPRECATED writeChunksWithBufferOf "Please use 'writeChunksWith' instead" #-}

498{-# INLINE writeChunksWithBufferOf #-}

499−writeChunksWithBufferOf :: (MonadIO m, Storable a)

499+writeChunksWithBufferOf :: (MonadIO m, Unboxed a)

500 => Int -> Socket -> Fold m (Array a) ()

501writeChunksWithBufferOf = writeChunksWith

502

@@ -630,7 +630,7 @@ readLines h f = foldLines (readUtf8 h) f

630--

631-- @since 0.7.0

632{-# INLINE readFrames #-}

633−readFrames :: (IsStream t, MonadIO m, Storable a)

633+readFrames :: (IsStream t, MonadIO m, Unboxed a)

634 => Array a -> Handle -> Fold m a b -> t m b

635readFrames = undefined -- foldFrames . read

636

@@ -639,7 +639,7 @@ readFrames = undefined -- foldFrames . read

639--

640-- @since 0.7.0

641{-# INLINE writeByFrames #-}

642−writeByFrames :: (IsStream t, MonadIO m, Storable a)

642+writeByFrames :: (IsStream t, MonadIO m, Unboxed a)

643 => Array a -> Handle -> t m a -> m ()

644writeByFrames = undefined

645-}