ead1601 · streamly · git.iko.soy

benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+1−1

compare with master

unifiedsplit

@@ -47,7 +47,7 @@ import Foreign.Storable (Storable)

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

48

49import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

50−import qualified Streamly.Internal.Data.Strict as Strict

50+import qualified Streamly.Internal.Data.Tuple.Strict as Strict

51import qualified Streamly.Internal.Memory.Array as A

52import qualified Streamly.Internal.Memory.Array.Types as AT

53

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

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

9import Data.Primitive.Types (Prim(..), sizeOf)

10import Streamly.Internal.Data.Fold.Types (Fold(..))

11import Streamly.Internal.Data.SVar (adaptState)

12−import Streamly.Internal.Data.Strict (Tuple'(..), Tuple3'(..))

12+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

13

14import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

15

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

@@ -13,7 +13,8 @@ import Data.Primitive.Types (Prim(..), sizeOf)

13import Data.Semigroup (Semigroup(..))

14#endif

15import Data.Word (Word8)

16−import Streamly.Internal.Data.Strict (Tuple3'(..), Maybe'(..))

16+import Streamly.Internal.Data.Tuple.Strict (Tuple3'(..))

17+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..))

17import Streamly.Internal.Data.Fold.Types (Fold(..))

18import Streamly.Internal.Data.Fold.Types (Fold(..))

18import Streamly.Internal.Data.SVar (adaptState)

19import Streamly.Internal.Data.SVar (adaptState)

19import System.IO.Unsafe (unsafePerformIO)

20import System.IO.Unsafe (unsafePerformIO)

src/Streamly/Internal/Data/Binary/Decode.hs+2−1

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

29import Data.Bits ((.|.), unsafeShiftL)

30import Data.Word (Word8, Word16, Word32, Word64)

31import Streamly.Internal.Data.Parser (Parser)

32−import Streamly.Internal.Data.Strict (Maybe'(..), Tuple' (..))

32+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..))

33+import Streamly.Internal.Data.Tuple.Strict (Tuple' (..))

33

34

34import qualified Streamly.Internal.Memory.Array as A

35import qualified Streamly.Internal.Memory.Array as A

35import qualified Streamly.Internal.Data.Parser as PR

36import qualified Streamly.Internal.Data.Parser as PR

src/Streamly/Internal/Data/Either/Strict.hsnew file+26

@@ -0,0 +1,26 @@

1+-- |

2+-- Module : Streamly.Internal.Data.Either.Strict

5+-- License : BSD3

6+-- Maintainer : streamly@composewell.com

7+-- Stability : experimental

8+-- Portability : GHC

9+--

10+-- | Strict data types to be used as accumulator for strict left folds and

11+-- scans. For more comprehensive strict data types see

12+-- https://hackage.haskell.org/package/strict-base-types . The names have been

13+-- suffixed by a prime so that programmers can easily distinguish the strict

14+-- versions from the lazy ones.

15+--

16+-- One major advantage of strict data structures as accumulators in folds and

17+-- scans is that it helps the compiler optimize the code much better by

18+-- unboxing. In a big tight loop the difference could be huge.

19+--

20+module Streamly.Internal.Data.Either.Strict

21+ ( Either' (..)

22+ )

23+where

24+

25+-- | A strict 'Either'

26+data Either' a b = Left' !a | Right' !b deriving Show

src/Streamly/Internal/Data/Fold.hs+13−13

@@ -211,24 +211,24 @@ import Data.Map.Strict (Map)

211#if __GLASGOW_HASKELL__ < 804

212import Data.Semigroup (Semigroup((<>)))

213#endif

214+import Streamly.Internal.Data.Pipe.Types (Pipe (..), PipeState(..))

215+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

216+import Streamly.Internal.Data.Either.Strict (Either'(..))

217+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)

214

218

215−import Prelude

219+import qualified Streamly.Internal.Data.Pipe.Types as Pipe

216− hiding (filter, drop, dropWhile, take, takeWhile, zipWith,

217− foldl, map, mapM_, sequence, all, any, sum, product, elem,

218− notElem, maximum, minimum, head, last, tail, length, null,

219− reverse, iterate, init, and, or, lookup, (!!),

220− scanl, scanl1, replicate, concatMap, mconcat, foldMap, unzip,

221− span, splitAt, break, mapM)

222−

223import qualified Data.Map.Strict as Map

220import qualified Data.Map.Strict as Map

224import qualified Prelude

221import qualified Prelude

225

222

226−import Streamly.Internal.Data.Pipe.Types (Pipe (..), PipeState(..))

223+import Prelude hiding

227−import Streamly.Internal.Data.Fold.Types

224+ ( filter, drop, dropWhile, take, takeWhile, zipWith

228−import Streamly.Internal.Data.Strict

225+ , foldl, map, mapM_, sequence, all, any, sum, product, elem

226+ , notElem, maximum, minimum, head, last, tail, length, null

227+ , reverse, iterate, init, and, or, lookup, (!!)

228+ , scanl, scanl1, replicate, concatMap, mconcat, foldMap, unzip

229+ , span, splitAt, break, mapM)

229import Streamly.Internal.Data.SVar

230import Streamly.Internal.Data.SVar

230−

231−import qualified Streamly.Internal.Data.Pipe.Types as Pipe

231+import Streamly.Internal.Data.Fold.Types

232

233------------------------------------------------------------------------------

234-- Smart constructors

src/Streamly/Internal/Data/Fold/Types.hs+2−1

@@ -152,7 +152,8 @@ import Data.Maybe (isJust, fromJust)

152#if __GLASGOW_HASKELL__ < 808

153import Data.Semigroup (Semigroup(..))

154#endif

155−import Streamly.Internal.Data.Strict (Tuple'(..), Tuple3'(..), Either'(..))

155+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

156+import Streamly.Internal.Data.Either.Strict (Either'(..))

156import Streamly.Internal.Data.SVar (MonadAsync)

157import Streamly.Internal.Data.SVar (MonadAsync)

157

158

158------------------------------------------------------------------------------

159------------------------------------------------------------------------------

src/Streamly/Internal/Data/Maybe/Strict.hsnew file+33

@@ -0,0 +1,33 @@

1+-- |

2+-- Module : Streamly.Internal.Data.Maybe.Strict

5+-- License : BSD3

6+-- Maintainer : streamly@composewell.com

7+-- Stability : experimental

8+-- Portability : GHC

9+--

10+-- | Strict data types to be used as accumulator for strict left folds and

11+-- scans. For more comprehensive strict data types see

12+-- https://hackage.haskell.org/package/strict-base-types . The names have been

13+-- suffixed by a prime so that programmers can easily distinguish the strict

14+-- versions from the lazy ones.

15+--

16+-- One major advantage of strict data structures as accumulators in folds and

17+-- scans is that it helps the compiler optimize the code much better by

18+-- unboxing. In a big tight loop the difference could be huge.

19+--

20+module Streamly.Internal.Data.Maybe.Strict

21+ ( Maybe' (..)

22+ , toMaybe

23+ )

24+where

25+

26+-- | A strict 'Maybe'

27+data Maybe' a = Just' !a | Nothing' deriving Show

28+

29+-- | Convert strict Maybe' to lazy Maybe

30+{-# INLINABLE toMaybe #-}

31+toMaybe :: Maybe' a -> Maybe a

32+toMaybe Nothing' = Nothing

33+toMaybe (Just' a) = Just a

src/Streamly/Internal/Data/Parser/ParserD.hs+3−3

@@ -160,13 +160,13 @@ where

160

161import Control.Exception (assert)

162import Control.Monad.Catch (MonadCatch, MonadThrow(..))

163−import Prelude

164− hiding (any, all, take, takeWhile, sequence, concatMap, maybe, either)

165import Streamly.Internal.Data.Fold.Types (Fold(..))

163import Streamly.Internal.Data.Fold.Types (Fold(..))

164+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

166

165

166+import Prelude hiding

167+ (any, all, take, takeWhile, sequence, concatMap, maybe, either)

167import Streamly.Internal.Data.Parser.ParserD.Tee

168import Streamly.Internal.Data.Parser.ParserD.Tee

168import Streamly.Internal.Data.Parser.ParserD.Types

169import Streamly.Internal.Data.Parser.ParserD.Types

169−import Streamly.Internal.Data.Strict

170

171-------------------------------------------------------------------------------

172-- Upgrade folds to parses

src/Streamly/Internal/Data/Parser/ParserD/Types.hs+3−3

@@ -133,11 +133,11 @@ import Control.Applicative (Alternative(..))

133import Control.Exception (assert, Exception(..))

134import Control.Monad (MonadPlus(..))

135import Control.Monad.Catch (MonadCatch, try, throwM, MonadThrow)

136−import Prelude hiding (concatMap)

137−

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

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

139import Streamly.Internal.Data.Fold (Fold(..), toList)

137import Streamly.Internal.Data.Fold (Fold(..), toList)

140−import Streamly.Internal.Data.Strict (Tuple3'(..))

138+import Streamly.Internal.Data.Tuple.Strict (Tuple3'(..))

139+

140+import Prelude hiding (concatMap)

141

142-- | The return type of a 'Parser' step.

143--

src/Streamly/Internal/Data/Pipe/Types.hs+1−1

@@ -26,7 +26,7 @@ import Data.Maybe (isJust)

26import Data.Semigroup (Semigroup(..))

27#endif

28import Prelude hiding (zipWith, map, id, unzip, null)

29−import Streamly.Internal.Data.Strict (Tuple'(..), Tuple3'(..))

29+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))

30

31import qualified Prelude

32

src/Streamly/Internal/Data/Stream/Serial.hs+9−8

@@ -48,7 +48,6 @@ import Control.DeepSeq (NFData1(..))

48#endif

49import Control.Monad.Base (MonadBase(..), liftBaseDefault)

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

51−-- import Control.Monad.Error.Class (MonadError(..))

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

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

53import Control.Monad.Reader.Class (MonadReader(..))

52import Control.Monad.Reader.Class (MonadReader(..))

54import Control.Monad.State.Class (MonadState(..))

53import Control.Monad.State.Class (MonadState(..))

@@ -61,18 +60,20 @@ import Data.Semigroup (Endo(..))

61import Data.Semigroup (Semigroup(..))

60import Data.Semigroup (Semigroup(..))

62#endif

61#endif

63import GHC.Exts (IsList(..), IsString(..))

62import GHC.Exts (IsList(..), IsString(..))

63+import Text.Read

64−import Text.Read (Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec,

64+ ( Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec

65− readListPrecDefault)

65+ , readListPrecDefault)

66−import Prelude hiding (map, mapM, errorWithoutStackTrace)

67−

68import Streamly.Internal.BaseCompat ((#.), errorWithoutStackTrace)

66import Streamly.Internal.BaseCompat ((#.), errorWithoutStackTrace)

69−import Streamly.Internal.Data.Stream.StreamK (IsStream(..), adapt, Stream, mkStream,

67+import Streamly.Internal.Data.Stream.StreamK

70− foldStream)

68+ (IsStream(..), adapt, Stream, mkStream, foldStream)

71−import Streamly.Internal.Data.Strict (Maybe'(..), toMaybe)

69+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)

70+

72import qualified Streamly.Internal.Data.Stream.Prelude as P

71import qualified Streamly.Internal.Data.Stream.Prelude as P

73import qualified Streamly.Internal.Data.Stream.StreamK as K

72import qualified Streamly.Internal.Data.Stream.StreamK as K

74import qualified Streamly.Internal.Data.Stream.StreamD as D

73import qualified Streamly.Internal.Data.Stream.StreamD as D

75

74

75+import Prelude hiding (map, mapM, errorWithoutStackTrace)

76+

76#include "Instances.hs"

77#include "Instances.hs"

77#include "inline.hs"

78#include "inline.hs"

78

79

src/Streamly/Internal/Data/Stream/StreamD.hs+14−17

@@ -322,24 +322,11 @@ import Foreign.Ptr (Ptr)

322import Foreign.Storable (Storable(..))

323import GHC.Types (SPEC(..))

324import System.Mem (performMajorGC)

325−import Prelude

326− hiding (map, mapM, mapM_, repeat, foldr, last, take, filter,

327− takeWhile, drop, dropWhile, all, any, maximum, minimum, elem,

328− notElem, null, head, tail, zipWith, lookup, foldr1, sequence,

329− (!!), scanl, scanl1, concatMap, replicate, enumFromTo, concat,

330− reverse, iterate, splitAt)

331−

332−import qualified Control.Monad.Catch as MC

333−import qualified Control.Monad.Trans.Reader as Reader

334−import qualified Control.Monad.Trans.State.Strict as State

335−import qualified Prelude

336−

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

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

338import Streamly.Internal.Mutable.Prim.Var

326import Streamly.Internal.Mutable.Prim.Var

339 (Prim, Var, readVar, newVar, modifyVar')

327 (Prim, Var, readVar, newVar, modifyVar')

340import Streamly.Internal.Data.Time.Units

328import Streamly.Internal.Data.Time.Units

341 (TimeUnit64, toRelTime64, diffAbsTime64, RelTime64)

329 (TimeUnit64, toRelTime64, diffAbsTime64, RelTime64)

342−

343import Streamly.Internal.Data.Atomics (atomicModifyIORefCAS_)

330import Streamly.Internal.Data.Atomics (atomicModifyIORefCAS_)

344import Streamly.Internal.Memory.Array.Types (Array(..))

331import Streamly.Internal.Memory.Array.Types (Array(..))

345import Streamly.Internal.Data.Fold.Types (Fold(..))

332import Streamly.Internal.Data.Fold.Types (Fold(..))

@@ -349,10 +336,7 @@ import Streamly.Internal.Data.Time.Clock (Clock(Monotonic), getTime)

349import Streamly.Internal.Data.Time.Units

336import Streamly.Internal.Data.Time.Units

350 (MicroSecond64(..), fromAbsTime, toAbsTime, AbsTime)

337 (MicroSecond64(..), fromAbsTime, toAbsTime, AbsTime)

351import Streamly.Internal.Data.Unfold.Types (Unfold(..))

338import Streamly.Internal.Data.Unfold.Types (Unfold(..))

352−import Streamly.Internal.Data.Strict (Tuple3'(..))

339+import Streamly.Internal.Data.Tuple.Strict (Tuple3'(..))

353−

354−import Streamly.Internal.Data.Stream.StreamD.Type

355−import Streamly.Internal.Data.SVar

356import Streamly.Internal.Data.Stream.SVar (fromConsumer, pushToFold)

340import Streamly.Internal.Data.Stream.SVar (fromConsumer, pushToFold)

357

341

358import qualified Streamly.Internal.Data.Pipe.Types as Pipe

342import qualified Streamly.Internal.Data.Pipe.Types as Pipe

@@ -363,6 +347,19 @@ import qualified Streamly.Memory.Ring as RB

363import qualified Streamly.Internal.Data.Stream.StreamK as K

347import qualified Streamly.Internal.Data.Stream.StreamK as K

364import qualified Streamly.Internal.Data.Parser as PR

348import qualified Streamly.Internal.Data.Parser as PR

365import qualified Streamly.Internal.Data.Parser.ParserD as PRD

349import qualified Streamly.Internal.Data.Parser.ParserD as PRD

350+import qualified Control.Monad.Catch as MC

351+import qualified Control.Monad.Trans.Reader as Reader

352+import qualified Control.Monad.Trans.State.Strict as State

353+import qualified Prelude

354+

355+import Prelude hiding

356+ ( map, mapM, mapM_, repeat, foldr, last, take, filter

357+ , takeWhile, drop, dropWhile, all, any, maximum, minimum, elem

358+ , notElem, null, head, tail, zipWith, lookup, foldr1, sequence

359+ , (!!), scanl, scanl1, concatMap, replicate, enumFromTo, concat

360+ , reverse, iterate, splitAt)

361+import Streamly.Internal.Data.Stream.StreamD.Type

362+import Streamly.Internal.Data.SVar

366

363

367------------------------------------------------------------------------------

364------------------------------------------------------------------------------

368-- Construction

365-- Construction

src/Streamly/Internal/Data/Stream/Zip.hs+6−6

@@ -45,25 +45,25 @@ import Data.Semigroup (Endo(..))

45import Data.Semigroup (Semigroup(..))

46#endif

47import GHC.Exts (IsList(..), IsString(..))

48+import Text.Read

48−import Text.Read (Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec,

49+ ( Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec

49− readListPrecDefault)

50+ , readListPrecDefault)

50−import Prelude hiding (map, repeat, zipWith, errorWithoutStackTrace)

51−

52import Streamly.Internal.BaseCompat ((#.), errorWithoutStackTrace)

51import Streamly.Internal.BaseCompat ((#.), errorWithoutStackTrace)

53import Streamly.Internal.Data.Stream.StreamK (IsStream(..), Stream)

52import Streamly.Internal.Data.Stream.StreamK (IsStream(..), Stream)

54−import Streamly.Internal.Data.Strict (Maybe'(..), toMaybe)

53+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)

55import Streamly.Internal.Data.SVar (MonadAsync)

54import Streamly.Internal.Data.SVar (MonadAsync)

56

55

57import qualified Streamly.Internal.Data.Stream.Prelude as P

56import qualified Streamly.Internal.Data.Stream.Prelude as P

58import qualified Streamly.Internal.Data.Stream.StreamK as K

57import qualified Streamly.Internal.Data.Stream.StreamK as K

59import qualified Streamly.Internal.Data.Stream.StreamD as D

58import qualified Streamly.Internal.Data.Stream.StreamD as D

60−

61#ifdef USE_STREAMK_ONLY

59#ifdef USE_STREAMK_ONLY

62import qualified Streamly.Internal.Data.Stream.StreamK as S

60import qualified Streamly.Internal.Data.Stream.StreamK as S

63#else

61#else

64import qualified Streamly.Internal.Data.Stream.StreamD as S

62import qualified Streamly.Internal.Data.Stream.StreamD as S

65#endif

63#endif

66

64

65+import Prelude hiding (map, repeat, zipWith, errorWithoutStackTrace)

66+

67#include "Instances.hs"

68

69-- | Like 'zipWith' but using a monadic zipping function.

src/Streamly/Internal/Data/Strict.hsdeleted−59

@@ -1,59 +0,0 @@

1−-- |

2−-- Module : Streamly.Internal.Data.Strict

5−-- License : BSD3

6−-- Maintainer : streamly@composewell.com

7−-- Stability : experimental

8−-- Portability : GHC

9−--

10−-- | Strict data types to be used as accumulator for strict left folds and

11−-- scans. For more comprehensive strict data types see

12−-- https://hackage.haskell.org/package/strict-base-types . The names have been

13−-- suffixed by a prime so that programmers can easily distinguish the strict

14−-- versions from the lazy ones.

15−--

16−-- One major advantage of strict data structures as accumulators in folds and

17−-- scans is that it helps the compiler optimize the code much better by

18−-- unboxing. In a big tight loop the difference could be huge.

19−--

20−module Streamly.Internal.Data.Strict

21− (

22− Tuple' (..)

23− , Tuple3' (..)

24− , Tuple4' (..)

25− , Maybe' (..)

26− , toMaybe

27− , Either' (..)

28− )

29−where

30−

31−-------------------------------------------------------------------------------

32−-- Tuples

33−-------------------------------------------------------------------------------

34−--

35−data Tuple' a b = Tuple' !a !b deriving Show

36−data Tuple3' a b c = Tuple3' !a !b !c deriving Show

37−data Tuple4' a b c d = Tuple4' !a !b !c !d deriving Show

38−

39−-------------------------------------------------------------------------------

40−-- Maybe

41−-------------------------------------------------------------------------------

42−--

43−-- | A strict 'Maybe'

44−data Maybe' a = Just' !a | Nothing' deriving Show

45−

46−-- XXX perhaps we can use a type class having fromStrict/toStrict operations.

47−--

48−-- | Convert strict Maybe' to lazy Maybe

49−{-# INLINABLE toMaybe #-}

50−toMaybe :: Maybe' a -> Maybe a

51−toMaybe Nothing' = Nothing

52−toMaybe (Just' a) = Just a

53−

54−-------------------------------------------------------------------------------

55−-- Either

56−-------------------------------------------------------------------------------

57−--

58−-- | A strict 'Either'

59−data Either' a b = Left' !a | Right' !b deriving Show

src/Streamly/Internal/Data/Tuple/Strict.hsnew file+35

@@ -0,0 +1,35 @@

1+-- |

2+-- Module : Streamly.Internal.Data.Tuple.Strict

5+-- License : BSD3

6+-- Maintainer : streamly@composewell.com

7+-- Stability : experimental

8+-- Portability : GHC

9+--

10+-- | Strict data types to be used as accumulator for strict left folds and

11+-- scans. For more comprehensive strict data types see

12+-- https://hackage.haskell.org/package/strict-base-types . The names have been

13+-- suffixed by a prime so that programmers can easily distinguish the strict

14+-- versions from the lazy ones.

15+--

16+-- One major advantage of strict data structures as accumulators in folds and

17+-- scans is that it helps the compiler optimize the code much better by

18+-- unboxing. In a big tight loop the difference could be huge.

19+--

20+module Streamly.Internal.Data.Tuple.Strict

21+ (

22+ Tuple' (..)

23+ , Tuple3' (..)

24+ , Tuple4' (..)

25+ )

26+where

27+

28+-- | A strict '(,)'

29+data Tuple' a b = Tuple' !a !b deriving Show

30+

31+-- | A strict '(,,)'

32+data Tuple3' a b c = Tuple3' !a !b !c deriving Show

33+

34+-- | A strict '(,,,)'

35+data Tuple4' a b c d = Tuple4' !a !b !c !d deriving Show

src/Streamly/Internal/Data/Unicode/Stream.hs+3−3

@@ -64,21 +64,21 @@ import GHC.Base (assert, unsafeChr)

64import GHC.ForeignPtr (ForeignPtr (..))

65import GHC.IO.Encoding.Failure (isSurrogate)

66import GHC.Ptr (Ptr (..), plusPtr)

67−import Prelude hiding (String, lines, words, unlines, unwords)

68import System.IO.Unsafe (unsafePerformIO)

67import System.IO.Unsafe (unsafePerformIO)

69−

70import Streamly (IsStream)

68import Streamly (IsStream)

71import Streamly.Data.Fold (Fold)

69import Streamly.Data.Fold (Fold)

72import Streamly.Memory.Array (Array)

70import Streamly.Memory.Array (Array)

73import Streamly.Internal.Data.Unfold (Unfold)

71import Streamly.Internal.Data.Unfold (Unfold)

74import Streamly.Internal.Data.SVar (adaptState)

72import Streamly.Internal.Data.SVar (adaptState)

75import Streamly.Internal.Data.Stream.StreamD (Stream(..), Step (..))

73import Streamly.Internal.Data.Stream.StreamD (Stream(..), Step (..))

76−import Streamly.Internal.Data.Strict (Tuple'(..))

74+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

77

75

78import qualified Streamly.Internal.Memory.Array.Types as A

76import qualified Streamly.Internal.Memory.Array.Types as A

79import qualified Streamly.Internal.Prelude as S

77import qualified Streamly.Internal.Prelude as S

80import qualified Streamly.Internal.Data.Stream.StreamD as D

78import qualified Streamly.Internal.Data.Stream.StreamD as D

81

79

80+import Prelude hiding (String, lines, words, unlines, unwords)

81+

82-------------------------------------------------------------------------------

83-- Encoding/Decoding Unicode (UTF-8) Characters

84-------------------------------------------------------------------------------

src/Streamly/Internal/Memory/Mutable/Array/Types.hs+10−13

@@ -94,6 +94,9 @@ import Control.DeepSeq (NFData(..))

94import Control.Monad (when, void)

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

96import Data.Functor.Identity (runIdentity)

97+#if __GLASGOW_HASKELL__ < 808

98+import Data.Semigroup (Semigroup(..))

99+#endif

97import Data.Word (Word8)

100import Data.Word (Word8)

98import Foreign.C.Types (CSize(..), CInt(..))

101import Foreign.C.Types (CSize(..), CInt(..))

99import Foreign.ForeignPtr (withForeignPtr, touchForeignPtr)

102import Foreign.ForeignPtr (withForeignPtr, touchForeignPtr)

@@ -105,11 +108,17 @@ import GHC.Exts (IsList, IsString(..))

105import GHC.ForeignPtr (ForeignPtr(..))

108import GHC.ForeignPtr (ForeignPtr(..))

106import GHC.IO (IO(IO), unsafePerformIO)

109import GHC.IO (IO(IO), unsafePerformIO)

107import GHC.Ptr (Ptr(..))

110import GHC.Ptr (Ptr(..))

111+#if !defined(mingw32_HOST_OS)

112+import Streamly.FileSystem.FDIO (IOVec(..))

113+#endif

108import Streamly.Internal.Data.Fold.Types (Fold(..))

114import Streamly.Internal.Data.Fold.Types (Fold(..))

109−import Streamly.Internal.Data.Strict (Tuple'(..))

115+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

110import Streamly.Internal.Data.SVar (adaptState)

116import Streamly.Internal.Data.SVar (adaptState)

111import Text.Read (readPrec, readListPrec, readListPrecDefault)

117import Text.Read (readPrec, readListPrec, readListPrecDefault)

112

118

119+#ifdef DEVBUILD

120+import qualified Data.Foldable as F

121+#endif

113import qualified Streamly.Memory.Malloc as Malloc

122import qualified Streamly.Memory.Malloc as Malloc

114import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

123import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

115import qualified Streamly.Internal.Data.Stream.StreamK as K

124import qualified Streamly.Internal.Data.Stream.StreamK as K

@@ -117,18 +126,6 @@ import qualified GHC.Exts as Exts

117

126

118import Prelude hiding (length, foldr, read, unlines, splitAt)

127import Prelude hiding (length, foldr, read, unlines, splitAt)

119

128

120−#if __GLASGOW_HASKELL__ < 808

121−import Data.Semigroup (Semigroup(..))

122−#endif

123−

124−#if !defined(mingw32_HOST_OS)

125−import Streamly.FileSystem.FDIO (IOVec(..))

126−#endif

127−

128−#ifdef DEVBUILD

129−import qualified Data.Foldable as F

130−#endif

131−

132#if MIN_VERSION_base(4,10,0)

129#if MIN_VERSION_base(4,10,0)

133import Foreign.ForeignPtr (plusForeignPtr)

130import Foreign.ForeignPtr (plusForeignPtr)

134#else

131#else

src/Streamly/Internal/Prelude.hs+21−26

@@ -535,25 +535,12 @@ import Data.Heap (Entry(..))

535import Data.Maybe (isJust, fromJust, isNothing)

536import Data.Void (Void)

537import Foreign.Storable (Storable)

538−import Prelude

539− hiding (filter, drop, dropWhile, take, takeWhile, zipWith, foldr,

540− foldl, map, mapM, mapM_, sequence, all, any, sum, product, elem,

541− notElem, maximum, minimum, head, last, tail, length, null,

542− reverse, iterate, init, and, or, lookup, foldr1, (!!),

543− scanl, scanl1, replicate, concatMap, span, splitAt, break,

544− repeat, concat, mconcat)

545−

546−import qualified Data.Heap as H

547−import qualified Data.Map.Strict as Map

548−import qualified Prelude

549−import qualified System.IO as IO

550−

551−import Streamly.Internal.Data.Stream.Enumeration (Enumerable(..), enumerate, enumerateTo)

538+import Streamly.Internal.Data.Stream.Enumeration

539+ (Enumerable(..), enumerate, enumerateTo)

552import Streamly.Internal.Data.Fold.Types (Fold (..), Fold2 (..))

540import Streamly.Internal.Data.Fold.Types (Fold (..), Fold2 (..))

553import Streamly.Internal.Data.Parser (Parser (..))

541import Streamly.Internal.Data.Parser (Parser (..))

554import Streamly.Internal.Data.Unfold.Types (Unfold)

542import Streamly.Internal.Data.Unfold.Types (Unfold)

555import Streamly.Internal.Memory.Array.Types (Array, writeNUnsafe)

543import Streamly.Internal.Memory.Array.Types (Array, writeNUnsafe)

556−-- import Streamly.Memory.Ring (Ring)

557import Streamly.Internal.Data.SVar (MonadAsync, defState, Rate)

544import Streamly.Internal.Data.SVar (MonadAsync, defState, Rate)

558import Streamly.Internal.Data.Stream.Combinators (inspectMode, maxYields)

545import Streamly.Internal.Data.Stream.Combinators (inspectMode, maxYields)

559import Streamly.Internal.Data.Stream.Prelude

546import Streamly.Internal.Data.Stream.Prelude

@@ -564,11 +551,10 @@ import Streamly.Internal.Data.Stream.Serial (SerialT, WSerialT)

564import Streamly.Internal.Data.Stream.Zip (ZipSerialM)

551import Streamly.Internal.Data.Stream.Zip (ZipSerialM)

565import Streamly.Internal.Data.Pipe.Types (Pipe (..))

552import Streamly.Internal.Data.Pipe.Types (Pipe (..))

566import Streamly.Internal.Data.Time.Units

553import Streamly.Internal.Data.Time.Units

567− (AbsTime, MilliSecond64(..), addToAbsTime, toRelTime,

554+ ( AbsTime, MilliSecond64(..), addToAbsTime, toRelTime

568− toAbsTime, TimeUnit64, RelTime64, addToAbsTime64)

555+ , toAbsTime, TimeUnit64, RelTime64, addToAbsTime64)

569import Streamly.Internal.Mutable.Prim.Var (Prim, Var)

556import Streamly.Internal.Mutable.Prim.Var (Prim, Var)

570−

571−import Streamly.Internal.Data.Strict

557+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))

572

558

573import qualified Streamly.Internal.Memory.Array as A

559import qualified Streamly.Internal.Memory.Array as A

574import qualified Streamly.Data.Fold as FL

560import qualified Streamly.Data.Fold as FL

@@ -576,19 +562,28 @@ import qualified Streamly.Internal.Data.Fold.Types as FL

576import qualified Streamly.Internal.Data.Stream.Prelude as P

562import qualified Streamly.Internal.Data.Stream.Prelude as P

577import qualified Streamly.Internal.Data.Stream.StreamK as K

563import qualified Streamly.Internal.Data.Stream.StreamK as K

578import qualified Streamly.Internal.Data.Stream.StreamD as D

564import qualified Streamly.Internal.Data.Stream.StreamD as D

579−

565+import qualified Streamly.Internal.Data.Stream.Serial as Serial

566+import qualified Streamly.Internal.Data.Stream.Parallel as Par

567+import qualified Streamly.Internal.Data.Stream.Zip as Z

568+import qualified Streamly.Internal.Data.Parser.ParserK.Types as PRK

569+import qualified Streamly.Internal.Data.Parser.ParserD as PRD

570+import qualified Data.Heap as H

571+import qualified Data.Map.Strict as Map

572+import qualified Prelude

573+import qualified System.IO as IO

580#ifdef USE_STREAMK_ONLY

574#ifdef USE_STREAMK_ONLY

581import qualified Streamly.Internal.Data.Stream.StreamK as S

575import qualified Streamly.Internal.Data.Stream.StreamK as S

582#else

576#else

583import qualified Streamly.Internal.Data.Stream.StreamD as S

577import qualified Streamly.Internal.Data.Stream.StreamD as S

584#endif

578#endif

585

579

586−-- import qualified Streamly.Internal.Data.Stream.Async as Async

580+import Prelude hiding

587−import qualified Streamly.Internal.Data.Stream.Serial as Serial

581+ ( filter, drop, dropWhile, take, takeWhile, zipWith, foldr

588−import qualified Streamly.Internal.Data.Stream.Parallel as Par

582+ , foldl, map, mapM, mapM_, sequence, all, any, sum, product, elem

589−import qualified Streamly.Internal.Data.Stream.Zip as Z

583+ , notElem, maximum, minimum, head, last, tail, length, null

590−import qualified Streamly.Internal.Data.Parser.ParserK.Types as PRK

584+ , reverse, iterate, init, and, or, lookup, foldr1, (!!)

591−import qualified Streamly.Internal.Data.Parser.ParserD as PRD

585+ , scanl, scanl1, replicate, concatMap, span, splitAt, break

586+ , repeat, concat, mconcat)

592

587

593------------------------------------------------------------------------------

588------------------------------------------------------------------------------

594-- Deconstruction

589-- Deconstruction

streamly.cabal+3−1

@@ -375,7 +375,9 @@ library

375 -- Internal modules

376 , Streamly.Internal.BaseCompat

377 , Streamly.Internal.Control.Monad

378− , Streamly.Internal.Data.Strict

378+ , Streamly.Internal.Data.Tuple.Strict

379+ , Streamly.Internal.Data.Maybe.Strict

380+ , Streamly.Internal.Data.Either.Strict

379 , Streamly.Internal.Data.Atomics

381 , Streamly.Internal.Data.Atomics

380 , Streamly.Internal.Data.Time

382 , Streamly.Internal.Data.Time

381 , Streamly.Internal.Data.Time.TimeSpec

383 , Streamly.Internal.Data.Time.TimeSpec