b9b94b3 · streamly · git.iko.soy

docs/ConcurrentStreams.hs+1−1

compare with master

unifiedsplit

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

95import Control.Monad.Trans.Class (MonadTrans (lift))

96

97-- CAUTION: please keep setup and imports sections in sync

98−--

98+

99-- $setup

100-- >>> :m

101-- >>> import Data.Function ((&))

docs/Tutorial.hs+1−1

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

82import Control.Monad.Trans.Class (MonadTrans (lift))

83

84-- CAUTION: please keep setup and imports sections in sync

85−--

85+

86-- $setup

87-- >>> :m

88-- >>> import Data.Function ((&))

src/Streamly/Data/Fold.hs+4

@@ -262,3 +262,7 @@ import Prelude

262 span, splitAt, break, mapM)

263

264import Streamly.Internal.Data.Fold

265+

266+-- $setup

267+-- >>> import qualified Streamly.Data.Fold as Fold

268+-- >>> import qualified Streamly.Prelude as Stream

src/Streamly/Data/Fold/Tee.hs+2−1

@@ -15,7 +15,8 @@

15-- through the stream twice:

16--

17-- >>> import Streamly.Data.Fold.Tee (Tee(..))

18+-- >>> import qualified Streamly.Prelude as Stream

18−-- >>> import Streamly.Data.Fold as Fold

19+-- >>> import qualified Streamly.Data.Fold as Fold

19--

20--

20-- >>> avg = (/) <$> (Tee Fold.sum) <*> (Tee $ fmap fromIntegral Fold.length)

21-- >>> avg = (/) <$> (Tee Fold.sum) <*> (Tee $ fmap fromIntegral Fold.length)

21-- >>> Stream.fold (toFold avg) $ Stream.fromList [1.0..100.0]

22-- >>> Stream.fold (toFold avg) $ Stream.fromList [1.0..100.0]

src/Streamly/Internal/Data/Array/Foreign/Type.hs+1

@@ -120,6 +120,7 @@ import qualified Data.Foldable as F

120--

121-- $setup

122-- >>> :m

123+-- >>> :set -XMagicHash

123-- >>> import Prelude hiding (length, foldr, read, unlines, splitAt)

124-- >>> import Prelude hiding (length, foldr, read, unlines, splitAt)

124-- >>> import Streamly.Internal.Data.Array.Foreign as Array

125-- >>> import Streamly.Internal.Data.Array.Foreign as Array

125

126

src/Streamly/Internal/Data/Fold/Type.hs+1

@@ -284,6 +284,7 @@ import Prelude hiding (concatMap, filter, foldr, map, take)

284

285-- $setup

286-- >>> :m

287+-- >>> :set -XFlexibleContexts

287-- >>> import Prelude hiding (concatMap, filter, map)

288-- >>> import Prelude hiding (concatMap, filter, map)

288-- >>> import qualified Streamly.Prelude as Stream

289-- >>> import qualified Streamly.Prelude as Stream

289-- >>> import qualified Streamly.Data.Fold as Fold

290-- >>> import qualified Streamly.Data.Fold as Fold

src/Streamly/Internal/Data/Stream/Ahead.hs+1

@@ -64,6 +64,7 @@ import Prelude hiding (map)

64#include "Instances.hs"

65

66-- $setup

67+-- >>> import qualified Streamly.Prelude as Stream

67-- >>> import Control.Concurrent (threadDelay)

68-- >>> import Control.Concurrent (threadDelay)

68-- >>> :{

69-- >>> :{

69-- delay n = do

70-- delay n = do

src/Streamly/Internal/Data/Stream/Async.hs+2

@@ -72,6 +72,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

72#include "Instances.hs"

73

74-- $setup

75+-- >>> import qualified Streamly.Prelude as Stream

75-- >>> import Control.Concurrent (threadDelay)

76-- >>> import Control.Concurrent (threadDelay)

76-- >>> :{

77-- >>> :{

77-- delay n = do

78-- delay n = do

@@ -79,6 +80,7 @@ import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

79-- putStrLn (show n ++ " sec") -- print "n sec"

80-- putStrLn (show n ++ " sec") -- print "n sec"

80-- return n -- IO Int

81-- return n -- IO Int

81-- :}

82-- :}

83+--

82

84

83-------------------------------------------------------------------------------

85-------------------------------------------------------------------------------

84-- Async

86-- Async

src/Streamly/Internal/Data/Stream/IsStream/Enumeration.hs+4−1

@@ -66,6 +66,10 @@ import Streamly.Internal.Data.Stream.StreamK.Type (IsStream(..))

66import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D

67import qualified Streamly.Internal.Data.Stream.Serial as Serial (map)

68

69+-- $setup

70+-- >>> import Streamly.Prelude as Stream

71+-- >>> import Streamly.Internal.Data.Stream.IsStream.Enumeration as Stream

72+

69-------------------------------------------------------------------------------

73-------------------------------------------------------------------------------

70-- Enumeration of Integral types

74-- Enumeration of Integral types

71-------------------------------------------------------------------------------

75-------------------------------------------------------------------------------

@@ -78,7 +82,6 @@ import qualified Streamly.Internal.Data.Stream.Serial as Serial (map)

78-- check for overflow, underflow or bounds.

82-- check for overflow, underflow or bounds.

79--

83--

80-- @

84-- @

81−-- >>> import Streamly.Internal.Data.Stream.IsStream.Enumeration as Stream

82-- >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromStepIntegral 0 2

85-- >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromStepIntegral 0 2

83-- [0,2,4,6]

86-- [0,2,4,6]

84--

87--

src/Streamly/Internal/Data/Stream/Parallel.hs+1

@@ -84,6 +84,7 @@ import qualified Streamly.Internal.Data.Stream.SVar as SVar

84

85--

86-- $setup

87+-- >>> import qualified Streamly.Prelude as Stream

87-- >>> import Control.Concurrent (threadDelay)

88-- >>> import Control.Concurrent (threadDelay)

88-- >>> :{

89-- >>> :{

89-- delay n = do

90-- delay n = do

src/Streamly/Internal/Data/Stream/Serial.hs+3

@@ -83,6 +83,9 @@ import Prelude hiding (map, mapM, errorWithoutStackTrace)

83#include "Instances.hs"

84#include "inline.hs"

85

86+-- $setup

87+-- >>> import qualified Streamly.Prelude as Stream

88+

86------------------------------------------------------------------------------

89------------------------------------------------------------------------------

87-- SerialT

90-- SerialT

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

91------------------------------------------------------------------------------

src/Streamly/Internal/Data/Stream/StreamK/Type.hs+3

@@ -89,6 +89,9 @@ import Prelude hiding (map, mapM, concatMap, foldr)

89

90import Streamly.Internal.Data.SVar

91

92+-- $setup

93+-- >>> import Streamly.Prelude as Stream

94+

92------------------------------------------------------------------------------

95------------------------------------------------------------------------------

93-- Basic stream type

96-- Basic stream type

94------------------------------------------------------------------------------

97------------------------------------------------------------------------------

src/Streamly/Internal/Data/Stream/Zip.hs+1

@@ -71,6 +71,7 @@ import Prelude hiding (map, repeat, zipWith, errorWithoutStackTrace)

71#include "Instances.hs"

72

73-- $setup

74+-- >>> import qualified Streamly.Prelude as Stream

74-- >>> import Control.Concurrent (threadDelay)

75-- >>> import Control.Concurrent (threadDelay)

75-- >>> :{

76-- >>> :{

76-- delay n = do

77-- delay n = do

src/Streamly/Internal/Data/Unfold.hs+4

@@ -256,6 +256,10 @@ import Prelude

256 hiding (map, mapM, takeWhile, take, filter, const, zipWith

257 , drop, dropWhile)

258

259+-- $setup

260+-- >>> import qualified Streamly.Data.Fold as Fold

261+-- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

262+

259-------------------------------------------------------------------------------

263-------------------------------------------------------------------------------

260-- Input operations

264-- Input operations

261-------------------------------------------------------------------------------

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

src/Streamly/Internal/Data/Unfold/Type.hs+5

@@ -63,6 +63,11 @@ import Streamly.Internal.Data.Stream.StreamD.Step (Step(..))

63

64import Prelude hiding (const, map, concatMap, zipWith)

65

66+-- $setup

67+-- >>> import qualified Streamly.Prelude as Stream

68+-- >>> import qualified Streamly.Data.Fold as Fold

69+-- >>> import qualified Streamly.Internal.Data.Unfold as Unfold

70+

66------------------------------------------------------------------------------

71------------------------------------------------------------------------------

67-- Monadic Unfolds

72-- Monadic Unfolds

68------------------------------------------------------------------------------

73------------------------------------------------------------------------------

src/Streamly/Prelude.hs+4

@@ -945,6 +945,10 @@ import Prelude

945

946import Streamly.Internal.Data.Stream.IsStream

947

948+-- $setup

949+-- >>> import qualified Streamly.Data.Fold as Fold

950+-- >>> import qualified Streamly.Prelude as Stream

951+

948-- $serial

952-- $serial

949--

953--

950-- Serial streams are /spatially ordered/, they execute the actions in the

954-- Serial streams are /spatially ordered/, they execute the actions in the