git.iko.soy/streamly
on master help sign in
swap
30c5a56517 ahead, 0 behind
341 files changed+32971−28104
since splitsnapshots
unifiedsplit
.circleci/config.yml+73−277 .github/workflows/haskell.yml+90−89 .github/workflows/regression-check.yml+15−26 .hlint.ignore+7−2 CHANGELOG.md+1−1 LICENSE−254 README.md+1−1 appveyor.yml+2 benchmark/NanoBenchmarks.hs+1−1 benchmark/Streamly/Benchmark/Data/Array/CommonImports.hs+2−2 benchmark/Streamly/Benchmark/Data/Array/Stream.hs+8−8 benchmark/Streamly/Benchmark/Data/Fold.hs+35−11 benchmark/Streamly/Benchmark/Data/Fold/Window.hs+42−42 benchmark/Streamly/Benchmark/Data/Array/Mut.hs → benchmark/Streamly/Benchmark/Data/MutArray.hs+7−7 benchmark/Streamly/Benchmark/Data/Parser.hs+12−12 benchmark/Streamly/Benchmark/Data/Parser/ParserK.hs → benchmark/Streamly/Benchmark/Data/ParserK.hs+92−39 benchmark/Streamly/Benchmark/Data/Ring/Unboxed.hs+3−4 benchmark/Streamly/Benchmark/Data/Serialize.hs+591 benchmark/Streamly/Benchmark/Data/Serialize/RecCompatible.hs+24 benchmark/Streamly/Benchmark/Data/Serialize/RecNonCompatible.hs+21 benchmark/Streamly/Benchmark/Data/Serialize/TH.hs+76 benchmark/Streamly/Benchmark/Data/Stream.hs+1−1 benchmark/Streamly/Benchmark/Data/Stream/Common.hs+11−9 benchmark/Streamly/Benchmark/Data/Stream/ConcurrentCommon.hs+3−3 benchmark/Streamly/Benchmark/Data/Stream/ConcurrentEager.hs+1−1 benchmark/Streamly/Benchmark/Data/Stream/ConcurrentInterleaved.hs+1−1 benchmark/Streamly/Benchmark/Data/Stream/ConcurrentOrdered.hs+1−1 benchmark/Streamly/Benchmark/Data/Stream/Eliminate.hs+8−6 benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hs+16−6 benchmark/Streamly/Benchmark/Data/Stream/Expand.hs+15−7 benchmark/Streamly/Benchmark/Data/Stream/Generate.hs+4−4 benchmark/Streamly/Benchmark/Data/Stream/Lift.hs+5−5 benchmark/Streamly/Benchmark/Data/Stream/Reduce.hs+40−21 benchmark/Streamly/Benchmark/Data/Stream/Split.hs+3−3 benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs+5−3 benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs+9−8 benchmark/Streamly/Benchmark/Data/Stream/StreamDK.hs → benchmark/Streamly/Benchmark/Data/Stream/StreamKAlt.hs+3−3 benchmark/Streamly/Benchmark/Data/Stream/ToStreamK.hs+5−6 benchmark/Streamly/Benchmark/Data/Stream/Transform.hs+6−6 benchmark/Streamly/Benchmark/Data/Unfold.hs+17−7 benchmark/Streamly/Benchmark/FileSystem/Handle.hs+1−1 benchmark/Streamly/Benchmark/FileSystem/Handle/Read.hs+11−12 benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+11−12 benchmark/Streamly/Benchmark/Prelude/Adaptive.hs+1−1 benchmark/Streamly/Benchmark/Prelude/Ahead.hs+1−1 benchmark/Streamly/Benchmark/Prelude/Async.hs+1−1 benchmark/Streamly/Benchmark/Prelude/Concurrent.hs+1−1 benchmark/Streamly/Benchmark/Prelude/Merge.hs+2−2 benchmark/Streamly/Benchmark/Prelude/Parallel.hs+1−1 benchmark/Streamly/Benchmark/Prelude/Rate.hs+1−1 benchmark/Streamly/Benchmark/Prelude/WAsync.hs+1−1 benchmark/Streamly/Benchmark/Prelude/WSerial.hs+2−2 benchmark/Streamly/Benchmark/Prelude/ZipAsync.hs+1−1 benchmark/Streamly/Benchmark/Prelude/ZipSerial.hs+2−2 benchmark/Streamly/Benchmark/Unicode/Char.hs+2−2 benchmark/Streamly/Benchmark/Unicode/Parser.hs+107 benchmark/Streamly/Benchmark/Unicode/Stream.hs+27−9 benchmark/Streamly/Benchmark/Unicode/Utf8.hs+1−1 benchmark/bench-runner/Main.hs+42−10 benchmark/bench-runner/default.nix+1−1 benchmark/lib/Streamly/Benchmark/Common.hs+2−2 benchmark/lib/Streamly/Benchmark/Common/Handle.hs+3−1 benchmark/lib/Streamly/Benchmark/Prelude.hs+1−1 benchmark/streamly-benchmarks.cabal+82−47 bin/mk-hscope.sh+1−1 bin/run-repl-quick.sh+1−1 cabal.project.packdiff+1−5 cabal.project.report+2−4 configure+9−9 configure.ac+1−1 core/Changelog.md+1 core/LICENSE+322 core/configure+9−9 core/configure.ac+1−1 core/docs/ApiChangelogs/0.1.0-0.2.0.txt+1471 core/docs/ApiChangelogs/0.1.0.txt+405 core/docs/ApiChangelogs/0.2.0-0.2.2.txt+306 core/docs/Changelog.md+97 core/docs/Readme.md+1 core/src/DocTestDataArray.hs+22 core/src/DocTestDataFold.hs+27 core/src/DocTestDataMutArray.hs+10 core/src/DocTestDataMutArrayGeneric.hs+10 core/src/DocTestDataParser.hs+20 core/src/DocTestDataParserK.hs+15 core/src/DocTestDataStream.hs+39 core/src/DocTestDataStreamK.hs+21 core/src/DocTestDataUnfold.hs+12 core/src/DocTestFileSystemHandle.hs+15 core/src/DocTestUnicodeParser.hs+9 core/src/DocTestUnicodeStream.hs+12 core/src/DocTestUnicodeString.hs+5 core/src/Streamly/Console/Stdio.hs+1−27 core/src/Streamly/Data/Array.hs+115−117 core/src/Streamly/Data/Array/Generic.hs+19−11 core/src/Streamly/Data/Fold.hs+90−51 core/src/Streamly/Data/MutArray.hs+56−15 core/src/Streamly/Data/MutArray/Generic.hs+38−8 core/src/Streamly/Data/MutByteArray.hs+106 core/src/Streamly/Data/Parser.hs+123−24 core/src/Streamly/Data/ParserK.hs+107−12 core/src/Streamly/Data/Stream.hs+344−122 core/src/Streamly/Data/Stream/StreamDK.hs−505 core/src/Streamly/Data/Stream/Zip.hs−16 core/src/Streamly/Data/StreamK.hs+94−21 core/src/Streamly/Data/Unfold.hs+98−85 core/src/Streamly/FileSystem/Handle.hs+15−29 core/src/Streamly/Internal/Console/Stdio.hs+2−2 core/src/Streamly/Internal/Data/Array.hs+644−187 core/src/Streamly/Internal/Data/Array/Generic.hs+148−181 core/src/Streamly/Internal/Data/Array/Mut.hs−100 core/src/Streamly/Internal/Data/Array/Mut/Stream.hs−323 core/src/Streamly/Internal/Data/Stream/Chunked.hs → core/src/Streamly/Internal/Data/Array/Stream.hs+91−581 core/src/Streamly/Internal/Data/Array/Type.hs+653−102 core/src/Streamly/Internal/Serialize/FromBytes.hs → core/src/Streamly/Internal/Data/Binary/Parser.hs+11−6 core/src/Streamly/Internal/Serialize/ToBytes.hs → core/src/Streamly/Internal/Data/Binary/Stream.hs+16−7 core/src/Streamly/Internal/Data/Builder.hs+11−9 core/src/Streamly/Internal/Data/Fold.hs+11−2594 core/src/Streamly/Internal/Data/Fold/Chunked.hs+23−21 core/src/Streamly/Internal/Data/Fold/Combinators.hs+2452 core/src/Streamly/Internal/Data/Fold/Container.hs+119−40 core/src/Streamly/Internal/Data/Fold/Step.hs+2−2 core/src/Streamly/Internal/Data/Fold/Tee.hs+8−7 core/src/Streamly/Internal/Data/Fold/Type.hs+373−151 core/src/Streamly/Internal/Data/Fold/Window.hs+59−53 core/src/Streamly/Internal/Data/IOFinalizer.hs+12−2 core/src/Streamly/Internal/Data/IORef/Unboxed.hs+23−22 core/src/Streamly/Internal/Data/IsMap.hs+8 core/src/Streamly/Internal/Data/List.hs+81−16 core/src/Streamly/Internal/Data/MutArray.hs+207 core/src/Streamly/Internal/Data/Array/Generic/Mut/Type.hs → core/src/Streamly/Internal/Data/MutArray/Generic.hs+414−75 core/src/Streamly/Internal/Data/MutArray/Stream.hs+145 core/src/Streamly/Internal/Data/Array/Mut/Type.hs → core/src/Streamly/Internal/Data/MutArray/Type.hs+1503−536 core/src/Streamly/Internal/Data/MutByteArray.hs+251 core/src/Streamly/Internal/Data/MutByteArray/Type.hs+321 core/src/Streamly/Internal/Data/Parser.hs+3611−4 core/src/Streamly/Internal/Data/Parser/ParserD.hs−3672 core/src/Streamly/Internal/Data/Parser/ParserDK.hs−1544 core/src/Streamly/Internal/Data/Parser/ParserD/Tee.hs → core/src/Streamly/Internal/Data/Parser/Tee.hs+1−1 core/src/Streamly/Internal/Data/Parser/ParserD/Type.hs → core/src/Streamly/Internal/Data/Parser/Type.hs+110−83 core/src/Streamly/Internal/Data/ParserK.hs+16 core/src/Streamly/Internal/Data/Parser/ParserK/Type.hs → core/src/Streamly/Internal/Data/ParserK/Type.hs+301−89 core/src/Streamly/Internal/Data/Pipe.hs+7−10 core/src/Streamly/Internal/Data/Producer.hs+6−13 core/src/Streamly/Internal/Data/Producer/Source.hs+22−9 core/src/Streamly/Internal/Data/Producer/Type.hs+1−1 core/src/Streamly/Internal/Data/Refold/Type.hs+2−2 core/src/Streamly/Internal/Data/Ring.hs+603−31 core/src/Streamly/Internal/Data/Ring/Generic.hs+185 core/src/Streamly/Internal/Data/Ring/Unboxed.hs−615 core/src/Streamly/Internal/Data/Serialize/TH.hs+530 core/src/Streamly/Internal/Data/Serialize/TH/Bottom.hs+475 core/src/Streamly/Internal/Data/Serialize/TH/Common.hs+70 core/src/Streamly/Internal/Data/Serialize/TH/RecHeader.hs+411 core/src/Streamly/Internal/Data/Serialize/Type.hs+317 core/src/Streamly/Internal/Data/Stream.hs+31−3 core/src/Streamly/Internal/Data/Stream/Bottom.hs−670 core/src/Streamly/Internal/Data/Stream/StreamD/Container.hs → core/src/Streamly/Internal/Data/Stream/Container.hs+70−63 core/src/Streamly/Internal/Data/Stream/Cross.hs−143 core/src/Streamly/Internal/Data/Stream/Eliminate.hs+701−229 core/src/Streamly/Internal/Data/Stream/Enumerate.hs−560 core/src/Streamly/Internal/Data/Stream/Exception.hs+369−90 core/src/Streamly/Internal/Data/Stream/Expand.hs−893 core/src/Streamly/Internal/Data/Stream/Generate.hs+948−217 core/src/Streamly/Internal/Data/Stream/Lift.hs+70−36 core/src/Streamly/Internal/Data/Stream/StreamD/Nesting.hs → core/src/Streamly/Internal/Data/Stream/Nesting.hs+152−250 core/src/Streamly/Internal/Data/Stream/Reduce.hs−444 core/src/Streamly/Internal/Data/Stream/StreamD/Step.hs → core/src/Streamly/Internal/Data/Stream/Step.hs+2−2 core/src/Streamly/Internal/Data/Stream/StreamD.hs+3−29 core/src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs−838 core/src/Streamly/Internal/Data/Stream/StreamD/Exception.hs−480 core/src/Streamly/Internal/Data/Stream/StreamD/Generate.hs−1211 core/src/Streamly/Internal/Data/Stream/StreamD/Lift.hs−131 core/src/Streamly/Internal/Data/Stream/StreamD/Top.hs−356 core/src/Streamly/Internal/Data/Stream/StreamD/Transform.hs−1962 core/src/Streamly/Internal/Data/Stream/StreamD/Transformer.hs−185 core/src/Streamly/Internal/Data/Stream/StreamD/Type.hs−2081 core/src/Streamly/Internal/Data/Stream/StreamDK.hs−52 core/src/Streamly/Internal/Data/Stream/Top.hs+480 core/src/Streamly/Internal/Data/Stream/Transform.hs+1197−282 core/src/Streamly/Internal/Data/Stream/Transformer.hs+91−43 core/src/Streamly/Internal/Data/Stream/Type.hs+1958−229 core/src/Streamly/Internal/Data/Stream/Zip.hs−91 core/src/Streamly/Internal/Data/Stream/StreamK.hs → core/src/Streamly/Internal/Data/StreamK.hs+508−191 core/src/Streamly/Internal/Data/Stream/StreamK/Alt.hs → core/src/Streamly/Internal/Data/StreamK/Alt.hs+1−1 core/src/Streamly/Internal/Data/Stream/StreamK/Transformer.hs → core/src/Streamly/Internal/Data/StreamK/Transformer.hs+3−3 core/src/Streamly/Internal/Data/Stream/StreamK/Type.hs → core/src/Streamly/Internal/Data/StreamK/Type.hs+137−58 core/src/Streamly/Internal/Data/Time/Clock.hs+3−3 core/src/Streamly/Internal/Data/Time/Units.hs+1−4 core/src/Streamly/Internal/Data/Unboxed.hs → core/src/Streamly/Internal/Data/Unbox.hs+316−263 core/src/Streamly/Internal/Data/Unbox/TH.hs+498 core/src/Streamly/Internal/Data/Unfold.hs+31−193 core/src/Streamly/Internal/Data/Unfold/Enumeration.hs+14−45 core/src/Streamly/Internal/Data/Unfold/Type.hs+127−20 core/src/Streamly/Internal/FileSystem/Dir.hs+69−22 core/src/Streamly/Internal/FileSystem/File.hs+30−31 core/src/Streamly/Internal/FileSystem/Handle.hs+40−49 core/src/Streamly/Internal/FileSystem/Path.hs+515 core/src/Streamly/Internal/Unicode/Array.hs+6 core/src/Streamly/Internal/Unicode/Parser.hs+354−25 core/src/Streamly/Internal/Unicode/Stream.hs+58−30 core/src/Streamly/Internal/Unicode/String.hs+17−12 core/src/Streamly/Unicode/Parser.hs+12−2 core/src/Streamly/Unicode/Stream.hs+13−10 core/src/Streamly/Unicode/String.hs+15−1 core/streamly-core.cabal+191−108 docs/Developer/Benchmarks.md+8 docs/Developer/MAINTAINING.md+6−9 docs/Developer/module-organization.md+1−1 docs/Developer/optimization-guidelines.md+13−1 docs/Developer/paths.rst+25−2 docs/Documentation.md+5 docs/User/HowTo/Compiling.md+27−14 docs/User/HowTo/streamly-vs-async.md+2 docs/User/HowTo/streamly-vs-lists.md+2 docs/User/Project/ApiChangelogs/0.8.3-0.9.0.txt+175 docs/User/ProjectRelated/API-changelog.txt → docs/User/Project/ApiChangelogs/0.8.3.txt docs/User/Project/ApiChangelogs/0.9.0-0.10.0.txt+424 docs/User/ProjectRelated/CONTRIBUTORS.md → docs/User/Project/CONTRIBUTORS.md+9−1 docs/User/ProjectRelated/Changelog.md → docs/User/Project/Changelog.md+49−9 docs/User/ProjectRelated/Credits.md → docs/User/Project/Credits.md docs/User/ProjectRelated/Github.link → docs/User/Project/Github.link docs/User/ProjectRelated/README.md → docs/User/Project/README.md+9−2 docs/User/ProjectRelated/Roadmap.link → docs/User/Project/Roadmap.link docs/User/ProjectRelated/Upgrading.md → docs/User/Project/Upgrading-0.8-to-0.9.md+132−23 docs/User/Tutorials/ConcurrentStreams.hs+2 docs/User/Tutorials/ReactiveProgramming.hs+2 docs/User/Tutorials/Tutorial.hs+2 docs/User/Tutorials/before-you-begin.md+22−3 docs/User/Tutorials/setup-and-usage.md → docs/User/Tutorials/getting-started.md+24−25 docs/User/Tutorials/quick-overview.md+12−14 docs/streamly-docs.cabal+8−6 hie.yaml+14−10 src/Streamly.hs−624 src/Streamly/Data/Fold/Prelude.hs+65 src/Streamly/Data/Fold/Tee.hs+2−1 src/Streamly/Data/Stream/Concurrent.hs−191 src/Streamly/Data/Stream/Exception.hs−24 src/Streamly/Data/Stream/MkType.hs+41−10 src/Streamly/Data/Stream/Prelude.hs+217−15 src/Streamly/Data/Stream/Time.hs−37 src/Streamly/Data/Unicode/Stream.hs−99 src/Streamly/Internal/Control/ForkLifted.hs+17−4 src/Streamly/Internal/Data/Array/ArrayMacros.h−40 src/Streamly/Internal/Data/Channel.hs+19 src/Streamly/Internal/Data/Stream/Channel/Dispatcher.hs → src/Streamly/Internal/Data/Channel/Dispatcher.hs+3−3 src/Streamly/Internal/Data/Stream/Channel/Types.hs → src/Streamly/Internal/Data/Channel/Types.hs+22−32 src/Streamly/Internal/Data/Stream/Channel/Worker.hs → src/Streamly/Internal/Data/Channel/Worker.hs+3−3 src/Streamly/Internal/Data/Fold/Async.hs+6−3 src/Streamly/Internal/Data/Fold/Concurrent.hs+37−49 src/Streamly/Internal/Data/Fold/Concurrent/Channel.hs+31−10 src/Streamly/Internal/Data/Fold/Concurrent/Channel/Type.hs+8−7 src/Streamly/Internal/Data/Fold/Prelude.hs+19 src/Streamly/Internal/Data/Fold/SVar.hs+8−7 src/Streamly/Internal/Data/IsMap/HashMap.hs+10 src/Streamly/Internal/Data/SVar.hs+1 src/Streamly/Internal/Data/SmallArray.hs+4−4 src/Streamly/Internal/Data/Stream/Ahead.hs+15−3 src/Streamly/Internal/Data/Stream/Async.hs+22−3 core/src/Streamly/Internal/Data/Stream/Common.hs → src/Streamly/Internal/Data/Stream/Common.hs+4−4 src/Streamly/Internal/Data/Stream/Concurrent.hs+205−76 src/Streamly/Internal/Data/Stream/Concurrent/Channel.hs+19−16 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Append.hs+11−11 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Consumer.hs+2−2 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Dispatcher.hs+3−3 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Interleave.hs+11−9 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Operations.hs+5−5 src/Streamly/Internal/Data/Stream/Concurrent/Channel/Type.hs+4−4 src/Streamly/Internal/Data/Stream/Instances.hs+6−9 src/Streamly/Internal/Data/Stream/IsStream.hs+8−2 src/Streamly/Internal/Data/Stream/IsStream/Combinators.hs+1−1 src/Streamly/Internal/Data/Stream/IsStream/Common.hs+7−7 src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+7−7 src/Streamly/Internal/Data/Stream/IsStream/Enumeration.hs+1−1 src/Streamly/Internal/Data/Stream/IsStream/Exception.hs+4−4 src/Streamly/Internal/Data/Stream/IsStream/Expand.hs+8−4 src/Streamly/Internal/Data/Stream/IsStream/Generate.hs+7−7 src/Streamly/Internal/Data/Stream/IsStream/Lift.hs+1−1 src/Streamly/Internal/Data/Stream/IsStream/Reduce.hs+9−9 src/Streamly/Internal/Data/Stream/IsStream/Top.hs+4−5 src/Streamly/Internal/Data/Stream/IsStream/Transform.hs+5−5 src/Streamly/Internal/Data/Stream/IsStream/Type.hs+6−5 src/Streamly/Internal/Data/Stream/Exception/Lifted.hs → src/Streamly/Internal/Data/Stream/Lifted.hs+16−12 src/Streamly/Internal/Data/Stream/MkType.hs+33−34 src/Streamly/Internal/Data/Stream/Parallel.hs+15−3 src/Streamly/Internal/Data/Stream/Prelude.hs+19 src/Streamly/Internal/Data/Stream/SVar.hs+18 src/Streamly/Internal/Data/Stream/SVar/Eliminate.hs+3−3 src/Streamly/Internal/Data/Stream/SVar/Generate.hs+4−2 src/Streamly/Internal/Data/Stream/Serial.hs+18−5 src/Streamly/Internal/Data/Stream/Time.hs+10−10 src/Streamly/Internal/Data/Stream/Zip.hs+42−3 src/Streamly/Internal/Data/Stream/Zip/Concurrent.hs−50 src/Streamly/Internal/Data/Stream/ZipAsync.hs+5−4 src/Streamly/Internal/Data/Unfold/Exception.hs+1−3 src/Streamly/Internal/Data/Unfold/Prelude.hs+17 src/Streamly/Internal/Data/Unfold/SVar.hs+3−2 src/Streamly/Internal/FileSystem/Event.hs+5−2 src/Streamly/Internal/FileSystem/Event/Darwin.hs+5−5 src/Streamly/Internal/FileSystem/Event/Linux.hs+15−9 src/Streamly/Internal/FileSystem/Event/Windows.hs+11−8 src/Streamly/Internal/FileSystem/FD.hs+15−14 src/Streamly/Internal/Network/Inet/TCP.hs+84−48 src/Streamly/Internal/Network/Socket.hs+34−31 src/Streamly/Internal/System/IOVec.hs+7−7 src/Streamly/Internal/Unicode/Char.hs+10−8 src/Streamly/Memory/Array.hs−74 src/Streamly/Network/Inet/TCP.hs+41−30 src/Streamly/Network/Socket.hs+16−30 src/Streamly/Prelude.hs+4−4 streamly.cabal+112−85 targets/Targets.hs+11−5 test/Streamly/Test/Data/Array.hs+9−10 test/Streamly/Test/Data/Array/Stream.hs+1−1 test/Streamly/Test/Data/Fold.hs+8−8 test/Streamly/Test/Data/Fold/Window.hs+8−9 test/Streamly/Test/Data/Array/Mut.hs → test/Streamly/Test/Data/MutArray.hs+5−5 test/Streamly/Test/Data/Parser.hs+264−115 test/Streamly/Test/Data/Parser/ParserD.hs → test/Streamly/Test/Data/ParserK.hs+17−13 test/Streamly/Test/Data/Ring/Unboxed.hs+2−2 test/Streamly/Test/Data/Serialize.hs+306 test/Streamly/Test/Data/Serialize/CompatV0.hs+46 test/Streamly/Test/Data/Serialize/CompatV1.hs+48 test/Streamly/Test/Data/Serialize/TH.hs+82 test/Streamly/Test/Data/Stream.hs+33 test/Streamly/Test/Data/Stream/Concurrent.hs+122−78 test/Streamly/Test/Data/Unbox.hs+166−38 test/Streamly/Test/Data/Unbox/TH.hs+146 test/Streamly/Test/Data/Unfold.hs+2−2 test/Streamly/Test/FileSystem/Event/Common.hs+1−1 test/Streamly/Test/FileSystem/Event/Linux.hs+16−3 test/Streamly/Test/FileSystem/Handle.hs+2−2 test/Streamly/Test/Prelude/Serial.hs+8−4 test/Streamly/Test/Prelude/Top.hs+1−1 test/Streamly/Test/Serialize/Serializable.hs+2−2 test/Streamly/Test/Unicode/Char.hs+1−1 test/Streamly/Test/Unicode/Parser.hs+231 test/Streamly/Test/Unicode/Stream.hs+2−2 test/lib/Streamly/Test/Common.hs+4 test/lib/Streamly/Test/Prelude/Common.hs+9−2 test/streamly-tests.cabal+94−32
.circleci/config.yml+73−277
@@ -1,7 +1,7 @@
11version: 2.1
22
33#-----------------------------------------------------------------------------
4−# packcheck-0.4.2
4+# packcheck-0.7.0
55# Packcheck global environment variables
66#-----------------------------------------------------------------------------
77
@@ -11,6 +11,8 @@ env: &env
1111 # Common options
1212 # ------------------------------------------------------------------------
1313 # GHC_OPTIONS: "-Werror"
14+ # For updating see: https://downloads.haskell.org/~ghcup/
15+ GHCUP_VERSION: 0.1.20.0
1416 CABAL_REINIT_CONFIG: "y"
1517 LC_ALL: "C.UTF-8"
1618
@@ -22,7 +24,6 @@ env: &env
2224 # DISABLE_DOCS: "y"
2325 # DISABLE_SDIST_BUILD: "y"
2426 # DISABLE_DIST_CHECKS: "y"
25− ENABLE_INSTALL: "y"
2627
2728 # ------------------------------------------------------------------------
2829 # stack options
@@ -38,15 +39,12 @@ env: &env
3839 # cabal options
3940 # ------------------------------------------------------------------------
4041 CABAL_CHECK_RELAX: "y"
41− CABAL_NO_SANDBOX: "y"
42− CABAL_HACKAGE_MIRROR: "hackage.haskell.org:http://hackage.fpcomplete.com"
4342 CABAL_BUILD_OPTIONS: "-j1 --flag limit-build-mem"
4443
4544 # ------------------------------------------------------------------------
4645 # Where to find the required tools
4746 # ------------------------------------------------------------------------
48− PATH: /opt/ghc/bin:/opt/ghcjs/bin:/sbin:/usr/sbin:/bin:/usr/bin
49− TOOLS_DIR: /opt
47+ PATH: /sbin:/usr/sbin:/bin:/usr/bin
5048
5149 # ------------------------------------------------------------------------
5250 # Location of packcheck.sh (the shell script invoked to perform CI tests ).
@@ -59,15 +57,15 @@ env: &env
5957 # If you have not committed packcheck.sh in your repo at PACKCHECK
6058 # then it is automatically pulled from this URL.
6159 PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/composewell/packcheck"
62− PACKCHECK_GITHUB_COMMIT: "a302772c8f3791c477edd1764b82f8d1f5b22fdf"
60+ PACKCHECK_GITHUB_COMMIT: "f6cfd7b7a33b4bf6fd63cce6a3fb3d26f5031403"
6361
6462executors:
6563 amd64-executor:
6664 docker:
67− - image: ubuntu:xenial
65+ - image: ubuntu:latest
6866 x86-executor:
6967 docker:
70− - image: i386/ubuntu:eoan
68+ - image: i386/ubuntu:focal
7169
7270#-----------------------------------------------------------------------------
7371# Common utility stuff, not to be modified usually
@@ -79,38 +77,50 @@ preinstall: &preinstall
7977 # required for https/cache save and restore
8078 apt-get install -y ca-certificates
8179
82− # required to (re)generate the configure script
83− apt-get install -y autoconf
84−
85− # For ghc and cabal-install packages from hvr's ppa
80+ # Alternative way of installing ghc and cabal, directly from
81+ # haskell.org instead of using ghcup. NOTE: this is for Debian
82+ # only and is debian release specific.
8683 # gnupg is required for apt-key to work
87− apt-get install -y gnupg
88− apt-get install -y apt-transport-https
89− apt-key adv --keyserver keyserver.ubuntu.com --recv-keys BA3CBA3FFE22B574
90− apt-get install -y software-properties-common
91− add-apt-repository -y ppa:hvr/ghc
92− # echo "deb http://downloads.haskell.org/debian stretch main" >> /etc/apt/sources.list
93− echo "deb-src http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main" >> /etc/apt/sources.list
94− apt-get update
84+ #apt-get install -y gnupg
85+ #apt-key adv --keyserver keyserver.ubuntu.com --recv-keys BA3CBA3FFE22B574
86+ #echo "deb http://downloads.haskell.org/debian buster main" >> /etc/apt/sources.list
87+ #apt-get update
9588
96− # required for packcheck
97− apt-get install -y curl
89+ # required for outbound https for stack and for stack setup
90+ apt-get install -y netbase xz-utils make
91+ apt-get install -y zlib1g-dev
9892
99− # required for circleci.
100− apt-get install -y libcurl4-gnutls-dev
101− apt-get install -y git
93+ # For ghcup to install ghc
94+ if test -n "$GHCUP_VERSION"
95+ then
96+ apt-get install -y gcc
97+ apt-get install -y g++
98+ fi
99+
100+ # libgmp required by ghc for linking
101+ apt-get install -y libgmp-dev
102102 apt-get install -y libtinfo-dev
103103
104− # required for outbound https for stack and for stack setup
105− apt-get install -y netbase xz-utils make
104+ # Required by cabal when git URL is specified in project file
105+ apt-get install -y git
106+
107+ # Required for and by packcheck
108+ apt-get install -y curl
106109
107−project-preinstall: &project-preinstall
108− run: |
109110 # Get packcheck if needed
110− CURL=$(which curl)
111− PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh
112− if test ! -e "$PACKCHECK"; then $CURL -sL -o "$PACKCHECK" $PACKCHECK_URL; fi;
113− chmod +x $PACKCHECK
111+ if test ! -e "$PACKCHECK"
112+ then
113+ if test -z "$PACKCHECK_GITHUB_COMMIT"
114+ then
115+ die "PACKCHECK_GITHUB_COMMIT is not specified."
116+ fi
117+ PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh
118+ curl --fail -sL -o "$PACKCHECK" $PACKCHECK_URL || exit 1
119+ chmod +x $PACKCHECK
120+ elif test ! -x "$PACKCHECK"
121+ then
122+ chmod +x $PACKCHECK
123+ fi
114124
115125restore: &restore
116126 # Needs to happen after installing ca-certificates
@@ -126,271 +136,71 @@ save: &save
126136 save_cache:
127137 key: v1-{{ .Environment.CIRCLE_JOB }}-{{ .Branch }}
128138 paths:
129− - ~/.cabal
130− - ~/.ghc
131139 - ~/.local
140+ - ~/.cabal
132141 - ~/.stack
142+ - ~/.ghcup
133143
134144#-----------------------------------------------------------------------------
135145# Build matrix
136146#-----------------------------------------------------------------------------
137147
138148jobs:
139− cabal-ghc-8_10_4:
149+ cabal-ghc-8_6_5:
140150 <<: *env
141151 executor: amd64-executor
142152 steps:
143− - *preinstall
144153 - checkout
145− - *project-preinstall
146154 - *restore
155+ - *preinstall
147156 - run:
148157 environment:
158+ GHCVER: "8.6.5"
159+ CABAL_VERSION: "3.6.2.0"
149160 CABAL_PROJECT: "cabal.project"
150− DISABLE_TEST: "yes"
151− DISABLE_BENCH: "yes"
152161 DISABLE_SDIST_BUILD: "yes"
162+ CABAL_BUILD_OPTIONS: "--flag debug --flag -opt"
153163 command: |
154− apt-get install -y ghc-8.10.4
155− apt-get install -y cabal-install-3.4
156164 bash -c "$PACKCHECK cabal"
157165 - *save
158− stack-ghc-8_8:
166+ cabal-ghc-9_8_1-docspec:
159167 <<: *env
160168 executor: amd64-executor
161169 steps:
162− - *preinstall
163170 - checkout
164− - *project-preinstall
165171 - *restore
166− - run:
167− name: GHC 8.8 + stack lts-16.12
168− environment:
169− BUILD: "stack"
170− RESOLVER: "lts-16.12"
171− SDIST_OPTIONS: "--ignore-check"
172− STACK_BUILD_OPTIONS: "--flag streamly-benchmarks:-opt"
173− command: |
174− apt-get build-dep -y ghc-8.8.4
175− apt-get install -y cabal-install-3.2
176− bash -c "$PACKCHECK $BUILD"
177− - *save
178− cabal-ghc-8_6_5:
179− <<: *env
180− executor: amd64-executor
181− steps:
182172 - *preinstall
183− - checkout
184− - *project-preinstall
185− - *restore
186− - run: |
187− apt-get install -y ghc-8.6.3
188− apt-get install -y cabal-install-2.4
189− bash -c "$PACKCHECK cabal-v2"
190− - *save
191− cabal-ghc-8_4_4:
192− <<: *env
193− executor: x86-executor
194− steps:
195− - *preinstall
196− - checkout
197− - *project-preinstall
198− - *restore
199− - run:
200− name: GHC 8.4.4 + x86 + debug
201− environment:
202− BUILD: "cabal-v2"
203− GHCVER: "8.4.4"
204− CABAL_BUILD_OPTIONS: "--flag debug --flag limit-build-mem"
205− command: |
206− apt-get install -y ghc-8.4.4
207− apt-get install -y cabal-install-3.2
208− bash -c "$PACKCHECK $BUILD"
209− - *save
210− cabal-ghc-8_2_2:
211− <<: *env
212− executor: amd64-executor
213− steps:
214− - *preinstall
215− - checkout
216− - *project-preinstall
217− - *restore
218173 - run:
219174 environment:
220− BUILD: "cabal-v2"
221− DISABLE_TEST: "yes"
222− DISABLE_BENCH: "yes"
223− DISABLE_DOCS: "yes"
224− DISABLE_SDIST_BUILD: "yes"
225− DISABLE_DIST_CHECKS: "yes"
175+ GHCVER: "9.8.1"
176+ CABAL_VERSION: "3.10.1.0"
177+ CABAL_PROJECT: "cabal.project.doctest"
178+ DISABLE_SDIST_BUILD: "y"
179+ DISABLE_TEST: "y"
180+ DISABLE_BENCH: "y"
181+ DISABLE_DOCS: "y"
182+ ENABLE_DOCSPEC: "y"
183+ DOCSPEC_URL: https://github.com/phadej/cabal-extras/releases/download/cabal-docspec-0.0.0.20210111/cabal-docspec-0.0.0.20210111.xz
184+ DOCSPEC_OPTIONS: "--timeout 60 --check-properties --property-variables xs"
226185 command: |
227− apt-get install -y ghc-8.2.2
228− apt-get install -y cabal-install-3.2
229− bash -c "$PACKCHECK $BUILD"
230− - *save
231− cabal-ghc-8_0_2:
232− <<: *env
233− executor: amd64-executor
234− steps:
235− - *preinstall
236− - checkout
237− - *project-preinstall
238− - *restore
239− - run:
240− environment:
241− BUILD: "cabal-v2"
242− DISABLE_TEST: "yes"
243− DISABLE_BENCH: "yes"
244− DISABLE_DOCS: "yes"
245− DISABLE_SDIST_BUILD: "yes"
246− DISABLE_DIST_CHECKS: "yes"
247− command: |
248− apt-get install -y ghc-8.0.2
249− apt-get install -y cabal-install-3.2
250− bash -c "$PACKCHECK $BUILD"
251− - *save
252− cabal-ghc-7_10_3:
253− <<: *env
254− executor: amd64-executor
255− steps:
256− - *preinstall
257− - checkout
258− - *project-preinstall
259− - *restore
260− - run: |
261− apt-get install -y ghc-7.10.3
262− apt-get install -y cabal-install-2.4
263− bash -c "$PACKCHECK cabal-v2"
186+ bash -c "$PACKCHECK cabal"
264187 - *save
265− stack-ghc-8_4:
188+ hlint-trailing-spaces:
266189 <<: *env
267190 executor: amd64-executor
268191 steps:
269− - *preinstall
270192 - checkout
271− - *project-preinstall
272193 - *restore
273− - run: |
274− bash -c "$PACKCHECK stack RESOLVER=lts-12"
275− - *save
276− stack-ghc-8_2:
277− <<: *env
278− executor: amd64-executor
279− steps:
280194 - *preinstall
281− - checkout
282− - *project-preinstall
283− - *restore
284− - run: |
285− bash -c "$PACKCHECK stack RESOLVER=lts-11"
286− - *save
287− cabal-ghcjs-8_4:
288− <<: *env
289− executor: amd64-executor
290− steps:
291− - *preinstall
292− - checkout
293− - *project-preinstall
294− - *restore
295195 - run:
296− name: GHCJS 8.4+no-test+no-docs
196+ name: hlint and trailing spaces
297197 environment:
298− BUILD: cabal-v2
299− ENABLE_GHCJS: "yes"
300− DISABLE_TEST: "yes"
301− ENABLE_INSTALL: ""
302− DISABLE_DOCS: "yes"
303198 DISABLE_SDIST_BUILD: "yes"
304− command: |
305− add-apt-repository -y ppa:hvr/ghcjs
306− add-apt-repository -y 'deb https://deb.nodesource.com/node_11.x xenial main'
307− curl -sSL https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -
308− apt-get update
309− apt-get install -y cabal-install-3.2
310− apt-get install -y nodejs
311− apt-get install -y ghcjs-8.4
312− cabal user-config update -a "jobs: 1"
313− bash -c "$PACKCHECK $BUILD"
314− - *save
315− coveralls-ghc-8_2_2:
316− <<: *env
317− executor: amd64-executor
318− steps:
319− - *preinstall
320− - checkout
321− - *project-preinstall
322− - *restore
323− - run:
324− environment:
325− BUILD: cabal
326− COVERALLS_OPTIONS: "--repo-token=\"$REPO_TOKEN\" --coverage-mode=StrictlyFullLines --exclude-dir=test test"
327− GHC_OPTIONS: "-DCOVERAGE_BUILD"
328− command: |
329− apt-get install -y ghc-8.2.2
330− apt-get install -y cabal-install-2.4
331− bash -c "$PACKCHECK cabal-v1"
332− - *save
333− coveralls-ghc-8_8_3:
334− <<: *env
335− executor: amd64-executor
336− steps:
337− - *preinstall
338− - checkout
339− - *project-preinstall
340− - *restore
341− - run:
342− environment:
343− BUILD: cabal-v2
344− COVERALLS_OPTIONS: "--repo-token=\"$REPO_TOKEN\" --coverage-mode=StrictlyFullLines --exclude-dir=test"
345− CABAL_PROJECT: "cabal.project.coverage"
346− CABAL_BUILD_TARGETS: ""
347− command: |
348− apt-get install -y ghc-8.8.3
349− apt-get install -y cabal-install-3.0
350− bash -c "$PACKCHECK cabal-v2"
351− no_output_timeout: 25m
352− - *save
353− coveralls-ghc-8_10_2:
354− <<: *env
355− executor: amd64-executor
356− steps:
357− - *preinstall
358− - checkout
359− - *project-preinstall
360− - *restore
361− - run:
362− name: Build and test with inspection, coverage, Werror
363− command: |
364− apt-get install -y ghc-8.10.2
365− apt-get install -y cabal-install-3.2
366− # Run tests with coverage
367− cabal update
368− cabal user-config update -a "jobs: 1"
369− bin/test.sh --coverage --raw
370− # Upload results to coveralls.io
371− PATH=$HOME/.cabal/bin:$PATH
372− export PATH
373− which hpc-coveralls 2>/dev/null || cabal install --project-file cabal.project.hpc-coveralls hpc-coveralls
374− hpc-coveralls --repo-token="$REPO_TOKEN" --coverage-mode=StrictlyFullLines
375− no_output_timeout: 25m
376− - *save
377− hlint-src:
378− <<: *env
379− executor: amd64-executor
380− steps:
381− - *preinstall
382− - checkout
383− - *project-preinstall
384− - *restore
385− - run:
386− name: Hlint src
387− environment:
388− BUILD: hlint
199+ HLINT_VERSION: 3.6.1
389200 HLINT_OPTIONS: lint
390− DISABLE_SDIST_BUILD: "yes"
391201 HLINT_TARGETS: core/src src test benchmark
392202 command: |
393− bash -c "$PACKCHECK $BUILD" || exit 1
203+ bash -c "$PACKCHECK hlint" || exit 1
394204 echo "Checking trailing spaces..."
395205 count=$(find . -name "*.hs" -exec grep -H '\ $' {} \; | tee /dev/tty | wc -l)
396206 exit $count
@@ -400,23 +210,9 @@ workflows:
400210 version: 2
401211 build:
402212 jobs:
403− - cabal-ghc-8_10_4:
404− name: GHC 8.10.4 + sdist + no-test + no-bench
405− #- cabal-ghc-8.6.5
406− #- cabal-ghc-8_4_4:
407− # name: GHC 8.4.4 + x86 + debug
408− #- cabal-ghc-8_2_2:
409− # name: GHC 8.2.2 + no-test + no-bench + no-docs
410− #- cabal-ghc-8_0_2:
411− # name: GHC 8.0.2 + no-test + no-bench + no-docs
412− #- cabal-ghc-7.10.3
413− # - cabal-ghcjs-8_4:
414− # name: GHCJS 8.4 + no-test + no-docs
415− #- stack-ghc-8.4
416− #- stack-ghc-8.2
417− #- coveralls-ghc-8.2.2
418− #- coveralls-ghc-8.8.3
419− #- coveralls-ghc-8_10_2:
420− # name: GHC 8.10.2 + inspection + coverage + Werror
421− - hlint-src:
422− name: Hlint src + Trailing Spaces
213+ #- cabal-ghc-8_6_5:
214+ # name: 8.6.5-debug-unoptimized
215+ - cabal-ghc-9_8_1-docspec:
216+ name: ghc-9.8.1-docspec
217+ - hlint-trailing-spaces:
218+ name: hlint and trailing spaces
.github/workflows/haskell.yml+90−89
@@ -13,9 +13,15 @@ jobs:
1313 # packcheck environment variables
1414 LC_ALL: C.UTF-8
1515 BUILD: ${{ matrix.build }}
16+ # For updating see: https://downloads.haskell.org/~ghcup/
17+ GHCUP_VERSION: 0.1.20.0
18+ DOCSPEC_URL: https://github.com/phadej/cabal-extras/releases/download/cabal-docspec-0.0.0.20210111/cabal-docspec-0.0.0.20210111.xz
19+ DOCSPEC_OPTIONS: "--timeout 60 --check-properties --property-variables xs"
20+ GHCUP_GHC_OPTIONS: ${{ matrix.ghcup_ghc_options }}
1621 GHCVER: ${{ matrix.ghc_version }}
1722 CABALVER: ${{ matrix.cabal_version }}
1823 DISABLE_DOCS: ${{ matrix.disable_docs }}
24+ ENABLE_DOCSPEC: ${{ matrix.enable_docspec }}
1925 DISABLE_TEST: ${{ matrix.disable_test }}
2026 DISABLE_BENCH: ${{ matrix.disable_bench }}
2127 DISABLE_DIST_CHECKS: ${{ matrix.disable_dist_checks }}
@@ -39,14 +45,18 @@ jobs:
3945 STACK_BUILD_OPTIONS: ${{ matrix.stack_build_options }}
4046
4147 # packcheck location and revision
42− PACKCHECK_LOCAL_PATH: "./packcheck.sh"
48+ PACKCHECK: "./packcheck.sh"
4349 PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/composewell/packcheck"
44− PACKCHECK_GITHUB_COMMIT: "a302772c8f3791c477edd1764b82f8d1f5b22fdf"
50+ PACKCHECK_GITHUB_COMMIT: "v0.7.0"
4551
4652 # Pull token from "secrets" setting of the github repo
4753 COVERALLS_TOKEN: ${{ secrets.COVERALLS_TOKEN }}
4854 COVERAGE: ${{ matrix.coverage }}
49− DOCTEST: ${{ matrix.doctest }}
55+
56+ # hlint
57+ HLINT_VERSION: 3.6.1
58+ HLINT_OPTIONS: "lint"
59+ HLINT_TARGETS: "core/src src test benchmark"
5060
5161 # Subdir
5262 SUBDIR: ${{ matrix.subdir }}
@@ -58,8 +68,8 @@ jobs:
5868 matrix:
5969 # The order is important to optimize fail-fast.
6070 name:
61− - 8.10.7-Werror
62− - 9.2.4-docspec
71+ - 9.8.1-Werror
72+ # - 9.8.1-docspec
6373 # - 8.10.7-coverage
6474
6575 # Note: if cabal.project is not specified benchmarks and tests won't
@@ -68,35 +78,74 @@ jobs:
6878 include:
6979 - name: head
7080 ghc_version: head
81+ # The URL may change, to find a working URL go to https://gitlab.haskell.org/ghc/ghc/-/jobs/
82+ # Find a debian10/11/12 job, click on a passed/failed status, at the
83+ # end of the output you will find the tar.xz name, put that tar
84+ # name after "raw/", and put the job name after "job=".
85+ # Also see https://github.com/mpickering/ghc-artefact-nix/blob/master/gitlab-artifact.nix
86+ #
87+ # May also use ghcup for installing ghc head version, use the
88+ # version "LatestNightly", and the following config:
89+ # ghcup config add-release-channel https://ghc.gitlab.haskell.org/ghcup-metadata/ghcup-nightlies-0.0.7.yaml
90+ ghcup_ghc_options: "-u https://gitlab.haskell.org/ghc/ghc/-/jobs/artifacts/master/raw/ghc-x86_64-linux-deb10-int_native-validate.tar.xz?job=x86_64-linux-deb10-int_native-validate"
7191 runner: ubuntu-latest
7292 build: cabal
73− cabal_version: 3.8.1.0
93+ cabal_version: 3.10.2.0
7494 cabal_project: cabal.project.ghc-head
7595 disable_sdist_build: "y"
7696 ignore_error: true
77− - name: 9.4.2-fusion-inspection
78− ghc_version: 9.4.2
97+ # Note: use linux for warning build for convenient dev testing
98+ - name: 9.8.1-Werror
99+ ghc_version: 9.8.1
79100 runner: ubuntu-latest
80101 build: cabal
81− cabal_version: 3.8.1.0
102+ cabal_version: 3.10.1.0
103+ disable_sdist_build: "y"
104+ cabal_project: cabal.project.Werror
105+ ignore_error: false
106+ #- name: 9.8.1-docspec
107+ # ghc_version: 9.8.1
108+ # runner: ubuntu-latest
109+ # build: cabal
110+ # cabal_version: 3.10.1.0
111+ # cabal_project: cabal.project.doctest
112+ # disable_test: "y"
113+ # disable_bench: "y"
114+ # disable_docs: "y"
115+ # enable_docspec: "y"
116+ # disable_sdist_build: "y"
117+ # ignore_error: false
118+ - name: 9.8.1-fusion-inspection
119+ ghc_version: 9.8.1
120+ runner: ubuntu-latest
121+ build: cabal
122+ cabal_version: 3.10.1.0
82123 disable_sdist_build: "y"
83124 cabal_project: cabal.project
84125 cabal_build_options: "--flag fusion-plugin --flag inspection"
85126 ignore_error: false
86− - name: 9.2.4
87− ghc_version: 9.2.4
88− runner: ubuntu-latest
127+ - name: 9.6.3-macos
128+ ghc_version: 9.6.3
129+ runner: macos-latest
89130 build: cabal
131+ cabal_version: 3.10.1.0
132+ disable_sdist_build: "y"
90133 cabal_project: cabal.project
91− cabal_version: 3.6.2.0
134+ ignore_error: false
135+ - name: 9.4.7
136+ ghc_version: 9.4.7
137+ runner: ubuntu-latest
138+ build: cabal
139+ cabal_version: 3.8.1.0
92140 disable_sdist_build: "y"
141+ cabal_project: cabal.project
93142 ignore_error: false
94− - name: 9.2.4-docspec
95− ghc_version: 9.2.4
143+ - name: 9.2.8
144+ ghc_version: 9.2.8
96145 runner: ubuntu-latest
97− doctest: "y"
98− cabal_version: 3.6.2.0
146+ build: cabal
99147 cabal_project: cabal.project
148+ cabal_version: 3.6.2.0
100149 disable_sdist_build: "y"
101150 ignore_error: false
102151 - name: 9.0.2-streamly-sdist
@@ -122,28 +171,12 @@ jobs:
122171 stack_build_options: "--flag streamly-benchmarks:-opt"
123172 cabal_version: 3.6.2.0
124173 ignore_error: false
125− - name: 8.10.7-macos
126− ghc_version: 8.10.7
127− runner: macos-latest
128− build: cabal
129− cabal_version: 3.6.2.0
130− cabal_project: cabal.project
131− disable_sdist_build: "y"
132− ignore_error: false
133174 # - name: 8.10.7-coverage
134175 # ghc_version: 8.10.7
135176 # runner: ubuntu-latest
136177 # coverage: "y"
137178 # cabal_version: 3.6.2.0
138179 # ignore_error: false
139− - name: 8.10.7-Werror
140− ghc_version: 8.10.7
141− runner: ubuntu-latest
142− build: cabal
143− cabal_version: 3.6.2.0
144− cabal_project: cabal.project.Werror
145− disable_sdist_build: "y"
146− ignore_error: false
147180 - name: 8.8.4
148181 ghc_version: 8.8.4
149182 runner: ubuntu-latest
@@ -152,15 +185,6 @@ jobs:
152185 cabal_project: cabal.project
153186 disable_sdist_build: "y"
154187 ignore_error: false
155− - name: 8.6.5-no-fusion-unoptimized
156− ghc_version: 8.6.5
157− runner: ubuntu-latest
158− build: cabal
159− cabal_version: 3.6.2.0
160− cabal_project: cabal.project
161− cabal_build_options: "--flag no-fusion --flag -opt"
162− disable_sdist_build: "y"
163− ignore_error: false
164188 - name: 8.6.5-debug-unoptimized
165189 ghc_version: 8.6.5
166190 runner: ubuntu-latest
@@ -170,66 +194,44 @@ jobs:
170194 cabal_build_options: "--flag debug --flag -opt"
171195 disable_sdist_build: "y"
172196 ignore_error: false
197+ - name: hlint
198+ build: hlint
199+ runner: ubuntu-latest
200+ ignore_error: true
173201
174202 steps:
175203 - uses: actions/checkout@v2
176204
177205 - uses: actions/cache@v1
178− name: Cache ~/.cabal
206+ name: Cache common directories
179207 with:
180− path: ~/.cabal
208+ path: |
209+ ~/.local
210+ ~/.cabal
211+ ~/.stack
212+ ~/.ghcup
181213 # Bump the key version to clear the cache
182214 key: ${{ runner.os }}-${{ matrix.ghc_version }}-cabal-v2
183215
184216 - name: Download packcheck
185217 run: |
186− # Get packcheck if needed
187− CURL=$(which curl)
188− PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh
189− if test ! -e "$PACKCHECK_LOCAL_PATH"; then $CURL -sL -o "$PACKCHECK_LOCAL_PATH" $PACKCHECK_URL; fi;
190− chmod +x $PACKCHECK_LOCAL_PATH
191−
192− os=$(uname -s -m)
193− case "$os" in
194− "Linux x86_64") GHCUP_ARCH="x86_64-linux" ;;
195− "Darwin x86_64") GHCUP_ARCH="x86_64-apple-darwin" ;;
196− *) echo "Unknown OS/Arch: $os"; exit 1;;
197− esac
198−
199− # Check available versions here: https://downloads.haskell.org/~ghcup/
200− GHCUP_VER=0.1.18.0
201− $CURL -sL -o ./ghcup https://downloads.haskell.org/~ghcup/$GHCUP_VER/${GHCUP_ARCH}-ghcup-$GHCUP_VER
202− chmod +x ./ghcup
203− if test "$GHCVER" = "head"
218+ if test ! -e "$PACKCHECK"
204219 then
205− # The URL may change, to find a working URL go to https://gitlab.haskell.org/ghc/ghc/-/jobs/
206− # Find a debian10 job, click on a passed/failed job, at the
207− # end of the output you will find the tar.xz name, put that after
208− # "raw/", and put the job name after "job=".
209− # Also see https://github.com/mpickering/ghc-artefact-nix/blob/master/gitlab-artifact.nix
210− ./ghcup install ghc -u https://gitlab.haskell.org/ghc/ghc/-/jobs/artifacts/master/raw/ghc-x86_64-linux-deb10-int_native-validate.tar.xz?job=x86_64-linux-deb10-int_native-validate head
211− else
212− ./ghcup install ghc $GHCVER
220+ if test -z "$PACKCHECK_GITHUB_COMMIT"
221+ then
222+ die "PACKCHECK_GITHUB_COMMIT is not specified."
223+ fi
224+ PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh
225+ curl --fail -sL -o "$PACKCHECK" $PACKCHECK_URL || exit 1
226+ chmod +x $PACKCHECK
227+ elif test ! -x "$PACKCHECK"
228+ then
229+ chmod +x $PACKCHECK
213230 fi
214− ./ghcup install cabal $CABALVER
215− ./ghcup set ghc $GHCVER
216− ./ghcup set cabal $CABALVER
217231
218232 - name: Run tests
219233 run: |
220− if test -n "$DOCTEST"
221− then
222− mkdir -p $HOME/.cabal/bin
223− curl -sL https://github.com/phadej/cabal-extras/releases/download/cabal-docspec-0.0.0.20210111/cabal-docspec-0.0.0.20210111.xz > cabal-docspec.xz
224− echo '0829bd034fba901cbcfe491d98ed8b28fd54f9cb5c91fa8e1ac62dc4413c9562 cabal-docspec.xz' | sha256sum -c -
225− xz -d < cabal-docspec.xz > $HOME/.cabal/bin/cabal-docspec
226− rm -f cabal-docspec.xz
227− chmod a+x $HOME/.cabal/bin/cabal-docspec
228− cabal update
229− cabal build --project-file cabal.project.doctest all
230− $HOME/.cabal/bin/cabal-docspec --version
231− $HOME/.cabal/bin/cabal-docspec --timeout 60 --check-properties --property-variables xs
232− elif test -n "$COVERAGE"
234+ if test -n "$COVERAGE"
233235 then
234236 # Run tests with coverage
235237 cabal update
@@ -242,16 +244,15 @@ jobs:
242244 # XXX Uncomment this and fix it properly later
243245 # hpc-coveralls --repo-token="$COVERALLS_TOKEN" --coverage-mode=StrictlyFullLines
244246 else
245− export TOOLS_DIR=/opt
246247 # /usr/local/opt/curl/bin for macOS
247248 export PATH=$HOME/.local/bin:$HOME/.ghcup/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/opt/curl/bin
248249 if test -n "$SUBDIR"
249250 then
250− mv "$PACKCHECK_LOCAL_PATH" "$SUBDIR/packcheck.sh"
251+ mv "$PACKCHECK" "$SUBDIR/packcheck.sh"
251252 # This is required as dist-newstyle will be created on the top level
252253 # directory as it is considered the working dir.
253254 rm cabal.project
254255 cd "$SUBDIR"
255256 fi
256− bash -c "$PACKCHECK_LOCAL_PATH $BUILD"
257+ bash -c "$PACKCHECK $BUILD"
257258 fi
.github/workflows/regression-check.yml+15−26
@@ -19,16 +19,15 @@ jobs:
1919 env:
2020 CI_BENCHMARKS_WITH_CUTOFF: >-
2121 Data.Array
22− Data.Array.Mut
22+ Data.MutArray
2323 Data.Array.Generic
2424 Data.Ring.Unboxed
2525 Data.Fold
2626 Data.Fold.Window
2727 Data.Parser
28− Data.Parser.ParserD
29− Data.Parser.ParserK
30− Data.Stream.StreamD
31− Data.Stream.StreamK:6
28+ Data.ParserK
29+ Data.StreamD
30+ Data.StreamK:6
3231 Data.Unfold
3332 Data.Stream
3433 Data.Stream.Concurrent
@@ -61,7 +60,7 @@ jobs:
6160 GHCUP_VER=0.1.18.0
6261 curl -sL -o ./ghcup https://downloads.haskell.org/~ghcup/$GHCUP_VER/x86_64-linux-ghcup-$GHCUP_VER
6362 chmod +x ./ghcup
64− GHCVER=8.10.7
63+ GHCVER=9.2.7
6564 ./ghcup install ghc $GHCVER
6665 ./ghcup set ghc $GHCVER
6766 cabal update
@@ -74,14 +73,6 @@ jobs:
7473 # Bump the key version to clear the cache
7574 key: cache-v2
7675
77− - name: Cache charts from master
78− id: cache-charts-master
79− uses: actions/cache@v2
80− with:
81− path: charts-master
82− # Bump the key version to clear the cache
83− key: charts-master-v1
84−
8576 - name: Cache bench-runner from pr
8677 id: cache-bench-runner-pr
8778 uses: actions/cache@v2
@@ -100,7 +91,6 @@ jobs:
10091 clean: false
10192
10293 - name: Install bench-runner
103− if: steps.cache-bench-runner-pr.outputs.cache-hit != 'true'
10494 run: |
10595 cabal install bench-runner --project-file=cabal.project.report --installdir=./
10696
@@ -109,19 +99,16 @@ jobs:
10999 # -----------------------------------------------------------------
110100
111101 - name: Checkout the base branch
112− if: steps.cache-charts-master.outputs.cache-hit != 'true'
113102 uses: actions/checkout@v2
114103 with:
115104 ref: master
116105 clean: false
117106
118107 - name: Run benchmarks
119− if: steps.cache-charts-master.outputs.cache-hit != 'true'
120108 run: |
121− ./bench-runner --targets "$CI_BENCHMARKS" --raw
109+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw
122110
123111 - name: Move charts to charts-master
124− if: steps.cache-charts-master.outputs.cache-hit != 'true'
125112 run: mv charts charts-master
126113
127114 # -----------------------------------------------------------------
@@ -138,7 +125,7 @@ jobs:
138125
139126 - name: Run benchmarks and append
140127 run: |
141− ./bench-runner --targets "$CI_BENCHMARKS" --raw --append
128+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw --append
142129
143130 # -----------------------------------------------------------------
144131 # -- Compare
@@ -146,7 +133,7 @@ jobs:
146133
147134 - name: List all benchmarks
148135 run: |
149− ./bench-runner --targets "$CI_BENCHMARKS" --no-measure
136+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --no-measure
150137
151138 - name: Compare benchmarks
152139 run: |
@@ -164,11 +151,13 @@ jobs:
164151
165152 echo
166153 echo "Checking $bname for regressions greater than $cutoff percent"
167− ! ./bench-runner \
168− --targets "$bname" \
169− --fields "$CI_FIELDS" \
170− --no-measure --silent \
171− --diff-cutoff-percent $cutoff \
154+ ! ./bench-runner \
155+ --package-name streamly-benchmarks \
156+ --package-version 0.0.0 \
157+ --targets "$bname" \
158+ --fields "$CI_FIELDS" \
159+ --no-measure --silent \
160+ --diff-cutoff-percent $cutoff \
172161 | grep -v "^$"
173162 test $? -eq 1 && EXIT_STATUS=1
174163 done
.hlint.ignore+7−2
@@ -2,14 +2,18 @@ core/src/Streamly/Internal/Data/Stream/StreamK/Type.hs
22core/src/Streamly/Internal/Data/Pipe/Type.hs
33core/src/Streamly/Internal/Unicode/Stream.hs
44src/Streamly/Internal/Data/SmallArray/Type.hs
5+src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs
6+src/Streamly/Internal/Data/Stream/Serial.hs
7+src/Streamly/Internal/Data/Stream/Zip.hs
58test/Streamly/Test/Data/Array.hs
69test/Streamly/Test/Data/Parser.hs
7−test/Streamly/Test/Data/Parser/ParserD.hs
10+test/Streamly/Test/Data/ParserK.hs
811test/Streamly/Test/Data/SmallArray.hs
912test/Streamly/Test/Data/Unfold.hs
1013test/Streamly/Test/FileSystem/Event.hs
1114test/Streamly/Test/Prelude/Concurrent.hs
1215test/Streamly/Test/Data/Stream/Concurrent.hs
16+test/lib/Streamly/Test/Prelude/Common.hs
1317test/Streamly/Test/Prelude/Fold.hs
1418test/Streamly/Test/Prelude/Rate.hs
1519test/Streamly/Test/Prelude/Serial.hs
@@ -21,12 +25,13 @@ benchmark/lib/Streamly/Benchmark/Prelude.hs
2125benchmark/NanoBenchmarks.hs
2226benchmark/Streamly/Benchmark/Data/Array.hs
2327benchmark/Streamly/Benchmark/Data/Parser.hs
24−benchmark/Streamly/Benchmark/Data/Parser/ParserD.hs
28+benchmark/Streamly/Benchmark/Data/ParserK.hs
2529benchmark/Streamly/Benchmark/Data/Stream/StreamDK.hs
2630benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs
2731benchmark/Streamly/Benchmark/Data/Unfold.hs
2832benchmark/Streamly/Benchmark/FileSystem/Handle.hs
2933benchmark/Streamly/Benchmark/Prelude/Async.hs
34+benchmark/Streamly/Benchmark/Prelude/Concurrent.hs
3035benchmark/Streamly/Benchmark/Prelude/Merge.hs
3136benchmark/Streamly/Benchmark/Prelude/Parallel.hs
3237benchmark/Streamly/Benchmark/Prelude/Rate.hs
CHANGELOG.md+1−1
@@ -1 +1 @@
1−docs/User/ProjectRelated/Changelog.md
1+docs/User/Project/Changelog.md
LICENSE−254
@@ -26,172 +26,6 @@ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
2626OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2727OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2828
29−-------------------------------------------------------------------------------
30−base-4.12.0.0 (http://hackage.haskell.org/package/base-4.12.0.0)
31−-------------------------------------------------------------------------------
32−This library (libraries/base) is derived from code from several
33−sources:
34−
35− * Code from the GHC project which is largely (c) The University of
36− Glasgow, and distributable under a BSD-style license (see below),
37−
38− * Code from the Haskell 98 Report which is (c) Simon Peyton Jones
39− and freely redistributable (but see the full license for
40− restrictions).
41−
42− * Code from the Haskell Foreign Function Interface specification,
43− which is (c) Manuel M. T. Chakravarty and freely redistributable
44− (but see the full license for restrictions).
45−
46−The full text of these licenses is reproduced below. All of the
47−licenses are BSD-style or compatible.
48−
49−The Glasgow Haskell Compiler License
50−
51−Copyright 2004, The University Court of the University of Glasgow.
52−All rights reserved.
53−
54−Redistribution and use in source and binary forms, with or without
55−modification, are permitted provided that the following conditions are met:
56−
57−- Redistributions of source code must retain the above copyright notice,
58−this list of conditions and the following disclaimer.
59−
60−- Redistributions in binary form must reproduce the above copyright notice,
61−this list of conditions and the following disclaimer in the documentation
62−and/or other materials provided with the distribution.
63−
64−- Neither name of the University nor the names of its contributors may be
65−used to endorse or promote products derived from this software without
66−specific prior written permission.
67−
68−THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
69−GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
70−INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
71−FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
72−UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
73−FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
74−DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
75−SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
76−CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
77−LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
78−OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
79−DAMAGE.
80−
81−Code derived from the document "Report on the Programming Language
82−Haskell 98", is distributed under the following license:
83−
84− Copyright (c) 2002 Simon Peyton Jones
85−
86− The authors intend this Report to belong to the entire Haskell
87− community, and so we grant permission to copy and distribute it for
88− any purpose, provided that it is reproduced in its entirety,
89− including this Notice. Modified versions of this Report may also be
90− copied and distributed for any purpose, provided that the modified
91− version is clearly presented as such, and that it does not claim to
92− be a definition of the Haskell 98 Language.
93−
94−Code derived from the document "The Haskell 98 Foreign Function
95−Interface, An Addendum to the Haskell 98 Report" is distributed under
96−the following license:
97−
98− Copyright (c) 2002 Manuel M. T. Chakravarty
99−
100− The authors intend this Report to belong to the entire Haskell
101− community, and so we grant permission to copy and distribute it for
102− any purpose, provided that it is reproduced in its entirety,
103− including this Notice. Modified versions of this Report may also be
104− copied and distributed for any purpose, provided that the modified
105− version is clearly presented as such, and that it does not claim to
106− be a definition of the Haskell 98 Foreign Function Interface.
107−
108−-------------------------------------------------------------------------------
109−bjoern-2008-2009 (http://bjoern.hoehrmann.de/utf-8/decoder/dfa/)
110−-------------------------------------------------------------------------------
111−Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
112−
113−Permission is hereby granted, free of charge, to any person obtaining a copy of
114−this software and associated documentation files (the "Software"), to deal in
115−the Software without restriction, including without limitation the rights to
116−use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
117−of the Software, and to permit persons to whom the Software is furnished to do
118−so, subject to the following conditions:
119−
120−The above copyright notice and this permission notice shall be included in all
121−copies or substantial portions of the Software.
122−
123−THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
124−IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
125−FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
126−AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
127−LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
128−OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
129−SOFTWARE.
130−
131−-------------------------------------------------------------------------------
132−clock-0.7.2 (http://hackage.haskell.org/package/clock-0.7.2)
133−-------------------------------------------------------------------------------
134−Copyright (c) 2009-2012, Cetin Sert
135−Copyright (c) 2010, Eugene Kirpichov
136−
137−All rights reserved.
138−
139−Redistribution and use in source and binary forms, with or without
140−modification, are permitted provided that the following conditions are
141−met:
142−
143− * Redistributions of source code must retain the above copyright
144− notice, this list of conditions and the following disclaimer.
145−
146− * Redistributions in binary form must reproduce the above
147− copyright notice, this list of conditions and the following
148− disclaimer in the documentation and/or other materials provided
149− with the distribution.
150−
151− * The names of contributors may not be used to endorse or promote
152− products derived from this software without specific prior
153− written permission.
154−
155−THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
156−"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
157−LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
158−A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
159−OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
160−SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
161−LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
162−DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
163−THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
164−(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
165−OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
166−
167−-------------------------------------------------------------------------------
168−foldl-1.4.5 (http://hackage.haskell.org/package/foldl-1.4.5)
169−-------------------------------------------------------------------------------
170−Copyright (c) 2013 Gabriel Gonzalez
171−All rights reserved.
172−
173−Redistribution and use in source and binary forms, with or without modification,
174−are permitted provided that the following conditions are met:
175− * Redistributions of source code must retain the above copyright notice,
176− this list of conditions and the following disclaimer.
177− * Redistributions in binary form must reproduce the above copyright notice,
178− this list of conditions and the following disclaimer in the documentation
179− and/or other materials provided with the distribution.
180− * Neither the name of Gabriel Gonzalez nor the names of other contributors
181− may be used to endorse or promote products derived from this software
182− without specific prior written permission.
183−
184−THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
185−ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
186−WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
187−DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
188−ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
189−(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
190−LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
191−ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
192−(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
193−SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
194−
19529-------------------------------------------------------------------------------
19630fsnotify-0.3.0.1 (http://hackage.haskell.org/package/fsnotify-0.3.0.1/)
19731-------------------------------------------------------------------------------
@@ -259,91 +93,3 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25993THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26094(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26195OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
262−
263−-------------------------------------------------------------------------------
264−primitive-0.7.0.0 (https://hackage.haskell.org/package/primitive-0.7.0.0)
265−-------------------------------------------------------------------------------
266−Copyright (c) 2008-2009, Roman Leshchinskiy
267−All rights reserved.
268−
269−Redistribution and use in source and binary forms, with or without
270−modification, are permitted provided that the following conditions are met:
271−
272−- Redistributions of source code must retain the above copyright notice,
273−this list of conditions and the following disclaimer.
274−
275−- Redistributions in binary form must reproduce the above copyright notice,
276−this list of conditions and the following disclaimer in the documentation
277−and/or other materials provided with the distribution.
278−
279−- Neither name of the University nor the names of its contributors may be
280−used to endorse or promote products derived from this software without
281−specific prior written permission.
282−
283−THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
284−GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
285−INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
286−FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
287−UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
288−FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
289−DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
290−SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
291−CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
292−LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
293−OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
294−DAMAGE.
295−
296−-------------------------------------------------------------------------------
297−transient-0.5.5 (http://hackage.haskell.org/package/transient-0.5.5)
298−-------------------------------------------------------------------------------
299−Copyright © 2014-2016 Alberto G. Corona <https://github.com/agocorona>
300−
301−Permission is hereby granted, free of charge, to any person obtaining a copy of
302−this software and associated documentation files (the "Software"), to deal in
303−the Software without restriction, including without limitation the rights to
304−use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
305−the Software, and to permit persons to whom the Software is furnished to do so,
306−subject to the following conditions:
307−
308−The above copyright notice and this permission notice shall be included in all
309−copies or substantial portions of the Software.
310−
311−THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
312−IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
313−FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
314−COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
315−IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
316−CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
317−
318−-------------------------------------------------------------------------------
319−vector-0.12.0.2 (http://hackage.haskell.org/package/vector-0.12.0.2)
320−-------------------------------------------------------------------------------
321−Copyright (c) 2008-2012, Roman Leshchinskiy
322−All rights reserved.
323−
324−Redistribution and use in source and binary forms, with or without
325−modification, are permitted provided that the following conditions are met:
326−
327−- Redistributions of source code must retain the above copyright notice,
328−this list of conditions and the following disclaimer.
329−
330−- Redistributions in binary form must reproduce the above copyright notice,
331−this list of conditions and the following disclaimer in the documentation
332−and/or other materials provided with the distribution.
333−
334−- Neither name of the University nor the names of its contributors may be
335−used to endorse or promote products derived from this software without
336−specific prior written permission.
337−
338−THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
339−GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
340−INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
341−FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
342−UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
343−FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
344−DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
345−SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
346−CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
347−LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
348−OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
349−DAMAGE.
README.md+1−1
@@ -1 +1 @@
1−docs/User/ProjectRelated/README.md
1+docs/User/Project/README.md
appveyor.yml+2
@@ -14,6 +14,8 @@ environment:
1414 # ------------------------------------------------------------------------
1515 # Common options
1616 # ------------------------------------------------------------------------
17+ # GHC 9.2.7 onwards redundant constraint warnings are incompatible with
18+ # older versions
1719 GHC_OPTIONS: "-Werror"
1820 CABAL_REINIT_CONFIG: "y"
1921 LC_ALL: "C.UTF-8"
benchmark/NanoBenchmarks.hs+1−1
@@ -18,7 +18,7 @@ import qualified Streamly.Data.Fold as FL
1818import qualified Streamly.Internal.Data.Stream as S
1919import qualified Streamly.Internal.Data.Stream.IsStream as Internal
2020
21−import Gauge
21+import Test.Tasty.Bench
2222import System.Random
2323
2424maxValue :: Int
benchmark/Streamly/Benchmark/Data/Array/CommonImports.hs+2−2
@@ -7,9 +7,9 @@ import System.Random (randomRIO)
77
88import qualified Streamly.Data.Fold as Fold
99import qualified Streamly.Data.Stream as S
10−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
10+import qualified Streamly.Internal.Data.Stream as Stream
1111
12−import Gauge
12+import Test.Tasty.Bench
1313import Streamly.Benchmark.Common hiding (benchPureSrc)
1414import qualified Stream.Common as P
1515
benchmark/Streamly/Benchmark/Data/Array/Stream.hs+8−8
@@ -31,30 +31,30 @@ import Control.Monad.Catch (MonadCatch)
3131import Data.Functor.Identity (runIdentity)
3232import Data.Maybe (isJust)
3333import Data.Word (Word8)
34−import Streamly.Internal.Data.Stream.StreamD (Stream)
35−import Streamly.Internal.Data.Stream.StreamK (StreamK)
34+import Streamly.Internal.Data.Stream (Stream)
35+import Streamly.Internal.Data.StreamK (StreamK)
3636import System.IO (Handle)
3737import System.Random (randomRIO)
3838import Prelude hiding ()
3939
4040import qualified Streamly.Data.Stream as Stream
4141import qualified Streamly.Internal.Data.Array as Array
42−import qualified Streamly.Internal.Data.Stream.Chunked as ArrayStream
42+import qualified Streamly.Internal.Data.Array.Stream as ArrayStream
4343import qualified Streamly.Internal.Data.Fold as Fold
4444import qualified Streamly.Internal.Data.Parser as Parser
45−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
46−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
45+import qualified Streamly.Internal.Data.Stream as Stream
46+import qualified Streamly.Internal.Data.StreamK as StreamK
4747import qualified Streamly.Internal.FileSystem.Handle as Handle
4848import qualified Streamly.Internal.Unicode.Stream as Unicode
4949
50−import Gauge hiding (env)
50+import Test.Tasty.Bench hiding (env)
5151import Streamly.Benchmark.Common
5252import Streamly.Benchmark.Common.Handle
5353import Control.Monad.IO.Class (MonadIO)
5454
5555#ifdef INSPECTION
56−import Streamly.Internal.Data.Unboxed (Unbox)
57−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
56+import Streamly.Internal.Data.MutByteArray (Unbox)
57+import Streamly.Internal.Data.Stream (Step(..))
5858import Test.Inspection
5959#endif
6060
benchmark/Streamly/Benchmark/Data/Fold.hs+35−11
@@ -12,6 +12,11 @@
1212{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
1313{-# OPTIONS_GHC -Wno-orphans #-}
1414
15+#undef FUSION_CHECK
16+#ifdef FUSION_CHECK
17+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
18+#endif
19+
1520module Main (main) where
1621
1722import Control.DeepSeq (NFData(..))
@@ -25,18 +30,18 @@ import Data.IntMap.Strict (IntMap)
2530import Data.Monoid (Last(..), Sum(..))
2631import System.Random (randomRIO)
2732
28−import Streamly.Internal.Data.Stream.StreamD (Stream)
33+import Streamly.Internal.Data.Stream (Stream)
2934import Streamly.Internal.Data.Fold (Fold(..))
3035import Streamly.Internal.Data.IsMap.HashMap ()
31−import Streamly.Internal.Data.Array.Mut (MutArray)
36+import Streamly.Internal.Data.MutArray (MutArray)
3237
3338import qualified Streamly.Internal.Data.Fold as FL
34−import qualified Streamly.Internal.Data.Fold.Container as FL
39+import qualified Streamly.Data.Fold.Prelude as Fold
3540import qualified Streamly.Internal.Data.Unfold as Unfold
3641import qualified Streamly.Internal.Data.Pipe as Pipe
37−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
42+import qualified Streamly.Internal.Data.Stream as Stream
3843
39−import Gauge
44+import Test.Tasty.Bench
4045import Streamly.Benchmark.Common
4146import Prelude hiding (all, any, take, unzip, sequence_, filter)
4247
@@ -214,7 +219,7 @@ demuxToIntMap :: Monad m =>
214219demuxToIntMap f g = Stream.fold (FL.demuxToContainer f g)
215220
216221{-# INLINE demuxToHashMap #-}
217−demuxToHashMap :: (Monad m, Ord k, Hashable k) =>
222+demuxToHashMap :: (Monad m, Hashable k) =>
218223 (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)
219224demuxToHashMap f g = Stream.fold (FL.demuxToContainer f g)
220225
@@ -224,7 +229,7 @@ demuxToMapIO :: (MonadIO m, Ord k) =>
224229demuxToMapIO f g = Stream.fold (FL.demuxToContainerIO f g)
225230
226231{-# INLINE demuxToHashMapIO #-}
227−demuxToHashMapIO :: (MonadIO m, Ord k, Hashable k) =>
232+demuxToHashMapIO :: (MonadIO m, Hashable k) =>
228233 (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)
229234demuxToHashMapIO f g = Stream.fold (FL.demuxToContainerIO f g)
230235
@@ -251,7 +256,7 @@ toIntMapIO f = Stream.fold (FL.toContainerIO f FL.sum)
251256{-# INLINE toHashMapIO #-}
252257toHashMapIO :: (MonadIO m, Ord k, Num a, Hashable k) =>
253258 (a -> k) -> Stream m a -> m (HashMap k a)
254−toHashMapIO f = Stream.fold (FL.toContainerIO f FL.sum)
259+toHashMapIO f = Stream.fold (Fold.toHashMapIO f FL.sum)
255260
256261-------------------------------------------------------------------------------
257262-- unzip
@@ -264,13 +269,13 @@ unzip = Stream.fold $ FL.lmap (\a -> (a, a)) (FL.unzip FL.sum FL.length)
264269{-# INLINE unzipWithFstM #-}
265270unzipWithFstM :: Monad m => Stream m Int -> m (Int, Int)
266271unzipWithFstM = do
267− let f = \a -> return (a + 1, a)
272+ let f a = return (a + 1, a)
268273 Stream.fold (FL.unzipWithFstM f FL.sum FL.length)
269274
270275{-# INLINE unzipWithMinM #-}
271276unzipWithMinM :: Monad m => Stream m Int -> m (Int, Int)
272277unzipWithMinM = do
273− let f = \a -> return (a + 1, a)
278+ let f a = return (a + 1, a)
274279 Stream.fold (FL.unzipWithMinM f FL.sum FL.length)
275280
276281-------------------------------------------------------------------------------
@@ -502,7 +507,9 @@ o_n_heap_serial value =
502507-------------------------------------------------------------------------------
503508
504509main :: IO ()
505−main = runWithCLIOpts defaultStreamSize allBenchmarks
510+main = do
511+#ifndef FUSION_CHECK
512+ runWithCLIOpts defaultStreamSize allBenchmarks
506513
507514 where
508515
@@ -515,3 +522,20 @@ main = runWithCLIOpts defaultStreamSize allBenchmarks
515522 , bgroup (o_n_space_prefix moduleName) (o_n_space_serial value)
516523 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)
517524 ]
525+#else
526+ -- Enable FUSION_CHECK macro at the beginning of the file
527+ -- Enable one benchmark below, and run the benchmark
528+ -- Check the .dump-simpl output
529+ let value = 100000
530+ let input = source value 1
531+ let getKey buckets = (`mod` buckets)
532+ let getFold k =
533+ return $ case k of
534+ 0 -> FL.sum
535+ 1 -> FL.length
536+ _ -> FL.length
537+
538+ -- demuxToMap (getKey 64) (getFold . getKey 64) input
539+ toIntMapIO (getKey 64) input
540+ return ()
541+#endif
benchmark/Streamly/Benchmark/Data/Fold/Window.hs+42−42
@@ -4,16 +4,16 @@ module Main (main) where
44
55import Control.DeepSeq (NFData)
66import Streamly.Data.Fold (Fold)
7−import Streamly.Internal.Data.Stream.StreamD (Stream)
7+import Streamly.Internal.Data.Stream (Stream)
88import System.Random (randomRIO)
99
1010import qualified Streamly.Data.Fold as Fold
11−import qualified Streamly.Internal.Data.Ring.Unboxed as Ring
12−import qualified Streamly.Internal.Data.Fold.Window as Window
13−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
11+import qualified Streamly.Internal.Data.Fold as Window
12+import qualified Streamly.Internal.Data.Ring as Ring
13+import qualified Streamly.Internal.Data.Stream as Stream
1414
1515import Streamly.Benchmark.Common
16−import Gauge
16+import Test.Tasty.Bench
1717
1818{-# INLINE source #-}
1919source :: (Monad m, Num a, Stream.Enumerable a) =>
@@ -70,55 +70,55 @@ o_1_space_folds :: Int -> [Benchmark]
7070o_1_space_folds numElements =
7171 [ bgroup "fold"
7272 [ benchWithFold numElements "minimum (window size 100)"
73− (Window.minimum 100)
73+ (Window.windowMinimum 100)
7474 , benchWithFold numElements "minimum (window size 1000)"
75− (Window.minimum 1000)
75+ (Window.windowMinimum 1000)
7676 , benchWith sourceDescendingInt numElements
7777 "minimum descending (window size 1000)"
78− (Window.minimum 1000)
78+ (Window.windowMinimum 1000)
7979
8080 , benchWithFold numElements "maximum (window size 100)"
81− (Window.maximum 100)
81+ (Window.windowMaximum 100)
8282 , benchWithFold numElements "maximum (window size 1000)"
83− (Window.maximum 1000)
83+ (Window.windowMaximum 1000)
8484 , benchWith sourceDescendingInt numElements
8585 "maximum descending (window size 1000)"
86− (Window.maximum 1000)
86+ (Window.windowMaximum 1000)
8787
8888 , benchWithFold numElements "range (window size 100)"
89− (Window.range 100)
89+ (Window.windowRange 100)
9090 , benchWithFold numElements "range (window size 1000)"
91− (Window.range 1000)
91+ (Window.windowRange 1000)
9292 , benchWith sourceDescendingInt numElements
9393 "range descending (window size 1000)"
94− (Window.range 1000)
94+ (Window.windowRange 1000)
9595
9696 , benchWithFoldInt numElements "sumInt (window size 100)"
97− (Ring.slidingWindow 100 Window.sumInt)
97+ (Ring.slidingWindow 100 Window.windowSumInt)
9898 , benchWithFoldInt numElements "sum for Int (window size 100)"
99− (Ring.slidingWindow 100 Window.sum)
99+ (Ring.slidingWindow 100 Window.windowSum)
100100 , benchWithFold numElements "sum (window size 100)"
101− (Ring.slidingWindow 100 Window.sum)
101+ (Ring.slidingWindow 100 Window.windowSum)
102102 , benchWithFold numElements "sum (window size 1000)"
103− (Ring.slidingWindow 1000 Window.sum)
103+ (Ring.slidingWindow 1000 Window.windowSum)
104104 , benchWithFold numElements "sum (entire stream)"
105− (Window.cumulative Window.sum)
105+ (Window.cumulative Window.windowSum)
106106 , benchWithFold numElements "sum (Data.Fold)"
107107 Fold.sum
108108
109109 , benchWithFold numElements "mean (window size 100)"
110− (Ring.slidingWindow 100 Window.mean)
110+ (Ring.slidingWindow 100 Window.windowMean)
111111 , benchWithFold numElements "mean (window size 1000)"
112− (Ring.slidingWindow 1000 Window.mean)
112+ (Ring.slidingWindow 1000 Window.windowMean)
113113 , benchWithFold numElements "mean (entire stream)"
114− (Window.cumulative Window.mean)
114+ (Window.cumulative Window.windowMean)
115115 , benchWithFold numElements "mean (Data.Fold)"
116116 Fold.mean
117117
118118 , benchWithFold numElements "powerSum 2 (window size 100)"
119− (Ring.slidingWindow 100 (Window.powerSum 2))
119+ (Ring.slidingWindow 100 (Window.windowPowerSum 2))
120120 , benchWithFold numElements "powerSum 2 (entire stream)"
121− (Window.cumulative (Window.powerSum 2))
121+ (Window.cumulative (Window.windowPowerSum 2))
122122
123123 ]
124124 ]
@@ -127,51 +127,51 @@ o_1_space_scans :: Int -> [Benchmark]
127127o_1_space_scans numElements =
128128 [ bgroup "scan"
129129 [ benchWithPostscan numElements "minimum (window size 10)"
130− (Window.minimum 10)
130+ (Window.windowMinimum 10)
131131 -- Below window size 30 the linear search based impl performs better
132132 -- than the dequeue based implementation.
133133 , benchWithPostscan numElements "minimum (window size 30)"
134− (Window.minimum 30)
134+ (Window.windowMinimum 30)
135135 , benchWithPostscan numElements "minimum (window size 1000)"
136− (Window.minimum 1000)
136+ (Window.windowMinimum 1000)
137137 , benchScanWith sourceDescendingInt numElements
138138 "minimum descending (window size 1000)"
139− (Window.minimum 1000)
139+ (Window.windowMinimum 1000)
140140
141141 , benchWithPostscan numElements "maximum (window size 10)"
142− (Window.maximum 10)
142+ (Window.windowMaximum 10)
143143 , benchWithPostscan numElements "maximum (window size 30)"
144− (Window.maximum 30)
144+ (Window.windowMaximum 30)
145145 , benchWithPostscan numElements "maximum (window size 1000)"
146− (Window.maximum 1000)
146+ (Window.windowMaximum 1000)
147147 , benchScanWith sourceDescendingInt numElements
148148 "maximum descending (window size 1000)"
149− (Window.maximum 1000)
149+ (Window.windowMaximum 1000)
150150
151151 , benchWithPostscan numElements "range (window size 10)"
152− (Window.range 10)
152+ (Window.windowRange 10)
153153 , benchWithPostscan numElements "range (window size 30)"
154− (Window.range 30)
154+ (Window.windowRange 30)
155155 , benchWithPostscan numElements "range (window size 1000)"
156− (Window.range 1000)
156+ (Window.windowRange 1000)
157157 , benchScanWith sourceDescendingInt numElements
158158 "range descending (window size 1000)"
159− (Window.range 1000)
159+ (Window.windowRange 1000)
160160
161161 , benchWithPostscan numElements "sum (window size 100)"
162− (Ring.slidingWindow 100 Window.sum)
162+ (Ring.slidingWindow 100 Window.windowSum)
163163 , benchWithPostscan numElements "sum (window size 1000)"
164− (Ring.slidingWindow 1000 Window.sum)
164+ (Ring.slidingWindow 1000 Window.windowSum)
165165
166166 , benchWithPostscan numElements "mean (window size 100)"
167− (Ring.slidingWindow 100 Window.mean)
167+ (Ring.slidingWindow 100 Window.windowMean)
168168 , benchWithPostscan numElements "mean (window size 1000)"
169− (Ring.slidingWindow 1000 Window.mean)
169+ (Ring.slidingWindow 1000 Window.windowMean)
170170
171171 , benchWithPostscan numElements "powerSum 2 (window size 100)"
172− (Ring.slidingWindow 100 (Window.powerSum 2))
172+ (Ring.slidingWindow 100 (Window.windowPowerSum 2))
173173 , benchWithPostscan numElements "powerSum 2 (window size 1000)"
174− (Ring.slidingWindow 1000 (Window.powerSum 2))
174+ (Ring.slidingWindow 1000 (Window.windowPowerSum 2))
175175 ]
176176 ]
177177
benchmark/Streamly/Benchmark/Data/Array/Mut.hs → benchmark/Streamly/Benchmark/Data/MutArray.hsrenamed+7−7
@@ -42,14 +42,14 @@ import Prelude
4242 , id
4343 , undefined
4444 )
45−import Streamly.Internal.Data.Array.Mut (MutArray)
45+import Streamly.Internal.Data.MutArray (MutArray)
4646
4747import qualified Streamly.Internal.Data.Array as Array
48−import qualified Streamly.Internal.Data.Array.Mut as MArray
48+import qualified Streamly.Internal.Data.MutArray as MArray
4949import qualified Streamly.Internal.Data.Fold as Fold
50−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
50+import qualified Streamly.Internal.Data.Stream as Stream
5151
52−import Gauge
52+import Test.Tasty.Bench
5353import Streamly.Benchmark.Common hiding (benchPureSrc)
5454
5555type Stream = MutArray
@@ -181,11 +181,11 @@ unfoldReadRevDrain = drain . Stream.unfold MArray.readerRev
181181
182182{-# INLINE toStreamDRevDrain #-}
183183toStreamDRevDrain :: MonadIO m => Stream Int -> m ()
184−toStreamDRevDrain = drain . MArray.toStreamDRev
184+toStreamDRevDrain = drain . MArray.readRev
185185
186186{-# INLINE toStreamDDrain #-}
187187toStreamDDrain :: MonadIO m => Stream Int -> m ()
188−toStreamDDrain = drain . MArray.toStreamD
188+toStreamDDrain = drain . MArray.read
189189
190190{-# INLINE unfoldFold #-}
191191unfoldFold :: MonadIO m => Stream Int -> m Int
@@ -274,7 +274,7 @@ o_1_space_serial_marray value ~(array, indices) =
274274-------------------------------------------------------------------------------
275275
276276moduleName :: String
277−moduleName = "Data.Array.Mut"
277+moduleName = "Data.MutArray"
278278
279279main :: IO ()
280280main = do
benchmark/Streamly/Benchmark/Data/Parser.hs+12−12
@@ -34,7 +34,7 @@ import System.Random (randomRIO)
3434import Streamly.Internal.Data.Fold (Fold(..))
3535import Streamly.Internal.Data.Parser
3636 (ParseError(..), Parser(..), Initial(..), Step(..))
37−import Streamly.Internal.Data.Stream.StreamD (Stream)
37+import Streamly.Internal.Data.Stream (Stream)
3838import Prelude hiding
3939 (any, all, take, sequence, sequence_, sequenceA, takeWhile, dropWhile, span)
4040
@@ -47,10 +47,9 @@ import qualified Streamly.Internal.Data.Fold as Fold
4747import qualified Streamly.Internal.Data.Parser as PR
4848import qualified Streamly.Data.Stream as Stream
4949import qualified Streamly.Internal.Data.Producer as Producer
50−import qualified Streamly.Internal.Data.Producer.Source as Source
51−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
50+import qualified Streamly.Internal.Data.Stream as Stream
5251
53−import Gauge hiding (env)
52+import Test.Tasty.Bench hiding (env)
5453import Streamly.Benchmark.Common
5554import Streamly.Benchmark.Common.Handle
5655
@@ -349,7 +348,7 @@ split_ value =
349348-- PR.dropWhile (<= (value * 1 `div` 4)) *> PR.die "alt"
350349{-# INLINE takeWhileFail #-}
351350takeWhileFail :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
352−takeWhileFail predicate (Fold fstep finitial fextract) =
351+takeWhileFail predicate (Fold fstep finitial _ ffinal) =
353352 Parser step initial extract
354353
355354 where
@@ -370,7 +369,7 @@ takeWhileFail predicate (Fold fstep finitial fextract) =
370369 Fold.Done b -> Done 0 b
371370 else return $ Error "fail"
372371
373− extract s = fmap (Done 0) (fextract s)
372+ extract s = fmap (Done 0) (ffinal s)
374373
375374{-# INLINE alt2 #-}
376375alt2 :: Monad m
@@ -635,13 +634,13 @@ choice value =
635634{-# INLINE parseManyUnfoldArrays #-}
636635parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()
637636parseManyUnfoldArrays count arrays = do
638− let src = Source.source (Just (Producer.OuterLoop arrays))
637+ let src = Producer.source (Just (Producer.OuterLoop arrays))
639638 let parser = PR.fromFold (Fold.take count Fold.drain)
640639 let readSrc =
641− Source.producer
640+ Producer.producer
642641 $ Producer.concat Producer.fromList Array.producer
643642 let streamParser =
644− Producer.simplify (Source.parseMany parser readSrc)
643+ Producer.simplify (Producer.parseMany parser readSrc)
645644 Stream.fold Fold.drain $ Stream.unfold streamParser src
646645
647646-------------------------------------------------------------------------------
@@ -715,8 +714,6 @@ instance NFData ParseError where
715714o_1_space_serial :: Int -> [Benchmark]
716715o_1_space_serial value =
717716 [ benchIOSink value "takeBetween" $ takeBetween value
718− , benchIOSink value "takeEQ" $ takeEQ value
719− , benchIOSink value "takeGE" $ takeGE value
720717 , benchIOSink value "takeWhile" $ takeWhile value
721718 , benchIOSink value "takeWhileP" $ takeWhileP value
722719 , benchIOSink value "takeP" $ takeP value
@@ -813,8 +810,11 @@ o_1_space_serial_unfold bound arrays =
813810o_n_heap_serial :: Int -> [Benchmark]
814811o_n_heap_serial value =
815812 [
813+ benchIOSink value "takeEQ" $ takeEQ value
814+ , benchIOSink value "takeGE" $ takeGE value
815+
816816 -- lookahead benchmark holds the entire input till end
817− benchIOSink value "lookAhead" $ lookAhead value
817+ , benchIOSink value "lookAhead" $ lookAhead value
818818
819819 -- o-n-heap because of backtracking
820820 , benchIOSrc sourceEscapedFrames value "takeFramedByEsc_"
benchmark/Streamly/Benchmark/Data/Parser/ParserK.hs → benchmark/Streamly/Benchmark/Data/ParserK.hsrenamed+92−39
@@ -5,6 +5,10 @@
55-- License : BSD-3-Clause
66-- Maintainer : streamly@composewell.com
77
8+-- BENCH_CHUNKED -> adaptC
9+-- BENCH_CHUNKED_GENERIC -> adaptCG
10+-- BENCH_SINGULAR -> adapt
11+
812{-# LANGUAGE CPP #-}
913{-# LANGUAGE FlexibleContexts #-}
1014{-# OPTIONS_GHC -Wno-orphans #-}
@@ -18,12 +22,18 @@ import Control.Applicative ((<|>))
1822import Control.DeepSeq (NFData(..))
1923import Control.Monad.IO.Class (MonadIO)
2024import Data.Foldable (asum)
25+#ifdef BENCH_CHUNKED
2126import Streamly.Data.Array (Array, Unbox)
22−import Streamly.Internal.Data.Fold.Type (Fold(..))
27+#endif
28+#ifdef BENCH_CHUNKED_GENERIC
29+import Streamly.Data.Array.Generic (Array)
30+import qualified Streamly.Internal.Data.Array.Generic as GenArr (chunksOf)
31+#endif
32+import Streamly.Internal.Data.Fold (Fold(..))
2333import Streamly.Data.StreamK (StreamK)
2434import Streamly.Internal.Data.Parser
2535 (ParseError(..), Parser(..), Initial(..), Step(..))
26−import Streamly.Internal.Data.Stream.StreamD (Stream)
36+import Streamly.Internal.Data.Stream (Stream)
2737import System.Random (randomRIO)
2838import Prelude hiding
2939 (any, all, take, sequence, sequence_, sequenceA, takeWhile)
@@ -35,12 +45,52 @@ import qualified Streamly.Data.Stream as Stream
3545import qualified Streamly.Data.Fold as FL
3646import qualified Streamly.Internal.Data.Fold as Fold
3747import qualified Streamly.Data.Parser as PRD
38−import qualified Streamly.Data.ParserK as PR
39−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
48+import qualified Streamly.Internal.Data.ParserK as PR
49+import qualified Streamly.Internal.Data.StreamK as StreamK
4050
41−import Gauge
51+import Test.Tasty.Bench
4252import Streamly.Benchmark.Common
4353
54+-------------------------------------------------------------------------------
55+-- CPP Helpers
56+-------------------------------------------------------------------------------
57+
58+#ifdef BENCH_CHUNKED
59+
60+#define PARSE_OP StreamK.parseChunks
61+#define FROM_PARSER adaptC
62+#define INPUT (Array a)
63+#define PARSE_ELEM (Array Int)
64+#define CONSTRAINT_IO (MonadIO m, Unbox a)
65+#define CONSTRAINT (Monad m, Unbox a)
66+#define MODULE_NAME "Data.ParserK.Chunked"
67+
68+#endif
69+
70+#ifdef BENCH_CHUNKED_GENERIC
71+
72+#define PARSE_OP StreamK.parseChunksGeneric
73+#define FROM_PARSER adaptCG
74+#define INPUT (Array a)
75+#define PARSE_ELEM (Array Int)
76+#define CONSTRAINT_IO (MonadIO m)
77+#define CONSTRAINT (Monad m)
78+#define MODULE_NAME "Data.ParserK.Chunked.Generic"
79+
80+#endif
81+
82+#ifdef BENCH_SINGULAR
83+
84+#define PARSE_OP StreamK.parse
85+#define FROM_PARSER adapt
86+#define INPUT a
87+#define PARSE_ELEM Int
88+#define CONSTRAINT_IO (MonadIO m)
89+#define CONSTRAINT (Monad m)
90+#define MODULE_NAME "Data.ParserK"
91+
92+#endif
93+
4494-------------------------------------------------------------------------------
4595-- Utilities
4696-------------------------------------------------------------------------------
@@ -60,49 +110,52 @@ sourceUnfoldrM value n = Stream.unfoldrM step n
60110{-# INLINE benchIOSink #-}
61111benchIOSink
62112 :: NFData b
63− => Int -> String -> (StreamK IO (Array Int) -> IO b) -> Benchmark
113+ => Int -> String -> (StreamK IO PARSE_ELEM -> IO b) -> Benchmark
64114benchIOSink value name f =
65115 bench name $ nfIO $ randomRIO (1,1)
66116 >>= f
67117 . StreamK.fromStream
118+#ifdef BENCH_CHUNKED
68119 . Stream.chunksOf 4000
120+#endif
121+#ifdef BENCH_CHUNKED_GENERIC
122+ . GenArr.chunksOf 4000
123+#endif
69124 . sourceUnfoldrM value
70125
71126-------------------------------------------------------------------------------
72127-- Parsers
73128-------------------------------------------------------------------------------
74129
75−#define PARSE_OP StreamK.parseChunks
76−
77130{-# INLINE one #-}
78131one :: MonadIO m =>
79− Int -> StreamK m (Array Int) -> m (Either ParseError (Maybe Int))
80−one value = StreamK.parseChunks p
132+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError (Maybe Int))
133+one value = PARSE_OP p
81134
82135 where
83136
84137 p = do
85− m <- PR.fromFold FL.one
138+ m <- PR.FROM_PARSER (PRD.fromFold FL.one)
86139 case m of
87140 Just i -> if i >= value then pure m else p
88141 Nothing -> pure Nothing
89142
90143{-# INLINE satisfy #-}
91−satisfy :: (MonadIO m, Unbox a) => (a -> Bool) -> PR.ParserK a m a
92−satisfy = PR.fromParser . PRD.satisfy
144+satisfy :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m a
145+satisfy = PR.FROM_PARSER . PRD.satisfy
93146
94147{-# INLINE takeWhile #-}
95−takeWhile :: (MonadIO m, Unbox a) => (a -> Bool) -> PR.ParserK a m ()
96−takeWhile p = PR.fromParser $ PRD.takeWhile p FL.drain
148+takeWhile :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m ()
149+takeWhile p = PR.FROM_PARSER $ PRD.takeWhile p FL.drain
97150
98151{-# INLINE takeWhileK #-}
99152takeWhileK :: MonadIO m =>
100− Int -> StreamK m (Array Int) -> m (Either ParseError ())
153+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
101154takeWhileK value = PARSE_OP (takeWhile (<= value))
102155
103156{-# INLINE splitAp2 #-}
104157splitAp2 :: MonadIO m
105− => Int -> StreamK m (Array Int) -> m (Either ParseError ((), ()))
158+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ((), ()))
106159splitAp2 value =
107160 PARSE_OP
108161 ((,)
@@ -112,7 +165,7 @@ splitAp2 value =
112165
113166{-# INLINE splitAp8 #-}
114167splitAp8 :: MonadIO m
115− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
168+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
116169splitAp8 value =
117170 PARSE_OP
118171 ( (\() () () () () () () () -> ())
@@ -127,7 +180,7 @@ splitAp8 value =
127180 )
128181
129182{-# INLINE sequenceA #-}
130−sequenceA :: MonadIO m => Int -> StreamK m (Array Int) -> m Int
183+sequenceA :: MonadIO m => Int -> StreamK m PARSE_ELEM -> m Int
131184sequenceA value xs = do
132185 let parser = satisfy (> 0)
133186 list = Prelude.replicate value parser
@@ -136,14 +189,14 @@ sequenceA value xs = do
136189
137190{-# INLINE sequenceA_ #-}
138191sequenceA_ :: MonadIO m =>
139− Int -> StreamK m (Array Int) -> m (Either ParseError ())
192+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
140193sequenceA_ value xs = do
141194 let parser = satisfy (> 0)
142195 list = Prelude.replicate value parser
143196 PARSE_OP (F.sequenceA_ list) xs
144197
145198{-# INLINE sequence #-}
146−sequence :: MonadIO m => Int -> StreamK m (Array Int) -> m Int
199+sequence :: MonadIO m => Int -> StreamK m PARSE_ELEM -> m Int
147200sequence value xs = do
148201 let parser = satisfy (> 0)
149202 list = Prelude.replicate value parser
@@ -152,7 +205,7 @@ sequence value xs = do
152205
153206{-# INLINE sequence_ #-}
154207sequence_ :: MonadIO m =>
155− Int -> StreamK m (Array Int) -> m (Either ParseError ())
208+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
156209sequence_ value =
157210 let parser = satisfy (> 0)
158211 list = Prelude.replicate value parser
@@ -160,7 +213,7 @@ sequence_ value =
160213
161214{-# INLINE takeWhileFailD #-}
162215takeWhileFailD :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
163−takeWhileFailD predicate (Fold fstep finitial fextract) =
216+takeWhileFailD predicate (Fold fstep finitial _ ffinal) =
164217 Parser step initial extract
165218
166219 where
@@ -181,16 +234,16 @@ takeWhileFailD predicate (Fold fstep finitial fextract) =
181234 Fold.Done b -> Done 0 b
182235 else return $ Error "fail"
183236
184− extract s = fmap (Done 0) (fextract s)
237+ extract s = fmap (Done 0) (ffinal s)
185238
186239{-# INLINE takeWhileFail #-}
187−takeWhileFail :: (Monad m, Unbox a) =>
188− (a -> Bool) -> Fold m a b -> PR.ParserK a m b
189−takeWhileFail p f = PR.fromParser (takeWhileFailD p f)
240+takeWhileFail :: CONSTRAINT =>
241+ (a -> Bool) -> Fold m a b -> PR.ParserK INPUT m b
242+takeWhileFail p f = PR.FROM_PARSER (takeWhileFailD p f)
190243
191244{-# INLINE alt2 #-}
192245alt2 :: MonadIO m
193− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
246+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
194247alt2 value =
195248 PARSE_OP
196249 ( takeWhileFail (<= (value `div` 2)) Fold.drain
@@ -199,7 +252,7 @@ alt2 value =
199252
200253{-# INLINE alt8 #-}
201254alt8 :: MonadIO m
202− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
255+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
203256alt8 value =
204257 PARSE_OP
205258 ( takeWhileFail (<= ( value `div` 8)) Fold.drain
@@ -214,7 +267,7 @@ alt8 value =
214267
215268{-# INLINE alt16 #-}
216269alt16 :: MonadIO m
217− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
270+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
218271alt16 value =
219272 PARSE_OP
220273 ( takeWhileFail (<= ( value `div` 16)) Fold.drain
@@ -236,27 +289,27 @@ alt16 value =
236289 )
237290
238291{-# INLINE manyAlt #-}
239−manyAlt :: MonadIO m => StreamK m (Array Int) -> m Int
292+manyAlt :: MonadIO m => StreamK m PARSE_ELEM -> m Int
240293manyAlt xs = do
241294 x <- PARSE_OP (AP.many (satisfy (> 0))) xs
242295 return $ Prelude.length x
243296
244297{-# INLINE someAlt #-}
245−someAlt :: MonadIO m => StreamK m (Array Int) -> m Int
298+someAlt :: MonadIO m => StreamK m PARSE_ELEM -> m Int
246299someAlt xs = do
247300 x <- PARSE_OP (AP.some (satisfy (> 0))) xs
248301 return $ Prelude.length x
249302
250303{-# INLINE choice #-}
251304choice :: MonadIO m =>
252− Int -> StreamK m (Array Int) -> m (Either ParseError Int)
305+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError Int)
253306choice value =
254307 PARSE_OP (asum (replicate value (satisfy (< 0)))
255308 AP.<|> satisfy (> 0))
256309
257310{-# INLINE monad2 #-}
258311monad2 :: MonadIO m
259− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
312+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
260313monad2 value =
261314 PARSE_OP $ do
262315 takeWhile (<= (value `div` 2))
@@ -264,7 +317,7 @@ monad2 value =
264317
265318{-# INLINE monad4 #-}
266319monad4 :: MonadIO m
267− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
320+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
268321monad4 value =
269322 PARSE_OP $ do
270323 takeWhile (<= ( value `div` 4))
@@ -274,7 +327,7 @@ monad4 value =
274327
275328{-# INLINE monad8 #-}
276329monad8 :: MonadIO m
277− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
330+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
278331monad8 value =
279332 PARSE_OP $ do
280333 takeWhile (<= ( value `div` 8))
@@ -288,7 +341,7 @@ monad8 value =
288341
289342{-# INLINE monad16 #-}
290343monad16 :: MonadIO m
291− => Int -> StreamK m (Array Int) -> m (Either ParseError ())
344+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())
292345monad16 value =
293346 PARSE_OP $ do
294347 takeWhile (<= ( value `div` 16))
@@ -313,7 +366,7 @@ monad16 value =
313366-------------------------------------------------------------------------------
314367
315368moduleName :: String
316−moduleName = "Data.Parser.ParserK"
369+moduleName = MODULE_NAME
317370
318371instance NFData ParseError where
319372 {-# INLINE rnf #-}
@@ -335,7 +388,7 @@ o_1_space_serial value =
335388 ]
336389
337390{-# INLINE sepBy1 #-}
338−sepBy1 :: MonadIO m => StreamK m (Array Int) -> m Int
391+sepBy1 :: MonadIO m => StreamK m PARSE_ELEM -> m Int
339392sepBy1 xs = do
340393 x <- PARSE_OP (parser (satisfy odd) (satisfy even)) xs
341394 return $ Prelude.length x
benchmark/Streamly/Benchmark/Data/Ring/Unboxed.hs+3−4
@@ -12,12 +12,11 @@ module Main (main) where
1212
1313import Control.Monad (void)
1414import GHC.Ptr (Ptr(..))
15−
16−import qualified Streamly.Internal.Data.Array.Type as Array
17−import qualified Streamly.Internal.Data.Ring.Unboxed as Ring
15+import qualified Streamly.Internal.Data.Array as Array
16+import qualified Streamly.Internal.Data.Ring as Ring
1817import qualified Data.Foldable as P
1918
20−import Gauge
19+import Test.Tasty.Bench
2120import Streamly.Benchmark.Common
2221
2322import Prelude as P
benchmark/Streamly/Benchmark/Data/Serialize.hsnew file+591
@@ -0,0 +1,591 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+{- HLINT ignore -}
3+
4+#undef FUSION_CHECK
5+#ifdef FUSION_CHECK
6+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
7+#endif
8+
9+-- |
10+-- Module : Streamly.Benchmark.Data.Serialize
11+-- Copyright : (c) 2023 Composewell
12+-- License : BSD-3-Clause
13+-- Maintainer : streamly@composewell.com
14+
15+module Main (main) where
16+
17+-------------------------------------------------------------------------------
18+-- Imports
19+-------------------------------------------------------------------------------
20+
21+import Control.DeepSeq (NFData(..), deepseq)
22+import Control.Monad (when, void)
23+import GHC.Generics (Generic)
24+import System.Random (randomRIO)
25+#ifndef USE_UNBOX
26+import Test.QuickCheck (Arbitrary, arbitrary)
27+#endif
28+
29+import Streamly.Internal.Data.MutByteArray
30+import qualified Streamly.Internal.Data.MutByteArray as MBA
31+#ifdef USE_UNBOX
32+import Data.Proxy (Proxy(..))
33+#else
34+import Control.DeepSeq (force)
35+import Test.QuickCheck (oneof, generate)
36+#endif
37+
38+import Test.Tasty.Bench
39+import Streamly.Benchmark.Common
40+
41+#ifndef USE_UNBOX
42+import Streamly.Benchmark.Data.Serialize.RecCompatible
43+import Streamly.Benchmark.Data.Serialize.RecNonCompatible
44+#endif
45+
46+#ifdef USE_UNBOX
47+#define SERIALIZE_CLASS Unbox
48+#define DERIVE_CLASS(typ) $(deriveUnbox [d|instance Unbox typ|])
49+#define SERIALIZE_OP pokeAt
50+#define DESERIALIZE_OP peekAt
51+#else
52+#define SERIALIZE_CLASS Serialize
53+#define DERIVE_CLASS(typ) $(deriveSerialize [d|instance Serialize typ|])
54+#define SERIALIZE_OP serializeAt
55+#define DESERIALIZE_OP deserializeAt
56+#endif
57+
58+-------------------------------------------------------------------------------
59+-- Types
60+-------------------------------------------------------------------------------
61+
62+data Unit = Unit
63+ deriving (Generic, Show, Eq)
64+
65+#ifndef USE_TH
66+instance SERIALIZE_CLASS Unit
67+#else
68+DERIVE_CLASS(Unit)
69+#endif
70+
71+instance NFData Unit where
72+ {-# INLINE rnf #-}
73+ rnf _ = ()
74+
75+data Sum2
76+ = Sum21
77+ | Sum22
78+ deriving (Generic, Show, Eq)
79+
80+#ifndef USE_TH
81+instance SERIALIZE_CLASS Sum2
82+#else
83+DERIVE_CLASS(Sum2)
84+#endif
85+
86+instance NFData Sum2 where
87+ {-# INLINE rnf #-}
88+ rnf _ = ()
89+
90+data Sum25
91+ = Sum251
92+ | Sum252
93+ | Sum253
94+ | Sum254
95+ | Sum255
96+ | Sum256
97+ | Sum257
98+ | Sum258
99+ | Sum259
100+ | Sum2510
101+ | Sum2511
102+ | Sum2512
103+ | Sum2513
104+ | Sum2514
105+ | Sum2515
106+ | Sum2516
107+ | Sum2517
108+ | Sum2518
109+ | Sum2519
110+ | Sum2520
111+ | Sum2521
112+ | Sum2522
113+ | Sum2523
114+ | Sum2524
115+ | Sum2525
116+ deriving (Generic, Show, Eq)
117+
118+#ifndef USE_TH
119+instance SERIALIZE_CLASS Sum25
120+#else
121+DERIVE_CLASS(Sum25)
122+#endif
123+
124+instance NFData Sum25 where
125+ {-# INLINE rnf #-}
126+ rnf _ = ()
127+
128+data Product25
129+ = Product25
130+ Int
131+ Int
132+ Int
133+ Int
134+ Int
135+ Int
136+ Int
137+ Int
138+ Int
139+ Int
140+ Int
141+ Int
142+ Int
143+ Int
144+ Int
145+ Int
146+ Int
147+ Int
148+ Int
149+ Int
150+ Int
151+ Int
152+ Int
153+ Int
154+ Int
155+ deriving (Generic, Show)
156+
157+#ifndef USE_TH
158+instance SERIALIZE_CLASS Product25
159+#else
160+DERIVE_CLASS(Product25)
161+#endif
162+
163+instance NFData Product25 where
164+ {-# INLINE rnf #-}
165+ rnf
166+ (Product25 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 a18 a19 a20 a21 a22 a23 a24 a25)
167+ = a1
168+ `seq` a2
169+ `seq` a3
170+ `seq` a4
171+ `seq` a5
172+ `seq` a6
173+ `seq` a7
174+ `seq` a8
175+ `seq` a9
176+ `seq` a10
177+ `seq` a11
178+ `seq` a12
179+ `seq` a13
180+ `seq` a14
181+ `seq` a15
182+ `seq` a16
183+ `seq` a17
184+ `seq` a18
185+ `seq` a19
186+ `seq` a20
187+ `seq` a21
188+ `seq` a22
189+ `seq` a23
190+ `seq` a24
191+ `seq` a25
192+ `seq` ()
193+
194+-- XXX derived Eq instance is not inlined
195+instance Eq Product25 where
196+ {-# INLINE (==) #-}
197+ (==)
198+ (Product25 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15 a16 a17 a18 a19 a20 a21 a22 a23 a24 a25)
199+ (Product25 b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 b19 b20 b21 b22 b23 b24 b25)
200+ = a1 == b1
201+ && a2 == b2
202+ && a3 == b3
203+ && a4 == b4
204+ && a5 == b5
205+ && a6 == b6
206+ && a7 == b7
207+ && a8 == b8
208+ && a9 == b9
209+ && a10 == b10
210+ && a11 == b11
211+ && a12 == b12
212+ && a13 == b13
213+ && a14 == b14
214+ && a15 == b15
215+ && a16 == b16
216+ && a17 == b17
217+ && a18 == b18
218+ && a19 == b19
219+ && a20 == b20
220+ && a21 == b21
221+ && a22 == b22
222+ && a23 == b23
223+ && a24 == b24
224+ && a25 == b25
225+
226+-------------------------------------------------------------------------------
227+-- Simple non-recursive ADT
228+-------------------------------------------------------------------------------
229+
230+{-
231+data CustomDT1
232+ = CDT1C1
233+ | CDT1C2 Int
234+ | CDT1C3 Int Int
235+ deriving (Generic, Show, Eq)
236+
237+#ifndef USE_TH
238+instance SERIALIZE_CLASS CustomDT1
239+#else
240+DERIVE_CLASS(CustomDT1)
241+#endif
242+
243+instance NFData CustomDT1 where
244+ {-# INLINE rnf #-}
245+ rnf CDT1C1 = ()
246+ rnf (CDT1C2 i) = i `seq` ()
247+ rnf (CDT1C3 i1 i2) = i1 `seq` i2 `seq` ()
248+-}
249+
250+-------------------------------------------------------------------------------
251+-- Recursive ADT
252+-------------------------------------------------------------------------------
253+
254+#ifndef USE_UNBOX
255+data BinTree a
256+ = Tree (BinTree a) (BinTree a)
257+ | Leaf a
258+ deriving (Show, Read, Eq, Generic)
259+
260+#ifndef USE_TH
261+instance Serialize (BinTree a)
262+#else
263+$(deriveSerialize [d|instance Serialize a => Serialize (BinTree a)|])
264+#endif
265+
266+instance NFData a => NFData (BinTree a) where
267+ {-# INLINE rnf #-}
268+ rnf (Leaf a) = rnf a `seq` ()
269+ rnf (Tree l r) = rnf l `seq` rnf r
270+
271+-- XXX This may not terminate, or could become really large.
272+instance Arbitrary a => Arbitrary (BinTree a) where
273+ arbitrary = oneof [Leaf <$> arbitrary, Tree <$> arbitrary <*> arbitrary]
274+
275+mkBinTree :: (Arbitrary a) => Int -> IO (BinTree a)
276+mkBinTree = go (generate arbitrary)
277+
278+ where
279+
280+ go r 0 = Leaf <$> r
281+ go r n = Tree <$> go r (n - 1) <*> go r (n - 1)
282+
283+#endif
284+
285+-------------------------------------------------------------------------------
286+-- Size helpers
287+-------------------------------------------------------------------------------
288+
289+{-# INLINE getSize #-}
290+getSize :: forall a. SERIALIZE_CLASS a => a -> Int
291+#ifdef USE_UNBOX
292+getSize _ = sizeOf (Proxy :: Proxy a)
293+#else
294+getSize = addSizeTo 0
295+#endif
296+
297+-------------------------------------------------------------------------------
298+-- Common helpers
299+-------------------------------------------------------------------------------
300+
301+{- HLINT ignore "Eta reduce" -}
302+-- Parts of "f" that are dependent on val will not be optimized out.
303+{-# INLINE loop #-}
304+loop :: Int -> (a -> IO b) -> a -> IO ()
305+loop count f val = go count val
306+ where
307+
308+ go n x = when (n > 0) $ f x >> go (n-1) x
309+
310+-- The first arg of "f" is the environment which is not threaded around in the
311+-- loop.
312+{-# INLINE loopWith #-}
313+loopWith :: Int -> (e -> a -> IO b) -> e -> a -> IO ()
314+loopWith count f e val = go count val
315+ where
316+
317+ go n x = when (n > 0) $ f e x >> go (n-1) x
318+
319+benchSink :: NFData b => String -> Int -> (Int -> IO b) -> Benchmark
320+benchSink name times f = bench name (nfIO (randomRIO (times, times) >>= f))
321+
322+-------------------------------------------------------------------------------
323+-- Serialization Helpers
324+-------------------------------------------------------------------------------
325+
326+{-
327+{-# INLINE pokeWithSize #-}
328+pokeWithSize :: SERIALIZE_CLASS a => MutByteArray -> a -> IO ()
329+pokeWithSize arr val = do
330+ let n = getSize val
331+ n `seq` SERIALIZE_OP 0 arr val >> return ()
332+
333+{-# INLINE pokeTimesWithSize #-}
334+pokeTimesWithSize :: SERIALIZE_CLASS a => a -> Int -> IO ()
335+pokeTimesWithSize val times = do
336+ let n = getSize val
337+ arr <- MBA.new n
338+ loopWith times pokeWithSize arr val
339+-}
340+
341+{-# INLINE poke #-}
342+poke :: SERIALIZE_CLASS a => MutByteArray -> a -> IO ()
343+poke arr val = void (SERIALIZE_OP 0 arr val)
344+
345+{-# INLINE pokeTimes #-}
346+pokeTimes :: SERIALIZE_CLASS a => a -> Int -> IO ()
347+pokeTimes val times = do
348+ let n = getSize val
349+ arr <- MBA.new n
350+ loopWith times poke arr val
351+
352+{-# INLINE encode #-}
353+encode :: SERIALIZE_CLASS a => a -> IO ()
354+encode val = do
355+ let n = getSize val
356+ arr <- MBA.new n
357+ void (SERIALIZE_OP 0 arr val)
358+
359+{-# INLINE encodeTimes #-}
360+encodeTimes :: SERIALIZE_CLASS a => a -> Int -> IO ()
361+encodeTimes val times = loop times encode val
362+
363+{-# INLINE peek #-}
364+peek :: forall a. (NFData a, SERIALIZE_CLASS a) =>
365+ (a, Int) -> MutByteArray -> IO ()
366+#ifdef USE_UNBOX
367+peek (_val, _) arr = do
368+ (val1 :: a) <- DESERIALIZE_OP 0 arr
369+#else
370+peek (_val, n) arr = do
371+ (_, val1 :: a) <- DESERIALIZE_OP 0 arr n
372+#endif
373+ -- If the datatype is not deeply strict or deepseq is not used then use
374+ -- Equality.
375+ -- Ensure that we are actually constructing the type and using it. This
376+ -- is important, otherwise the structure is created and discarded, the
377+ -- cost of creation of the structure is not accounted. Otherwise we may
378+ -- just read the values and discard them. The comparison adds to the
379+ -- cost though. We could use deepseq but then we need to write
380+ -- instances of NFData and ensure that they are correct and perform
381+ -- well. Equality check also ensures correctness.
382+ {-
383+ if (val1 /= val)
384+ then error "peek: no match"
385+ else return ()
386+ -}
387+ val1 `deepseq` return ()
388+
389+{-# INLINE peekTimes #-}
390+peekTimes :: (NFData a, SERIALIZE_CLASS a) => Int -> a -> Int -> IO ()
391+peekTimes n val times = do
392+ arr <- MBA.new n
393+ _ <- SERIALIZE_OP 0 arr val
394+ loopWith times peek (val, n) arr
395+
396+{-# INLINE trip #-}
397+trip :: forall a. (NFData a, SERIALIZE_CLASS a) => a -> IO ()
398+trip val = do
399+ let n = getSize val
400+ arr <- MBA.new n
401+ _ <- SERIALIZE_OP 0 arr val
402+#ifdef USE_UNBOX
403+ (val1 :: a) <- DESERIALIZE_OP 0 arr
404+#else
405+ (_, val1 :: a) <- DESERIALIZE_OP 0 arr n
406+#endif
407+ -- Do not remove this or use deepseq, see the comments in peek.
408+ {-
409+ if (val1 /= val)
410+ then error "roundtrip: no match"
411+ else return ()
412+ -}
413+ -- Note: deepseq is not needed if the datatype is strict
414+ val1 `deepseq` return ()
415+
416+{-# INLINE roundtrip #-}
417+roundtrip :: (NFData a, SERIALIZE_CLASS a) => a -> Int -> IO ()
418+roundtrip val times = loop times trip val
419+
420+-------------------------------------------------------------------------------
421+-- Benchmarks
422+-------------------------------------------------------------------------------
423+
424+{-# INLINE benchConst #-}
425+benchConst ::
426+ String
427+ -> (forall a. (NFData a, SERIALIZE_CLASS a) =>
428+ Int -> a -> Int -> IO ())
429+ -> Int
430+ -> Benchmark
431+benchConst gname f times =
432+ bgroup gname
433+ [ let !n = getSize Unit
434+ in benchSink "Unit" times (f n Unit)
435+ {-
436+ , let !n = getSize CDT1C1
437+ in benchSink "C1" times (f n CDT1C1)
438+ , let val = CDT1C2 5
439+ !n = getSize val
440+ in benchSink "C2" (times `div` 2) (f n val)
441+ , let val = CDT1C3 5 2
442+ !n = getSize val
443+ in benchSink "C3" (times `div` 3) (f n val)
444+ -}
445+ , let !n = getSize Sum21
446+ in benchSink "Sum2" times (f n Sum21)
447+ , let !n = getSize Sum2525
448+ in benchSink "Sum25" times (f n Sum2525)
449+ , let val = Product25 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
450+ !n = getSize val
451+ in benchSink "Product25" (times `div` 26) (f n val)
452+ ]
453+
454+#ifndef USE_UNBOX
455+{-# INLINE benchVar #-}
456+benchVar ::
457+ String
458+ -> (forall a. (NFData a, SERIALIZE_CLASS a) =>
459+ Int -> a -> Int -> IO ())
460+ -> BinTree Int
461+ -> [Int]
462+ -> Int
463+ -> Benchmark
464+benchVar gname f tInt lInt times =
465+ bgroup gname
466+ [ let !n = getSize tInt
467+ in benchSink "bintree-int" times (f n tInt)
468+ , let !n = getSize lInt
469+ in benchSink "list-int" times (f n lInt)
470+ ]
471+
472+{-
473+{-# INLINE benchGeneric #-}
474+benchGeneric
475+ :: (NFData b, Serialize b)
476+ => String
477+ -> String
478+ -> (forall a. (NFData a, Serialize a) =>
479+ Int -> a -> Int -> IO ())
480+ -> b
481+ -> Int
482+ -> Benchmark
483+benchGeneric gname valId f val times =
484+ bgroup gname
485+ [ let !n = getSize val
486+ in benchSink valId times (f n val)
487+ ]
488+-}
489+
490+{-# INLINE benchLargeRec #-}
491+benchLargeRec ::
492+ String
493+ -> (forall a. (NFData a, Serialize a) =>
494+ Int -> a -> Int -> IO ())
495+ -> RecNonCompatible
496+ -> RecCompatible
497+ -> Int
498+ -> Benchmark
499+benchLargeRec gname f recL recR times =
500+ bgroup gname
501+ [ let !n = getSize recL
502+ in benchSink "RecNonCompatible" times (f n recL)
503+ , let !n = getSize recR
504+ in benchSink "RecCompatible" times (f n recR)
505+ ]
506+#endif
507+
508+-- Times is scaled by the number of constructors to normalize
509+#ifdef USE_UNBOX
510+allBenchmarks :: Int -> [Benchmark]
511+allBenchmarks times =
512+#else
513+allBenchmarks ::
514+ BinTree Int -> [Int] -> RecNonCompatible -> RecCompatible -> Int -> [Benchmark]
515+allBenchmarks tInt lInt recL recR times =
516+#endif
517+ [ bgroup "sizeOf"
518+ [
519+#ifndef USE_UNBOX
520+ bench "bintree-int" $ nf getSize tInt
521+ , bench "list-int" $ nf getSize lInt
522+#endif
523+ ]
524+ , benchConst "poke" (const pokeTimes) times
525+ -- , benchConst "pokeWithSize" (const pokeTimesWithSize) times
526+ , benchConst "encode" (const encodeTimes) times
527+ , benchConst "peek" peekTimes times
528+ , benchConst "roundtrip" (const roundtrip) times
529+#ifndef USE_UNBOX
530+ , benchVar "poke" (const pokeTimes) tInt lInt 1
531+ -- , benchVar "pokeWithSize" (const pokeTimesWithSize) tInt lInt 1
532+ , benchVar "encode" (const encodeTimes) tInt lInt 1
533+ , benchVar "peek" peekTimes tInt lInt 1
534+ , benchVar "roundtrip" (const roundtrip) tInt lInt 1
535+ , benchLargeRec "poke" (const pokeTimes) recL recR times
536+ , benchLargeRec "encode" (const encodeTimes) recL recR times
537+ , benchLargeRec "peek" peekTimes recL recR times
538+ , benchLargeRec "roundtrip" (const roundtrip) recL recR times
539+#endif
540+ ]
541+
542+-------------------------------------------------------------------------------
543+-- Driver
544+-------------------------------------------------------------------------------
545+
546+main :: IO ()
547+main = do
548+#ifndef USE_UNBOX
549+ -- Approximately 100000 constructors
550+ -- Assuming Leaf nodes constitute two constructors (Leaf, Int) and internal
551+ -- nodes 1 level = log_2 (100001/3) + 1 = 16
552+ !(tInt :: BinTree Int) <- force <$> mkBinTree 16
553+
554+ let !recL = valRecNonCompatible
555+ let !recR = valRecCompatible
556+
557+ -- Approximately 100000 constructors, assuming two constructors (Cons, Int)
558+ -- per element.
559+ let lInt = [1..50000 :: Int]
560+ let !len = length lInt -- evaluate the list
561+#endif
562+#ifndef FUSION_CHECK
563+#ifdef USE_UNBOX
564+ runWithCLIOpts defaultStreamSize allBenchmarks
565+#else
566+ len
567+ `seq` runWithCLIOpts
568+ defaultStreamSize
569+ (allBenchmarks tInt lInt recL recR)
570+#endif
571+#else
572+ -- Enable FUSION_CHECK macro at the beginning of the file
573+ -- Enable one benchmark below, and run the benchmark
574+ -- Check the .dump-simpl output
575+ let value = 100000
576+ -- print $ getSize (CDT1C3 4 2)
577+ -- print $ getSize tInt
578+ -- print $ getSize lInt
579+
580+ -- pokeTimes tInt 1
581+
582+ -- peekTimes ((CDT1C2 (5 :: Int)) :: CustomDT1) value
583+ -- peekTimes (Sum2525) value
584+ -- peekTimes (Product25 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) value
585+ -- peekTimes tInt 1
586+ let !n = getSize lInt
587+ peekTimes n lInt 1
588+
589+ -- roundtrip ((CDT1C2 (5 :: Int)) :: CustomDT1) value
590+ return ()
591+#endif
benchmark/Streamly/Benchmark/Data/Serialize/RecCompatible.hsnew file+24
@@ -0,0 +1,24 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Streamly.Benchmark.Data.Serialize.RecCompatible
4+ ( RecCompatible(..)
5+ , valRecCompatible
6+ ) where
7+
8+--------------------------------------------------------------------------------
9+-- Imports
10+--------------------------------------------------------------------------------
11+
12+import Streamly.Internal.Data.MutByteArray (Serialize)
13+import Streamly.Benchmark.Data.Serialize.TH (genLargeRecord)
14+
15+import qualified Streamly.Internal.Data.MutByteArray as Serialize
16+
17+--------------------------------------------------------------------------------
18+-- Code
19+--------------------------------------------------------------------------------
20+
21+$(genLargeRecord "RecCompatible" 50)
22+$(Serialize.deriveSerializeWith
23+ (Serialize.encodeRecordFields True)
24+ [d|instance Serialize RecCompatible|])
benchmark/Streamly/Benchmark/Data/Serialize/RecNonCompatible.hsnew file+21
@@ -0,0 +1,21 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Streamly.Benchmark.Data.Serialize.RecNonCompatible
4+ ( RecNonCompatible(..)
5+ , valRecNonCompatible
6+ ) where
7+
8+--------------------------------------------------------------------------------
9+-- Imports
10+--------------------------------------------------------------------------------
11+
12+import Streamly.Benchmark.Data.Serialize.TH (genLargeRecord)
13+
14+import qualified Streamly.Internal.Data.MutByteArray as Serialize
15+
16+--------------------------------------------------------------------------------
17+-- Code
18+--------------------------------------------------------------------------------
19+
20+$(genLargeRecord "RecNonCompatible" 50)
21+$(Serialize.deriveSerialize [d|instance Serialize.Serialize RecNonCompatible|])
benchmark/Streamly/Benchmark/Data/Serialize/TH.hsnew file+76
@@ -0,0 +1,76 @@
1+{-# LANGUAGE TemplateHaskell #-}
2+
3+module Streamly.Benchmark.Data.Serialize.TH (genLargeRecord) where
4+
5+--------------------------------------------------------------------------------
6+-- Imports
7+--------------------------------------------------------------------------------
8+
9+import Language.Haskell.TH
10+
11+import Streamly.Internal.Data.MutByteArray (makeI)
12+import Control.DeepSeq (NFData(..))
13+
14+--------------------------------------------------------------------------------
15+-- Large Record
16+--------------------------------------------------------------------------------
17+
18+genLargeRecord :: String -> Int -> Q [Dec]
19+genLargeRecord tyName numFields =
20+ sequence
21+ [ dataD
22+ (pure [])
23+ (mkName tyName)
24+ []
25+ Nothing
26+ [mkCon tyName]
27+ [derivClause Nothing [conT ''Eq, conT ''Show]]
28+ , mkValueSigDec
29+ , mkValueDec
30+ , nfDataInstance tyName
31+ ]
32+
33+ where
34+
35+ fieldTypeChoices = [conT ''()]
36+ chooseCycle i xs = xs !! (i `mod` length xs)
37+ nfDataInstance nm =
38+ instanceD
39+ (pure [])
40+ (appT (conT ''NFData) (conT (mkName nm)))
41+ [ funD
42+ 'rnf
43+ [ clause
44+ [ conP
45+ (mkName nm)
46+ (varP . makeI <$> [0 .. (numFields - 1)])
47+ ]
48+ (normalB
49+ (foldl
50+ (\b a -> [|rnf $(b) `seq` rnf $(a)|])
51+ [|()|]
52+ (varE . makeI <$> [0 .. (numFields - 1)])))
53+ []
54+ ]
55+ ]
56+ valueName = mkName $ "val" ++ tyName
57+ mkValueSigDec = sigD valueName [t|$(conT (mkName tyName))|]
58+ mkValueDec =
59+ funD
60+ valueName
61+ [ clause
62+ []
63+ (normalB
64+ (foldl
65+ (\b a -> [|$(b) $(a)|])
66+ (conE (mkName tyName))
67+ (conE '() <$ [0 .. (numFields - 1)])))
68+ []
69+ ]
70+ mkCon nm = recC (mkName nm) (mkField <$> [0 .. (numFields - 1)])
71+ mkField i =
72+ varBangType
73+ (mkName ("field" ++ show i))
74+ (bangType
75+ (bang noSourceUnpackedness noSourceStrictness)
76+ (chooseCycle i fieldTypeChoices))
benchmark/Streamly/Benchmark/Data/Stream.hs+1−1
@@ -36,7 +36,7 @@ import Streamly.Benchmark.Common
3636#ifdef FUSION_CHECK
3737import Data.Function ((&))
3838import Streamly.Data.Stream (Stream)
39−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
39+import qualified Streamly.Internal.Data.Stream as Stream
4040import qualified Streamly.Internal.Data.Fold as Fold
4141import qualified Data.Foldable as Foldable
4242import Stream.Common
benchmark/Streamly/Benchmark/Data/Stream/Common.hs+11−9
@@ -71,7 +71,9 @@ module Stream.Common
7171 )
7272where
7373
74+#if !MIN_VERSION_base(4,18,0)
7475import Control.Applicative (liftA2)
76+#endif
7577import Control.DeepSeq (NFData)
7678import Control.Exception (try)
7779import GHC.Exception (ErrorCall)
@@ -90,20 +92,20 @@ import Streamly.Benchmark.Prelude
9092 , concatStreamsWith
9193 )
9294#else
93−import Streamly.Internal.Data.Stream.StreamD (Stream)
94−import qualified Streamly.Internal.Data.Stream.StreamD as D
95+import Streamly.Internal.Data.Stream (Stream)
96+import qualified Streamly.Internal.Data.Stream as D
9597#ifdef USE_STREAMK
96−import Streamly.Internal.Data.Stream.StreamK (StreamK)
97−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
98−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
98+import Streamly.Internal.Data.StreamK (StreamK)
99+import qualified Streamly.Internal.Data.Stream as Stream
100+import qualified Streamly.Internal.Data.StreamK as StreamK
99101#else
100−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
101−import qualified Streamly.Internal.Data.Stream.StreamD as StreamK
102+import qualified Streamly.Internal.Data.Stream as Stream
103+import qualified Streamly.Internal.Data.Stream as StreamK
102104#endif
103105#endif
104106
105−import Gauge
106−import Prelude hiding (mapM, replicate)
107+import Test.Tasty.Bench
108+import Prelude hiding (Foldable(..), mapM, replicate)
107109
108110#ifdef USE_STREAMK
109111toStream :: Applicative m => StreamK m a -> Stream m a
benchmark/Streamly/Benchmark/Data/Stream/ConcurrentCommon.hs+3−3
@@ -14,14 +14,14 @@ where
1414import Stream.Common
1515 (composeN, benchIO, benchIOSink, benchIOSrc, sourceUnfoldrM)
1616import Streamly.Data.Stream (Stream)
17−import Streamly.Internal.Data.Stream.Concurrent (MonadAsync, Config)
17+import Streamly.Internal.Data.Stream.Prelude (MonadAsync, Config)
1818
1919import qualified Data.List as List
2020import qualified Streamly.Data.Fold as Fold
2121import qualified Streamly.Data.Stream as Stream
22−import qualified Streamly.Internal.Data.Stream.Concurrent as Async
22+import qualified Streamly.Internal.Data.Stream.Prelude as Async
2323
24−import Gauge
24+import Test.Tasty.Bench
2525import Prelude hiding (mapM)
2626import Streamly.Benchmark.Common
2727
benchmark/Streamly/Benchmark/Data/Stream/ConcurrentEager.hs+1−1
@@ -9,7 +9,7 @@
99import Stream.ConcurrentCommon (allBenchmarks)
1010import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
1111
12−import qualified Streamly.Internal.Data.Stream.Concurrent as Async
12+import qualified Streamly.Internal.Data.Stream.Prelude as Async
1313
1414moduleName :: String
1515moduleName = "Data.Stream.ConcurrentEager"
benchmark/Streamly/Benchmark/Data/Stream/ConcurrentInterleaved.hs+1−1
@@ -9,7 +9,7 @@
99import Stream.ConcurrentCommon (allBenchmarks)
1010import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
1111
12−import qualified Streamly.Internal.Data.Stream.Concurrent as Async
12+import qualified Streamly.Internal.Data.Stream.Prelude as Async
1313
1414moduleName :: String
1515moduleName = "Data.Stream.ConcurrentInterleaved"
benchmark/Streamly/Benchmark/Data/Stream/ConcurrentOrdered.hs+1−1
@@ -9,7 +9,7 @@
99import Stream.ConcurrentCommon (allBenchmarks)
1010import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
1111
12−import qualified Streamly.Internal.Data.Stream.Concurrent as Async
12+import qualified Streamly.Internal.Data.Stream.Prelude as Async
1313
1414moduleName :: String
1515moduleName = "Data.Stream.ConcurrentOrdered"
benchmark/Streamly/Benchmark/Data/Stream/Eliminate.hs+8−6
@@ -37,7 +37,7 @@ import qualified Streamly.Internal.Data.Fold as Fold
3737#ifdef INSPECTION
3838import GHC.Types (SPEC(..))
3939import Test.Inspection
40−import qualified Streamly.Internal.Data.Stream.StreamD as D
40+import qualified Streamly.Internal.Data.Stream as D
4141#endif
4242
4343#ifdef USE_PRELUDE
@@ -47,17 +47,17 @@ import qualified Streamly.Internal.Data.Stream.IsStream as S
4747import qualified Streamly.Internal.Data.Stream.IsStream as StreamK
4848#else
4949import Stream.Common
50−import Streamly.Internal.Data.Stream.StreamD (Stream)
51−import qualified Streamly.Internal.Data.Stream.StreamD as S
50+import Streamly.Internal.Data.Stream (Stream)
51+import qualified Streamly.Internal.Data.Stream as S
5252#ifdef USE_STREAMK
53−import Streamly.Internal.Data.Stream.StreamK (StreamK)
53+import Streamly.Internal.Data.StreamK (StreamK)
5454import qualified Streamly.Data.StreamK as StreamK
5555#else
56−import qualified Streamly.Internal.Data.Stream.StreamD as StreamK
56+import qualified Streamly.Internal.Data.Stream as StreamK
5757#endif
5858#endif
5959
60−import Gauge
60+import Test.Tasty.Bench
6161import Streamly.Benchmark.Common
6262import Prelude hiding (length, sum, or, and, any, all, notElem, elem, (!!),
6363 lookup, repeat, minimum, maximum, product, last, mapM_, init)
@@ -132,12 +132,14 @@ foldableAny :: Int -> Int -> Bool
132132foldableAny value n =
133133 Prelude.any (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)
134134
135+{- HLINT ignore "Use all"-}
135136{-# INLINE foldableAnd #-}
136137foldableAnd :: Int -> Int -> Bool
137138foldableAnd value n =
138139 Prelude.and $ fmap
139140 (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)
140141
142+{- HLINT ignore "Use any"-}
141143{-# INLINE foldableOr #-}
142144foldableOr :: Int -> Int -> Bool
143145foldableOr value n =
benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hs+16−6
@@ -36,24 +36,25 @@ import System.IO (Handle, hClose, hPutChar)
3636import qualified Streamly.FileSystem.Handle as FH
3737import qualified Streamly.Internal.FileSystem.Handle as IFH
3838import qualified Streamly.Internal.Data.Unfold as IUF
39−import qualified Streamly.Internal.Data.Unfold.Exception as IUF
39+import qualified Streamly.Internal.Data.Unfold.Prelude as IUF
4040
4141#ifdef USE_PRELUDE
4242import qualified Streamly.Internal.Data.Stream.IsStream as Stream
4343#else
44−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
45−import qualified Streamly.Internal.Data.Stream.Exception.Lifted as Stream
44+import qualified Streamly.Internal.Data.Stream as Stream
45+import qualified Streamly.Internal.Data.Stream.Prelude as Stream
4646#endif
4747
48−import Gauge hiding (env)
48+import Test.Tasty.Bench hiding (env)
4949import Prelude hiding (last, length)
5050import Streamly.Benchmark.Common
5151import Streamly.Benchmark.Common.Handle
5252
5353#ifdef INSPECTION
54+import Control.Monad.Catch (MonadCatch)
5455import Test.Inspection
5556
56−import qualified Streamly.Internal.Data.Stream.StreamD as D
57+import qualified Streamly.Internal.Data.Stream as D
5758#endif
5859
5960#ifdef USE_PRELUDE
@@ -177,7 +178,8 @@ inspect $ hasNoTypeClasses 'readWriteOnExceptionStream
177178-- | Send the file contents to /dev/null with exception handling
178179readWriteHandleExceptionStream :: Handle -> Handle -> IO ()
179180readWriteHandleExceptionStream inh devNull =
180− let handler (_e :: SomeException) = Stream.fromEffect (hClose inh >> return 10)
181+ let handler (_e :: SomeException) =
182+ return $ Stream.fromEffect (hClose inh >> return 10)
181183 readEx = Stream.handle handler (Stream.unfold FH.reader inh)
182184 in Stream.fold (FH.write devNull) readEx
183185
@@ -285,8 +287,12 @@ readChunksOnException inh devNull =
285287 in IUF.fold (IFH.writeChunks devNull) readEx inh
286288
287289#ifdef INSPECTION
290+#if __GLASGOW_HASKELL__ >= 906
291+inspect $ hasNoTypeClassesExcept 'readChunksOnException [''MonadCatch]
292+#else
288293inspect $ hasNoTypeClasses 'readChunksOnException
289294#endif
295+#endif
290296
291297-- | Send the file contents to /dev/null with exception handling
292298readChunksBracket_ :: Handle -> Handle -> IO ()
@@ -295,8 +301,12 @@ readChunksBracket_ inh devNull =
295301 in IUF.fold (IFH.writeChunks devNull) readEx inh
296302
297303#ifdef INSPECTION
304+#if __GLASGOW_HASKELL__ >= 906
305+inspect $ hasNoTypeClassesExcept 'readChunksBracket_ [''MonadCatch]
306+#else
298307inspect $ hasNoTypeClasses 'readChunksBracket_
299308#endif
309+#endif
300310
301311readChunksBracket :: Handle -> Handle -> IO ()
302312readChunksBracket inh devNull =
benchmark/Streamly/Benchmark/Data/Stream/Expand.hs+15−7
@@ -29,7 +29,7 @@ module Stream.Expand (benchmarks) where
2929import GHC.Types (SPEC(..))
3030import Test.Inspection
3131
32−import qualified Streamly.Internal.Data.Stream.StreamD as D
32+import qualified Streamly.Internal.Data.Stream as D
3333#endif
3434
3535import qualified Stream.Common as Common
@@ -42,19 +42,19 @@ import Streamly.Benchmark.Prelude
4242 ( sourceFoldMapM, sourceFoldMapWith, sourceFoldMapWithM
4343 , sourceFoldMapWithStream, concatFoldableWith, concatForFoldableWith)
4444#else
45−import qualified Streamly.Internal.Data.Stream.StreamD as S
45+import qualified Streamly.Internal.Data.Stream as S
4646#ifdef USE_STREAMK
47−import Streamly.Internal.Data.Stream.StreamD (Stream)
48−import Streamly.Internal.Data.Stream.StreamK (StreamK, CrossStreamK)
47+import Streamly.Internal.Data.Stream (Stream)
48+import Streamly.Internal.Data.StreamK (StreamK, CrossStreamK)
4949import qualified Control.Applicative as AP
5050import qualified Streamly.Internal.Data.Fold as Fold
51−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
51+import qualified Streamly.Internal.Data.StreamK as StreamK
5252#else
53−import qualified Streamly.Internal.Data.Stream.StreamD as StreamK
53+import qualified Streamly.Internal.Data.Stream as StreamK
5454#endif
5555#endif
5656
57−import Gauge
57+import Test.Tasty.Bench
5858import Stream.Common
5959import Streamly.Benchmark.Common
6060import Prelude hiding (concatMap)
@@ -198,7 +198,11 @@ concatMapPure outer inner n =
198198 (fromStream $ sourceUnfoldr outer n)
199199
200200#ifdef INSPECTION
201+#if __GLASGOW_HASKELL__ >= 906
202+inspect $ hasNoTypeClassesExcept 'concatMapPure [''Applicative]
203+#else
201204inspect $ hasNoTypeClasses 'concatMapPure
205+#endif
202206inspect $ 'concatMapPure `hasNoType` ''SPEC
203207#endif
204208
@@ -211,7 +215,11 @@ concatMapRepl outer inner n =
211215 (fromStream . S.replicate inner) (fromStream $ sourceUnfoldrM outer n)
212216
213217#ifdef INSPECTION
218+#if __GLASGOW_HASKELL__ >= 906
219+inspect $ hasNoTypeClassesExcept 'concatMapRepl [''Applicative]
220+#else
214221inspect $ hasNoTypeClasses 'concatMapRepl
222+#endif
215223inspect $ 'concatMapRepl `hasNoType` ''SPEC
216224#endif
217225
benchmark/Streamly/Benchmark/Data/Stream/Generate.hs+4−4
@@ -31,16 +31,16 @@ import qualified Streamly.Prelude as S
3131import qualified Streamly.Internal.Data.Stream.IsStream as Stream
3232#else
3333import Stream.Common
34−import Streamly.Internal.Data.Stream.StreamD (Stream)
35−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
34+import Streamly.Internal.Data.Stream (Stream)
35+import qualified Streamly.Internal.Data.Stream as Stream
3636#ifdef USE_STREAMK
3737import System.IO.Unsafe (unsafeInterleaveIO)
38−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
38+import qualified Streamly.Internal.Data.StreamK as StreamK
3939import qualified Stream.Common as Common
4040#endif
4141#endif
4242
43−import Gauge
43+import Test.Tasty.Bench
4444import Streamly.Benchmark.Common
4545import qualified Prelude
4646
benchmark/Streamly/Benchmark/Data/Stream/Lift.hs+5−5
@@ -27,17 +27,17 @@ import qualified Streamly.Internal.Data.Fold as Fold
2727#ifdef USE_PRELUDE
2828import qualified Streamly.Internal.Data.Stream.IsStream as Stream
2929#else
30−import Streamly.Internal.Data.Stream.StreamD (Stream)
31−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
30+import Streamly.Internal.Data.Stream (Stream)
31+import qualified Streamly.Internal.Data.Stream as Stream
3232#ifdef USE_STREAMK
3333import Stream.Common (benchIO, drain)
34−import Streamly.Internal.Data.Stream.StreamK (StreamK)
35−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
34+import Streamly.Internal.Data.StreamK (StreamK)
35+import qualified Streamly.Internal.Data.StreamK as StreamK
3636import qualified Control.Monad.State.Strict as State
3737#endif
3838#endif
3939
40−import Gauge
40+import Test.Tasty.Bench
4141import Streamly.Benchmark.Common
4242import Prelude hiding (reverse, tail)
4343
benchmark/Streamly/Benchmark/Data/Stream/Reduce.hs+40−21
@@ -44,24 +44,24 @@ import Streamly.Benchmark.Prelude hiding
4444 , transformComposeMapM, transformTeeMapM, transformZipMapM)
4545#else
4646
47−import Streamly.Internal.Data.Stream.StreamD (Stream)
48−import qualified Streamly.Internal.Data.Stream.StreamD as S
47+import Streamly.Internal.Data.Stream (Stream)
48+import qualified Streamly.Internal.Data.Stream as S
4949#ifndef USE_STREAMLY_CORE
5050import qualified Streamly.Data.Stream.Prelude as S
51−import qualified Streamly.Internal.Data.Stream.Time as S
51+import qualified Streamly.Internal.Data.Stream.Prelude as S
5252#endif
5353
5454#ifdef USE_STREAMK
55−import Streamly.Internal.Data.Stream.StreamK (StreamK)
55+import Streamly.Internal.Data.StreamK (StreamK)
5656import qualified Streamly.Internal.Data.Parser as PR
57−import qualified Streamly.Internal.Data.Stream.StreamK as K
57+import qualified Streamly.Internal.Data.StreamK as K
5858#else
59−import qualified Streamly.Internal.Data.Stream.StreamD as K
59+import qualified Streamly.Internal.Data.Stream as K
6060#endif
6161
6262#endif
6363
64−import Gauge
64+import Test.Tasty.Bench
6565import Streamly.Benchmark.Common
6666import Stream.Common
6767import Prelude hiding (reverse, tail)
@@ -107,30 +107,50 @@ iterateSource g count len n = f count (sourceUnfoldrM len n)
107107-- Grouping transformations
108108-------------------------------------------------------------------------------
109109
110−#ifdef USE_PRELUDE
111110{-# INLINE groups #-}
112111groups :: MonadIO m => Stream m Int -> m ()
113−groups = Common.drain . S.groups FL.drain
112+groups =
113+#ifdef USE_PRELUDE
114+ Common.drain . S.groups FL.drain
115+#else
116+ Common.drain . S.groupsWhile (==) FL.drain
117+#endif
114118
115−-- XXX Change this test when the order of comparison is later changed
116−{-# INLINE groupsByGT #-}
117−groupsByGT :: MonadIO m => Stream m Int -> m ()
118−groupsByGT = Common.drain . S.groupsBy (>) FL.drain
119+{-# INLINE groupsWhileLT #-}
120+groupsWhileLT :: MonadIO m => Stream m Int -> m ()
121+groupsWhileLT =
122+#ifdef USE_PRELUDE
123+ Common.drain . S.groupsBy (>) FL.drain
124+#else
125+ Common.drain . S.groupsWhile (<) FL.drain
126+#endif
127+
128+{-# INLINE groupsWhileEq #-}
129+groupsWhileEq :: MonadIO m => Stream m Int -> m ()
130+groupsWhileEq =
131+#ifdef USE_PRELUDE
132+ Common.drain . S.groupsBy (==) FL.drain
133+#else
134+ Common.drain . S.groupsWhile (==) FL.drain
135+#endif
119136
120−{-# INLINE groupsByEq #-}
121−groupsByEq :: MonadIO m => Stream m Int -> m ()
122−groupsByEq = Common.drain . S.groupsBy (==) FL.drain
123137
124−-- XXX Change this test when the order of comparison is later changed
125138{-# INLINE groupsByRollingLT #-}
126139groupsByRollingLT :: MonadIO m => Stream m Int -> m ()
127140groupsByRollingLT =
141+#ifdef USE_PRELUDE
128142 Common.drain . S.groupsByRolling (<) FL.drain
143+#else
144+ Common.drain . S.groupsRollingBy (<) FL.drain
145+#endif
129146
130147{-# INLINE groupsByRollingEq #-}
131148groupsByRollingEq :: MonadIO m => Stream m Int -> m ()
132149groupsByRollingEq =
150+#ifdef USE_PRELUDE
133151 Common.drain . S.groupsByRolling (==) FL.drain
152+#else
153+ Common.drain . S.groupsRollingBy (==) FL.drain
134154#endif
135155
136156{-# INLINE foldMany #-}
@@ -190,14 +210,13 @@ o_1_space_grouping value =
190210 -- Buffering operations using heap proportional to group/window sizes.
191211 [ bgroup "grouping"
192212 [
193−#ifdef USE_PRELUDE
194213 benchIOSink value "groups" groups
195− , benchIOSink value "groupsByGT" groupsByGT
196− , benchIOSink value "groupsByEq" groupsByEq
214+ , benchIOSink value "groupsWhileLT" groupsWhileLT
215+ , benchIOSink value "groupsWhileEq" groupsWhileEq
197216 , benchIOSink value "groupsByRollingLT" groupsByRollingLT
198217 , benchIOSink value "groupsByRollingEq" groupsByRollingEq
199218 ,
200−#endif
219+
201220 -- XXX parseMany/parseIterate benchmarks are in the Parser/ParserD
202221 -- modules we can bring those here. chunksOf benchmarks are in
203222 -- Parser/ParserD/Array.Stream/FileSystem.Handle.
benchmark/Streamly/Benchmark/Data/Stream/Split.hs+3−3
@@ -35,15 +35,15 @@ import qualified Streamly.Internal.FileSystem.Handle as IFH
3535import qualified Streamly.Internal.Unicode.Stream as IUS
3636import qualified Streamly.Prelude as S
3737
38−import Gauge hiding (env)
38+import Test.Tasty.Bench hiding (env)
3939import Prelude hiding (last, length)
4040import Streamly.Benchmark.Common
4141import Streamly.Benchmark.Common.Handle
4242
4343#ifdef INSPECTION
44−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
44+import Streamly.Internal.Data.Stream (Step(..))
4545
46−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
46+import qualified Streamly.Internal.Data.MutArray as MA
4747import qualified Streamly.Internal.Data.Unfold as IUF
4848
4949import Test.Inspection
benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs+5−3
@@ -22,15 +22,17 @@
2222
2323module Main (main) where
2424
25+#if !MIN_VERSION_base(4,18,0)
2526import Control.Applicative (liftA2)
27+#endif
2628import Control.Monad (when)
2729import Data.Maybe (isJust)
28−import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)
30+import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)
2931import System.Random (randomRIO)
3032import Prelude hiding (tail, mapM_, foldl, last, map, mapM, concatMap, zip)
3133
3234import qualified Prelude as P
33−import qualified Streamly.Internal.Data.Stream.StreamD as S
35+import qualified Streamly.Internal.Data.Stream as S
3436import qualified Streamly.Internal.Data.Unfold as UF
3537import qualified Streamly.Internal.Data.Fold as FL
3638
@@ -461,7 +463,7 @@ inspect $ 'unfoldManyRepl `hasNoType` ''SPEC
461463-------------------------------------------------------------------------------
462464
463465moduleName :: String
464−moduleName = "Data.Stream.StreamD"
466+moduleName = "Data.StreamD"
465467
466468o_1_space :: [Benchmark]
467469o_1_space =
benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs+9−8
@@ -21,22 +21,23 @@
2121
2222module Main (main) where
2323
24+#if !MIN_VERSION_base(4,18,0)
2425import Control.Applicative (liftA2)
26+#endif
2527import Control.Monad (when)
2628import Data.Maybe (isJust)
2729import System.Random (randomRIO)
2830import Prelude hiding
29− ( tail, mapM_, foldl, last, map, mapM, concatMap, zipWith, init, iterate
31+ ( Foldable(..), tail, mapM_, last, map, mapM, concatMap, zipWith, init, iterate
3032 , repeat, replicate
3133 )
3234
3335import qualified Prelude as P
3436import qualified Data.List as List
3537
36−import qualified Streamly.Internal.Data.Stream.StreamK.Type as S
37−import qualified Streamly.Internal.Data.Stream.StreamK as S
38+import qualified Streamly.Internal.Data.StreamK as S
3839
39−import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)
40+import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)
4041
4142import Streamly.Benchmark.Common
4243
@@ -167,15 +168,15 @@ fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]
167168{-# INLINE fromFoldableM #-}
168169fromFoldableM :: Monad m => Int -> Int -> Stream m Int
169170fromFoldableM streamLen n =
170− Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
171+ List.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
171172
172173{-# INLINABLE concatMapFoldableWith #-}
173−concatMapFoldableWith :: Foldable f
174+concatMapFoldableWith :: P.Foldable f
174175 => (Stream m b -> Stream m b -> Stream m b)
175176 -> (a -> Stream m b)
176177 -> f a
177178 -> Stream m b
178−concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil
179+concatMapFoldableWith f g = P.foldr (f . g) S.nil
179180
180181{-# INLINE concatMapFoldableSerial #-}
181182concatMapFoldableSerial :: Int -> Int -> Stream m Int
@@ -633,7 +634,7 @@ filterAllInNestedList str = do
633634-------------------------------------------------------------------------------
634635
635636moduleName :: String
636−moduleName = "Data.Stream.StreamK"
637+moduleName = "Data.StreamK"
637638
638639o_1_space_generation :: Int -> Benchmark
639640o_1_space_generation streamLen =
benchmark/Streamly/Benchmark/Data/Stream/StreamDK.hs → benchmark/Streamly/Benchmark/Data/Stream/StreamKAlt.hsrenamed+3−3
@@ -18,12 +18,12 @@ import Prelude hiding ()
1818-- import qualified Prelude as P
1919-- import qualified Data.List as List
2020
21−import qualified Streamly.Internal.Data.Stream.StreamDK as S
21+import qualified Streamly.Internal.Data.StreamK.Alt as S
2222-- import qualified Streamly.Internal.Data.Stream.Common as SP
2323-- import qualified Streamly.Internal.Data.SVar as S
2424
2525import Streamly.Benchmark.Common
26−import Gauge (bgroup, Benchmark, defaultMain)
26+import Test.Tasty.Bench (bgroup, Benchmark, defaultMain)
2727
2828value :: Int
2929value = 100000
@@ -452,4 +452,4 @@ o_1_space =
452452 ]
453453
454454main :: IO ()
455−main = defaultMain $ concat [o_1_space]
455+main = defaultMain [o_1_space]
benchmark/Streamly/Benchmark/Data/Stream/ToStreamK.hs+5−6
@@ -1,5 +1,5 @@
11-- |
2−-- Module : Streamly.Benchmark.Data.Stream.StreamK
2+-- Module : Streamly.Benchmark.Data.StreamK
33-- Copyright : (c) 2018 Composewell Technologies
44--
55-- License : BSD3
@@ -33,12 +33,11 @@ import Prelude hiding
3333import qualified Prelude as P
3434-- import qualified Data.List as List
3535
36−import qualified Streamly.Internal.Data.Stream.StreamK.Type as S
37−import qualified Streamly.Internal.Data.Stream.StreamK as S
38−import qualified Streamly.Internal.Data.Stream.StreamD as D
36+import qualified Streamly.Internal.Data.StreamK as S
37+import qualified Streamly.Internal.Data.Stream as D
3938import qualified Streamly.Internal.Data.Fold as Fold
4039
41−import Gauge (bgroup, Benchmark, defaultMain)
40+import Test.Tasty.Bench (bgroup, Benchmark, defaultMain)
4241
4342import Streamly.Benchmark.Common
4443
@@ -121,7 +120,7 @@ fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]
121120{-# INLINE fromFoldableM #-}
122121fromFoldableM :: Monad m => Int -> Int -> Stream m Int
123122fromFoldableM streamLen n =
124− Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+streamLen])
123+ Prelude.foldr (S.consM . return) S.nil [n .. n + streamLen]
125124
126125{-
127126{-# INLINABLE concatMapFoldableWith #-}
benchmark/Streamly/Benchmark/Data/Stream/Transform.hs+6−6
@@ -43,22 +43,22 @@ import qualified Streamly.Internal.Data.Fold as Fold
4343import qualified Streamly.Internal.Data.Stream.IsStream as Stream
4444import Streamly.Internal.Data.Time.Units
4545#else
46−import Streamly.Internal.Data.Stream.StreamD (Stream)
47−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
46+import Streamly.Internal.Data.Stream (Stream)
47+import qualified Streamly.Internal.Data.Stream as Stream
4848#ifndef USE_STREAMLY_CORE
49−import qualified Streamly.Internal.Data.Stream.Time as Stream
49+import qualified Streamly.Internal.Data.Stream.Prelude as Stream
5050#endif
5151#ifdef USE_STREAMK
5252import Control.DeepSeq (NFData(..))
5353import Data.Functor.Identity (Identity(..))
5454import qualified Prelude
5555import qualified Streamly.Internal.Data.Fold as Fold
56−import Streamly.Internal.Data.Stream.StreamK (StreamK)
57−import qualified Streamly.Internal.Data.Stream.StreamK as StreamK
56+import Streamly.Internal.Data.StreamK (StreamK)
57+import qualified Streamly.Internal.Data.StreamK as StreamK
5858#endif
5959#endif
6060
61−import Gauge
61+import Test.Tasty.Bench
6262import Stream.Common hiding (scanl')
6363import Streamly.Benchmark.Common
6464import Prelude hiding (sequence, mapM)
benchmark/Streamly/Benchmark/Data/Unfold.hs+17−7
@@ -31,17 +31,18 @@ import qualified Prelude
3131import qualified Streamly.FileSystem.Handle as FH
3232import qualified Streamly.Internal.Data.Fold as FL
3333import qualified Streamly.Internal.Data.Unfold as UF
34−import qualified Streamly.Internal.Data.Unfold.Exception as UF
35−import qualified Streamly.Internal.Data.Stream.StreamD as S
36−import qualified Streamly.Internal.Data.Stream.StreamD as D
37−import qualified Streamly.Internal.Data.Stream.StreamK as K
34+import qualified Streamly.Internal.Data.Unfold.Prelude as UF
35+import qualified Streamly.Internal.Data.Stream as S
36+import qualified Streamly.Internal.Data.Stream as D
37+import qualified Streamly.Internal.Data.StreamK as K
3838
39−import Gauge hiding (env)
39+import Test.Tasty.Bench hiding (env)
4040import Prelude hiding (take, filter, zipWith, map, mapM, takeWhile)
4141import Streamly.Benchmark.Common
4242import Streamly.Benchmark.Common.Handle
4343
4444#ifdef INSPECTION
45+import Control.Monad.Catch (MonadCatch)
4546import Test.Inspection
4647#endif
4748
@@ -752,7 +753,7 @@ readWriteOnExceptionUnfold inh devNull =
752753 in S.fold (FH.write devNull) $ S.unfold readEx inh
753754
754755#ifdef INSPECTION
755−inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold
756+-- inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold
756757-- inspect $ 'readWriteOnExceptionUnfold `hasNoType` ''Step
757758#endif
758759
@@ -764,7 +765,8 @@ readWriteHandleExceptionUnfold inh devNull =
764765 in S.fold (FH.write devNull) $ S.unfold readEx inh
765766
766767#ifdef INSPECTION
767−inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold
768+-- hasNoTypeClasses started failing in GHC 9.4.4
769+-- inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold
768770-- inspect $ 'readWriteHandleExceptionUnfold `hasNoType` ''Step
769771#endif
770772
@@ -775,7 +777,11 @@ readWriteFinally_Unfold inh devNull =
775777 in S.fold (FH.write devNull) $ S.unfold readEx inh
776778
777779#ifdef INSPECTION
780+#if __GLASGOW_HASKELL__ >= 906
781+inspect $ hasNoTypeClassesExcept 'readWriteFinally_Unfold [''MonadCatch]
782+#else
778783inspect $ hasNoTypeClasses 'readWriteFinally_Unfold
784+#endif
779785-- inspect $ 'readWriteFinallyUnfold `hasNoType` ''Step
780786#endif
781787
@@ -791,7 +797,11 @@ readWriteBracket_Unfold inh devNull =
791797 in S.fold (FH.write devNull) $ S.unfold readEx inh
792798
793799#ifdef INSPECTION
800+#if __GLASGOW_HASKELL__ >= 906
801+inspect $ hasNoTypeClassesExcept 'readWriteBracket_Unfold [''MonadCatch]
802+#else
794803inspect $ hasNoTypeClasses 'readWriteBracket_Unfold
804+#endif
795805-- inspect $ 'readWriteBracketUnfold `hasNoType` ''Step
796806#endif
797807
benchmark/Streamly/Benchmark/FileSystem/Handle.hs+1−1
@@ -22,7 +22,7 @@ import Streamly.Benchmark.Common.Handle (mkHandleBenchEnv)
2222import qualified Handle.ReadWrite as RW
2323import qualified Handle.Read as RO
2424
25−import Gauge hiding (env)
25+import Test.Tasty.Bench hiding (env)
2626import Prelude hiding (last, length)
2727import Streamly.Benchmark.Common
2828
benchmark/Streamly/Benchmark/FileSystem/Handle/Read.hs+11−12
@@ -33,23 +33,22 @@ import qualified Streamly.Data.Stream as Stream
3333import qualified Streamly.Data.Fold as Fold
3434import qualified Streamly.FileSystem.Handle as FH
3535import qualified Streamly.Internal.Data.Array as A
36−import qualified Streamly.Internal.Data.Array.Type as AT
3736import qualified Streamly.Internal.Data.Fold as FL
38−import qualified Streamly.Internal.Data.Stream.StreamD as IP
37+import qualified Streamly.Internal.Data.Stream as IP
3938import qualified Streamly.Internal.FileSystem.Handle as IFH
4039import qualified Streamly.Internal.Unicode.Stream as IUS
4140import qualified Streamly.Data.Stream.Prelude as S
4241import qualified Streamly.Unicode.Stream as SS
4342
44−import Gauge hiding (env)
43+import Test.Tasty.Bench hiding (env)
4544import Prelude hiding (last, length)
4645import Streamly.Benchmark.Common.Handle
4746
4847#ifdef INSPECTION
49−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..), FoldMany)
48+import Streamly.Internal.Data.Stream (Step(..), FoldMany)
5049
51−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
52−import qualified Streamly.Internal.Data.Stream.StreamD as D
50+import qualified Streamly.Internal.Data.MutArray as MutArray
51+import qualified Streamly.Internal.Data.Stream as D
5352import qualified Streamly.Internal.Data.Unfold as IUF
5453
5554import Test.Inspection
@@ -69,7 +68,7 @@ readLast = S.fold Fold.last . S.unfold FH.reader
6968inspect $ hasNoTypeClasses 'readLast
7069inspect $ 'readLast `hasNoType` ''Step -- S.unfold
7170inspect $ 'readLast `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
72−inspect $ 'readLast `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read
71+inspect $ 'readLast `hasNoType` ''MutArray.ArrayUnsafe -- FH.read/A.read
7372#endif
7473
7574-- assert that flattenArrays constructors are not present
@@ -81,7 +80,7 @@ readCountBytes = S.fold Fold.length . S.unfold FH.reader
8180inspect $ hasNoTypeClasses 'readCountBytes
8281inspect $ 'readCountBytes `hasNoType` ''Step -- S.unfold
8382inspect $ 'readCountBytes `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
84−inspect $ 'readCountBytes `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read
83+inspect $ 'readCountBytes `hasNoType` ''MutArray.ArrayUnsafe -- FH.read/A.read
8584#endif
8685
8786-- | Count the number of lines in a file.
@@ -96,7 +95,7 @@ readCountLines =
9695inspect $ hasNoTypeClasses 'readCountLines
9796inspect $ 'readCountLines `hasNoType` ''Step
9897inspect $ 'readCountLines `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
99−inspect $ 'readCountLines `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read
98+inspect $ 'readCountLines `hasNoType` ''MutArray.ArrayUnsafe -- FH.read/A.read
10099#endif
101100
102101-- | Count the number of words in a file.
@@ -120,7 +119,7 @@ readSumBytes = S.fold Fold.sum . S.unfold FH.reader
120119inspect $ hasNoTypeClasses 'readSumBytes
121120inspect $ 'readSumBytes `hasNoType` ''Step
122121inspect $ 'readSumBytes `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
123−inspect $ 'readSumBytes `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read
122+inspect $ 'readSumBytes `hasNoType` ''MutArray.ArrayUnsafe -- FH.read/A.read
124123#endif
125124
126125-- XXX When we mark this with INLINE and we have two benchmarks using S.drain
@@ -236,13 +235,13 @@ groupsOf :: Int -> Handle -> IO Int
236235groupsOf n inh =
237236 -- writeNUnsafe gives 2.5x boost here over writeN.
238237 S.fold Fold.length
239− $ IP.groupsOf n (AT.writeNUnsafe n) (S.unfold FH.reader inh)
238+ $ IP.groupsOf n (A.writeNUnsafe n) (S.unfold FH.reader inh)
240239
241240#ifdef INSPECTION
242241inspect $ hasNoTypeClasses 'groupsOf
243242inspect $ 'groupsOf `hasNoType` ''Step
244243inspect $ 'groupsOf `hasNoType` ''FoldMany
245−inspect $ 'groupsOf `hasNoType` ''AT.ArrayUnsafe -- AT.writeNUnsafe
244+inspect $ 'groupsOf `hasNoType` ''MutArray.ArrayUnsafe -- AT.writeNUnsafe
246245 -- FH.read/A.read
247246inspect $ 'groupsOf `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
248247#endif
benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+11−12
@@ -34,16 +34,15 @@ import qualified Streamly.Internal.FileSystem.Handle as IFH
3434import qualified Streamly.Data.Array as A
3535import qualified Streamly.Data.Stream.Prelude as S
3636
37−import Gauge hiding (env)
37+import Test.Tasty.Bench hiding (env)
3838import Streamly.Benchmark.Common.Handle
3939
4040#ifdef INSPECTION
41−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
41+import Streamly.Internal.Data.Stream (Step(..))
4242
43−import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
43+import qualified Streamly.Internal.Data.Stream as D
4444import qualified Streamly.Internal.Data.Tuple.Strict as Strict
45−import qualified Streamly.Internal.Data.Array.Mut.Stream as MAS
46−import qualified Streamly.Internal.Data.Array.Type as AT
45+import qualified Streamly.Internal.Data.MutArray as MutArray
4746
4847import Test.Inspection
4948#endif
@@ -83,7 +82,7 @@ copyStream inh outh = S.fold (FH.write outh) (S.unfold FH.reader inh)
8382inspect $ hasNoTypeClasses 'copyStream
8483inspect $ 'copyStream `hasNoType` ''Step -- S.unfold
8584inspect $ 'copyStream `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
86−inspect $ 'copyStream `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
85+inspect $ 'copyStream `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe
8786 -- FH.read/A.read
8887inspect $ 'copyStream `hasNoType` ''Strict.Tuple3' -- FH.write/chunksOf
8988#endif
@@ -109,8 +108,8 @@ readFromBytesNull inh devNull = IFH.putBytes devNull $ S.unfold FH.reader inh
109108#ifdef INSPECTION
110109inspect $ hasNoTypeClasses 'readFromBytesNull
111110inspect $ 'readFromBytesNull `hasNoType` ''Step
112−inspect $ 'readFromBytesNull `hasNoType` ''MAS.SpliceState
113−inspect $ 'readFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.chunksOf
111+inspect $ 'readFromBytesNull `hasNoType` ''MutArray.SpliceState
112+inspect $ 'readFromBytesNull `hasNoType` ''MutArray.ArrayUnsafe -- FH.fromBytes/S.chunksOf
114113inspect $ 'readFromBytesNull `hasNoType` ''D.FoldMany
115114#endif
116115
@@ -123,8 +122,8 @@ readWithFromBytesNull inh devNull =
123122#ifdef INSPECTION
124123inspect $ hasNoTypeClasses 'readWithFromBytesNull
125124inspect $ 'readWithFromBytesNull `hasNoType` ''Step
126−inspect $ 'readWithFromBytesNull `hasNoType` ''MAS.SpliceState
127−inspect $ 'readWithFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.chunksOf
125+inspect $ 'readWithFromBytesNull `hasNoType` ''MutArray.SpliceState
126+inspect $ 'readWithFromBytesNull `hasNoType` ''MutArray.ArrayUnsafe -- FH.fromBytes/S.chunksOf
128127inspect $ 'readWithFromBytesNull `hasNoType` ''D.FoldMany
129128#endif
130129
@@ -171,7 +170,7 @@ writeReadWith inh devNull = IUF.fold fld unf (defaultChunkSize, inh)
171170inspect $ hasNoTypeClasses 'writeReadWith
172171inspect $ 'writeReadWith `hasNoType` ''Step
173172inspect $ 'writeReadWith `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
174−inspect $ 'writeReadWith `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
173+inspect $ 'writeReadWith `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe
175174 -- FH.read/A.read
176175#endif
177176
@@ -188,7 +187,7 @@ writeRead inh devNull = IUF.fold fld unf inh
188187inspect $ hasNoTypeClasses 'writeRead
189188inspect $ 'writeRead `hasNoType` ''Step
190189inspect $ 'writeRead `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
191−inspect $ 'writeRead `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
190+inspect $ 'writeRead `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe
192191 -- FH.read/A.read
193192#endif
194193
benchmark/Streamly/Benchmark/Prelude/Adaptive.hs+1−1
@@ -10,7 +10,7 @@
1010import Control.Concurrent (threadDelay)
1111import Control.Monad (when)
1212import Control.Monad.IO.Class (liftIO)
13−import Gauge
13+import Test.Tasty.Bench
1414import Streamly.Prelude as S
1515import System.Random (randomRIO)
1616
benchmark/Streamly/Benchmark/Prelude/Ahead.hs+1−1
@@ -15,7 +15,7 @@ import qualified Streamly.Prelude as S
1515import Streamly.Benchmark.Common
1616import Streamly.Benchmark.Prelude
1717
18−import Gauge
18+import Test.Tasty.Bench
1919
2020moduleName :: String
2121moduleName = "Prelude.Ahead"
benchmark/Streamly/Benchmark/Prelude/Async.hs+1−1
@@ -16,7 +16,7 @@ import qualified Streamly.Internal.Data.Stream.IsStream.Transform as Transform
1616import Streamly.Benchmark.Common
1717import Streamly.Benchmark.Prelude
1818
19−import Gauge
19+import Test.Tasty.Bench
2020
2121moduleName :: String
2222moduleName = "Prelude.Async"
benchmark/Streamly/Benchmark/Prelude/Concurrent.hs+1−1
@@ -15,7 +15,7 @@ import Streamly.Prelude
1515 , fromWAsync, parallel, fromParallel
1616 )
1717
18−import Gauge
18+import Test.Tasty.Bench
1919import qualified Streamly.Prelude as S
2020
2121-------------------------------------------------------------------------------
benchmark/Streamly/Benchmark/Prelude/Merge.hs+2−2
@@ -30,13 +30,13 @@ import qualified Streamly.Internal.Data.Stream.IsStream as Stream
3030import Streamly.Benchmark.Common
3131import Streamly.Benchmark.Prelude
3232
33−import Gauge
33+import Test.Tasty.Bench
3434
3535#ifdef INSPECTION
3636import GHC.Types (SPEC(..))
3737import Test.Inspection
3838
39−import qualified Streamly.Internal.Data.Stream.StreamD as D
39+import qualified Streamly.Internal.Data.Stream as D
4040#endif
4141
4242moduleName :: String
benchmark/Streamly/Benchmark/Prelude/Parallel.hs+1−1
@@ -22,7 +22,7 @@ import qualified Streamly.Internal.Data.Stream.IsStream as Internal
2222import Streamly.Benchmark.Common
2323import Streamly.Benchmark.Prelude
2424
25−import Gauge
25+import Test.Tasty.Bench
2626
2727moduleName :: String
2828moduleName = "Prelude.Parallel"
benchmark/Streamly/Benchmark/Prelude/Rate.hs+1−1
@@ -14,7 +14,7 @@ import qualified Streamly.Prelude as S
1414import Streamly.Benchmark.Common
1515import Streamly.Benchmark.Prelude
1616
17−import Gauge
17+import Test.Tasty.Bench
1818
1919moduleName :: String
2020moduleName = "Prelude.Rate"
benchmark/Streamly/Benchmark/Prelude/WAsync.hs+1−1
@@ -15,7 +15,7 @@ import qualified Streamly.Prelude as S
1515import Streamly.Benchmark.Common
1616import Streamly.Benchmark.Prelude
1717
18−import Gauge
18+import Test.Tasty.Bench
1919
2020moduleName :: String
2121moduleName = "Prelude.WAsync"
benchmark/Streamly/Benchmark/Prelude/WSerial.hs+2−2
@@ -29,13 +29,13 @@ import qualified Streamly.Internal.Data.Unfold as UF
2929import Streamly.Benchmark.Common
3030import Streamly.Benchmark.Prelude
3131
32−import Gauge
32+import Test.Tasty.Bench
3333
3434#ifdef INSPECTION
3535import GHC.Types (SPEC(..))
3636import Test.Inspection
3737
38−import qualified Streamly.Internal.Data.Stream.StreamD as D
38+import qualified Streamly.Internal.Data.Stream as D
3939#endif
4040
4141moduleName :: String
benchmark/Streamly/Benchmark/Prelude/ZipAsync.hs+1−1
@@ -15,7 +15,7 @@ import qualified Streamly.Prelude as S
1515import Streamly.Benchmark.Common
1616import Streamly.Benchmark.Prelude
1717
18−import Gauge
18+import Test.Tasty.Bench
1919
2020moduleName :: String
2121moduleName = "Prelude.ZipAsync"
benchmark/Streamly/Benchmark/Prelude/ZipSerial.hs+2−2
@@ -29,13 +29,13 @@ import qualified Streamly.Prelude as S
2929import Streamly.Benchmark.Common
3030import Streamly.Benchmark.Prelude hiding (sourceUnfoldrM)
3131
32−import Gauge
32+import Test.Tasty.Bench
3333
3434#ifdef INSPECTION
3535import GHC.Types (SPEC(..))
3636import Test.Inspection
3737
38−import qualified Streamly.Internal.Data.Stream.StreamD as D
38+import qualified Streamly.Internal.Data.Stream as D
3939#endif
4040
4141moduleName :: String
benchmark/Streamly/Benchmark/Unicode/Char.hs+2−2
@@ -16,7 +16,7 @@ import Control.DeepSeq (NFData(..))
1616import Streamly.Internal.Data.Array (Array)
1717import System.FilePath (dropExtensions, takeFileName)
1818import System.FilePath.Posix ((</>))
19−import Gauge.Main (Benchmark, bench, bgroup, defaultMain, env, nfIO)
19+import Test.Tasty.Bench (Benchmark, bench, bgroup, defaultMain, env, nfIO)
2020import Streamly.Internal.Unicode.Char
2121 ( NormalizationMode(NFC, NFD, NFKC, NFKD)
2222 , normalize
@@ -24,7 +24,7 @@ import Streamly.Internal.Unicode.Char
2424import Streamly.Benchmark.Common (o_1_space_prefix)
2525
2626import qualified Streamly.Internal.Data.Array as Array
27−import qualified Streamly.Internal.Data.Stream.StreamD as IsStream
27+import qualified Streamly.Internal.Data.Stream as IsStream
2828import qualified System.Directory as Dir
2929
3030--------------------------------------------------------------------------------
benchmark/Streamly/Benchmark/Unicode/Parser.hsnew file+107
@@ -0,0 +1,107 @@
1+-- |
2+-- Module : Streamly.Benchmark.Data.Parser
3+-- Copyright : (c) 2020 Composewell Technologies
4+--
5+-- License : BSD-3-Clause
6+-- Maintainer : streamly@composewell.com
7+
8+{-# LANGUAGE CPP #-}
9+{-# LANGUAGE FlexibleContexts #-}
10+{-# LANGUAGE ScopedTypeVariables #-}
11+{-# OPTIONS_GHC -Wno-orphans #-}
12+
13+#undef FUSION_CHECK
14+#ifdef FUSION_CHECK
15+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
16+#endif
17+
18+module Main
19+ (
20+ main
21+ ) where
22+
23+import Control.DeepSeq (NFData(..))
24+import Control.Monad (replicateM_)
25+import Streamly.Internal.Data.Parser (ParseError(..))
26+import Streamly.Internal.Data.Stream (Stream)
27+import Prelude hiding
28+ (any, all, take, sequence, sequence_, sequenceA, takeWhile, dropWhile)
29+
30+import qualified Streamly.Data.Array as Array
31+import qualified Streamly.Data.Stream as Stream
32+import qualified Streamly.Internal.Unicode.Parser as PRU
33+
34+import Test.Tasty.Bench hiding (env)
35+import Streamly.Benchmark.Common
36+
37+runParser :: Int -> (Stream IO Char -> IO a) -> IO ()
38+runParser count p = do
39+ let v = "+123456789.123456789e-123"
40+ let !(arr :: Array.Array Char) = Array.fromListN (length v) v
41+ let s = Stream.unfold Array.reader arr
42+ replicateM_ count (p s)
43+
44+-- | Takes a fold method, and uses it with a default source.
45+{-# INLINE benchIOSink #-}
46+benchIOSink :: Int -> String -> (Stream IO Char -> IO b) -> Benchmark
47+benchIOSink value name f = bench name $ nfIO $ runParser value f
48+
49+{-# INLINE doubleParser #-}
50+doubleParser :: Monad m => Stream m Char -> m (Either ParseError (Int, Int))
51+doubleParser = Stream.parse PRU.doubleParser
52+
53+{-# INLINE number #-}
54+number :: Monad m => Stream m Char -> m (Either ParseError (Integer, Int))
55+number = Stream.parse PRU.number
56+
57+{-# INLINE double #-}
58+double :: Monad m => Stream m Char -> m (Either ParseError Double)
59+double = Stream.parse PRU.double
60+
61+{-# INLINE numberDouble #-}
62+numberDouble :: Monad m => Stream m Char -> m (Either ParseError Double)
63+numberDouble = Stream.parse p
64+ where p = uncurry PRU.mkDouble <$> PRU.number
65+
66+-------------------------------------------------------------------------------
67+-- Benchmarks
68+-------------------------------------------------------------------------------
69+
70+moduleName :: String
71+moduleName = "Unicode.Parser"
72+
73+instance NFData ParseError where
74+ {-# INLINE rnf #-}
75+ rnf (ParseError x) = rnf x
76+
77+o_n_heap_serial :: Int -> [Benchmark]
78+o_n_heap_serial value =
79+ [
80+ benchIOSink value "doubleParser" doubleParser
81+ , benchIOSink value "number" number
82+ , benchIOSink value "double (doubleParser)" double
83+ , benchIOSink value "double (number)" numberDouble
84+ ]
85+
86+-------------------------------------------------------------------------------
87+-- Driver
88+-------------------------------------------------------------------------------
89+
90+main :: IO ()
91+main = do
92+#ifndef FUSION_CHECK
93+ runWithCLIOpts defaultStreamSize allBenchmarks
94+
95+ where
96+
97+ allBenchmarks value =
98+ [ bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)
99+ ]
100+#else
101+ -- Enable FUSION_CHECK macro at the beginning of the file
102+ -- Enable one benchmark below, and run the benchmark
103+ -- Check the .dump-simpl output
104+ let value = 100000
105+ runParser value double
106+ return ()
107+#endif
benchmark/Streamly/Benchmark/Unicode/Stream.hs+27−9
@@ -11,6 +11,11 @@
1111{-# LANGUAGE CPP #-}
1212{-# LANGUAGE ScopedTypeVariables #-}
1313
14+#undef FUSION_CHECK
15+#ifdef FUSION_CHECK
16+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
17+#endif
18+
1419#ifdef __HADDOCK_VERSION__
1520#undef INSPECTION
1621#endif
@@ -27,22 +32,23 @@ import System.IO (Handle)
2732
2833import qualified Streamly.Data.Array as Array
2934import qualified Streamly.Data.Fold as Fold
30−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
35+import qualified Streamly.Internal.Data.Stream as Stream
3136import qualified Streamly.Internal.Data.Unfold as Unfold
3237import qualified Streamly.Internal.FileSystem.Handle as Handle
3338import qualified Streamly.Internal.Unicode.Array as UnicodeArr
3439import qualified Streamly.Internal.Unicode.Stream as Unicode
3540
36−import Gauge hiding (env)
41+import Test.Tasty.Bench hiding (env)
3742import Streamly.Benchmark.Common
3843import Streamly.Benchmark.Common.Handle
3944
4045#ifdef INSPECTION
41−import Streamly.Internal.Data.Unboxed (Unbox)
42−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
43−import qualified Streamly.Internal.Data.Fold.Type as Fold
46+import Streamly.Internal.Data.MutByteArray (Unbox)
47+import Streamly.Internal.Data.Stream (Step(..))
48+import qualified Streamly.Internal.Data.Array as Array
49+import qualified Streamly.Internal.Data.MutArray as MutArray
50+import qualified Streamly.Internal.Data.Fold as Fold
4451import qualified Streamly.Internal.Data.Tuple.Strict as Strict
45−import qualified Streamly.Internal.Data.Array.Type as Array
4652
4753import Test.Inspection
4854#endif
@@ -218,7 +224,7 @@ inspect $ 'copyStreamLatin1' `hasNoType` ''Step
218224inspect $ 'copyStreamLatin1' `hasNoType` ''Unfold.ConcatState -- Handle.read/UF.many
219225
220226inspect $ 'copyStreamLatin1' `hasNoType` ''Fold.Step
221−inspect $ 'copyStreamLatin1' `hasNoType` ''Array.ArrayUnsafe -- Handle.write/writeNUnsafe
227+inspect $ 'copyStreamLatin1' `hasNoType` ''MutArray.ArrayUnsafe -- Handle.write/writeNUnsafe
222228 -- Handle.read/Array.read
223229inspect $ 'copyStreamLatin1' `hasNoType` ''Strict.Tuple3' -- Handle.write/chunksOf
224230#endif
@@ -239,7 +245,7 @@ inspect $ 'copyStreamLatin1 `hasNoType` ''Unfold.ConcatState -- Handle.read/UF.m
239245
240246inspect $ 'copyStreamLatin1 `hasNoType` ''Fold.ManyState
241247inspect $ 'copyStreamLatin1 `hasNoType` ''Fold.Step
242−inspect $ 'copyStreamLatin1 `hasNoType` ''Array.ArrayUnsafe -- Handle.write/writeNUnsafe
248+inspect $ 'copyStreamLatin1 `hasNoType` ''MutArray.ArrayUnsafe -- Handle.write/writeNUnsafe
243249 -- Handle.read/Array.read
244250inspect $ 'copyStreamLatin1 `hasNoType` ''Strict.Tuple3' -- Handle.write/chunksOf
245251#endif
@@ -280,7 +286,8 @@ _copyStreamUtf8'Fold :: Handle -> Handle -> IO ()
280286_copyStreamUtf8'Fold inh outh =
281287 Stream.fold (Handle.write outh)
282288 $ Unicode.encodeUtf8
283− $ Stream.foldMany Unicode.writeCharUtf8'
289+ $ Stream.catRights
290+ $ Stream.parseMany Unicode.writeCharUtf8'
284291 $ Stream.unfold Handle.reader inh
285292
286293{-# NOINLINE _copyStreamUtf8Parser #-}
@@ -317,6 +324,7 @@ o_1_space_decode_encode_read env =
317324
318325main :: IO ()
319326main = do
327+#ifndef FUSION_CHECK
320328 env <- mkHandleBenchEnv
321329 defaultMain (allBenchmarks env)
322330
@@ -329,3 +337,13 @@ main = do
329337 , o_1_space_decode_encode_read env
330338 ]
331339 ]
340+#else
341+ -- Enable FUSION_CHECK macro at the beginning of the file
342+ -- Enable one benchmark below, and run the benchmark
343+ -- Check the .dump-simpl output
344+ env <- mkHandleBenchEnv
345+ let mkHandles (RefHandles {bigInH = inh, outputH = outh}) = Handles inh outh
346+ (Handles inh outh) <- getHandles env mkHandles
347+ copyStreamLatin1' inh outh
348+ return ()
349+#endif
benchmark/Streamly/Benchmark/Unicode/Utf8.hs+1−1
@@ -13,7 +13,7 @@
1313import Data.Char (chr)
1414import Streamly.Internal.Unicode.Utf8 (Utf8)
1515
16−import Gauge hiding (env)
16+import Test.Tasty.Bench hiding (env)
1717import Streamly.Benchmark.Common
1818
1919import qualified Streamly.Internal.Unicode.Utf8 as Utf8
benchmark/bench-runner/Main.hs+42−10
@@ -16,9 +16,11 @@ rtsOpts exeName benchName0 = unwords [general, exeSpecific, benchSpecific]
1616 benchName = drop 4 benchName0
1717
1818 general
19− | "o-1-sp" `isInfixOf` benchName = "-K36K -M16M"
19+ -- GHC-9.6 requires 32M heap vs 16M for GHC-9.4
20+ | "o-1-sp" `isInfixOf` benchName = "-K36K -M32M"
2021 | "o-n-h" `isInfixOf` benchName = "-K36K -M32M"
21− | "o-n-st" `isInfixOf` benchName = "-K1M -M16M"
22+ -- GHC-9.6 requires 32M heap vs 16M for GHC-9.4
23+ | "o-n-st" `isInfixOf` benchName = "-K1M -M32M"
2224 | "o-n-sp" `isInfixOf` benchName = "-K1M -M32M"
2325 | otherwise = ""
2426
@@ -27,6 +29,17 @@ rtsOpts exeName benchName0 = unwords [general, exeSpecific, benchSpecific]
2729 | otherwise = ""
2830
2931 benchSpecific
32+ -- GHC-9.6 requires 64M, earlier it was 16M
33+ | "Data.Fold/o-n-heap.key-value.toHashMapIO (max buckets) sum" == benchName =
34+ "-M64M"
35+
36+ -- This is required only for the --long case because we allocate all
37+ -- the arrays upfront. depends on the size of the stream.
38+ | "Data.Parser/o-1-space" `isPrefixOf` benchName =
39+ "-M128M"
40+
41+ -----------------------------------------------------------------------
42+
3043 | "Prelude.Parallel/o-n-heap.mapping.mapM" == benchName = "-M256M"
3144 | "Prelude.Parallel/o-n-heap.monad-outer-product."
3245 `isPrefixOf` benchName = "-M256M"
@@ -54,14 +67,21 @@ rtsOpts exeName benchName0 = unwords [general, exeSpecific, benchSpecific]
5467 `isPrefixOf` benchName = "-K4M"
5568 | "Data.Stream.StreamDK/o-n-space.iterated."
5669 `isPrefixOf` benchName = "-K4M -M64M"
70+ -- GHC 9.4.4 requires 4M
5771 | "Data.Stream.StreamDK/o-n-space.traversable."
58− `isPrefixOf` benchName = "-K2M"
72+ `isPrefixOf` benchName = "-K4M"
73+ -- GHC-9.6 requires 64M, earlier it was 32M
74+ | "Data.Stream.StreamDK/o-n-heap.buffered.readsPrec pure streams" == benchName =
75+ "-M64M"
76+ -- GHC-9.6 requires 64M, earlier it was 32M
77+ | "Data.Stream.StreamDK/o-n-heap.buffered.showPrec Haskell lists" == benchName =
78+ "-M64M"
5979
6080 -----------------------------------------------------------------------
6181
62− | "Data.Stream.StreamD/o-n-space.elimination.toList" == benchName =
82+ | "Data.StreamD/o-n-space.elimination.toList" == benchName =
6383 "-K2M"
64− | "Data.Stream.StreamK/o-n-space.elimination.toList" == benchName =
84+ | "Data.StreamK/o-n-space.elimination.toList" == benchName =
6585 "-K2M"
6686
6787 -----------------------------------------------------------------------
@@ -73,19 +93,31 @@ rtsOpts exeName benchName0 = unwords [general, exeSpecific, benchSpecific]
7393 | "Data.Stream/o-n-space.iterated."
7494 `isPrefixOf` benchName = "-K4M"
7595
76− | "Data.Stream.ConcurrentEager/o-n-space.monad-outer-product.toNullAp"
77− `isPrefixOf` benchName = "-M768M"
96+ -- GHC-9.6 requires 64M, earlier it was 32M
97+ | "Data.Stream/o-n-heap.buffered.showPrec Haskell lists" == benchName =
98+ "-M64M"
99+ -- GHC-9.6 requires 64M, earlier it was 32M
100+ | "Data.Stream/o-n-heap.buffered.readsPrec pure streams" == benchName =
101+ "-M64M"
102+
103+ | "Data.Stream.ConcurrentEager/o-n-heap.monad-outer-product.toNullAp"
104+ `isPrefixOf` benchName = "-M1024M"
78105 | "Data.Stream.ConcurrentEager/o-1-space."
79106 `isPrefixOf` benchName = "-M128M"
80107
108+ | "Data.Stream.ConcurrentOrdered/o-1-space.concat-foldable.foldMapWith"
109+ `isPrefixOf` benchName = "-K128K"
110+
81111 ----------------------------------------------------------------------
82112
83113 | "Data.Array" `isPrefixOf` benchName
84114 && "/o-1-space.generation.read" `isSuffixOf` benchName = "-M32M"
115+ -- XXX GHC 9.6 onwards needs 64M, earlier it was 32M
85116 | "Data.Array" `isPrefixOf` benchName
86− && "/o-1-space.generation.show" `isSuffixOf` benchName = "-M32M"
117+ && "/o-1-space.generation.show" `isSuffixOf` benchName = "-M64M"
118+ -- XXX GHC 9.6 onwards needs 64M, earlier it was 32M
87119 | "Data.Array.Generic/o-1-space.transformationX4.map"
88− `isPrefixOf` benchName = "-M32M"
120+ `isPrefixOf` benchName = "-M64M"
89121
90122 -- XXX For --long option, need to check why so much heap is required.
91123 -- Note, if we remove the chunked stream module we need to keep the
@@ -94,7 +126,7 @@ rtsOpts exeName benchName0 = unwords [general, exeSpecific, benchSpecific]
94126 `isPrefixOf` benchName = "-K4M -M512M"
95127 -- XXX Takes up to 160MB heap for --long, we use chunked stream for
96128 -- this, so the reason may be related to chunked streams.
97− | "Data.Parser.ParserK/o-1-space"
129+ | "Data.ParserK/o-1-space"
98130 `isPrefixOf` benchName = "-K4M -M256M"
99131
100132 -----------------------------------------------------------------------
benchmark/bench-runner/default.nix+1−1
@@ -49,7 +49,7 @@ let haskellPackages =
4949 nixpkgs.haskell.lib.overrideCabal
5050 (let src = fetchGit {
5151 url = "git@github.com:composewell/bench-report.git";
52− rev = "ca3872acd4b817731b951c6ed91bfa6c58f26c5a";
52+ rev = "3b50bf0ad06f746bca42f30c8d40a0426e159af3";
5353 }; in super.callCabal2nix "bench-report" src {})
5454 (old:
5555 { enableLibraryProfiling = false;
benchmark/lib/Streamly/Benchmark/Common.hs+2−2
@@ -54,9 +54,9 @@ import Data.Functor.Identity (Identity, runIdentity)
5454import System.Random (randomRIO)
5555
5656import qualified Streamly.Internal.Data.Fold as Fold
57−import qualified Streamly.Internal.Data.Stream.StreamD as S
57+import qualified Streamly.Internal.Data.Stream as S
5858
59−import Gauge
59+import Test.Tasty.Bench
6060
6161-------------------------------------------------------------------------------
6262-- Benchmark Prefixes
benchmark/lib/Streamly/Benchmark/Common/Handle.hs+3−1
@@ -30,6 +30,8 @@ module Streamly.Benchmark.Common.Handle
3030 , isSpace
3131 , isSp
3232 , mkHandleBenchEnv
33+ , Handles(..)
34+ , getHandles
3335 )
3436where
3537
@@ -46,7 +48,7 @@ import System.Process (callCommand)
4648
4749import Data.IORef
4850import Prelude hiding (last, length)
49−import Gauge hiding (env)
51+import Test.Tasty.Bench hiding (env)
5052
5153
5254scratchDir :: String
benchmark/lib/Streamly/Benchmark/Prelude.hs+1−1
@@ -82,7 +82,7 @@ import qualified Streamly.Internal.Data.Stream.IsStream.Type as IsStream
8282import qualified Streamly.Internal.Data.Pipe as Pipe
8383import qualified Streamly.Internal.Data.Stream.Serial as Serial
8484
85−import Gauge
85+import Test.Tasty.Bench
8686import Streamly.Internal.Data.Time.Units
8787
8888-- Common polymorphic stream APIs used across multiple stream modules
benchmark/streamly-benchmarks.cabal+82−47
@@ -54,11 +54,6 @@ flag opt
5454 manual: True
5555 default: True
5656
57−flag use-gauge
58− description: Use gauge instead of tasty-bench for benchmarking
59− manual: True
60− default: False
61−
6257flag use-streamly-core
6358 description: Benchmark only core package
6459 manual: True
@@ -145,6 +140,10 @@ common compile-options
145140 -Wno-missing-kind-signatures
146141 -Wno-operator-whitespace
147142
143+ if impl(ghc >= 9.8)
144+ ghc-options:
145+ -Wno-missing-role-annotations
146+
148147 if flag(has-llvm)
149148 ghc-options: -fllvm
150149
@@ -152,15 +151,17 @@ common compile-options
152151 ghc-options: -Wmissed-specialisations
153152 -Wall-missed-specialisations
154153
155− if flag(dev) || flag(debug)
156− ghc-options: -fno-ignore-asserts
157−
158154common optimization-options
159155 if flag(opt)
160156 ghc-options: -O2
161157 -fdicts-strict
162158 -fspec-constr-recursive=16
163159 -fmax-worker-args=16
160+
161+ -- For this to be effective it must come after the -O2 option
162+ if flag(dev) || flag(debug)
163+ ghc-options: -fno-ignore-asserts
164+
164165 if flag(fusion-plugin) && !impl(ghcjs) && !impl(ghc < 8.6)
165166 ghc-options: -fplugin Fusion.Plugin
166167 else
@@ -174,43 +175,34 @@ common bench-depends
174175 -- Core libraries shipped with ghc, the min and max
175176 -- constraints of these libraries should match with
176177 -- the GHC versions we support
177− base >= 4.9 && < 4.18
178− , deepseq >= 1.4.1 && < 1.5
179− , mtl >= 2.2 && < 2.3
178+ base >= 4.9 && < 4.20
179+ , deepseq >= 1.4.1 && < 1.6
180+ , mtl >= 2.2 && < 2.3.2
180181
181182 -- other libraries
183+ , exceptions >= 0.8 && < 0.11
182184 , random >= 1.0 && < 2.0
183185 , transformers >= 0.4 && < 0.7
184− , containers >= 0.5 && < 0.7
186+ , containers >= 0.5 && < 0.8
185187 , hashable >= 1.3 && < 1.5
186188 , unordered-containers >= 0.2 && < 0.3
187189 , process >= 1.4 && < 1.7
188190 , directory >= 1.2.2 && < 1.4
189− , filepath >= 1.4.1 && < 1.5
190− , ghc-prim >= 0.4 && < 0.10
191+ , filepath >= 1.4.1 && < 1.6
192+ , ghc-prim >= 0.4 && < 0.12
193+ , tasty-bench >= 0.3 && < 0.4
194+ , tasty >= 1.4.1 && < 1.6
195+ , streamly-core
191196
192− if flag(use-streamly-core)
193− build-depends: streamly-core
194− else
197+ if !flag(use-streamly-core)
195198 build-depends: streamly
196− , streamly-core
197−
198− if flag(use-gauge)
199− build-depends: gauge >= 0.2.4 && < 0.3
200− else
201− build-depends: tasty-bench >= 0.3 && < 0.4
202− , tasty >= 1.4.1 && < 1.5
203− mixins: tasty-bench
204− (Test.Tasty.Bench as Gauge
205− , Test.Tasty.Bench as Gauge.Main
206− )
207199
208200 if flag(fusion-plugin) && !impl(ghcjs) && !impl(ghc < 8.6)
209201 build-depends:
210202 fusion-plugin >= 0.2 && < 0.3
211203 if flag(inspection)
212− build-depends: template-haskell >= 2.14 && < 2.20
213− , inspection-testing >= 0.4 && < 0.5
204+ build-depends: template-haskell >= 2.14 && < 2.22
205+ , inspection-testing >= 0.4 && < 0.6
214206 -- Array uses a Storable constraint in dev build making several inspection
215207 -- tests fail
216208 if flag(dev) && flag(inspection)
@@ -356,6 +348,34 @@ benchmark Data.Stream.ConcurrentOrdered
356348 else
357349 buildable: True
358350
351+benchmark Data.Unbox
352+ import: bench-options
353+ type: exitcode-stdio-1.0
354+ hs-source-dirs: .
355+ cpp-options: -DUSE_UNBOX
356+ main-is: Streamly/Benchmark/Data/Serialize.hs
357+
358+benchmark Data.Unbox.Derive.TH
359+ import: bench-options
360+ type: exitcode-stdio-1.0
361+ hs-source-dirs: .
362+ cpp-options: -DUSE_UNBOX
363+ cpp-options: -DUSE_TH
364+ main-is: Streamly/Benchmark/Data/Serialize.hs
365+
366+benchmark Data.Serialize
367+ import: bench-options
368+ type: exitcode-stdio-1.0
369+ hs-source-dirs: .
370+ cpp-options: -DUSE_TH
371+ main-is: Streamly/Benchmark/Data/Serialize.hs
372+ build-depends: QuickCheck, template-haskell
373+ other-modules:
374+ Streamly.Benchmark.Data.Serialize.TH
375+ Streamly.Benchmark.Data.Serialize.RecCompatible
376+ Streamly.Benchmark.Data.Serialize.RecNonCompatible
377+ if flag(limit-build-mem)
378+ ghc-options: +RTS -M1000M -RTS
359379
360380benchmark Data.Unfold
361381 import: bench-options
@@ -401,12 +421,13 @@ benchmark Data.Parser
401421 if flag(dev)
402422 ghc-options: +RTS -M3000M -RTS
403423 else
404− ghc-options: +RTS -M1000M -RTS
424+ ghc-options: +RTS -M2000M -RTS
405425
406−benchmark Data.Parser.ParserK
426+benchmark Data.ParserK
407427 import: bench-options
408428 type: exitcode-stdio-1.0
409− hs-source-dirs: Streamly/Benchmark/Data/Parser
429+ hs-source-dirs: Streamly/Benchmark/Data
430+ cpp-options: -DBENCH_SINGULAR
410431 main-is: ParserK.hs
411432 if impl(ghcjs)
412433 buildable: False
@@ -414,17 +435,25 @@ benchmark Data.Parser.ParserK
414435 buildable: True
415436 build-depends: exceptions >= 0.8 && < 0.11
416437
417−-- Note: to use this we have to set DISABLE_FUSION in ParserD.hs so that
418−-- the rewrite rules are disabled. We can also use the "no-fusion" build
419−-- flag but we need to keep in mind that it disables fusion for streams
420−-- as well.
421−benchmark Data.Parser.FromParserK
438+benchmark Data.ParserK.Chunked
422439 import: bench-options
423440 type: exitcode-stdio-1.0
424− hs-source-dirs: Streamly/Benchmark/Data/Parser
425− cpp-options: -DFROM_PARSERK
441+ hs-source-dirs: Streamly/Benchmark/Data
442+ cpp-options: -DBENCH_CHUNKED
426443 main-is: ParserK.hs
427− if flag(use-streamly-core) || impl(ghcjs)
444+ if impl(ghcjs)
445+ buildable: False
446+ else
447+ buildable: True
448+ build-depends: exceptions >= 0.8 && < 0.11
449+
450+benchmark Data.ParserK.Chunked.Generic
451+ import: bench-options
452+ type: exitcode-stdio-1.0
453+ hs-source-dirs: Streamly/Benchmark/Data
454+ cpp-options: -DBENCH_CHUNKED_GENERIC
455+ main-is: ParserK.hs
456+ if impl(ghcjs)
428457 buildable: False
429458 else
430459 buildable: True
@@ -434,7 +463,7 @@ benchmark Data.Parser.FromParserK
434463-- Raw Streams
435464-------------------------------------------------------------------------------
436465
437−benchmark Data.Stream.StreamD
466+benchmark Data.StreamD
438467 import: bench-options
439468 type: exitcode-stdio-1.0
440469 hs-source-dirs: Streamly/Benchmark/Data/Stream
@@ -442,7 +471,7 @@ benchmark Data.Stream.StreamD
442471 if impl(ghcjs)
443472 buildable: False
444473
445−benchmark Data.Stream.StreamK
474+benchmark Data.StreamK
446475 import: bench-options
447476 type: exitcode-stdio-1.0
448477 hs-source-dirs: Streamly/Benchmark/Data/Stream
@@ -458,11 +487,11 @@ benchmark Data.Stream.ToStreamK
458487 if !flag(dev) || impl(ghcjs)
459488 buildable: False
460489
461−benchmark Data.Stream.StreamK.Alt
490+benchmark Data.StreamK.Alt
462491 import: bench-options
463492 type: exitcode-stdio-1.0
464493 hs-source-dirs: Streamly/Benchmark/Data/Stream
465− main-is: StreamDK.hs
494+ main-is: StreamKAlt.hs
466495 if !flag(dev) || impl(ghcjs)
467496 buildable: False
468497
@@ -651,10 +680,10 @@ benchmark Data.Array
651680 if flag(limit-build-mem)
652681 ghc-options: +RTS -M1500M -RTS
653682
654−benchmark Data.Array.Mut
683+benchmark Data.MutArray
655684 import: bench-options
656685 type: exitcode-stdio-1.0
657− main-is: Streamly/Benchmark/Data/Array/Mut.hs
686+ main-is: Streamly/Benchmark/Data/MutArray.hs
658687 if flag(limit-build-mem)
659688 ghc-options: +RTS -M1500M -RTS
660689 if flag(use-streamly-core)
@@ -741,3 +770,9 @@ benchmark Unicode.Utf8
741770 buildable: False
742771 else
743772 buildable: True
773+
774+benchmark Unicode.Parser
775+ import: bench-options
776+ type: exitcode-stdio-1.0
777+ hs-source-dirs: Streamly/Benchmark/Unicode
778+ main-is: Parser.hs
bin/mk-hscope.sh+1−1
@@ -1,7 +1,7 @@
11#!/usr/bin/env bash
22
33GHC_VERSION=8.10.4
4−STREAMLY_VERSION=0.8.2
4+STREAMLY_VERSION=0.9.0
55
66case `uname` in
77 Darwin) SYSTEM=x86_64-osx;;
bin/run-repl-quick.sh+1−1
@@ -13,7 +13,7 @@ set -e
1313
1414SCRIPT_DIR=$(dirname $0)
1515
16−STREAMLY_VERSION=0.8.2
16+STREAMLY_VERSION=0.9.0
1717BENCH_REPORT_DIR=benchmark/bench-report
1818source $SCRIPT_DIR/targets.sh
1919
cabal.project.packdiff+1−5
@@ -1,7 +1,3 @@
1−packages:
2− streamly.cabal
3− core/streamly-core.cabal
4−
51source-repository-package
62 type: git
73 location: https://github.com/composewell/packdiff.git
@@ -10,4 +6,4 @@ source-repository-package
106source-repository-package
117 type: git
128 location: https://github.com/composewell/streamly-process.git
13− tag: 65e3ae489637099d0189a1ba184bb08a5c16de48
9+ tag: d80b860d9d8ea98e4f7f63390442b3155c34dd08
cabal.project.report+2−4
@@ -2,8 +2,6 @@ packages:
22 targets/streamly-targets.cabal
33 benchmark/bench-runner/bench-runner.cabal
44 test/test-runner/test-runner.cabal
5− streamly.cabal
6− core/streamly-core.cabal
75
86package bench-report
97 flags: +no-charts
@@ -14,7 +12,7 @@ package bench-show
1412source-repository-package
1513 type: git
1614 location: https://github.com/composewell/bench-report.git
17− tag: 11713fde39d9973d8210e84de801f250a05a6735
15+ tag: 3b50bf0ad06f746bca42f30c8d40a0426e159af3
1816
1917source-repository-package
2018 type: git
@@ -29,4 +27,4 @@ source-repository-package
2927source-repository-package
3028 type: git
3129 location: https://github.com/composewell/streamly-process.git
32− tag: 794a4102f82a13a94c66f6453c20703a5296229c
30+ tag: d80b860d9d8ea98e4f7f63390442b3155c34dd08
configure+9−9
@@ -1,6 +1,6 @@
11#! /bin/sh
22# Guess values for system-dependent variables and create Makefiles.
3−# Generated by GNU Autoconf 2.71 for streamly 0.9.0.
3+# Generated by GNU Autoconf 2.71 for streamly 0.10.1.
44#
55# Report bugs to <streamly@composewell.com>.
66#
@@ -610,8 +610,8 @@ MAKEFLAGS=
610610# Identity of this package.
611611PACKAGE_NAME='streamly'
612612PACKAGE_TARNAME='streamly'
613−PACKAGE_VERSION='0.9.0'
614−PACKAGE_STRING='streamly 0.9.0'
613+PACKAGE_VERSION='0.10.1'
614+PACKAGE_STRING='streamly 0.10.1'
615615PACKAGE_BUGREPORT='streamly@composewell.com'
616616PACKAGE_URL='https://streamly.composewell.com'
617617
@@ -1224,7 +1224,7 @@ if test "$ac_init_help" = "long"; then
12241224 # Omit some internal or obsolete options to make the list less imposing.
12251225 # This message is too long to be a string in the A/UX 3.1 sh.
12261226 cat <<_ACEOF
1227−\`configure' configures streamly 0.9.0 to adapt to many kinds of systems.
1227+\`configure' configures streamly 0.10.1 to adapt to many kinds of systems.
12281228
12291229Usage: $0 [OPTION]... [VAR=VALUE]...
12301230
@@ -1286,7 +1286,7 @@ fi
12861286
12871287if test -n "$ac_init_help"; then
12881288 case $ac_init_help in
1289− short | recursive ) echo "Configuration of streamly 0.9.0:";;
1289+ short | recursive ) echo "Configuration of streamly 0.10.1:";;
12901290 esac
12911291 cat <<\_ACEOF
12921292
@@ -1372,7 +1372,7 @@ fi
13721372test -n "$ac_init_help" && exit $ac_status
13731373if $ac_init_version; then
13741374 cat <<\_ACEOF
1375−streamly configure 0.9.0
1375+streamly configure 0.10.1
13761376generated by GNU Autoconf 2.71
13771377
13781378Copyright (C) 2021 Free Software Foundation, Inc.
@@ -1500,7 +1500,7 @@ cat >config.log <<_ACEOF
15001500This file contains any messages produced by compilers while
15011501running configure, to aid debugging if configure makes a mistake.
15021502
1503−It was created by streamly $as_me 0.9.0, which was
1503+It was created by streamly $as_me 0.10.1, which was
15041504generated by GNU Autoconf 2.71. Invocation command line was
15051505
15061506 $ $0$ac_configure_args_raw
@@ -3800,7 +3800,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
38003800# report actual input values of CONFIG_FILES etc. instead of their
38013801# values after options handling.
38023802ac_log="
3803−This file was extended by streamly $as_me 0.9.0, which was
3803+This file was extended by streamly $as_me 0.10.1, which was
38043804generated by GNU Autoconf 2.71. Invocation command line was
38053805
38063806 CONFIG_FILES = $CONFIG_FILES
@@ -3856,7 +3856,7 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\
38563856cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
38573857ac_cs_config='$ac_cs_config_escaped'
38583858ac_cs_version="\\
3859−streamly config.status 0.9.0
3859+streamly config.status 0.10.1
38603860configured by $0, generated by GNU Autoconf 2.71,
38613861 with options \\"\$ac_cs_config\\"
38623862
configure.ac+1−1
@@ -3,7 +3,7 @@
33# See https://www.gnu.org/software/autoconf/manual/autoconf.html for help on
44# the macros used in this file.
55
6−AC_INIT([streamly], [0.9.0], [streamly@composewell.com], [streamly], [https://streamly.composewell.com])
6+AC_INIT([streamly], [0.10.1], [streamly@composewell.com], [streamly], [https://streamly.composewell.com])
77
88# To suppress "WARNING: unrecognized options: --with-compiler"
99AC_ARG_WITH([compiler], [GHC])
core/Changelog.mdnew file+1
@@ -0,0 +1 @@
1+docs/Changelog.md
core/LICENSEnew file+322
@@ -0,0 +1,322 @@
1+Copyright (c) 2017, Composewell Technologies
2+All rights reserved.
3+
4+Redistribution and use in source and binary forms, with or without
5+modification, are permitted provided that the following conditions are met:
6+
7+1. Redistributions of source code must retain the above copyright notice, this
8+list of conditions and the following disclaimer.
9+
10+2. Redistributions in binary form must reproduce the above copyright notice,
11+this list of conditions and the following disclaimer in the documentation
12+and/or other materials provided with the distribution.
13+
14+3. Neither the name of the copyright holder nor the names of its contributors
15+may be used to endorse or promote products derived from this software without
16+specific prior written permission.
17+
18+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28+
29+-------------------------------------------------------------------------------
30+base-4.12.0.0 (http://hackage.haskell.org/package/base-4.12.0.0)
31+-------------------------------------------------------------------------------
32+This library (libraries/base) is derived from code from several
33+sources:
34+
35+ * Code from the GHC project which is largely (c) The University of
36+ Glasgow, and distributable under a BSD-style license (see below),
37+
38+ * Code from the Haskell 98 Report which is (c) Simon Peyton Jones
39+ and freely redistributable (but see the full license for
40+ restrictions).
41+
42+ * Code from the Haskell Foreign Function Interface specification,
43+ which is (c) Manuel M. T. Chakravarty and freely redistributable
44+ (but see the full license for restrictions).
45+
46+The full text of these licenses is reproduced below. All of the
47+licenses are BSD-style or compatible.
48+
49+The Glasgow Haskell Compiler License
50+
51+Copyright 2004, The University Court of the University of Glasgow.
52+All rights reserved.
53+
54+Redistribution and use in source and binary forms, with or without
55+modification, are permitted provided that the following conditions are met:
56+
57+- Redistributions of source code must retain the above copyright notice,
58+this list of conditions and the following disclaimer.
59+
60+- Redistributions in binary form must reproduce the above copyright notice,
61+this list of conditions and the following disclaimer in the documentation
62+and/or other materials provided with the distribution.
63+
64+- Neither name of the University nor the names of its contributors may be
65+used to endorse or promote products derived from this software without
66+specific prior written permission.
67+
68+THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
69+GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
70+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
71+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
72+UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
73+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
74+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
75+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
76+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
77+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
78+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
79+DAMAGE.
80+
81+Code derived from the document "Report on the Programming Language
82+Haskell 98", is distributed under the following license:
83+
84+ Copyright (c) 2002 Simon Peyton Jones
85+
86+ The authors intend this Report to belong to the entire Haskell
87+ community, and so we grant permission to copy and distribute it for
88+ any purpose, provided that it is reproduced in its entirety,
89+ including this Notice. Modified versions of this Report may also be
90+ copied and distributed for any purpose, provided that the modified
91+ version is clearly presented as such, and that it does not claim to
92+ be a definition of the Haskell 98 Language.
93+
94+Code derived from the document "The Haskell 98 Foreign Function
95+Interface, An Addendum to the Haskell 98 Report" is distributed under
96+the following license:
97+
98+ Copyright (c) 2002 Manuel M. T. Chakravarty
99+
100+ The authors intend this Report to belong to the entire Haskell
101+ community, and so we grant permission to copy and distribute it for
102+ any purpose, provided that it is reproduced in its entirety,
103+ including this Notice. Modified versions of this Report may also be
104+ copied and distributed for any purpose, provided that the modified
105+ version is clearly presented as such, and that it does not claim to
106+ be a definition of the Haskell 98 Foreign Function Interface.
107+
108+-------------------------------------------------------------------------------
109+bjoern-2008-2009 (http://bjoern.hoehrmann.de/utf-8/decoder/dfa/)
110+-------------------------------------------------------------------------------
111+Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
112+
113+Permission is hereby granted, free of charge, to any person obtaining a copy of
114+this software and associated documentation files (the "Software"), to deal in
115+the Software without restriction, including without limitation the rights to
116+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
117+of the Software, and to permit persons to whom the Software is furnished to do
118+so, subject to the following conditions:
119+
120+The above copyright notice and this permission notice shall be included in all
121+copies or substantial portions of the Software.
122+
123+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
124+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
125+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
126+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
127+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
128+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
129+SOFTWARE.
130+
131+-------------------------------------------------------------------------------
132+clock-0.7.2 (http://hackage.haskell.org/package/clock-0.7.2)
133+-------------------------------------------------------------------------------
134+Copyright (c) 2009-2012, Cetin Sert
135+Copyright (c) 2010, Eugene Kirpichov
136+
137+All rights reserved.
138+
139+Redistribution and use in source and binary forms, with or without
140+modification, are permitted provided that the following conditions are
141+met:
142+
143+ * Redistributions of source code must retain the above copyright
144+ notice, this list of conditions and the following disclaimer.
145+
146+ * Redistributions in binary form must reproduce the above
147+ copyright notice, this list of conditions and the following
148+ disclaimer in the documentation and/or other materials provided
149+ with the distribution.
150+
151+ * The names of contributors may not be used to endorse or promote
152+ products derived from this software without specific prior
153+ written permission.
154+
155+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
156+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
157+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
158+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
159+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
160+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
161+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
162+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
163+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
164+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
165+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
166+
167+-------------------------------------------------------------------------------
168+foldl-1.4.5 (http://hackage.haskell.org/package/foldl-1.4.5)
169+-------------------------------------------------------------------------------
170+Copyright (c) 2013 Gabriel Gonzalez
171+All rights reserved.
172+
173+Redistribution and use in source and binary forms, with or without modification,
174+are permitted provided that the following conditions are met:
175+ * Redistributions of source code must retain the above copyright notice,
176+ this list of conditions and the following disclaimer.
177+ * Redistributions in binary form must reproduce the above copyright notice,
178+ this list of conditions and the following disclaimer in the documentation
179+ and/or other materials provided with the distribution.
180+ * Neither the name of Gabriel Gonzalez nor the names of other contributors
181+ may be used to endorse or promote products derived from this software
182+ without specific prior written permission.
183+
184+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
185+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
186+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
187+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
188+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
189+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
190+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
191+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
192+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
193+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
194+
195+-------------------------------------------------------------------------------
196+primitive-0.7.0.0 (https://hackage.haskell.org/package/primitive-0.7.0.0)
197+-------------------------------------------------------------------------------
198+Copyright (c) 2008-2009, Roman Leshchinskiy
199+All rights reserved.
200+
201+Redistribution and use in source and binary forms, with or without
202+modification, are permitted provided that the following conditions are met:
203+
204+- Redistributions of source code must retain the above copyright notice,
205+this list of conditions and the following disclaimer.
206+
207+- Redistributions in binary form must reproduce the above copyright notice,
208+this list of conditions and the following disclaimer in the documentation
209+and/or other materials provided with the distribution.
210+
211+- Neither name of the University nor the names of its contributors may be
212+used to endorse or promote products derived from this software without
213+specific prior written permission.
214+
215+THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
216+GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
217+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
218+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
219+UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
220+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
221+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
222+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
223+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
224+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
225+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
226+DAMAGE.
227+
228+-------------------------------------------------------------------------------
229+transient-0.5.5 (http://hackage.haskell.org/package/transient-0.5.5)
230+-------------------------------------------------------------------------------
231+Copyright © 2014-2016 Alberto G. Corona <https://github.com/agocorona>
232+
233+Permission is hereby granted, free of charge, to any person obtaining a copy of
234+this software and associated documentation files (the "Software"), to deal in
235+the Software without restriction, including without limitation the rights to
236+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
237+the Software, and to permit persons to whom the Software is furnished to do so,
238+subject to the following conditions:
239+
240+The above copyright notice and this permission notice shall be included in all
241+copies or substantial portions of the Software.
242+
243+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
244+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
245+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
246+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
247+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
248+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
249+
250+-------------------------------------------------------------------------------
251+vector-0.12.0.2 (http://hackage.haskell.org/package/vector-0.12.0.2)
252+-------------------------------------------------------------------------------
253+Copyright (c) 2008-2012, Roman Leshchinskiy
254+All rights reserved.
255+
256+Redistribution and use in source and binary forms, with or without
257+modification, are permitted provided that the following conditions are met:
258+
259+- Redistributions of source code must retain the above copyright notice,
260+this list of conditions and the following disclaimer.
261+
262+- Redistributions in binary form must reproduce the above copyright notice,
263+this list of conditions and the following disclaimer in the documentation
264+and/or other materials provided with the distribution.
265+
266+- Neither name of the University nor the names of its contributors may be
267+used to endorse or promote products derived from this software without
268+specific prior written permission.
269+
270+THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF
271+GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
272+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
273+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
274+UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE
275+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
276+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
277+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
278+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
279+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
280+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
281+DAMAGE.
282+
283+-------------------------------------------------------------------------------
284+th-utilities-0.2.5.0 (https://hackage.haskell.org/package/th-utilities)
285+-------------------------------------------------------------------------------
286+Copyright (c) 2016 FP Complete Corporation.
287+
288+Permission is hereby granted, free of charge, to any person obtaining
289+a copy of this software and associated documentation files (the
290+"Software"), to deal in the Software without restriction, including
291+without limitation the rights to use, copy, modify, merge, publish,
292+distribute, sublicense, and/or sell copies of the Software, and to
293+permit persons to whom the Software is furnished to do so, subject to
294+the following conditions:
295+
296+The above copyright notice and this permission notice shall be
297+included in all copies or substantial portions of the Software.
298+
299+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
300+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
301+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
302+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
303+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
304+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
305+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
306+
307+-------------------------------------------------------------------------------
308+th-abstraction-0.5.0.0 (https://hackage.haskell.org/package/th-abstraction)
309+-------------------------------------------------------------------------------
310+Copyright (c) 2017-2020 Eric Mertens
311+
312+Permission to use, copy, modify, and/or distribute this software for any purpose
313+with or without fee is hereby granted, provided that the above copyright notice
314+and this permission notice appear in all copies.
315+
316+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
317+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
318+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
319+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
320+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
321+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
322+THIS SOFTWARE.
core/configure+9−9
@@ -1,6 +1,6 @@
11#! /bin/sh
22# Guess values for system-dependent variables and create Makefiles.
3−# Generated by GNU Autoconf 2.71 for streamly-core 0.8.2.
3+# Generated by GNU Autoconf 2.71 for streamly-core 0.2.2.
44#
55# Report bugs to <streamly@composewell.com>.
66#
@@ -610,8 +610,8 @@ MAKEFLAGS=
610610# Identity of this package.
611611PACKAGE_NAME='streamly-core'
612612PACKAGE_TARNAME='streamly-core'
613−PACKAGE_VERSION='0.8.2'
614−PACKAGE_STRING='streamly-core 0.8.2'
613+PACKAGE_VERSION='0.2.2'
614+PACKAGE_STRING='streamly-core 0.2.2'
615615PACKAGE_BUGREPORT='streamly@composewell.com'
616616PACKAGE_URL='https://streamly.composewell.com'
617617
@@ -1256,7 +1256,7 @@ if test "$ac_init_help" = "long"; then
12561256 # Omit some internal or obsolete options to make the list less imposing.
12571257 # This message is too long to be a string in the A/UX 3.1 sh.
12581258 cat <<_ACEOF
1259−\`configure' configures streamly-core 0.8.2 to adapt to many kinds of systems.
1259+\`configure' configures streamly-core 0.2.2 to adapt to many kinds of systems.
12601260
12611261Usage: $0 [OPTION]... [VAR=VALUE]...
12621262
@@ -1318,7 +1318,7 @@ fi
13181318
13191319if test -n "$ac_init_help"; then
13201320 case $ac_init_help in
1321− short | recursive ) echo "Configuration of streamly-core 0.8.2:";;
1321+ short | recursive ) echo "Configuration of streamly-core 0.2.2:";;
13221322 esac
13231323 cat <<\_ACEOF
13241324
@@ -1404,7 +1404,7 @@ fi
14041404test -n "$ac_init_help" && exit $ac_status
14051405if $ac_init_version; then
14061406 cat <<\_ACEOF
1407−streamly-core configure 0.8.2
1407+streamly-core configure 0.2.2
14081408generated by GNU Autoconf 2.71
14091409
14101410Copyright (C) 2021 Free Software Foundation, Inc.
@@ -1622,7 +1622,7 @@ cat >config.log <<_ACEOF
16221622This file contains any messages produced by compilers while
16231623running configure, to aid debugging if configure makes a mistake.
16241624
1625−It was created by streamly-core $as_me 0.8.2, which was
1625+It was created by streamly-core $as_me 0.2.2, which was
16261626generated by GNU Autoconf 2.71. Invocation command line was
16271627
16281628 $ $0$ac_configure_args_raw
@@ -3832,7 +3832,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
38323832# report actual input values of CONFIG_FILES etc. instead of their
38333833# values after options handling.
38343834ac_log="
3835−This file was extended by streamly-core $as_me 0.8.2, which was
3835+This file was extended by streamly-core $as_me 0.2.2, which was
38363836generated by GNU Autoconf 2.71. Invocation command line was
38373837
38383838 CONFIG_FILES = $CONFIG_FILES
@@ -3888,7 +3888,7 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\
38883888cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
38893889ac_cs_config='$ac_cs_config_escaped'
38903890ac_cs_version="\\
3891−streamly-core config.status 0.8.2
3891+streamly-core config.status 0.2.2
38923892configured by $0, generated by GNU Autoconf 2.71,
38933893 with options \\"\$ac_cs_config\\"
38943894
core/configure.ac+1−1
@@ -3,7 +3,7 @@
33# See https://www.gnu.org/software/autoconf/manual/autoconf.html for help on
44# the macros used in this file.
55
6−AC_INIT([streamly-core], [0.8.2], [streamly@composewell.com], [streamly-core], [https://streamly.composewell.com])
6+AC_INIT([streamly-core], [0.2.2], [streamly@composewell.com], [streamly-core], [https://streamly.composewell.com])
77
88# To suppress "WARNING: unrecognized options: --with-compiler"
99AC_ARG_WITH([compiler], [GHC])
core/docs/ApiChangelogs/0.1.0-0.2.0.txtnew file+1471
@@ -0,0 +1,1471 @@
1+---------------------------------
2+API Annotations
3+---------------------------------
4+
5+[A] : Added
6+[R] : Removed
7+[C] : Changed
8+[O] : Old definition
9+[N] : New definition
10+[D] : Deprecated
11+
12+---------------------------------
13+API diff
14+---------------------------------
15+
16+[C] Streamly.Unicode.Parser
17+ [A] double :: Monad m => Parser Char m Double
18+[C] Streamly.FileSystem.Handle
19+ [A] readWith :: MonadIO m => Int -> Handle -> Stream m Word8
20+ [A] readChunksWith :: MonadIO m => Int -> Handle -> Stream m (Array Word8)
21+[C] Streamly.FileSystem.Dir
22+ [C] readEither
23+ [O] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
24+ [N] readEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
25+ [C] read
26+ [O] read :: MonadIO m => FilePath -> Stream m FilePath
27+ [N] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
28+[C] Streamly.Data.Unfold
29+ [A] class Enum a => Enumerable a
30+ [A] second :: b -> Unfold m (a, b) c -> Unfold m a c
31+ [A] first :: a -> Unfold m (a, b) c -> Unfold m b c
32+ [A] enumerateFromTo :: (Enumerable a, Monad m) => Unfold m (a, a) a
33+ [A] enumerateFromThenTo :: (Enumerable a, Monad m) => Unfold m (a, a, a) a
34+ [A] enumerateFromThen :: (Enumerable a, Monad m) => Unfold m (a, a) a
35+ [A] enumerateFrom :: (Enumerable a, Monad m) => Unfold m a a
36+[C] Streamly.Data.StreamK
37+ [C] parseChunks
38+ [O] parseChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b)
39+ [N] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
40+ [C] parseBreakChunks
41+ [O] parseBreakChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
42+ [N] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
43+ [A] parseBreak :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b, StreamK m a)
44+ [A] parse :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b)
45+ [A] handle :: (MonadCatch m, Exception e) => (e -> m (StreamK m a)) -> StreamK m a -> StreamK m a
46+ [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> StreamK m a) -> StreamK m a
47+[C] Streamly.Data.Stream
48+ [A] wordsBy :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
49+ [A] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
50+ [C] handle
51+ [O] handle :: (MonadCatch m, Exception e) => (e -> Stream m a) -> Stream m a -> Stream m a
52+ [N] handle :: (MonadCatch m, Exception e) => (e -> m (Stream m a)) -> Stream m a -> Stream m a
53+ [A] groupsOf :: Monad m => Int -> Fold m a b -> Stream m a -> Stream m b
54+[C] Streamly.Data.ParserK
55+ [D] fromParser :: (MonadIO m, Unbox a) => Parser a m b -> ParserK (Array a) m b
56+ [D] fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK (Array a) m b
57+ [A] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b
58+ [A] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
59+ [A] adapt :: Monad m => Parser a m b -> ParserK a m b
60+[C] Streamly.Data.Parser
61+ [A] groupByRollingEither :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (Either b c)
62+ [A] groupByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
63+[A] Streamly.Data.MutByteArray
64+ [A] class Unbox a
65+ [A] class Serialize a
66+ [A] SerializeConfig
67+ [A] MutByteArray
68+ [A] unpin :: MutByteArray -> IO MutByteArray
69+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
70+ [A] serializeAt :: Serialize a => Int -> MutByteArray -> a -> IO Int
71+ [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO ()
72+ [A] pinnedNew :: Int -> IO MutByteArray
73+ [A] pin :: MutByteArray -> IO MutByteArray
74+ [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a
75+ [A] new :: Int -> IO MutByteArray
76+ [A] isPinned :: MutByteArray -> Bool
77+ [A] inlineSerializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig
78+ [A] inlineDeserializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig
79+ [A] inlineAddSizeTo :: Maybe Inline -> SerializeConfig -> SerializeConfig
80+ [A] deserializeAt :: Serialize a => Int -> MutByteArray -> Int -> IO (Int, a)
81+ [A] deriveUnbox :: Q [Dec] -> Q [Dec]
82+ [A] deriveSerializeWith :: (SerializeConfig -> SerializeConfig) -> Q [Dec] -> Q [Dec]
83+ [A] deriveSerialize :: Q [Dec] -> Q [Dec]
84+ [A] addSizeTo :: Serialize a => Int -> a -> Int
85+[C] Streamly.Data.MutArray.Generic
86+ [A] write :: MonadIO m => Fold m a (MutArray a)
87+ [A] readRev :: MonadIO m => MutArray a -> Stream m a
88+ [A] read :: MonadIO m => MutArray a -> Stream m a
89+ [A] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
90+ [A] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
91+ [A] length :: MutArray a -> Int
92+ [A] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a
93+ [C] getIndex
94+ [O] getIndex :: MonadIO m => Int -> MutArray a -> m a
95+ [N] getIndex :: MonadIO m => Int -> MutArray a -> m (Maybe a)
96+ [A] fromListN :: MonadIO m => Int -> [a] -> m (MutArray a)
97+ [A] fromList :: MonadIO m => [a] -> m (MutArray a)
98+[C] Streamly.Data.MutArray
99+ [A] unpin :: MutArray a -> IO (MutArray a)
100+ [A] readRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a
101+ [A] read :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a
102+ [A] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
103+ [D] pokeByteIndex :: Unbox a => Int -> MutByteArray -> a -> IO ()
104+ [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO ()
105+ [A] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
106+ [A] pin :: MutArray a -> IO (MutArray a)
107+ [D] peekByteIndex :: Unbox a => Int -> MutByteArray -> IO a
108+ [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a
109+ [D] newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
110+ [A] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
111+ [A] modifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
112+ [A] modify :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (a -> a) -> m ()
113+ [A] isPinned :: MutArray a -> Bool
114+ [A] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
115+ [C] getIndex
116+ [O] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
117+ [N] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (Maybe a)
118+[C] Streamly.Data.Array.Generic
119+ [A] toList :: Array a -> [a]
120+ [A] getIndex :: Int -> Array a -> Maybe a
121+[C] Streamly.Data.Array
122+ [A] unpin :: Array a -> IO (Array a)
123+ [D] pokeByteIndex :: Unbox a => Int -> MutByteArray -> a -> IO ()
124+ [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO ()
125+ [A] pin :: Array a -> IO (Array a)
126+ [D] peekByteIndex :: Unbox a => Int -> MutByteArray -> IO a
127+ [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a
128+ [A] isPinned :: Array a -> Bool
129+[C] Streamly.Console.Stdio
130+
131+---------------------------------
132+Internal API diff
133+---------------------------------
134+
135+[C] Streamly.Internal.Unicode.Stream
136+ [C] writeCharUtf8'
137+ [O] writeCharUtf8' :: Monad m => Fold m Word8 Char
138+ [N] writeCharUtf8' :: Monad m => Parser Word8 m Char
139+[C] Streamly.Internal.Unicode.Parser
140+ [A] number :: Monad m => Parser Char m (Integer, Int)
141+ [A] mkDouble :: Integer -> Int -> Double
142+ [A] doubleParser :: Monad m => Parser Char m (Int, Int)
143+ [C] double
144+ [O] double :: Parser Char m Double
145+ [N] double :: Monad m => Parser Char m Double
146+[R] Streamly.Internal.Serialize.ToBytes
147+[R] Streamly.Internal.Serialize.FromBytes
148+[C] Streamly.Internal.FileSystem.File
149+ [A] writeAppendWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m Word8 -> m ()
150+ [A] writeAppendChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
151+ [A] writeAppendArray :: FilePath -> Array a -> IO ()
152+ [A] writeAppend :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8 -> m ()
153+ [R] appendWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m Word8 -> m ()
154+ [R] appendChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
155+ [R] appendArray :: FilePath -> Array a -> IO ()
156+ [R] append :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8 -> m ()
157+[C] Streamly.Internal.FileSystem.Dir
158+ [C] reader
159+ [O] reader :: MonadIO m => Unfold m FilePath FilePath
160+ [N] reader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
161+ [C] readFiles
162+ [O] readFiles :: MonadIO m => FilePath -> Stream m FilePath
163+ [N] readFiles :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
164+ [C] readEitherPaths
165+ [O] readEitherPaths :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
166+ [N] readEitherPaths :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
167+ [C] readEither
168+ [O] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
169+ [N] readEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath)
170+ [C] readDirs
171+ [O] readDirs :: MonadIO m => FilePath -> Stream m FilePath
172+ [N] readDirs :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
173+ [C] read
174+ [O] read :: MonadIO m => FilePath -> Stream m FilePath
175+ [N] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath
176+ [C] fileReader
177+ [O] fileReader :: MonadIO m => Unfold m FilePath FilePath
178+ [N] fileReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
179+ [C] eitherReaderPaths
180+ [O] eitherReaderPaths :: MonadIO m => Unfold m FilePath (Either FilePath FilePath)
181+ [N] eitherReaderPaths :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
182+ [C] eitherReader
183+ [O] eitherReader :: MonadIO m => Unfold m FilePath (Either FilePath FilePath)
184+ [N] eitherReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
185+ [C] dirReader
186+ [O] dirReader :: MonadIO m => Unfold m FilePath FilePath
187+ [N] dirReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
188+[R] Streamly.Internal.Data.Unfold.Type
189+[R] Streamly.Internal.Data.Unfold.Enumeration
190+[C] Streamly.Internal.Data.Unfold
191+ [C] Unfold
192+ [A] Unfold :: (s -> m (Step s b)) -> (a -> m s) -> Unfold m a b
193+ [A] takeWhileMWithInput :: Monad m => (a -> b -> m Bool) -> Unfold m a b -> Unfold m a b
194+ [A] manyInterleave :: Monad m => Unfold m a b -> Unfold m c a -> Unfold m c b
195+ [A] enumerateFromStepIntegral :: (Monad m, Integral a) => Unfold m (a, a) a
196+ [A] crossApplySnd :: Unfold m a b -> Unfold m a c -> Unfold m a c
197+ [A] crossApplyFst :: Unfold m a b -> Unfold m a c -> Unfold m a b
198+ [A] concatMap :: Monad m => (b -> Unfold m a c) -> Unfold m a b -> Unfold m a c
199+[R] Streamly.Internal.Data.Unboxed
200+[C] Streamly.Internal.Data.Time.Units
201+ [R] Streamly.Internal.Data.Unboxed.Unbox
202+ [A] Streamly.Internal.Data.Unbox.Unbox
203+ [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.NanoSecond64
204+ [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.MilliSecond64
205+ [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.MicroSecond64
206+[R] Streamly.Internal.Data.Time.Clock.Type
207+[A] Streamly.Internal.Data.StreamK
208+ [A] CrossStreamK
209+ [A] (FixityR,6)
210+ [A] (FixityR,6)
211+ [A] (FixityR,6)
212+ [A] (FixityR,5)
213+ [A] (FixityR,5)
214+ [A] (FixityR,6)
215+ [A] (FixityR,5)
216+ [A] StreamK
217+ [A] MkStream :: (forall r. State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a
218+ [A] zipWithM :: Monad m => (a -> b -> m c) -> StreamK m a -> StreamK m b -> StreamK m c
219+ [A] zipWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
220+ [A] unfoldrMWith :: Monad m => (m a -> StreamK m a -> StreamK m a) -> (b -> m (Maybe (a, b))) -> b -> StreamK m a
221+ [A] unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> StreamK m a
222+ [A] unfoldr :: (b -> Maybe (a, b)) -> b -> StreamK m a
223+ [A] uncons :: Applicative m => StreamK m a -> m (Maybe (a, StreamK m a))
224+ [A] unShare :: StreamK m a -> StreamK m a
225+ [A] unCross :: CrossStreamK m a -> StreamK m a
226+ [A] toStream :: Applicative m => StreamK m a -> Stream m a
227+ [A] toList :: Monad m => StreamK m a -> m [a]
228+ [A] the :: (Eq a, Monad m) => StreamK m a -> m (Maybe a)
229+ [A] takeWhile :: (a -> Bool) -> StreamK m a -> StreamK m a
230+ [A] take :: Int -> StreamK m a -> StreamK m a
231+ [A] tail :: Applicative m => StreamK m a -> m (Maybe (StreamK m a))
232+ [A] sortBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> StreamK m a
233+ [A] sequence :: Monad m => StreamK m (m a) -> StreamK m a
234+ [A] scanlx' :: (x -> a -> x) -> x -> (x -> b) -> StreamK m a -> StreamK m b
235+ [A] scanl' :: (b -> a -> b) -> b -> StreamK m a -> StreamK m b
236+ [A] reverse :: StreamK m a -> StreamK m a
237+ [A] replicateMWith :: (m a -> StreamK m a -> StreamK m a) -> Int -> m a -> StreamK m a
238+ [A] replicateM :: Monad m => Int -> m a -> StreamK m a
239+ [A] replicate :: Int -> a -> StreamK m a
240+ [A] repeatMWith :: (m a -> t m a -> t m a) -> m a -> t m a
241+ [A] repeatM :: Monad m => m a -> StreamK m a
242+ [A] repeat :: a -> StreamK m a
243+ [A] parseDBreak :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b, StreamK m a)
244+ [A] parseD :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b)
245+ [A] parseChunksGeneric :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
246+ [A] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
247+ [A] parseBreakChunksGeneric :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
248+ [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
249+ [A] parseBreak :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b, StreamK m a)
250+ [A] parse :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b)
251+ [A] null :: Monad m => StreamK m a -> m Bool
252+ [A] notElem :: (Monad m, Eq a) => a -> StreamK m a -> m Bool
253+ [A] nilM :: Applicative m => m b -> StreamK m a
254+ [A] nil :: StreamK m a
255+ [A] mkStream :: (forall r. State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a
256+ [A] mkCross :: StreamK m a -> CrossStreamK m a
257+ [A] minimumBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> m (Maybe a)
258+ [A] minimum :: (Monad m, Ord a) => StreamK m a -> m (Maybe a)
259+ [A] mfix :: Monad m => (m a -> StreamK m a) -> StreamK m a
260+ [A] mergeMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
261+ [A] mergeIterateWith :: (StreamK m a -> StreamK m a -> StreamK m a) -> (a -> StreamK m a) -> StreamK m a -> StreamK m a
262+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
263+ [A] mergeBy :: (a -> a -> Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
264+ [A] maximumBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> m (Maybe a)
265+ [A] maximum :: (Monad m, Ord a) => StreamK m a -> m (Maybe a)
266+ [A] mapMaybe :: (a -> Maybe b) -> StreamK m a -> StreamK m b
267+ [A] mapM_ :: Monad m => (a -> m b) -> StreamK m a -> m ()
268+ [A] mapMWith :: (m b -> StreamK m b -> StreamK m b) -> (a -> m b) -> StreamK m a -> StreamK m b
269+ [A] mapMSerial :: Monad m => (a -> m b) -> StreamK m a -> StreamK m b
270+ [A] mapM :: Monad m => (a -> m b) -> StreamK m a -> StreamK m b
271+ [A] map :: (a -> b) -> StreamK m a -> StreamK m b
272+ [A] lookup :: (Monad m, Eq a) => a -> StreamK m (a, b) -> m (Maybe b)
273+ [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => StreamK m a -> StreamK (t m) a
274+ [A] last :: Monad m => StreamK m a -> m (Maybe a)
275+ [A] iterateMWith :: Monad m => (m a -> StreamK m a -> StreamK m a) -> (a -> m a) -> m a -> StreamK m a
276+ [A] iterateM :: Monad m => (a -> m a) -> m a -> StreamK m a
277+ [A] iterate :: (a -> a) -> a -> StreamK m a
278+ [A] intersperseM :: Monad m => m a -> StreamK m a -> StreamK m a
279+ [A] intersperse :: Monad m => a -> StreamK m a -> StreamK m a
280+ [A] interleaveMin :: StreamK m a -> StreamK m a -> StreamK m a
281+ [A] interleaveFst :: StreamK m a -> StreamK m a -> StreamK m a
282+ [A] interleave :: StreamK m a -> StreamK m a -> StreamK m a
283+ [A] insertBy :: (a -> a -> Ordering) -> a -> StreamK m a -> StreamK m a
284+ [A] init :: Applicative m => StreamK m a -> m (Maybe (StreamK m a))
285+ [A] hoist :: (Monad m, Monad n) => (forall x. m x -> n x) -> StreamK m a -> StreamK n a
286+ [A] head :: Monad m => StreamK m a -> m (Maybe a)
287+ [A] handle :: (MonadCatch m, Exception e) => (e -> m (StreamK m a)) -> StreamK m a -> StreamK m a
288+ [A] fromYieldK :: YieldK m a -> StreamK m a
289+ [A] fromStream :: Monad m => Stream m a -> StreamK m a
290+ [A] fromStopK :: StopK m -> StreamK m a
291+ [A] fromPure :: a -> StreamK m a
292+ [A] fromList :: [a] -> StreamK m a
293+ [A] fromIndicesMWith :: (m a -> StreamK m a -> StreamK m a) -> (Int -> m a) -> StreamK m a
294+ [A] fromIndicesM :: Monad m => (Int -> m a) -> StreamK m a
295+ [A] fromIndices :: (Int -> a) -> StreamK m a
296+ [A] fromFoldableM :: (Foldable f, Monad m) => f (m a) -> StreamK m a
297+ [A] fromFoldable :: Foldable f => f a -> StreamK m a
298+ [A] fromEffect :: Monad m => m a -> StreamK m a
299+ [A] foldrT :: (Monad m, Monad (s m), MonadTrans s) => (a -> s m b -> s m b) -> s m b -> StreamK m a -> s m b
300+ [A] foldrSShared :: (a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b
301+ [A] foldrSM :: Monad m => (m a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b
302+ [A] foldrS :: (a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b
303+ [A] foldrM :: (a -> m b -> m b) -> m b -> StreamK m a -> m b
304+ [A] foldr1 :: Monad m => (a -> a -> a) -> StreamK m a -> m (Maybe a)
305+ [A] foldr :: Monad m => (a -> b -> b) -> b -> StreamK m a -> m b
306+ [A] foldlx' :: forall m a b x. Monad m => (x -> a -> x) -> x -> (x -> b) -> StreamK m a -> m b
307+ [A] foldlT :: (Monad m, Monad (s m), MonadTrans s) => (s m b -> a -> s m b) -> s m b -> StreamK m a -> s m b
308+ [A] foldlS :: (StreamK m b -> a -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b
309+ [A] foldlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> StreamK m a -> m b
310+ [A] foldlM' :: Monad m => (b -> a -> m b) -> m b -> StreamK m a -> m b
311+ [A] foldl' :: Monad m => (b -> a -> b) -> b -> StreamK m a -> m b
312+ [A] foldStreamShared :: State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> StreamK m a -> m r
313+ [A] foldStream :: State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> StreamK m a -> m r
314+ [A] foldEither :: Monad m => Fold m a b -> StreamK m a -> m (Either (Fold m a b) (b, StreamK m a))
315+ [A] foldConcat :: Monad m => Producer m a b -> Fold m b c -> StreamK m a -> m (c, StreamK m a)
316+ [A] foldBreak :: Monad m => Fold m a b -> StreamK m a -> m (b, StreamK m a)
317+ [A] fold :: Monad m => Fold m a b -> StreamK m a -> m b
318+ [A] findM :: Monad m => (a -> m Bool) -> StreamK m a -> m (Maybe a)
319+ [A] findIndices :: (a -> Bool) -> StreamK m a -> StreamK m Int
320+ [A] find :: Monad m => (a -> Bool) -> StreamK m a -> m (Maybe a)
321+ [A] filter :: (a -> Bool) -> StreamK m a -> StreamK m a
322+ [A] evalStateT :: Monad m => m s -> StreamK (StateT s m) a -> StreamK m a
323+ [A] elem :: (Monad m, Eq a) => a -> StreamK m a -> m Bool
324+ [A] dropWhile :: (a -> Bool) -> StreamK m a -> StreamK m a
325+ [A] drop :: Int -> StreamK m a -> StreamK m a
326+ [A] drain :: Monad m => StreamK m a -> m ()
327+ [A] deleteBy :: (a -> a -> Bool) -> a -> StreamK m a -> StreamK m a
328+ [A] crossWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
329+ [A] crossApplyWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m (a -> b) -> StreamK m a -> StreamK m b
330+ [A] crossApplySnd :: StreamK m a -> StreamK m b -> StreamK m b
331+ [A] crossApplyFst :: StreamK m a -> StreamK m b -> StreamK m a
332+ [A] crossApply :: StreamK m (a -> b) -> StreamK m a -> StreamK m b
333+ [A] cross :: Monad m => StreamK m a -> StreamK m b -> StreamK m (a, b)
334+ [A] consMBy :: Monad m => (StreamK m a -> StreamK m a -> StreamK m a) -> m a -> StreamK m a -> StreamK m a
335+ [A] consM :: Monad m => m a -> StreamK m a -> StreamK m a
336+ [A] consK :: YieldK m a -> StreamK m a -> StreamK m a
337+ [A] cons :: a -> StreamK m a -> StreamK m a
338+ [A] conjoin :: Monad m => StreamK m a -> StreamK m a -> StreamK m a
339+ [A] concatMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
340+ [A] concatMapEffect :: Monad m => (b -> StreamK m a) -> m b -> StreamK m a
341+ [A] concatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
342+ [A] concatIterateWith :: (StreamK m a -> StreamK m a -> StreamK m a) -> (a -> StreamK m a) -> StreamK m a -> StreamK m a
343+ [A] concatIterateScanWith :: Monad m => (StreamK m a -> StreamK m a -> StreamK m a) -> (b -> a -> m (b, StreamK m a)) -> m b -> StreamK m a -> StreamK m a
344+ [A] concatIterateLeftsWith :: b ~ Either a c => (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m b -> StreamK m b
345+ [A] concatEffect :: Monad m => m (StreamK m a) -> StreamK m a
346+ [A] buildSM :: Monad m => ((m a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a
347+ [A] buildS :: ((a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a
348+ [A] buildM :: Monad m => (forall r. (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a
349+ [A] build :: forall m a. (forall b. (a -> b -> b) -> b -> b) -> StreamK m a
350+ [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> StreamK m a) -> StreamK m a
351+ [A] bindWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m a -> (a -> StreamK m b) -> StreamK m b
352+ [A] before :: Monad m => m b -> StreamK m a -> StreamK m a
353+ [A] augmentSM :: Monad m => ((m a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a
354+ [A] augmentS :: ((a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a
355+ [A] append :: StreamK m a -> StreamK m a -> StreamK m a
356+ [A] any :: Monad m => (a -> Bool) -> StreamK m a -> m Bool
357+ [A] all :: Monad m => (a -> Bool) -> StreamK m a -> m Bool
358+ [A] (.:) :: a -> StreamK m a -> StreamK m a
359+ [A] (!!) :: Monad m => StreamK m a -> Int -> m (Maybe a)
360+[R] Streamly.Internal.Data.Stream.StreamK.Type
361+[R] Streamly.Internal.Data.Stream.StreamK.Transformer
362+[R] Streamly.Internal.Data.Stream.StreamK
363+[R] Streamly.Internal.Data.Stream.StreamD.Type
364+[R] Streamly.Internal.Data.Stream.StreamD.Transformer
365+[R] Streamly.Internal.Data.Stream.StreamD.Transform
366+[R] Streamly.Internal.Data.Stream.StreamD.Top
367+[R] Streamly.Internal.Data.Stream.StreamD.Step
368+[R] Streamly.Internal.Data.Stream.StreamD.Nesting
369+[R] Streamly.Internal.Data.Stream.StreamD.Lift
370+[R] Streamly.Internal.Data.Stream.StreamD.Generate
371+[R] Streamly.Internal.Data.Stream.StreamD.Exception
372+[R] Streamly.Internal.Data.Stream.StreamD.Eliminate
373+[R] Streamly.Internal.Data.Stream.StreamD.Container
374+[D] Streamly.Internal.Data.Stream.StreamD
375+[R] Streamly.Internal.Data.Stream.Common
376+[R] Streamly.Internal.Data.Stream.Chunked
377+[C] Streamly.Internal.Data.Stream
378+ [A] class Enum a => Enumerable a
379+ [A] Stream
380+ [A] UnStream :: (State StreamK m a -> s -> m (Step s a)) -> s -> Stream m a
381+ [A] Step
382+ [A] Yield :: a -> s -> Step s a
383+ [A] Stop :: Step s a
384+ [A] Skip :: s -> Step s a
385+ [A] InterleaveState
386+ [A] InterleaveSecondOnly :: s2 -> InterleaveState s1 s2
387+ [A] InterleaveSecond :: s1 -> s2 -> InterleaveState s1 s2
388+ [A] InterleaveFirstOnly :: s1 -> InterleaveState s1 s2
389+ [A] InterleaveFirst :: s1 -> s2 -> InterleaveState s1 s2
390+ [A] FoldManyPost
391+ [A] FoldManyPostYield :: b -> FoldManyPost s fs b a -> FoldManyPost s fs b a
392+ [A] FoldManyPostStart :: s -> FoldManyPost s fs b a
393+ [A] FoldManyPostLoop :: s -> fs -> FoldManyPost s fs b a
394+ [A] FoldManyPostDone :: FoldManyPost s fs b a
395+ [A] FoldMany
396+ [A] FoldManyYield :: b -> FoldMany s fs b a -> FoldMany s fs b a
397+ [A] FoldManyStart :: s -> FoldMany s fs b a
398+ [A] FoldManyLoop :: s -> fs -> FoldMany s fs b a
399+ [A] FoldManyFirst :: fs -> s -> FoldMany s fs b a
400+ [A] FoldManyDone :: FoldMany s fs b a
401+ [A] CrossStream
402+ [A] ConcatUnfoldInterleaveState
403+ [A] ConcatUnfoldInterleaveOuter :: o -> [i] -> ConcatUnfoldInterleaveState o i
404+ [A] ConcatUnfoldInterleaveInnerR :: [i] -> [i] -> ConcatUnfoldInterleaveState o i
405+ [A] ConcatUnfoldInterleaveInnerL :: [i] -> [i] -> ConcatUnfoldInterleaveState o i
406+ [A] ConcatUnfoldInterleaveInner :: o -> [i] -> ConcatUnfoldInterleaveState o i
407+ [A] ConcatMapUState
408+ [A] ConcatMapUOuter :: o -> ConcatMapUState o i
409+ [A] ConcatMapUInner :: o -> i -> ConcatMapUState o i
410+ [A] AppendState
411+ [A] AppendSecond :: s2 -> AppendState s1 s2
412+ [A] AppendFirst :: s1 -> AppendState s1 s2
413+ [A] pattern Stream :: (State StreamK m a -> s -> m (Step s a)) -> s -> Stream m a
414+ [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
415+ [A] zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
416+ [A] wordsBy :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
417+ [A] with :: Monad m => (Stream m a -> Stream m (s, a)) -> (((s, a) -> b) -> Stream m (s, a) -> Stream m (s, a)) -> ((s, a) -> b) -> Stream m a -> Stream m a
418+ [A] usingStateT :: Monad m => m s -> (Stream (StateT s m) a -> Stream (StateT s m) a) -> Stream m a -> Stream m a
419+ [A] usingReaderT :: Monad m => m r -> (Stream (ReaderT r m) a -> Stream (ReaderT r m) a) -> Stream m a -> Stream m a
420+ [A] uniqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a
421+ [A] uniq :: (Eq a, Monad m) => Stream m a -> Stream m a
422+ [A] unionWithStreamGenericBy :: MonadIO m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
423+ [A] unionWithStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
424+ [A] unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
425+ [A] unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
426+ [A] unfoldRoundRobin :: Monad m => Unfold m a b -> Stream m a -> Stream m b
427+ [A] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
428+ [A] unfoldIterateDfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a
429+ [A] unfoldIterateBfsRev :: Monad m => Unfold m a a -> Stream m a -> Stream m a
430+ [A] unfoldIterateBfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a
431+ [A] unfoldInterleave :: Monad m => Unfold m a b -> Stream m a -> Stream m b
432+ [A] unfold :: Applicative m => Unfold m a b -> a -> Stream m b
433+ [A] uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a))
434+ [A] unCross :: CrossStream m a -> Stream m a
435+ [A] transform :: Monad m => Pipe m a b -> Stream m a -> Stream m b
436+ [A] trace_ :: Monad m => m b -> Stream m a -> Stream m a
437+ [A] trace :: Monad m => (a -> m b) -> Stream m a -> Stream m a
438+ [A] toStreamK :: Monad m => Stream m a -> StreamK m a
439+ [A] toListRev :: Monad m => Stream m a -> m [a]
440+ [A] toList :: Monad m => Stream m a -> m [a]
441+ [A] timestamped :: MonadIO m => Stream m a -> Stream m (AbsTime, a)
442+ [A] timestampWith :: MonadIO m => Double -> Stream m a -> Stream m (AbsTime, a)
443+ [A] timesWith :: MonadIO m => Double -> Stream m (AbsTime, RelTime64)
444+ [A] times :: MonadIO m => Stream m (AbsTime, RelTime64)
445+ [A] timeout :: AbsTime -> t m ()
446+ [A] timeIndexed :: MonadIO m => Stream m a -> Stream m (RelTime64, a)
447+ [A] timeIndexWith :: MonadIO m => Double -> Stream m a -> Stream m (RelTime64, a)
448+ [A] the :: (Eq a, Monad m) => Stream m a -> m (Maybe a)
449+ [A] tapOffsetEvery :: Monad m => Int -> Int -> Fold m a b -> Stream m a -> Stream m a
450+ [A] tap :: Monad m => Fold m a b -> Stream m a -> Stream m a
451+ [A] takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
452+ [A] takeWhileLast :: (a -> Bool) -> Stream m a -> Stream m a
453+ [A] takeWhileAround :: (a -> Bool) -> Stream m a -> Stream m a
454+ [A] takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
455+ [A] takeEndByM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
456+ [A] takeEndBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
457+ [A] take :: Applicative m => Int -> Stream m a -> Stream m a
458+ [A] tail :: Monad m => Stream m a -> m (Maybe (Stream m a))
459+ [A] stripSuffixUnbox :: (MonadIO m, Eq a, Unbox a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
460+ [A] stripSuffix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
461+ [A] stripPrefix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
462+ [A] strideFromThen :: Monad m => Int -> Int -> Stream m a -> Stream m a
463+ [A] splitOnSuffixSeqAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
464+ [A] splitOnSuffixSeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Bool -> Array a -> Fold m a b -> Stream m a -> Stream m b
465+ [A] splitOnSeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
466+ [A] splitOnPrefix :: (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
467+ [A] splitOnAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
468+ [A] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
469+ [A] splitInnerBySuffix :: (Monad m, Eq (f a), Monoid (f a)) => (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a)
470+ [A] splitInnerBy :: Monad m => (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a)
471+ [A] slicesBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
472+ [A] sliceOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
473+ [A] sequence :: Monad m => Stream m (m a) -> Stream m a
474+ [A] scanlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> Stream m b
475+ [A] scanlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> Stream m b
476+ [A] scanlMAfter' :: Monad m => (b -> a -> m b) -> m b -> (b -> m b) -> Stream m a -> Stream m b
477+ [A] scanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b
478+ [A] scanlM :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b
479+ [A] scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
480+ [A] scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a
481+ [A] scanl1' :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a
482+ [A] scanl1 :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a
483+ [A] scanl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b
484+ [A] scanl :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b
485+ [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
486+ [A] scanMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
487+ [A] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
488+ [A] runStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m (s, a)
489+ [A] runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a
490+ [A] runInnerWithState :: Monad m => (forall b. s -> t m b -> m (b, s)) -> m s -> Stream (t m) a -> Stream m (s, a)
491+ [A] runInnerWith :: Monad m => (forall b. t m b -> m b) -> Stream (t m) a -> Stream m a
492+ [A] roundRobin :: Monad m => Stream m a -> Stream m a -> Stream m a
493+ [A] rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Stream m a -> Stream m b
494+ [A] rollingMap2 :: Monad m => (a -> a -> b) -> Stream m a -> Stream m b
495+ [A] rollingMap :: Monad m => (Maybe a -> a -> b) -> Stream m a -> Stream m b
496+ [A] reverseUnbox :: (MonadIO m, Unbox a) => Stream m a -> Stream m a
497+ [A] reverse :: Monad m => Stream m a -> Stream m a
498+ [A] replicateM :: Monad m => Int -> m a -> Stream m a
499+ [A] replicate :: Monad m => Int -> a -> Stream m a
500+ [A] repeated :: Stream m a -> Stream m a
501+ [A] repeatM :: Monad m => m a -> Stream m a
502+ [A] repeat :: Monad m => a -> Stream m a
503+ [A] relTimesWith :: MonadIO m => Double -> Stream m RelTime64
504+ [A] relTimes :: MonadIO m => Stream m RelTime64
505+ [A] refoldMany :: Monad m => Refold m x a b -> m x -> Stream m a -> Stream m b
506+ [A] refoldIterateM :: Monad m => Refold m b a b -> m b -> Stream m a -> Stream m b
507+ [A] reduceIterateBfs :: Monad m => (a -> a -> m a) -> Stream m a -> m (Maybe a)
508+ [A] reassembleBy :: Fold m a b -> (a -> a -> Int) -> Stream m a -> Stream m b
509+ [A] prune :: (a -> Bool) -> Stream m a -> Stream m a
510+ [A] prescanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b
511+ [A] prescanl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b
512+ [A] postscanlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> Stream m b
513+ [A] postscanlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> Stream m b
514+ [A] postscanlMAfter' :: Monad m => (b -> a -> m b) -> m b -> (b -> m b) -> Stream m a -> Stream m b
515+ [A] postscanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b
516+ [A] postscanlM :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b
517+ [A] postscanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
518+ [A] postscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
519+ [A] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
520+ [A] parseSequence :: Stream m (Parser a m b) -> Stream m a -> Stream m b
521+ [A] parseManyTill :: Parser a m b -> Parser a m x -> Stream m a -> Stream m b
522+ [A] parseManyD :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
523+ [A] parseMany :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
524+ [A] parseIterateD :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseError b)
525+ [A] parseIterate :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseError b)
526+ [A] parseD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
527+ [A] parseBreakD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a)
528+ [A] parseBreak :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a)
529+ [A] parse :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
530+ [A] onException :: MonadCatch m => m b -> Stream m a -> Stream m a
531+ [A] null :: Monad m => Stream m a -> m Bool
532+ [A] nub :: (Monad m, Ord a) => Stream m a -> Stream m a
533+ [A] notElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
534+ [A] nilM :: Applicative m => m b -> Stream m a
535+ [A] nil :: Applicative m => Stream m a
536+ [A] morphInner :: Monad n => (forall x. m x -> n x) -> Stream m a -> Stream n a
537+ [A] mkCross :: Stream m a -> CrossStream m a
538+ [A] minimumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a)
539+ [A] minimum :: (Monad m, Ord a) => Stream m a -> m (Maybe a)
540+ [A] mergeMinBy :: (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
541+ [A] mergeFstBy :: (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
542+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
543+ [A] mergeBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
544+ [A] maximumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a)
545+ [A] maximum :: (Monad m, Ord a) => Stream m a -> m (Maybe a)
546+ [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
547+ [A] mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
548+ [A] mapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()
549+ [A] mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
550+ [A] map :: Monad m => (a -> b) -> Stream m a -> Stream m b
551+ [A] lookup :: (Monad m, Eq a) => a -> Stream m (a, b) -> m (Maybe b)
552+ [A] liftInnerWith :: Monad (t m) => (forall b. m b -> t m b) -> Stream m a -> Stream (t m) a
553+ [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => Stream m a -> Stream (t m) a
554+ [A] last :: Monad m => Stream m a -> m (Maybe a)
555+ [A] joinOuterGeneric :: MonadIO m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
556+ [A] joinOuterAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
557+ [A] joinOuter :: (Ord k, MonadIO m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, Maybe a, Maybe b)
558+ [A] joinLeftGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
559+ [A] joinLeftAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
560+ [A] joinLeft :: (Ord k, Monad m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, Maybe b)
561+ [A] joinInnerGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, b)
562+ [A] joinInnerAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, b)
563+ [A] joinInner :: (Monad m, Ord k) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, b)
564+ [A] iterateM :: Monad m => (a -> m a) -> m a -> Stream m a
565+ [A] iterate :: Monad m => (a -> a) -> a -> Stream m a
566+ [A] isSuffixOfUnbox :: (MonadIO m, Eq a, Unbox a) => Stream m a -> Stream m a -> m Bool
567+ [A] isSuffixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
568+ [A] isSubsequenceOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
569+ [A] isPrefixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
570+ [A] isInfixOf :: (MonadIO m, Eq a, Enum a, Storable a, Unbox a) => Stream m a -> Stream m a -> m Bool
571+ [A] intersperseM_ :: Monad m => m b -> Stream m a -> Stream m a
572+ [A] intersperseMWith :: Int -> m a -> Stream m a -> Stream m a
573+ [A] intersperseMSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
574+ [A] intersperseMSuffixWith :: forall m a. Monad m => Int -> m a -> Stream m a -> Stream m a
575+ [A] intersperseMSuffix :: forall m a. Monad m => m a -> Stream m a -> Stream m a
576+ [A] intersperseMPrefix_ :: Monad m => m b -> Stream m a -> Stream m a
577+ [A] intersperseM :: Monad m => m a -> Stream m a -> Stream m a
578+ [A] intersperse :: Monad m => a -> Stream m a -> Stream m a
579+ [A] intersectBySorted :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
580+ [A] interposeSuffixM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
581+ [A] interposeSuffix :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
582+ [A] interposeM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
583+ [A] interpose :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
584+ [A] interleaveMin :: Monad m => Stream m a -> Stream m a -> Stream m a
585+ [A] interleaveFstSuffix :: Monad m => Stream m a -> Stream m a -> Stream m a
586+ [A] interleaveFst :: Monad m => Stream m a -> Stream m a -> Stream m a
587+ [A] interleave :: Monad m => Stream m a -> Stream m a -> Stream m a
588+ [A] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
589+ [A] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
590+ [A] insertBy :: Monad m => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a
591+ [A] indexedR :: Monad m => Int -> Stream m a -> Stream m (Int, a)
592+ [A] indexed :: Monad m => Stream m a -> Stream m (Int, a)
593+ [A] headElse :: Monad m => a -> Stream m a -> m a
594+ [A] head :: Monad m => Stream m a -> m (Maybe a)
595+ [A] handle :: (MonadCatch m, Exception e) => (e -> m (Stream m a)) -> Stream m a -> Stream m a
596+ [A] groupsWhile :: Monad m => (a -> a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
597+ [A] groupsRollingBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
598+ [A] groupsOf :: Monad m => Int -> Fold m a b -> Stream m a -> Stream m b
599+ [A] gintercalateSuffix :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c
600+ [A] gintercalate :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c
601+ [A] ghandle :: (MonadCatch m, Exception e) => (e -> Stream m a -> m (Stream m a)) -> Stream m a -> Stream m a
602+ [A] generateM :: Monad m => Int -> (Int -> m a) -> Stream m a
603+ [A] generate :: Monad m => Int -> (Int -> a) -> Stream m a
604+ [A] generalizeInner :: Monad m => Stream Identity a -> Stream m a
605+ [A] gbracket_ :: Monad m => m c -> (c -> m d) -> (c -> e -> Stream m b -> m (Stream m b)) -> (forall s. m s -> m (Either e s)) -> (c -> Stream m b) -> Stream m b
606+ [A] gbracket :: MonadIO m => IO c -> (c -> IO d1) -> (c -> e -> Stream m b -> IO (Stream m b)) -> (c -> IO d2) -> (forall s. m s -> m (Either e s)) -> (c -> Stream m b) -> Stream m b
607+ [A] fromStreamK :: Applicative m => StreamK m a -> Stream m a
608+ [A] fromPure :: Applicative m => a -> Stream m a
609+ [A] fromPtrN :: (Monad m, Storable a) => Int -> Ptr a -> Stream m a
610+ [A] fromPtr :: forall m a. (Monad m, Storable a) => Ptr a -> Stream m a
611+ [A] fromListM :: Monad m => [m a] -> Stream m a
612+ [A] fromList :: Applicative m => [a] -> Stream m a
613+ [A] fromIndicesM :: Monad m => (Int -> m a) -> Stream m a
614+ [A] fromIndices :: Monad m => (Int -> a) -> Stream m a
615+ [A] fromFoldableM :: (Monad m, Foldable f) => f (m a) -> Stream m a
616+ [A] fromFoldable :: (Monad m, Foldable f) => f a -> Stream m a
617+ [A] fromEffect :: Applicative m => m a -> Stream m a
618+ [A] fromByteStr# :: Monad m => Addr# -> Stream m Word8
619+ [A] foldrT :: (Monad m, Monad (t m), MonadTrans t) => (a -> t m b -> t m b) -> t m b -> Stream m a -> t m b
620+ [A] foldrS :: Monad m => (a -> Stream m b -> Stream m b) -> Stream m b -> Stream m a -> Stream m b
621+ [A] foldrMx :: Monad m => (a -> m x -> m x) -> m x -> (m x -> m b) -> Stream m a -> m b
622+ [A] foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b
623+ [A] foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m (Maybe a)
624+ [A] foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
625+ [A] foldlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> m b
626+ [A] foldlT :: (Monad m, Monad (s m), MonadTrans s) => (s m b -> a -> s m b) -> s m b -> Stream m a -> s m b
627+ [A] foldlS :: Monad m => (Stream m b -> a -> Stream m b) -> Stream m b -> Stream m a -> Stream m b
628+ [A] foldlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> m b
629+ [A] foldlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> m b
630+ [A] foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b
631+ [A] foldSequence :: Stream m (Fold m a b) -> Stream m a -> Stream m b
632+ [A] foldManyPost :: Monad m => Fold m a b -> Stream m a -> Stream m b
633+ [A] foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
634+ [A] foldIterateM :: Monad m => (b -> m (Fold m a b)) -> m b -> Stream m a -> Stream m b
635+ [A] foldIterateBfs :: Fold m a (Either a a) -> Stream m a -> m (Maybe a)
636+ [A] foldEither :: Monad m => Fold m a b -> Stream m a -> m (Either (Fold m a b) (b, Stream m a))
637+ [A] foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)
638+ [A] foldAddLazy :: Monad m => Fold m a b -> Stream m a -> Fold m a b
639+ [A] foldAdd :: Monad m => Fold m a b -> Stream m a -> m (Fold m a b)
640+ [A] fold :: Monad m => Fold m a b -> Stream m a -> m b
641+ [A] findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a)
642+ [A] findIndices :: Monad m => (a -> Bool) -> Stream m a -> Stream m Int
643+ [A] find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)
644+ [A] finallyUnsafe :: MonadCatch m => m b -> Stream m a -> Stream m a
645+ [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Stream m a -> Stream m a
646+ [A] filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
647+ [A] filterInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
648+ [A] filterInStreamAscBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
649+ [A] filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
650+ [A] evalStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m a
651+ [A] eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
652+ [A] enumerateTo :: (Monad m, Bounded a, Enumerable a) => a -> Stream m a
653+ [A] enumerateFromToSmall :: (Monad m, Enum a) => a -> a -> Stream m a
654+ [A] enumerateFromToIntegral :: (Monad m, Integral a) => a -> a -> Stream m a
655+ [A] enumerateFromToFractional :: (Monad m, Fractional a, Ord a) => a -> a -> Stream m a
656+ [A] enumerateFromTo :: (Enumerable a, Monad m) => a -> a -> Stream m a
657+ [A] enumerateFromThenToSmall :: (Monad m, Enum a) => a -> a -> a -> Stream m a
658+ [A] enumerateFromThenToIntegral :: (Monad m, Integral a) => a -> a -> a -> Stream m a
659+ [A] enumerateFromThenToFractional :: (Monad m, Fractional a, Ord a) => a -> a -> a -> Stream m a
660+ [A] enumerateFromThenTo :: (Enumerable a, Monad m) => a -> a -> a -> Stream m a
661+ [A] enumerateFromThenSmallBounded :: (Monad m, Enumerable a, Bounded a) => a -> a -> Stream m a
662+ [A] enumerateFromThenNum :: (Monad m, Num a) => a -> a -> Stream m a
663+ [A] enumerateFromThenIntegral :: (Monad m, Integral a, Bounded a) => a -> a -> Stream m a
664+ [A] enumerateFromThenFractional :: (Monad m, Fractional a) => a -> a -> Stream m a
665+ [A] enumerateFromThen :: (Enumerable a, Monad m) => a -> a -> Stream m a
666+ [A] enumerateFromStepNum :: (Monad m, Num a) => a -> a -> Stream m a
667+ [A] enumerateFromStepIntegral :: (Integral a, Monad m) => a -> a -> Stream m a
668+ [A] enumerateFromNum :: (Monad m, Num a) => a -> Stream m a
669+ [A] enumerateFromIntegral :: (Monad m, Integral a, Bounded a) => a -> Stream m a
670+ [A] enumerateFromFractional :: (Monad m, Fractional a) => a -> Stream m a
671+ [A] enumerateFromBounded :: (Monad m, Enumerable a, Bounded a) => a -> Stream m a
672+ [A] enumerateFrom :: (Enumerable a, Monad m) => a -> Stream m a
673+ [A] enumerate :: (Monad m, Bounded a, Enumerable a) => Stream m a
674+ [A] elemIndices :: (Monad m, Eq a) => a -> Stream m a -> Stream m Int
675+ [A] elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool
676+ [A] durations :: Double -> t m RelTime64
677+ [A] dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
678+ [A] dropWhileLast :: (a -> Bool) -> Stream m a -> Stream m a
679+ [A] dropWhileAround :: (a -> Bool) -> Stream m a -> Stream m a
680+ [A] dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
681+ [A] dropSuffix :: Stream m a -> Stream m a -> Stream m a
682+ [A] dropPrefix :: Stream m a -> Stream m a -> Stream m a
683+ [A] dropLast :: Int -> Stream m a -> Stream m a
684+ [A] dropInfix :: Stream m a -> Stream m a -> Stream m a
685+ [A] drop :: Monad m => Int -> Stream m a -> Stream m a
686+ [A] drain :: Monad m => Stream m a -> m ()
687+ [A] deleteInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
688+ [A] deleteInStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
689+ [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Stream m a -> Stream m a
690+ [A] delayPre :: MonadIO m => Double -> Stream m a -> Stream m a
691+ [A] delayPost :: MonadIO m => Double -> Stream m a -> Stream m a
692+ [A] delay :: MonadIO m => Double -> Stream m a -> Stream m a
693+ [A] crossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
694+ [A] crossApplySnd :: Functor f => Stream f a -> Stream f b -> Stream f b
695+ [A] crossApplyFst :: Functor f => Stream f a -> Stream f b -> Stream f a
696+ [A] crossApply :: Functor f => Stream f (a -> b) -> Stream f a -> Stream f b
697+ [A] cross :: Monad m => Stream m a -> Stream m b -> Stream m (a, b)
698+ [A] consM :: Applicative m => m a -> Stream m a -> Stream m a
699+ [A] cons :: Applicative m => a -> Stream m a -> Stream m a
700+ [A] concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
701+ [A] concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
702+ [A] concatIterateScan :: Monad m => (b -> a -> m b) -> (b -> m (Maybe (b, Stream m a))) -> b -> Stream m a
703+ [A] concatIterateDfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
704+ [A] concatIterateBfsRev :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
705+ [A] concatIterateBfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
706+ [A] concatEffect :: Monad m => m (Stream m a) -> Stream m a
707+ [A] concat :: Monad m => Stream m (Stream m a) -> Stream m a
708+ [A] cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
709+ [A] catRights :: Monad m => Stream m (Either a b) -> Stream m b
710+ [A] catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a
711+ [A] catLefts :: Monad m => Stream m (Either a b) -> Stream m a
712+ [A] catEithers :: Monad m => Stream m (Either a a) -> Stream m a
713+ [A] bracketUnsafe :: MonadCatch m => m b -> (b -> m c) -> (b -> Stream m a) -> Stream m a
714+ [A] bracketIO3 :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> IO d) -> (b -> IO e) -> (b -> Stream m a) -> Stream m a
715+ [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
716+ [A] before :: Monad m => m b -> Stream m a -> Stream m a
717+ [A] append :: Monad m => Stream m a -> Stream m a -> Stream m a
718+ [A] any :: Monad m => (a -> Bool) -> Stream m a -> m Bool
719+ [A] all :: Monad m => (a -> Bool) -> Stream m a -> m Bool
720+ [A] afterUnsafe :: Monad m => m b -> Stream m a -> Stream m a
721+ [A] afterIO :: MonadIO m => IO b -> Stream m a -> Stream m a
722+ [A] absTimesWith :: MonadIO m => Double -> Stream m AbsTime
723+ [A] absTimes :: MonadIO m => Stream m AbsTime
724+ [A] (!!) :: Monad m => Stream m a -> Int -> m (Maybe a)
725+[R] Streamly.Internal.Data.Ring.Unboxed
726+[A] Streamly.Internal.Data.Ring.Generic
727+ [A] Ring
728+ [A] [ringMax] :: Ring a -> !Int
729+ [A] [ringHead] :: Ring a -> !Int
730+ [A] [ringArr] :: Ring a -> MutArray a
731+ [A] Ring :: MutArray a -> !Int -> !Int -> Ring a
732+ [A] writeLastN :: MonadIO m => Int -> Fold m a (Ring a)
733+ [A] unsafeInsertRingWith :: Ring a -> a -> IO Int
734+ [A] toStreamWith :: Int -> Ring a -> Stream m a
735+ [A] toMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a)
736+ [A] seek :: MonadIO m => Int -> Ring a -> m (Ring a)
737+ [A] createRing :: MonadIO m => Int -> m (Ring a)
738+ [A] copyToMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a)
739+[C] Streamly.Internal.Data.Ring
740+ [C] Ring
741+ [A] [ringStart] :: Ring a -> {-# UNPACK #-} !ForeignPtr a
742+ [R] [ringMax] :: Ring a -> !Int
743+ [R] [ringHead] :: Ring a -> !Int
744+ [A] [ringBound] :: Ring a -> {-# UNPACK #-} !Ptr a
745+ [R] [ringArr] :: Ring a -> MutArray a
746+ [C] Ring
747+ [O] Ring :: MutArray a -> !Int -> !Int -> Ring a
748+ [N] Ring :: {-# UNPACK #-} !ForeignPtr a -> {-# UNPACK #-} !Ptr a -> Ring a
749+ [A] GHC.Show.Show
750+ [A] instance (GHC.Show.Show a, GHC.Show.Show b, GHC.Show.Show c, GHC.Show.Show d) => GHC.Show.Show (Streamly.Internal.Data.Ring.Tuple4' a b c d)
751+ [A] writeN :: Int -> Fold m a (Ring a)
752+ [R] writeLastN :: MonadIO m => Int -> Fold m a (Ring a)
753+ [R] unsafeInsertRingWith :: Ring a -> a -> IO Int
754+ [A] unsafeInsert :: Storable a => Ring a -> Ptr a -> a -> IO (Ptr a)
755+ [A] unsafeFoldRingNM :: forall m a b. (MonadIO m, Storable a) => Int -> Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b
756+ [A] unsafeFoldRingM :: forall m a b. (MonadIO m, Storable a) => Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b
757+ [A] unsafeFoldRingFullM :: forall m a b. (MonadIO m, Storable a) => Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b
758+ [A] unsafeFoldRing :: forall a b. Storable a => Ptr a -> (b -> a -> b) -> b -> Ring a -> b
759+ [A] unsafeEqArrayN :: Ring a -> Ptr a -> Array a -> Int -> Bool
760+ [A] unsafeEqArray :: Ring a -> Ptr a -> Array a -> Bool
761+ [R] toStreamWith :: Int -> Ring a -> Stream m a
762+ [R] toMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a)
763+ [A] startOf :: Ring a -> Ptr a
764+ [A] slidingWindowWith :: forall m a b. (MonadIO m, Storable a, Unbox a) => Int -> Fold m ((a, Maybe a), m (MutArray a)) b -> Fold m a b
765+ [A] slidingWindow :: forall m a b. (MonadIO m, Storable a, Unbox a) => Int -> Fold m (a, Maybe a) b -> Fold m a b
766+ [A] slide :: Ring a -> a -> m (Ring a)
767+ [R] seek :: MonadIO m => Int -> Ring a -> m (Ring a)
768+ [A] ringsOf :: Int -> Stream m a -> Stream m (MutArray a)
769+ [A] readRev :: Unfold m (MutArray a) a
770+ [A] read :: forall m a. (MonadIO m, Storable a) => Unfold m (Ring a, Ptr a, Int) a
771+ [A] putIndex :: Ring a -> Int -> a -> m ()
772+ [A] newRing :: Int -> m (Ring a)
773+ [A] new :: forall a. Storable a => Int -> IO (Ring a, Ptr a)
774+ [A] moveBy :: forall a. Storable a => Int -> Ring a -> Ptr a -> Ptr a
775+ [A] modifyIndex :: Ring a -> Int -> (a -> (a, b)) -> m b
776+ [A] length :: Ring a -> Int
777+ [A] getIndexUnsafe :: Ring a -> Int -> m a
778+ [A] getIndexRev :: Ring a -> Int -> m a
779+ [A] getIndex :: Ring a -> Int -> m a
780+ [A] fromArray :: MutArray a -> Ring a
781+ [R] createRing :: MonadIO m => Int -> m (Ring a)
782+ [A] castUnsafe :: Ring a -> Ring b
783+ [A] cast :: forall a b. Storable b => Ring a -> Maybe (Ring b)
784+ [A] bytesFree :: Ring a -> Int
785+ [A] byteLength :: Ring a -> Int
786+ [A] byteCapacity :: Ring a -> Int
787+ [A] asBytes :: Ring a -> Ring Word8
788+ [A] advance :: forall a. Storable a => Ring a -> Ptr a -> Ptr a
789+[R] Streamly.Internal.Data.Producer.Type
790+[R] Streamly.Internal.Data.Producer.Source
791+[C] Streamly.Internal.Data.Producer
792+ [A] Source
793+ [A] unread :: [b] -> Source a b -> Source a b
794+ [A] translate :: Functor m => (a -> c) -> (c -> a) -> Producer m c b -> Producer m a b
795+ [A] source :: Maybe a -> Source a b
796+ [A] producer :: Monad m => Producer m a b -> Producer m (Source a b) b
797+ [A] parseManyD :: Monad m => Parser a m b -> Producer m (Source x a) a -> Producer m (Source x a) (Either ParseError b)
798+ [A] parseMany :: Monad m => Parser a m b -> Producer m (Source x a) a -> Producer m (Source x a) (Either ParseError b)
799+ [A] parse :: Monad m => Parser a m b -> Producer m (Source s a) a -> Source s a -> m (Either ParseError b, Source s a)
800+ [A] lmap :: (a -> a) -> Producer m a b -> Producer m a b
801+ [A] isEmpty :: Source a b -> Bool
802+[R] Streamly.Internal.Data.Pipe.Type
803+[C] Streamly.Internal.Data.Pipe
804+ [A] Step
805+ [A] Yield :: a -> s -> Step s a
806+ [A] Continue :: s -> Step s a
807+ [A] PipeState
808+ [A] Produce :: s2 -> PipeState s1 s2
809+ [A] Consume :: s1 -> PipeState s1 s2
810+ [C] Pipe
811+ [A] Pipe :: (s1 -> a -> m (Step (PipeState s1 s2) b)) -> (s2 -> m (Step (PipeState s1 s2) b)) -> s1 -> Pipe m a b
812+[A] Streamly.Internal.Data.ParserK
813+ [A] Step
814+ [A] Partial :: !Int -> (Input a -> m (Step a m r)) -> Step a m r
815+ [A] Error :: !Int -> String -> Step a m r
816+ [A] Done :: !Int -> r -> Step a m r
817+ [A] Continue :: !Int -> (Input a -> m (Step a m r)) -> Step a m r
818+ [A] ParseResult
819+ [A] Success :: !Int -> !b -> ParseResult b
820+ [A] Failure :: !Int -> !String -> ParseResult b
821+ [A] Input
822+ [A] None :: Input a
823+ [A] Chunk :: a -> Input a
824+ [A] ParserK
825+ [A] [runParser] :: ParserK a m b -> forall r. (ParseResult b -> Int -> Input a -> m (Step a m r)) -> Int -> Int -> Input a -> m (Step a m r)
826+ [A] MkParser :: (forall r. (ParseResult b -> Int -> Input a -> m (Step a m r)) -> Int -> Int -> Input a -> m (Step a m r)) -> ParserK a m b
827+ [A] fromPure :: b -> ParserK a m b
828+ [A] fromEffect :: Monad m => m b -> ParserK a m b
829+ [A] die :: String -> ParserK a m b
830+ [A] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b
831+ [A] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
832+ [A] adapt :: Monad m => Parser a m b -> ParserK a m b
833+[R] Streamly.Internal.Data.Parser.ParserK.Type
834+[R] Streamly.Internal.Data.Parser.ParserD.Type
835+[R] Streamly.Internal.Data.Parser.ParserD.Tee
836+[R] Streamly.Internal.Data.Parser.ParserD
837+[C] Streamly.Internal.Data.Parser
838+ [A] Step
839+ [A] Partial :: !Int -> !s -> Step s b
840+ [A] Error :: !String -> Step s b
841+ [A] Done :: !Int -> !b -> Step s b
842+ [A] Continue :: !Int -> !s -> Step s b
843+ [A] Parser
844+ [A] Parser :: (s -> a -> m (Step s b)) -> m (Initial s b) -> (s -> m (Step s b)) -> Parser a m b
845+ [A] Initial
846+ [A] IPartial :: !s -> Initial s b
847+ [A] IError :: !String -> Initial s b
848+ [A] IDone :: !b -> Initial s b
849+ [A] GHC.Show.Show
850+ [A] instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Streamly.Internal.Data.Parser.Tuple'Fused a b)
851+ [A] ParseError
852+ [A] ParseError :: String -> ParseError
853+ [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Fold m c x -> Parser b m x
854+ [A] zip :: Monad m => Stream m a -> Fold m (a, b) x -> Parser b m x
855+ [A] wordWithQuotes :: (Monad m, Eq a) => Bool -> (a -> a -> Maybe a) -> a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b
856+ [A] wordProcessQuotes :: (Monad m, Eq a) => a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b
857+ [A] wordKeepQuotes :: (Monad m, Eq a) => a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b
858+ [A] wordFramedBy :: Monad m => (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b
859+ [A] wordBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
860+ [A] toFold :: Monad m => Parser a m b -> Fold m a b
861+ [A] takeWhileP :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
862+ [A] takeWhile1 :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
863+ [A] takeWhile :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
864+ [A] takeStartBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
865+ [A] takeStartBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
866+ [A] takeP :: Monad m => Int -> Parser a m b -> Parser a m b
867+ [A] takeGE :: Monad m => Int -> Fold m a b -> Parser a m b
868+ [A] takeFramedBy_ :: Monad m => (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b
869+ [A] takeFramedByGeneric :: Monad m => Maybe (a -> Bool) -> Maybe (a -> Bool) -> Maybe (a -> Bool) -> Fold m a b -> Parser a m b
870+ [A] takeFramedByEsc_ :: Monad m => (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b
871+ [A] takeEndBy_ :: (a -> Bool) -> Parser a m b -> Parser a m b
872+ [A] takeEndByEsc :: Monad m => (a -> Bool) -> (a -> Bool) -> Parser a m b -> Parser a m b
873+ [A] takeEndBy :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
874+ [A] takeEitherSepBy :: (a -> Bool) -> Fold m (Either a b) c -> Parser a m c
875+ [A] takeEQ :: Monad m => Int -> Fold m a b -> Parser a m b
876+ [A] takeBetween :: Monad m => Int -> Int -> Fold m a b -> Parser a m b
877+ [A] subsequenceBy :: (a -> a -> Bool) -> Stream m a -> Parser a m ()
878+ [A] streamEqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Parser a m ()
879+ [A] split_ :: Monad m => Parser x m a -> Parser x m b -> Parser x m b
880+ [A] splitWith :: Monad m => (a -> b -> c) -> Parser x m a -> Parser x m b -> Parser x m c
881+ [A] splitSome :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
882+ [A] splitManyPost :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
883+ [A] splitMany :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
884+ [A] spanByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c)
885+ [A] spanBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c)
886+ [A] span :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c)
887+ [A] some :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
888+ [A] sequence :: Monad m => Stream m (Parser a m b) -> Fold m b c -> Parser a m c
889+ [A] sepByAll :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
890+ [A] sepBy1 :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
891+ [A] sepBy :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
892+ [A] satisfy :: Monad m => (a -> Bool) -> Parser a m a
893+ [A] sampleFromthen :: Monad m => Int -> Int -> Fold m a b -> Parser a m b
894+ [A] roundRobin :: t (Parser a m b) -> Fold m b c -> Parser a m c
895+ [A] rmapM :: Monad m => (b -> m c) -> Parser a m b -> Parser a m c
896+ [A] retryMaxTotal :: Int -> Parser a m b -> Fold m b c -> Parser a m c
897+ [A] retryMaxSuccessive :: Int -> Parser a m b -> Fold m b c -> Parser a m c
898+ [A] retry :: Parser a m b -> Parser a m b
899+ [A] postscan :: Fold m a b -> Parser b m c -> Parser a m c
900+ [A] peek :: Monad m => Parser a m a
901+ [A] oneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
902+ [A] oneNotEq :: (Monad m, Eq a) => a -> Parser a m a
903+ [A] oneEq :: (Monad m, Eq a) => a -> Parser a m a
904+ [A] one :: Monad m => Parser a m a
905+ [A] noneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
906+ [A] noErrorUnsafeSplit_ :: Monad m => Parser x m a -> Parser x m b -> Parser x m b
907+ [A] noErrorUnsafeSplitWith :: Monad m => (a -> b -> c) -> Parser x m a -> Parser x m b -> Parser x m c
908+ [A] noErrorUnsafeConcatMap :: Monad m => (b -> Parser a m c) -> Parser a m b -> Parser a m c
909+ [A] maybe :: Monad m => (a -> Maybe b) -> Parser a m b
910+ [A] manyTillP :: Parser a m b -> Parser a m x -> Parser b m c -> Parser a m c
911+ [A] manyTill :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
912+ [A] manyThen :: Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
913+ [A] manyP :: Parser a m b -> Parser b m c -> Parser a m c
914+ [A] many :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
915+ [A] makeIndexFilter :: (Fold m (s, a) b -> Parser a m b) -> (((s, a) -> Bool) -> Fold m (s, a) b -> Fold m (s, a) b) -> ((s, a) -> Bool) -> Fold m a b -> Parser a m b
916+ [A] lookAhead :: Monad m => Parser a m b -> Parser a m b
917+ [A] lmapM :: Monad m => (a -> m b) -> Parser b m r -> Parser a m r
918+ [A] lmap :: (a -> b) -> Parser b m r -> Parser a m r
919+ [A] listEqBy :: Monad m => (a -> a -> Bool) -> [a] -> Parser a m [a]
920+ [A] listEq :: (Monad m, Eq a) => [a] -> Parser a m [a]
921+ [A] indexed :: forall m a b. Monad m => Fold m (Int, a) b -> Parser a m b
922+ [A] groupByRollingEither :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (Either b c)
923+ [A] groupByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
924+ [A] groupBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
925+ [A] fromPure :: Monad m => b -> Parser a m b
926+ [A] fromFoldMaybe :: Monad m => String -> Fold m a (Maybe b) -> Parser a m b
927+ [A] fromFold :: Monad m => Fold m a b -> Parser a m b
928+ [A] fromEffect :: Monad m => m b -> Parser a m b
929+ [A] filter :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
930+ [A] extractStep :: Monad m => (s -> m (Step s1 b)) -> Step s b -> m (Step s1 b)
931+ [A] eof :: Monad m => Parser a m ()
932+ [A] either :: Monad m => (a -> Either String b) -> Parser a m b
933+ [A] dropWhile :: Monad m => (a -> Bool) -> Parser a m ()
934+ [A] dieM :: Monad m => m String -> Parser a m b
935+ [A] die :: Monad m => String -> Parser a m b
936+ [A] deintercalateAll :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
937+ [A] deintercalate1 :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
938+ [A] deintercalate :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
939+ [A] countBetween :: Int -> Int -> Parser a m b -> Fold m b c -> Parser a m c
940+ [A] count :: Int -> Parser a m b -> Fold m b c -> Parser a m c
941+ [A] concatMap :: Monad m => (b -> Parser a m c) -> Parser a m b -> Parser a m c
942+ [A] blockWithQuotes :: (Monad m, Eq a) => (a -> Bool) -> (a -> Bool) -> a -> a -> Fold m a b -> Parser a m b
943+ [A] bimapOverrideCount :: Int -> (s -> s1) -> (b -> b1) -> Step s b -> Step s1 b1
944+ [A] alt :: Monad m => Parser x m a -> Parser x m a -> Parser x m a
945+[A] Streamly.Internal.Data.MutByteArray
946+ [A] class Unbox a
947+ [A] class SizeOfRep (f :: Type -> Type)
948+ [A] class Serialize a
949+ [A] TypeOfType
950+ [A] UnitType :: Name -> TypeOfType
951+ [A] TheType :: SimpleDataCon -> TypeOfType
952+ [A] MultiType :: [SimpleDataCon] -> TypeOfType
953+ [A] SimpleDataCon
954+ [A] SimpleDataCon :: Name -> [Field] -> SimpleDataCon
955+ [A] SerializeConfig
956+ [A] [cfgRecordSyntaxWithHeader] :: SerializeConfig -> Bool
957+ [A] [cfgInlineSize] :: SerializeConfig -> Maybe Inline
958+ [A] [cfgInlineSerialize] :: SerializeConfig -> Maybe Inline
959+ [A] [cfgInlineDeserialize] :: SerializeConfig -> Maybe Inline
960+ [A] [cfgConstructorTagAsString] :: SerializeConfig -> Bool
961+ [A] SerializeConfig :: Maybe Inline -> Maybe Inline -> Maybe Inline -> Bool -> Bool -> SerializeConfig
962+ [A] PinnedState
963+ [A] Unpinned :: PinnedState
964+ [A] Pinned :: PinnedState
965+ [A] MutByteArray
966+ [A] MutByteArray :: MutableByteArray# RealWorld -> MutByteArray
967+ [A] DataType
968+ [A] [dtTvs] :: DataType -> [Name]
969+ [A] [dtName] :: DataType -> Name
970+ [A] [dtCxt] :: DataType -> Cxt
971+ [A] [dtCons] :: DataType -> [DataCon]
972+ [A] DataType :: Name -> [Name] -> Cxt -> [DataCon] -> DataType
973+ [A] DataCon
974+ [A] [dcTvs] :: DataCon -> [Name]
975+ [A] [dcName] :: DataCon -> Name
976+ [A] [dcFields] :: DataCon -> [(Maybe Name, Type)]
977+ [A] [dcCxt] :: DataCon -> Cxt
978+ [A] DataCon :: Name -> [Name] -> Cxt -> [(Maybe Name, Type)] -> DataCon
979+ [A] BoundedPtr
980+ [A] BoundedPtr :: MutByteArray -> Int -> Int -> BoundedPtr
981+ [A] Streamly.Internal.Data.Serialize.Type.Serialize
982+ [A] instance Streamly.Internal.Data.Serialize.Type.Serialize Streamly.Internal.Data.MutByteArray.LiftedInteger
983+ [A] instance Streamly.Internal.Data.Serialize.Type.Serialize GHC.Num.Integer.Integer
984+ [A] instance Streamly.Internal.Data.Serialize.Type.Serialize a => Streamly.Internal.Data.Serialize.Type.Serialize (GHC.Maybe.Maybe a)
985+ [A] instance Streamly.Internal.Data.Serialize.Type.Serialize (Data.Proxy.Proxy a)
986+ [A] instance (Streamly.Internal.Data.Serialize.Type.Serialize a, Streamly.Internal.Data.Serialize.Type.Serialize b) => Streamly.Internal.Data.Serialize.Type.Serialize (Data.Either.Either a b)
987+ [A] Peeker
988+ [A] Peeker :: Builder BoundedPtr IO a -> Peeker a
989+ [A] type Field = (Maybe Name, Type)
990+ [A] xorCmp :: [Word8] -> Name -> Name -> Q Exp
991+ [A] wListToString :: [Word8] -> String
992+ [A] w8_int :: Word8 -> Int
993+ [A] w32_int :: Word32 -> Int
994+ [A] unpin :: MutByteArray -> IO MutByteArray
995+ [A] typeOfType :: Type -> [DataCon] -> TypeOfType
996+ [A] skipByte :: Peeker ()
997+ [A] sizeOfRep :: SizeOfRep f => f x -> Int
998+ [A] sizeOfMutableByteArray :: MutByteArray -> IO Int
999+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
1000+ [A] simplifyDataCon :: DataCon -> SimpleDataCon
1001+ [A] serializeW8List :: Name -> Name -> [Word8] -> Q Exp
1002+ [A] serializeConfig :: SerializeConfig
1003+ [A] serializeAt :: Serialize a => Int -> MutByteArray -> a -> IO Int
1004+ [A] runPeeker :: Peeker a -> BoundedPtr -> IO a
1005+ [A] reifyDataType :: Name -> Q DataType
1006+ [A] readUnsafe :: Unbox a => Peeker a
1007+ [A] read :: Unbox a => Peeker a
1008+ [A] putSliceUnsafe :: MonadIO m => MutByteArray -> Int -> MutByteArray -> Int -> Int -> m ()
1009+ [A] pokeRep :: PokeRep f => f a -> BoundedPtr -> IO BoundedPtr
1010+ [A] pokeBoundedPtrUnsafe :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr
1011+ [A] pokeBoundedPtr :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr
1012+ [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO ()
1013+ [A] pinnedNewAlignedBytes :: Int -> Int -> IO MutByteArray
1014+ [A] pinnedNew :: Int -> IO MutByteArray
1015+ [A] pinnedCloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
1016+ [A] pin :: MutByteArray -> IO MutByteArray
1017+ [A] peekRep :: PeekRep f => Peeker (f x)
1018+ [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a
1019+ [A] openConstructor :: Name -> Int -> Q Pat
1020+ [A] nil :: MutByteArray
1021+ [A] newBytesAs :: PinnedState -> Int -> IO MutByteArray
1022+ [A] new :: Int -> IO MutByteArray
1023+ [A] mkSerializeExprFields :: Name -> [Field] -> Q Exp
1024+ [A] mkRecSizeOfExpr :: SimpleDataCon -> Q Exp
1025+ [A] mkRecSerializeExpr :: Name -> SimpleDataCon -> Q Exp
1026+ [A] mkRecDeserializeExpr :: Name -> Name -> Name -> SimpleDataCon -> Q Exp
1027+ [A] mkFieldName :: Int -> Name
1028+ [A] mkDeserializeKeysDec :: Name -> Name -> SimpleDataCon -> Q [Dec]
1029+ [A] mkDeserializeExprOne :: Name -> SimpleDataCon -> Q Exp
1030+ [A] matchConstructor :: Name -> Int -> Q Exp -> Q Match
1031+ [A] makeN :: Int -> Name
1032+ [A] makeI :: Int -> Name
1033+ [A] makeA :: Int -> Name
1034+ [A] litProxy :: Unbox a => Proxy a -> Q Exp
1035+ [A] litIntegral :: Integral a => a -> Q Exp
1036+ [A] isUnitType :: [DataCon] -> Bool
1037+ [A] isRecordSyntax :: SimpleDataCon -> Bool
1038+ [A] isPinned :: MutByteArray -> Bool
1039+ [A] int_w8 :: Int -> Word8
1040+ [A] int_w32 :: Int -> Word32
1041+ [A] inlineSerializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig
1042+ [A] inlineDeserializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig
1043+ [A] inlineAddSizeTo :: Maybe Inline -> SerializeConfig -> SerializeConfig
1044+ [A] getMutableByteArray# :: MutByteArray -> MutableByteArray# RealWorld
1045+ [A] genericSizeOf :: forall a. SizeOfRep (Rep a) => Proxy a -> Int
1046+ [A] genericPokeByteIndex :: (Generic a, PokeRep (Rep a)) => MutByteArray -> Int -> a -> IO ()
1047+ [A] genericPeekByteIndex :: (Generic a, PeekRep (Rep a)) => MutByteArray -> Int -> IO a
1048+ [A] errorUnsupported :: String -> a
1049+ [A] errorUnimplemented :: a
1050+ [A] encodeRecordFields :: Bool -> SerializeConfig -> SerializeConfig
1051+ [A] encodeConstrNames :: Bool -> SerializeConfig -> SerializeConfig
1052+ [A] deserializeAt :: Serialize a => Int -> MutByteArray -> Int -> IO (Int, a)
1053+ [A] deriveUnbox :: Q [Dec] -> Q [Dec]
1054+ [A] deriveSerializeWith :: (SerializeConfig -> SerializeConfig) -> Q [Dec] -> Q [Dec]
1055+ [A] deriveSerialize :: Q [Dec] -> Q [Dec]
1056+ [A] conUpdateFuncDec :: Name -> [Field] -> Q [Dec]
1057+ [A] cloneSliceUnsafeAs :: MonadIO m => PinnedState -> Int -> Int -> MutByteArray -> m MutByteArray
1058+ [A] cloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
1059+ [A] c2w :: Char -> Word8
1060+ [A] asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
1061+ [A] addSizeTo :: Serialize a => Int -> a -> Int
1062+ [A] _x :: Name
1063+ [A] _val :: Name
1064+ [A] _tag :: Name
1065+ [A] _initialOffset :: Name
1066+ [A] _endOffset :: Name
1067+ [A] _arr :: Name
1068+ [A] _acc :: Name
1069+[A] Streamly.Internal.Data.MutArray.Stream
1070+ [A] SpliceState
1071+ [A] SpliceYielding :: arr -> SpliceState s arr -> SpliceState s arr
1072+ [A] SpliceInitial :: s -> SpliceState s arr
1073+ [A] SpliceFinish :: SpliceState s arr
1074+ [A] SpliceBuffering :: s -> arr -> SpliceState s arr
1075+ [A] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))
1076+ [A] splitOn :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a)
1077+ [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
1078+ [A] packArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
1079+ [A] lpackArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
1080+ [A] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)
1081+ [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
1082+ [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
1083+ [A] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (Either ParseError (MutArray a))
1084+ [A] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
1085+ [A] compactEQ :: Int -> Stream m (MutArray a) -> Stream m (MutArray a)
1086+ [A] compact :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
1087+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
1088+[A] Streamly.Internal.Data.MutArray.Generic
1089+ [A] MutArray
1090+ [A] [arrTrueLen] :: MutArray a -> {-# UNPACK #-} !Int
1091+ [A] [arrStart] :: MutArray a -> {-# UNPACK #-} !Int
1092+ [A] [arrLen] :: MutArray a -> {-# UNPACK #-} !Int
1093+ [A] [arrContents#] :: MutArray a -> MutableArray# RealWorld a
1094+ [A] MutArray :: MutableArray# RealWorld a -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> MutArray a
1095+ [A] writeWith :: MonadIO m => Int -> Fold m a (MutArray a)
1096+ [A] writeNUnsafe :: MonadIO m => Int -> Fold m a (MutArray a)
1097+ [A] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
1098+ [A] write :: MonadIO m => Fold m a (MutArray a)
1099+ [A] uninit :: MonadIO m => MutArray a -> Int -> m (MutArray a)
1100+ [A] toStreamK :: MonadIO m => MutArray a -> StreamK m a
1101+ [A] toList :: MonadIO m => MutArray a -> m [a]
1102+ [A] strip :: MonadIO m => (a -> Bool) -> MutArray a -> m (MutArray a)
1103+ [A] snocWith :: MonadIO m => (Int -> Int) -> MutArray a -> a -> m (MutArray a)
1104+ [A] snocUnsafe :: MonadIO m => MutArray a -> a -> m (MutArray a)
1105+ [A] snoc :: MonadIO m => MutArray a -> a -> m (MutArray a)
1106+ [A] realloc :: MonadIO m => Int -> MutArray a -> m (MutArray a)
1107+ [A] reader :: MonadIO m => Unfold m (MutArray a) a
1108+ [A] readRev :: MonadIO m => MutArray a -> Stream m a
1109+ [A] read :: MonadIO m => MutArray a -> Stream m a
1110+ [A] putSliceUnsafe :: MonadIO m => MutArray a -> Int -> MutArray a -> Int -> Int -> m ()
1111+ [A] putIndices :: MonadIO m => MutArray a -> Fold m (Int, a) ()
1112+ [A] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
1113+ [A] putIndex :: MonadIO m => Int -> MutArray a -> a -> m ()
1114+ [A] producerWith :: Monad m => (forall b. IO b -> m b) -> Producer m (MutArray a) a
1115+ [A] producer :: MonadIO m => Producer m (MutArray a) a
1116+ [A] nil :: MonadIO m => m (MutArray a)
1117+ [A] new :: MonadIO m => Int -> m (MutArray a)
1118+ [A] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
1119+ [A] modifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
1120+ [A] length :: MutArray a -> Int
1121+ [A] getSliceUnsafe :: Int -> Int -> MutArray a -> MutArray a
1122+ [A] getSlice :: Int -> Int -> MutArray a -> MutArray a
1123+ [A] getIndexUnsafeWith :: MonadIO m => MutableArray# RealWorld a -> Int -> m a
1124+ [A] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a
1125+ [A] getIndex :: MonadIO m => Int -> MutArray a -> m (Maybe a)
1126+ [A] fromStreamN :: MonadIO m => Int -> Stream m a -> m (MutArray a)
1127+ [A] fromStream :: MonadIO m => Stream m a -> m (MutArray a)
1128+ [A] fromPureStream :: MonadIO m => Stream Identity a -> m (MutArray a)
1129+ [A] fromListN :: MonadIO m => Int -> [a] -> m (MutArray a)
1130+ [A] fromList :: MonadIO m => [a] -> m (MutArray a)
1131+ [A] eq :: (MonadIO m, Eq a) => MutArray a -> MutArray a -> m Bool
1132+ [A] cmp :: (MonadIO m, Ord a) => MutArray a -> MutArray a -> m Ordering
1133+ [A] clone :: MonadIO m => MutArray a -> m (MutArray a)
1134+ [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (MutArray a)
1135+[A] Streamly.Internal.Data.MutArray
1136+ [A] MutByteArray
1137+ [A] MutArray
1138+ [A] [arrStart] :: MutArray a -> {-# UNPACK #-} !Int
1139+ [A] [arrEnd] :: MutArray a -> {-# UNPACK #-} !Int
1140+ [A] [arrContents] :: MutArray a -> {-# UNPACK #-} !MutByteArray
1141+ [A] [arrBound] :: MutArray a -> {-# UNPACK #-} !Int
1142+ [A] MutArray :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> MutArray a
1143+ [A] IORef
1144+ [A] ArrayUnsafe
1145+ [A] ArrayUnsafe :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> ArrayUnsafe a
1146+ [A] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1147+ [A] writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1148+ [A] writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1149+ [A] writeNWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1150+ [A] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1151+ [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1152+ [A] writeIORef :: Unbox a => IORef a -> a -> IO ()
1153+ [A] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))
1154+ [A] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
1155+ [A] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
1156+ [A] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
1157+ [A] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
1158+ [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
1159+ [A] unsafeSwapIndices :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> MutArray a -> m ()
1160+ [A] unpin :: MutArray a -> IO (MutArray a)
1161+ [A] toStreamKWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> StreamK m a
1162+ [A] toStreamKRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> StreamK m a
1163+ [A] toStreamKRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> StreamK m a
1164+ [A] toStreamK :: forall m a. (MonadIO m, Unbox a) => MutArray a -> StreamK m a
1165+ [A] toStreamDWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
1166+ [A] toStreamDRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
1167+ [A] toList :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m [a]
1168+ [A] swapIndices :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> MutArray a -> m ()
1169+ [A] strip :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a)
1170+ [A] splitOn :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a)
1171+ [A] splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
1172+ [A] spliceWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
1173+ [A] spliceUnsafe :: MonadIO m => MutArray a -> MutArray a -> m (MutArray a)
1174+ [A] spliceExp :: (MonadIO m, Unbox a) => MutArray a -> MutArray a -> m (MutArray a)
1175+ [A] spliceCopy :: forall m a. MonadIO m => MutArray a -> MutArray a -> m (MutArray a)
1176+ [A] splice :: (MonadIO m, Unbox a) => MutArray a -> MutArray a -> m (MutArray a)
1177+ [A] snocWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> MutArray a -> a -> m (MutArray a)
1178+ [A] snocUnsafe :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
1179+ [A] snocMay :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (Maybe (MutArray a))
1180+ [A] snocLinear :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
1181+ [A] snoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
1182+ [A] shuffleBy :: (a -> a -> m Bool) -> MutArray a -> MutArray a -> m ()
1183+ [A] roundUpToPower2 :: Int -> Int
1184+ [A] rightSize :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m (MutArray a)
1185+ [A] reverse :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m ()
1186+ [A] resizeExp :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
1187+ [A] resize :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
1188+ [A] realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
1189+ [A] readerRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Unfold m (MutArray a) a
1190+ [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
1191+ [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
1192+ [A] readRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a
1193+ [A] readIORef :: Unbox a => IORef a -> IO a
1194+ [A] read :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a
1195+ [A] putIndices :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Fold m (Int, a) ()
1196+ [A] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
1197+ [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
1198+ [A] producerWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Producer m (MutArray a) a
1199+ [A] producer :: forall m a. (MonadIO m, Unbox a) => Producer m (MutArray a) a
1200+ [A] pollIntIORef :: (MonadIO m, Unbox a) => IORef a -> Stream m a
1201+ [A] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1202+ [A] pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (MutArray a)
1203+ [A] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1204+ [A] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
1205+ [A] pinnedNewBytes :: MonadIO m => Int -> m (MutArray a)
1206+ [A] pinnedNewAligned :: (MonadIO m, Unbox a) => Int -> Int -> m (MutArray a)
1207+ [A] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
1208+ [A] pinnedFromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
1209+ [A] pinnedFromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
1210+ [A] pinnedClone :: MonadIO m => MutArray a -> m (MutArray a)
1211+ [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
1212+ [A] pin :: MutArray a -> IO (MutArray a)
1213+ [A] permute :: MutArray a -> m Bool
1214+ [A] partitionBy :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a)
1215+ [A] nil :: MutArray a
1216+ [A] newIORef :: forall a. Unbox a => a -> IO (IORef a)
1217+ [A] newArrayWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> m MutByteArray) -> Int -> Int -> m (MutArray a)
1218+ [A] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
1219+ [A] modifyIndices :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (Int -> a -> a) -> Fold m Int ()
1220+ [A] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
1221+ [A] modifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
1222+ [A] modifyIORef' :: Unbox a => IORef a -> (a -> a) -> IO ()
1223+ [A] modify :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (a -> a) -> m ()
1224+ [A] mergeBy :: Int -> (MutArray a -> MutArray a -> m ()) -> MutArray a -> m ()
1225+ [A] memcpy :: Ptr Word8 -> Ptr Word8 -> Int -> IO ()
1226+ [A] memcmp :: Ptr Word8 -> Ptr Word8 -> Int -> IO Bool
1227+ [A] length :: forall a. Unbox a => MutArray a -> Int
1228+ [A] isPinned :: MutArray a -> Bool
1229+ [A] getSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a)
1230+ [A] getSliceUnsafe :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
1231+ [A] getSlice :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
1232+ [A] getIndicesD :: (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m Int -> Unfold m (MutArray a) a
1233+ [A] getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1234+ [A] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
1235+ [A] getIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
1236+ [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (Maybe a)
1237+ [A] genSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int)
1238+ [A] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (MutArray a)
1239+ [A] fromStreamD :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
1240+ [A] fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
1241+ [A] fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
1242+ [A] fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
1243+ [A] fromListRev :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
1244+ [A] fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
1245+ [A] fromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
1246+ [A] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)
1247+ [A] foldr :: (MonadIO m, Unbox a) => (a -> b -> b) -> b -> MutArray a -> m b
1248+ [A] foldl' :: (MonadIO m, Unbox a) => (b -> a -> b) -> b -> MutArray a -> m b
1249+ [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
1250+ [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
1251+ [A] divideBy :: Int -> (MutArray a -> m (MutArray a, MutArray a)) -> MutArray a -> m ()
1252+ [A] cmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
1253+ [A] clone :: MonadIO m => MutArray a -> m (MutArray a)
1254+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
1255+ [A] castUnsafe :: MutArray a -> MutArray b
1256+ [A] cast :: forall a b. Unbox b => MutArray a -> Maybe (MutArray b)
1257+ [A] c_memchr :: Ptr Word8 -> Word8 -> CSize -> IO (Ptr Word8)
1258+ [A] bytesFree :: MutArray a -> Int
1259+ [A] byteLength :: MutArray a -> Int
1260+ [A] byteCapacity :: MutArray a -> Int
1261+ [A] bubble :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> MutArray a -> m ()
1262+ [A] breakOn :: MonadIO m => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
1263+ [A] blockSize :: Int
1264+ [A] asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
1265+ [A] asBytes :: MutArray a -> MutArray Word8
1266+ [A] arrayChunkBytes :: Int
1267+ [A] allocBytesToElemCount :: Unbox a => a -> Int -> Int
1268+[C] Streamly.Internal.Data.IsMap
1269+ [A] mapTraverseWithKey :: (IsMap f, Applicative t) => (Key f -> a -> t b) -> f a -> t (f b)
1270+[R] Streamly.Internal.Data.IORef.Unboxed
1271+[R] Streamly.Internal.Data.Fold.Window
1272+[R] Streamly.Internal.Data.Fold.Type
1273+[R] Streamly.Internal.Data.Fold.Tee
1274+[R] Streamly.Internal.Data.Fold.Step
1275+[R] Streamly.Internal.Data.Fold.Container
1276+[D] Streamly.Internal.Data.Fold.Chunked
1277+[C] Streamly.Internal.Data.Fold
1278+ [A] ManyState
1279+ [C] Fold
1280+ [C] Fold
1281+ [O] Fold :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> Fold m a b
1282+ [N] Fold :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b
1283+ [A] windowSumInt :: forall m a. (Monad m, Integral a) => Fold m (a, Maybe a) a
1284+ [A] windowSum :: forall m a. (Monad m, Num a) => Fold m (a, Maybe a) a
1285+ [A] windowRollingMapM :: Monad m => (Maybe a -> a -> m (Maybe b)) -> Fold m (a, Maybe a) (Maybe b)
1286+ [A] windowRollingMap :: Monad m => (Maybe a -> a -> Maybe b) -> Fold m (a, Maybe a) (Maybe b)
1287+ [A] windowRange :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe (a, a))
1288+ [A] windowPowerSumFrac :: (Monad m, Floating a) => a -> Fold m (a, Maybe a) a
1289+ [A] windowPowerSum :: (Monad m, Num a) => Int -> Fold m (a, Maybe a) a
1290+ [A] windowMinimum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
1291+ [A] windowMean :: forall m a. (Monad m, Fractional a) => Fold m (a, Maybe a) a
1292+ [A] windowMaximum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
1293+ [A] windowLmap :: (c -> a) -> Fold m (a, Maybe a) b -> Fold m (c, Maybe c) b
1294+ [A] windowLength :: (Monad m, Num b) => Fold m (a, Maybe a) b
1295+ [A] toSet :: (Monad m, Ord a) => Fold m a (Set a)
1296+ [A] toMapIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
1297+ [A] toMap :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
1298+ [A] toIntSet :: Monad m => Fold m Int IntSet
1299+ [A] toContainerIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
1300+ [A] toContainer :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
1301+ [A] nubInt :: Monad m => Fold m Int (Maybe Int)
1302+ [A] nub :: (Monad m, Ord a) => Fold m a (Maybe a)
1303+ [A] mapMStep :: Applicative m => (a -> m b) -> Step s a -> m (Step s b)
1304+ [A] kvToMap :: (Monad m, Ord k) => Fold m a b -> Fold m (k, a) (Map k b)
1305+ [A] frequency :: (Monad m, Ord a) => Fold m a (Map a Int)
1306+ [A] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
1307+ [A] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
1308+ [A] demuxToContainerIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b)
1309+ [A] demuxToContainer :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b)
1310+ [A] demuxKvToMap :: (Monad m, Ord k) => (k -> m (Fold m a b)) -> Fold m (k, a) (Map k b)
1311+ [A] demuxKvToContainer :: (Monad m, IsMap f, Traversable f) => (Key f -> m (Fold m a b)) -> Fold m (Key f, a) (f b)
1312+ [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
1313+ [A] demuxGenericIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (m (f b), Maybe (Key f, b))
1314+ [A] demuxGeneric :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (m (f b), Maybe (Key f, b))
1315+ [A] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
1316+ [A] cumulative :: Fold m (a, Maybe a) b -> Fold m a b
1317+ [A] countDistinctInt :: Monad m => Fold m Int Int
1318+ [A] countDistinct :: (Monad m, Ord a) => Fold m a Int
1319+ [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
1320+ [A] classifyGenericIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
1321+ [A] classifyGeneric :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
1322+ [A] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
1323+ [A] chainStepM :: Applicative m => (s1 -> m s2) -> (a -> m (Step s2 b)) -> Step s1 a -> m (Step s2 b)
1324+[C] Streamly.Internal.Data.Builder
1325+ [C] Builder
1326+ [C] Builder
1327+ [O] Builder :: (s -> m (s, a)) -> Builder s m a
1328+ [N] Builder :: (s -> m (a, s)) -> Builder s m a
1329+[A] Streamly.Internal.Data.Binary.Stream
1330+ [A] class ToBytes a
1331+ [A] word8 :: Applicative m => Word8 -> Stream m Word8
1332+ [A] word64le :: Monad m => Word64 -> Stream m Word8
1333+ [A] word64host :: Monad m => Word64 -> Stream m Word8
1334+ [A] word64be :: Monad m => Word64 -> Stream m Word8
1335+ [A] word32le :: Monad m => Word32 -> Stream m Word8
1336+ [A] word32be :: Monad m => Word32 -> Stream m Word8
1337+ [A] word16le :: Monad m => Word16 -> Stream m Word8
1338+ [A] word16be :: Monad m => Word16 -> Stream m Word8
1339+ [A] unit :: Applicative m => Stream m Word8
1340+ [A] toBytes :: ToBytes a => a -> Stream m Word8
1341+ [A] ordering :: Applicative m => Ordering -> Stream m Word8
1342+ [A] int8 :: Applicative m => Int8 -> Stream m Word8
1343+ [A] int64le :: Monad m => Int64 -> Stream m Word8
1344+ [A] int64be :: Monad m => Int64 -> Stream m Word8
1345+ [A] int32le :: Monad m => Int32 -> Stream m Word8
1346+ [A] int32be :: Monad m => Int32 -> Stream m Word8
1347+ [A] int16le :: Monad m => Int16 -> Stream m Word8
1348+ [A] int16be :: Monad m => Int16 -> Stream m Word8
1349+ [A] float32le :: Monad m => Float -> Stream m Word8
1350+ [A] float32be :: Monad m => Float -> Stream m Word8
1351+ [A] double64le :: Monad m => Double -> Stream m Word8
1352+ [A] double64be :: Monad m => Double -> Stream m Word8
1353+ [A] charUtf8 :: Monad m => Char -> Stream m Word8
1354+ [A] charLatin1 :: Applicative m => Char -> Stream m Word8
1355+ [A] bool :: Applicative m => Bool -> Stream m Word8
1356+[A] Streamly.Internal.Data.Binary.Parser
1357+ [A] class FromBytes a
1358+ [A] word8 :: Monad m => Parser Word8 m Word8
1359+ [A] word64le :: Monad m => Parser Word8 m Word64
1360+ [A] word64host :: MonadIO m => Parser Word8 m Word64
1361+ [A] word64be :: Monad m => Parser Word8 m Word64
1362+ [A] word32le :: Monad m => Parser Word8 m Word32
1363+ [A] word32be :: Monad m => Parser Word8 m Word32
1364+ [A] word16le :: Monad m => Parser Word8 m Word16
1365+ [A] word16be :: Monad m => Parser Word8 m Word16
1366+ [A] unit :: Monad m => Parser Word8 m ()
1367+ [A] ordering :: Monad m => Parser Word8 m Ordering
1368+ [A] int8 :: Monad m => Parser Word8 m Int8
1369+ [A] int64le :: Monad m => Parser Word8 m Int64
1370+ [A] int64be :: Monad m => Parser Word8 m Int64
1371+ [A] int32le :: Monad m => Parser Word8 m Int32
1372+ [A] int32be :: Monad m => Parser Word8 m Int32
1373+ [A] int16le :: Monad m => Parser Word8 m Int16
1374+ [A] int16be :: Monad m => Parser Word8 m Int16
1375+ [A] fromBytes :: FromBytes a => Parser Word8 m a
1376+ [A] float32le :: MonadIO m => Parser Word8 m Float
1377+ [A] float32be :: MonadIO m => Parser Word8 m Float
1378+ [A] eqWord8 :: Monad m => Word8 -> Parser Word8 m Word8
1379+ [A] double64le :: MonadIO m => Parser Word8 m Double
1380+ [A] double64be :: MonadIO m => Parser Word8 m Double
1381+ [A] charLatin1 :: Monad m => Parser Word8 m Char
1382+ [A] bool :: Monad m => Parser Word8 m Bool
1383+[R] Streamly.Internal.Data.Array.Type
1384+[A] Streamly.Internal.Data.Array.Stream
1385+ [A] unlines :: forall m a. (MonadIO m, Unbox a) => a -> Stream m (Array a) -> Stream m a
1386+ [A] toArray :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)
1387+ [A] splitOnSuffix :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
1388+ [A] splitOn :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
1389+ [A] runArrayParserDBreak :: forall m a b. (MonadIO m, Unbox a) => Parser (Array a) m b -> Stream m (Array a) -> m (Either ParseError b, Stream m (Array a))
1390+ [A] runArrayFoldMany :: (Monad m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> StreamK m (Either ParseError b)
1391+ [A] runArrayFoldBreak :: (MonadIO m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
1392+ [A] runArrayFold :: (MonadIO m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> m (Either ParseError b)
1393+ [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
1394+ [A] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
1395+ [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
1396+ [A] parseBreak :: (MonadIO m, Unbox a) => Parser a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
1397+ [A] lpackArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()
1398+ [A] interposeSuffix :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
1399+ [A] interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
1400+ [A] intercalateSuffix :: (Monad m, Unbox a) => Array a -> Stream m (Array a) -> Stream m a
1401+ [A] foldBreakD :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> Stream m (Array a) -> m (b, Stream m (Array a))
1402+ [A] foldBreak :: (MonadIO m, Unbox a) => Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a))
1403+ [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
1404+ [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
1405+ [A] concatRev :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
1406+ [A] concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
1407+ [A] compact :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
1408+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
1409+ [A] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))
1410+[R] Streamly.Internal.Data.Array.Mut.Type
1411+[R] Streamly.Internal.Data.Array.Mut.Stream
1412+[R] Streamly.Internal.Data.Array.Mut
1413+[R] Streamly.Internal.Data.Array.Generic.Mut.Type
1414+[C] Streamly.Internal.Data.Array.Generic
1415+ [A] getIndex :: Int -> Array a -> Maybe a
1416+ [A] fromPureStream :: Stream Identity a -> Array a
1417+ [A] fromByteStr# :: Addr# -> Array Word8
1418+ [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (Array a)
1419+[C] Streamly.Internal.Data.Array
1420+ [A] ArrayUnsafe
1421+ [A] ArrayUnsafe :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> ArrayUnsafe a
1422+ [C] Array
1423+ [A] [arrStart] :: Array a -> {-# UNPACK #-} !Int
1424+ [A] [arrEnd] :: Array a -> {-# UNPACK #-} !Int
1425+ [A] [arrContents] :: Array a -> {-# UNPACK #-} !MutByteArray
1426+ [A] Array :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> Array a
1427+ [A] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
1428+ [A] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
1429+ [R] writeNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a)
1430+ [A] unsafeMakePure :: Monad m => Fold IO a b -> Fold m a b
1431+ [A] unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a
1432+ [D] unsafeIndex :: forall a. Unbox a => Int -> Array a -> a
1433+ [A] unsafeFreezeWithShrink :: Unbox a => MutArray a -> Array a
1434+ [A] unpin :: Array a -> IO (Array a)
1435+ [A] toStreamKRev :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a
1436+ [A] toStreamK :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a
1437+ [A] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a
1438+ [A] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a
1439+ [A] splitAt :: Unbox a => Int -> Array a -> (Array a, Array a)
1440+ [A] splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)
1441+ [A] serialize :: Serialize a => a -> Array Word8
1442+ [A] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
1443+ [A] pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a)
1444+ [A] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
1445+ [A] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
1446+ [A] pinnedSerialize :: Serialize a => a -> Array Word8
1447+ [A] pinnedFromListN :: Unbox a => Int -> [a] -> Array a
1448+ [A] pinnedFromList :: Unbox a => [a] -> Array a
1449+ [A] pinnedClone :: MonadIO m => Array a -> m (Array a)
1450+ [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
1451+ [A] pin :: Array a -> IO (Array a)
1452+ [A] nil :: Array a
1453+ [A] isPinned :: Array a -> Bool
1454+ [A] getIndexUnsafe :: forall a. Unbox a => Int -> Array a -> a
1455+ [A] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)
1456+ [A] fromStreamD :: forall m a. (MonadIO m, Unbox a) => Stream m a -> m (Array a)
1457+ [A] fromPureStream :: Unbox a => Stream Identity a -> Array a
1458+ [A] fromListRevN :: Unbox a => Int -> [a] -> Array a
1459+ [A] fromListRev :: Unbox a => [a] -> Array a
1460+ [A] fromByteStr# :: Addr# -> Array Word8
1461+ [A] foldr :: Unbox a => (a -> b -> b) -> b -> Array a -> b
1462+ [A] foldl' :: forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b
1463+ [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
1464+ [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
1465+ [A] encodeAs :: forall a. Serialize a => PinnedState -> a -> Array Word8
1466+ [A] deserialize :: Serialize a => Array Word8 -> a
1467+ [A] clone :: MonadIO m => Array a -> m (Array a)
1468+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
1469+ [A] byteLength :: Array a -> Int
1470+ [A] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))
1471+ [A] breakOn :: MonadIO m => Word8 -> Array Word8 -> m (Array Word8, Maybe (Array Word8))
core/docs/ApiChangelogs/0.1.0.txtnew file+405
@@ -0,0 +1,405 @@
1+---------------------------------
2+Terminology
3+---------------------------------
4+
5+[A]: Added
6+[R]: Removed
7+[C]: Changed
8+[D]: Deprecated
9+[O]: Old
10+[N]: New
11+
12+---------------------------------
13+Difference
14+---------------------------------
15+
16+The moved modules have been compared with their version in streamly v0.8.3
17+
18+[A] Streamly.Unicode.String
19+ [A] str :: QuasiQuoter
20+[C] Streamly.Unicode.Stream
21+ [C] encodeUtf8'
22+ [O] encodeUtf8' :: (Monad m, IsStream t) => t m Char -> t m Word8
23+ [N] encodeUtf8' :: Monad m => Stream m Char -> Stream m Word8
24+ [C] encodeUtf8
25+ [O] encodeUtf8 :: (Monad m, IsStream t) => t m Char -> t m Word8
26+ [N] encodeUtf8 :: Monad m => Stream m Char -> Stream m Word8
27+ [C] encodeStrings
28+ [O] encodeStrings :: (MonadIO m, IsStream t) => (SerialT m Char -> SerialT m Word8) -> t m String -> t m (Array Word8)
29+ [N] encodeStrings :: MonadIO m => (Stream m Char -> Stream m Word8) -> Stream m String -> Stream m (Array Word8)
30+ [C] encodeLatin1'
31+ [O] encodeLatin1' :: (IsStream t, Monad m) => t m Char -> t m Word8
32+ [N] encodeLatin1' :: Monad m => Stream m Char -> Stream m Word8
33+ [C] encodeLatin1
34+ [O] encodeLatin1 :: (IsStream t, Monad m) => t m Char -> t m Word8
35+ [N] encodeLatin1 :: Monad m => Stream m Char -> Stream m Word8
36+ [A] decodeUtf8Chunks :: MonadIO m => Stream m (Array Word8) -> Stream m Char
37+ [C] decodeUtf8'
38+ [O] decodeUtf8' :: (Monad m, IsStream t) => t m Word8 -> t m Char
39+ [N] decodeUtf8' :: Monad m => Stream m Word8 -> Stream m Char
40+ [C] decodeUtf8
41+ [O] decodeUtf8 :: (Monad m, IsStream t) => t m Word8 -> t m Char
42+ [N] decodeUtf8 :: Monad m => Stream m Word8 -> Stream m Char
43+ [C] decodeLatin1
44+ [O] decodeLatin1 :: (IsStream t, Monad m) => t m Word8 -> t m Char
45+ [N] decodeLatin1 :: Monad m => Stream m Word8 -> Stream m Char
46+[A] Streamly.Unicode.Parser
47+ [A] upper :: Monad m => Parser Char m Char
48+ [A] symbol :: Monad m => Parser Char m Char
49+ [A] stringIgnoreCase :: Monad m => String -> Parser Char m String
50+ [A] string :: Monad m => String -> Parser Char m String
51+ [A] space :: Monad m => Parser Char m Char
52+ [A] signed :: (Num a, Monad m) => Parser Char m a -> Parser Char m a
53+ [A] separator :: Monad m => Parser Char m Char
54+ [A] punctuation :: Monad m => Parser Char m Char
55+ [A] printable :: Monad m => Parser Char m Char
56+ [A] octDigit :: Monad m => Parser Char m Char
57+ [A] numeric :: Monad m => Parser Char m Char
58+ [A] mark :: Monad m => Parser Char m Char
59+ [A] lower :: Monad m => Parser Char m Char
60+ [A] letter :: Monad m => Parser Char m Char
61+ [A] latin1 :: Monad m => Parser Char m Char
62+ [A] hexadecimal :: (Monad m, Integral a, Bits a) => Parser Char m a
63+ [A] hexDigit :: Monad m => Parser Char m Char
64+ [A] dropSpace1 :: Monad m => Parser Char m ()
65+ [A] dropSpace :: Monad m => Parser Char m ()
66+ [A] digit :: Monad m => Parser Char m Char
67+ [A] decimal :: (Monad m, Integral a) => Parser Char m a
68+ [A] charIgnoreCase :: Monad m => Char -> Parser Char m Char
69+ [A] char :: Monad m => Char -> Parser Char m Char
70+ [A] asciiUpper :: Monad m => Parser Char m Char
71+ [A] asciiLower :: Monad m => Parser Char m Char
72+ [A] ascii :: Monad m => Parser Char m Char
73+ [A] alphaNum :: Monad m => Parser Char m Char
74+ [A] alpha :: Monad m => Parser Char m Char
75+[C] Streamly.FileSystem.Handle
76+ [D] writeWithBufferOf :: MonadIO m => Int -> Handle -> Fold m Word8 ()
77+ [A] writeWith :: MonadIO m => Int -> Handle -> Fold m Word8 ()
78+ [C] writeChunks
79+ [O] writeChunks :: (MonadIO m, Storable a) => Handle -> Fold m (Array a) ()
80+ [N] writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()
81+ [A] readerWith :: MonadIO m => Unfold m (Int, Handle) Word8
82+ [A] reader :: MonadIO m => Unfold m Handle Word8
83+ [D] readWithBufferOf :: MonadIO m => Unfold m (Int, Handle) Word8
84+ [D] readChunksWithBufferOf :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
85+ [D] readChunks :: MonadIO m => Unfold m Handle (Array Word8)
86+ [D] read :: MonadIO m => Unfold m Handle Word8
87+ [C] putChunk
88+ [O] putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()
89+ [N] putChunk :: MonadIO m => Handle -> Array a -> m ()
90+ [A] chunkReaderWith :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
91+ [A] chunkReader :: MonadIO m => Unfold m Handle (Array Word8)
92+[A] Streamly.FileSystem.File
93+ [A] writeWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Fold m Word8 ()
94+ [A] writeChunks :: (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
95+ [A] write :: (MonadIO m, MonadCatch m) => FilePath -> Fold m Word8 ()
96+ [A] withFile :: (MonadIO m, MonadCatch m) => FilePath -> IOMode -> (Handle -> Stream m a) -> Stream m a
97+ [A] readChunksWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m (Array Word8)
98+ [A] readChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array Word8)
99+ [A] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8
100+[A] Streamly.FileSystem.Dir
101+ [A] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
102+ [A] read :: MonadIO m => FilePath -> Stream m FilePath
103+[C] Streamly.Data.Unfold
104+ [C] take
105+ [O] take :: Monad m => Int -> Unfold m a b -> Unfold m a b
106+ [N] take :: Applicative m => Int -> Unfold m a b -> Unfold m a b
107+ [C] replicateM
108+ [O] replicateM :: Monad m => Int -> Unfold m (m a) a
109+ [N] replicateM :: Applicative m => Unfold m (Int, m a) a
110+ [C] repeatM
111+ [O] repeatM :: Monad m => Unfold m (m a) a
112+ [N] repeatM :: Applicative m => Unfold m (m a) a
113+ [C] many
114+ [O] many :: Monad m => Unfold m a b -> Unfold m b c -> Unfold m a c
115+ [N] many :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
116+ [C] iterateM
117+ [O] iterateM :: Monad m => (a -> m a) -> Unfold m (m a) a
118+ [N] iterateM :: Applicative m => (a -> m a) -> Unfold m (m a) a
119+ [C] fromStream
120+ [O] fromStream :: (IsStream t, Monad m) => Unfold m (t m a) a
121+ [N] fromStream :: Applicative m => Unfold m (Stream m a) a
122+ [C] fromListM
123+ [O] fromListM :: Monad m => Unfold m [m a] a
124+ [N] fromListM :: Applicative m => Unfold m [m a] a
125+ [C] fromList
126+ [O] fromList :: Monad m => Unfold m [a] a
127+ [N] fromList :: Applicative m => Unfold m [a] a
128+ [C] drop
129+ [O] drop :: Monad m => Int -> Unfold m a b -> Unfold m a b
130+ [N] drop :: Applicative m => Int -> Unfold m a b -> Unfold m a b
131+[A] Streamly.Data.StreamK
132+ [A] StreamK
133+ [A] zipWithM :: Monad m => (a -> b -> m c) -> StreamK m a -> StreamK m b -> StreamK m c
134+ [A] zipWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
135+ [A] uncons :: Applicative m => StreamK m a -> m (Maybe (a, StreamK m a))
136+ [A] toStream :: Applicative m => StreamK m a -> Stream m a
137+ [A] sortBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> StreamK m a
138+ [A] reverse :: StreamK m a -> StreamK m a
139+ [A] parseChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b)
140+ [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
141+ [A] nilM :: Applicative m => m b -> StreamK m a
142+ [A] nil :: StreamK m a
143+ [A] mergeMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
144+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
145+ [A] mergeBy :: (a -> a -> Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
146+ [A] interleave :: StreamK m a -> StreamK m a -> StreamK m a
147+ [A] fromStream :: Monad m => Stream m a -> StreamK m a
148+ [A] fromPure :: a -> StreamK m a
149+ [A] fromFoldable :: Foldable f => f a -> StreamK m a
150+ [A] fromEffect :: Monad m => m a -> StreamK m a
151+ [A] crossWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
152+ [A] consM :: Monad m => m a -> StreamK m a -> StreamK m a
153+ [A] cons :: a -> StreamK m a -> StreamK m a
154+ [A] concatMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
155+ [A] concatEffect :: Monad m => m (StreamK m a) -> StreamK m a
156+ [A] append :: StreamK m a -> StreamK m a -> StreamK m a
157+[A] Streamly.Data.Stream
158+ [A] class Enum a => Enumerable a
159+ [A] Stream
160+ [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
161+ [A] zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
162+ [A] unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
163+ [A] unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
164+ [A] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
165+ [A] unfold :: Applicative m => Unfold m a b -> a -> Stream m b
166+ [A] uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a))
167+ [A] trace :: Monad m => (a -> m b) -> Stream m a -> Stream m a
168+ [A] toList :: Monad m => Stream m a -> m [a]
169+ [A] tap :: Monad m => Fold m a b -> Stream m a -> Stream m a
170+ [A] takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
171+ [A] takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
172+ [A] take :: Applicative m => Int -> Stream m a -> Stream m a
173+ [A] stripPrefix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
174+ [A] sequence :: Monad m => Stream m (m a) -> Stream m a
175+ [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
176+ [A] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
177+ [A] runStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m (s, a)
178+ [A] runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a
179+ [A] reverse :: Monad m => Stream m a -> Stream m a
180+ [A] replicateM :: Monad m => Int -> m a -> Stream m a
181+ [A] replicate :: Monad m => Int -> a -> Stream m a
182+ [A] repeatM :: Monad m => m a -> Stream m a
183+ [A] repeat :: Monad m => a -> Stream m a
184+ [A] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
185+ [A] parseMany :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
186+ [A] parse :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
187+ [A] onException :: MonadCatch m => m b -> Stream m a -> Stream m a
188+ [A] nilM :: Applicative m => m b -> Stream m a
189+ [A] nil :: Applicative m => Stream m a
190+ [A] morphInner :: Monad n => (forall x. m x -> n x) -> Stream m a -> Stream n a
191+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
192+ [A] mergeBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
193+ [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
194+ [A] mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
195+ [A] mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
196+ [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => Stream m a -> Stream (t m) a
197+ [A] iterateM :: Monad m => (a -> m a) -> m a -> Stream m a
198+ [A] iterate :: Monad m => (a -> a) -> a -> Stream m a
199+ [A] isSubsequenceOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
200+ [A] isPrefixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
201+ [A] intersperseM_ :: Monad m => m b -> Stream m a -> Stream m a
202+ [A] intersperseM :: Monad m => m a -> Stream m a -> Stream m a
203+ [A] intersperse :: Monad m => a -> Stream m a -> Stream m a
204+ [A] interleave :: Monad m => Stream m a -> Stream m a -> Stream m a
205+ [A] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
206+ [A] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
207+ [A] insertBy :: Monad m => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a
208+ [A] indexed :: Monad m => Stream m a -> Stream m (Int, a)
209+ [A] handle :: (MonadCatch m, Exception e) => (e -> Stream m a) -> Stream m a -> Stream m a
210+ [A] fromPure :: Applicative m => a -> Stream m a
211+ [A] fromList :: Applicative m => [a] -> Stream m a
212+ [A] fromEffect :: Applicative m => m a -> Stream m a
213+ [A] foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b
214+ [A] foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
215+ [A] foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
216+ [A] foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)
217+ [A] fold :: Monad m => Fold m a b -> Stream m a -> m b
218+ [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Stream m a -> Stream m a
219+ [A] filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
220+ [A] filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
221+ [A] eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
222+ [A] enumerateTo :: (Monad m, Bounded a, Enumerable a) => a -> Stream m a
223+ [A] enumerateFromTo :: (Enumerable a, Monad m) => a -> a -> Stream m a
224+ [A] enumerateFromThenTo :: (Enumerable a, Monad m) => a -> a -> a -> Stream m a
225+ [A] enumerateFromThen :: (Enumerable a, Monad m) => a -> a -> Stream m a
226+ [A] enumerateFrom :: (Enumerable a, Monad m) => a -> Stream m a
227+ [A] enumerate :: (Monad m, Bounded a, Enumerable a) => Stream m a
228+ [A] dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
229+ [A] dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
230+ [A] drop :: Monad m => Int -> Stream m a -> Stream m a
231+ [A] delay :: MonadIO m => Double -> Stream m a -> Stream m a
232+ [A] crossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
233+ [A] consM :: Applicative m => m a -> Stream m a -> Stream m a
234+ [A] cons :: Applicative m => a -> Stream m a -> Stream m a
235+ [A] concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
236+ [A] concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
237+ [A] concatEffect :: Monad m => m (Stream m a) -> Stream m a
238+ [A] cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
239+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
240+ [A] catRights :: Monad m => Stream m (Either a b) -> Stream m b
241+ [A] catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a
242+ [A] catLefts :: Monad m => Stream m (Either a b) -> Stream m a
243+ [A] catEithers :: Monad m => Stream m (Either a a) -> Stream m a
244+ [A] bracketIO3 :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> IO d) -> (b -> IO e) -> (b -> Stream m a) -> Stream m a
245+ [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
246+ [A] before :: Monad m => m b -> Stream m a -> Stream m a
247+ [A] append :: Monad m => Stream m a -> Stream m a -> Stream m a
248+ [A] afterIO :: MonadIO m => IO b -> Stream m a -> Stream m a
249+[A] Streamly.Data.ParserK
250+ [A] ParserK
251+ [A] fromPure :: b -> ParserK a m b
252+ [A] fromParser :: (Monad m, Unbox a) => Parser a m b -> ParserK a m b
253+ [A] fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK a m b
254+ [A] fromEffect :: Monad m => m b -> ParserK a m b
255+ [A] die :: String -> ParserK a m b
256+[A] Streamly.Data.Parser
257+ [A] Parser
258+ [A] wordWithQuotes :: (Monad m, Eq a) => Bool -> (a -> a -> Maybe a) -> a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b
259+ [A] wordBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
260+ [A] takeWhile1 :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
261+ [A] takeWhile :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
262+ [A] takeEQ :: Monad m => Int -> Fold m a b -> Parser a m b
263+ [A] streamEqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Parser a m ()
264+ [A] some :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
265+ [A] satisfy :: Monad m => (a -> Bool) -> Parser a m a
266+ [A] rmapM :: Monad m => (b -> m c) -> Parser a m b -> Parser a m c
267+ [A] peek :: Monad m => Parser a m a
268+ [A] oneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
269+ [A] one :: Monad m => Parser a m a
270+ [A] noneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
271+ [A] manyTill :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
272+ [A] many :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
273+ [A] lookAhead :: Monad m => Parser a m b -> Parser a m b
274+ [A] lmapM :: Monad m => (a -> m b) -> Parser b m r -> Parser a m r
275+ [A] lmap :: (a -> b) -> Parser b m r -> Parser a m r
276+ [A] listEqBy :: Monad m => (a -> a -> Bool) -> [a] -> Parser a m [a]
277+ [A] listEq :: (Monad m, Eq a) => [a] -> Parser a m [a]
278+ [A] groupBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
279+ [A] fromPure :: Monad m => b -> Parser a m b
280+ [A] fromFold :: Monad m => Fold m a b -> Parser a m b
281+ [A] fromEffect :: Monad m => m b -> Parser a m b
282+ [A] filter :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
283+ [A] eof :: Monad m => Parser a m ()
284+ [A] dropWhile :: Monad m => (a -> Bool) -> Parser a m ()
285+ [A] die :: Monad m => String -> Parser a m b
286+ [A] deintercalate :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
287+[A] Streamly.Data.MutArray.Generic
288+ [A] MutArray
289+ [A] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
290+ [A] toList :: MonadIO m => MutArray a -> m [a]
291+ [A] snoc :: MonadIO m => MutArray a -> a -> m (MutArray a)
292+ [A] reader :: MonadIO m => Unfold m (MutArray a) a
293+ [A] putIndex :: MonadIO m => Int -> MutArray a -> a -> m ()
294+ [A] new :: forall m a. MonadIO m => Int -> m (MutArray a)
295+ [A] modifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
296+ [A] getIndex :: MonadIO m => Int -> MutArray a -> m a
297+[A] Streamly.Data.MutArray
298+ [A] class Unbox a
299+ [A] MutArray
300+ [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
301+ [A] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
302+ [A] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
303+ [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
304+ [A] toList :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m [a]
305+ [A] snoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
306+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
307+ [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
308+ [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
309+ [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
310+ [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
311+ [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
312+ [A] newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
313+ [A] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
314+ [A] length :: forall a. Unbox a => MutArray a -> Int
315+ [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
316+ [A] fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
317+ [A] fromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
318+ [A] cast :: forall a b. Unbox b => MutArray a -> Maybe (MutArray b)
319+ [A] asBytes :: MutArray a -> MutArray Word8
320+[C] Streamly.Data.Fold
321+ [A] Tee
322+ [A] [unTee] :: Tee m a b -> Fold m a b
323+ [A] Tee :: Fold m a b -> Tee m a b
324+ [D] variance :: (Monad m, Fractional a) => Fold m a a
325+ [A] uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
326+ [A] topBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
327+ [A] toSet :: (Monad m, Ord a) => Fold m a (Set a)
328+ [A] toMapIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
329+ [A] toMap :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
330+ [A] toIntSet :: Monad m => Fold m Int IntSet
331+ [A] the :: (Monad m, Eq a) => Fold m a (Maybe a)
332+ [D] stdDev :: (Monad m, Floating a) => Fold m a a
333+ [A] splitWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
334+ [D] serialWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
335+ [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c
336+ [A] scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
337+ [A] postscan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
338+ [A] one :: Monad m => Fold m a (Maybe a)
339+ [A] nubInt :: Monad m => Fold m Int (Maybe Int)
340+ [A] nub :: (Monad m, Ord a) => Fold m a (Maybe a)
341+ [A] morphInner :: (forall x. m x -> n x) -> Fold m a b -> Fold n a b
342+ [A] latest :: Monad m => Fold m a (Maybe a)
343+ [D] last :: Monad m => Fold m a (Maybe a)
344+ [D] head :: Monad m => Fold m a (Maybe a)
345+ [A] groupsOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
346+ [A] frequency :: (Monad m, Ord a) => Fold m a (Map a Int)
347+ [A] foldr' :: Monad m => (a -> b -> b) -> b -> Fold m a b
348+ [D] foldr :: Monad m => (a -> b -> b) -> b -> Fold m a b
349+ [A] foldlM1' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
350+ [A] foldl1' :: Monad m => (a -> a -> a) -> Fold m a (Maybe a)
351+ [A] findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
352+ [A] findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
353+ [A] elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
354+ [A] duplicate :: Monad m => Fold m a b -> Fold m a (Fold m a b)
355+ [A] drive :: Monad m => Stream m a -> Fold m a b -> m b
356+ [A] drainMapM :: Monad m => (a -> m b) -> Fold m a ()
357+ [D] drainBy :: Monad m => (a -> m b) -> Fold m a ()
358+ [A] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
359+ [A] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
360+ [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
361+ [A] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
362+ [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
363+ [A] countDistinctInt :: Monad m => Fold m Int Int
364+ [A] countDistinct :: (Monad m, Ord a) => Fold m a Int
365+ [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
366+ [A] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
367+ [D] chunksOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
368+ [A] catRights :: Monad m => Fold m b c -> Fold m (Either a b) c
369+ [A] catLefts :: Monad m => Fold m a c -> Fold m (Either a b) c
370+ [A] catEithers :: Fold m a b -> Fold m (Either a a) b
371+ [A] addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
372+ [A] addOne :: Monad m => a -> Fold m a b -> m (Fold m a b)
373+[A] Streamly.Data.Array.Generic
374+ [A] Array
375+ [A] writeN :: MonadIO m => Int -> Fold m a (Array a)
376+ [A] write :: MonadIO m => Fold m a (Array a)
377+ [A] reader :: Monad m => Unfold m (Array a) a
378+ [A] readRev :: Monad m => Array a -> Stream m a
379+ [A] read :: MonadIO m => Array a -> Stream m a
380+ [A] length :: Array a -> Int
381+ [A] fromListN :: Int -> [a] -> Array a
382+ [A] fromList :: [a] -> Array a
383+[A] Streamly.Data.Array
384+ [A] class Unbox a
385+ [A] Array
386+ [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
387+ [A] writeLastN :: (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)
388+ [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
389+ [A] toList :: Unbox a => Array a -> [a]
390+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
391+ [A] readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
392+ [A] reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
393+ [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
394+ [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
395+ [A] length :: Unbox a => Array a -> Int
396+ [A] getIndex :: forall a. Unbox a => Int -> Array a -> Maybe a
397+ [A] fromListN :: Unbox a => Int -> [a] -> Array a
398+ [A] fromList :: Unbox a => [a] -> Array a
399+ [A] cast :: forall a b. Unbox b => Array a -> Maybe (Array b)
400+ [A] asBytes :: Array a -> Array Word8
401+[C] Streamly.Console.Stdio
402+ [A] reader :: MonadIO m => Unfold m () Word8
403+ [D] readChunks :: MonadIO m => Unfold m () (Array Word8)
404+ [D] read :: MonadIO m => Unfold m () Word8
405+ [A] chunkReader :: MonadIO m => Unfold m () (Array Word8)
core/docs/ApiChangelogs/0.2.0-0.2.2.txtnew file+306
@@ -0,0 +1,306 @@
1+---------------------------------
2+API Annotations
3+---------------------------------
4+
5+[A] : Added
6+[R] : Removed
7+[C] : Changed
8+[O] : Old definition
9+[N] : New definition
10+[D] : Deprecated
11+
12+---------------------------------
13+API diff
14+---------------------------------
15+
16+[C] Streamly.Data.Stream
17+ [A] (FixityR,5)
18+ [A] (FixityR,5)
19+[C] Streamly.Data.MutArray.Generic
20+ [A] emptyOf :: MonadIO m => Int -> m (MutArray a)
21+ [A] createOf :: MonadIO m => Int -> Fold m a (MutArray a)
22+ [A] create :: MonadIO m => Fold m a (MutArray a)
23+[C] Streamly.Data.MutArray
24+ [A] pinnedEmptyOf :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
25+ [A] emptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
26+ [A] createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
27+ [A] create :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
28+ [A] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
29+ [A] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
30+[C] Streamly.Data.Array.Generic
31+ [A] createOf :: MonadIO m => Int -> Fold m a (Array a)
32+ [A] create :: MonadIO m => Fold m a (Array a)
33+[C] Streamly.Data.Array
34+ [A] class Serialize a
35+ [A] serializeAt :: Serialize a => Int -> MutByteArray -> a -> IO Int
36+ [A] pinnedSerialize :: Serialize a => a -> Array Word8
37+ [A] deserializeAt :: Serialize a => Int -> MutByteArray -> Int -> IO (Int, a)
38+ [A] deserialize :: Serialize a => Array Word8 -> a
39+ [A] createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
40+ [A] create :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
41+ [A] addSizeTo :: Serialize a => Int -> a -> Int
42+
43+---------------------------------
44+Internal API diff
45+---------------------------------
46+
47+[C] Streamly.Internal.Unicode.Stream
48+ [A] encodeUtf16le' :: Stream m Char -> Stream m Word16
49+ [A] decodeUtf16le' :: Stream m Word16 -> Stream m Char
50+[A] Streamly.Internal.FileSystem.Path
51+ [A] class IsPath a
52+ [A] Rel
53+ [A] File
54+ [A] Dir
55+ [A] Abs
56+ [A] Streamly.Internal.FileSystem.Path.IsPath
57+ [A] instance Streamly.Internal.FileSystem.Path.IsPath Streamly.Internal.FileSystem.Path.Path
58+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Rel Streamly.Internal.FileSystem.Path.Path)
59+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Rel (Streamly.Internal.FileSystem.Path.File Streamly.Internal.FileSystem.Path.Path))
60+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Rel (Streamly.Internal.FileSystem.Path.Dir Streamly.Internal.FileSystem.Path.Path))
61+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.File Streamly.Internal.FileSystem.Path.Path)
62+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Dir Streamly.Internal.FileSystem.Path.Path)
63+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Abs Streamly.Internal.FileSystem.Path.Path)
64+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Abs (Streamly.Internal.FileSystem.Path.File Streamly.Internal.FileSystem.Path.Path))
65+ [A] instance Streamly.Internal.FileSystem.Path.IsPath (Streamly.Internal.FileSystem.Path.Abs (Streamly.Internal.FileSystem.Path.Dir Streamly.Internal.FileSystem.Path.Path))
66+ [A] GHC.Show.Show
67+ [A] instance GHC.Show.Show Streamly.Internal.FileSystem.Path.PathException
68+ [A] GHC.Exception.Type.Exception
69+ [A] instance GHC.Exception.Type.Exception Streamly.Internal.FileSystem.Path.PathException
70+ [A] GHC.Classes.Eq
71+ [A] instance GHC.Classes.Eq Streamly.Internal.FileSystem.Path.PathException
72+ [A] Path
73+ [A] Path :: Array Word8 -> Path
74+ [A] toString :: Path -> [Char]
75+ [A] toPath :: IsPath a => a -> Path
76+ [A] toChunk :: Path -> Array Word8
77+ [A] toChars :: Monad m => Path -> Stream m Char
78+ [A] relfile :: QuasiQuoter
79+ [A] reldir :: QuasiQuoter
80+ [A] rel :: QuasiQuoter
81+ [A] primarySeparator :: Char
82+ [A] path :: QuasiQuoter
83+ [A] mkRelFile :: String -> Q Exp
84+ [A] mkRelDir :: String -> Q Exp
85+ [A] mkRel :: String -> Q Exp
86+ [A] mkPath :: String -> Q Exp
87+ [A] mkFile :: String -> Q Exp
88+ [A] mkDir :: String -> Q Exp
89+ [A] mkAbsFile :: String -> Q Exp
90+ [A] mkAbsDir :: String -> Q Exp
91+ [A] mkAbs :: String -> Q Exp
92+ [A] isSeparator :: Char -> Bool
93+ [A] fromString :: MonadThrow m => [Char] -> m Path
94+ [A] fromPathUnsafe :: IsPath a => Path -> a
95+ [A] fromPath :: (IsPath a, MonadThrow m) => Path -> m a
96+ [A] fromChunkUnsafe :: Array Word8 -> Path
97+ [A] fromChunk :: MonadThrow m => Array Word8 -> m Path
98+ [A] fromChars :: MonadThrow m => Stream Identity Char -> m Path
99+ [A] file :: QuasiQuoter
100+ [A] extendPath :: Path -> Path -> Path
101+ [A] extendDir :: (IsPath (a (Dir Path)), IsPath b, IsPath (a b)) => a (Dir Path) -> Rel b -> a b
102+ [A] dir :: QuasiQuoter
103+ [A] adaptPath :: (MonadThrow m, IsPath a, IsPath b) => a -> m b
104+ [A] absfile :: QuasiQuoter
105+ [A] absdir :: QuasiQuoter
106+ [A] abs :: QuasiQuoter
107+[C] Streamly.Internal.Data.Stream
108+ [A] (FixityR,5)
109+ [A] (FixityR,5)
110+ [C] splitInnerBySuffix
111+ [O] splitInnerBySuffix :: (Monad m, Eq (f a), Monoid (f a)) => (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a)
112+ [N] splitInnerBySuffix :: Monad m => (f a -> Bool) -> (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a)
113+ [D] sliceOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
114+ [A] indexOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
115+[C] Streamly.Internal.Data.MutByteArray
116+ [A] unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
117+ [A] unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
118+ [D] nil :: MutByteArray
119+ [A] empty :: MutByteArray
120+ [D] asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
121+[D] Streamly.Internal.Data.MutArray.Stream
122+ [D] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))
123+ [D] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)
124+ [D] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
125+ [D] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
126+[C] Streamly.Internal.Data.MutArray.Generic
127+ [D] writeWith :: MonadIO m => Int -> Fold m a (MutArray a)
128+ [D] writeNUnsafe :: MonadIO m => Int -> Fold m a (MutArray a)
129+ [A] unsafeCreateOf :: MonadIO m => Int -> Fold m a (MutArray a)
130+ [A] emptyOf :: MonadIO m => Int -> m (MutArray a)
131+ [A] createWith :: MonadIO m => Int -> Fold m a (MutArray a)
132+ [A] createOf :: MonadIO m => Int -> Fold m a (MutArray a)
133+ [A] create :: MonadIO m => Fold m a (MutArray a)
134+[C] Streamly.Internal.Data.MutArray
135+ [A] SpliceState
136+ [A] SpliceYielding :: arr -> SpliceState s arr -> SpliceState s arr
137+ [A] SpliceInitial :: s -> SpliceState s arr
138+ [A] SpliceFinish :: SpliceState s arr
139+ [A] SpliceBuffering :: s -> arr -> SpliceState s arr
140+ [R] MutByteArray
141+ [D] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
142+ [D] writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
143+ [D] writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
144+ [D] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
145+ [D] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))
146+ [D] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
147+ [D] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
148+ [A] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
149+ [A] unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
150+ [A] unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
151+ [A] unsafeCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
152+ [A] unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
153+ [A] unsafeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
154+ [A] toStreamWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
155+ [A] toStreamRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
156+ [R] toStreamDWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
157+ [R] toStreamDRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a
158+ [A] slicerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a)
159+ [A] sliceIndexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int)
160+ [A] revCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
161+ [D] resizeExp :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
162+ [D] resize :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
163+ [A] pokeSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
164+ [A] pokeAppendMay :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (Maybe (MutArray Word8))
165+ [A] pokeAppend :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (MutArray Word8)
166+ [D] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
167+ [D] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
168+ [D] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
169+ [D] pinnedNewBytes :: MonadIO m => Int -> m (MutArray a)
170+ [A] pinnedEmptyOf :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
171+ [A] pinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
172+ [A] pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
173+ [A] pinnedCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
174+ [A] peekUnconsUnsafe :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (a, MutArray Word8)
175+ [A] peekUncons :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (Maybe a, MutArray Word8)
176+ [A] peekSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
177+ [A] pPinnedCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
178+ [A] pCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
179+ [D] nil :: MutArray a
180+ [A] lPinnedCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
181+ [A] lCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
182+ [A] indexReaderWith :: (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m Int -> Unfold m (MutArray a) a
183+ [A] indexReader :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
184+ [A] growExp :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
185+ [A] grow :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
186+ [D] getSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a)
187+ [R] getIndicesD :: (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m Int -> Unfold m (MutArray a) a
188+ [D] getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
189+ [D] genSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int)
190+ [A] fromStreamN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (MutArray a)
191+ [D] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (MutArray a)
192+ [D] fromStreamD :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
193+ [A] fromPureStreamN :: (MonadIO m, Unbox a) => Int -> Stream Identity a -> m (MutArray a)
194+ [A] fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
195+ [A] fromChunksRealloced :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> m (MutArray a)
196+ [A] fromChunksK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)
197+ [A] fromByteStr# :: MonadIO m => Addr# -> m (MutArray Word8)
198+ [D] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)
199+ [D] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
200+ [D] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
201+ [A] fPinnedCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
202+ [A] fCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
203+ [A] emptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
204+ [A] empty :: MutArray a
205+ [A] createWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
206+ [A] createOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
207+ [A] createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
208+ [A] create :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
209+ [A] concatWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m (MutArray a) -> Stream m a
210+ [A] concatRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m (MutArray a) -> Stream m a
211+ [A] concatRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
212+ [A] concat :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a
213+ [A] compactOnByteSuffix :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
214+ [A] compactOnByte :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
215+ [A] compactLeAs :: forall m a. (MonadIO m, Unbox a) => PinnedState -> Int -> Stream m (MutArray a) -> Stream m (MutArray a)
216+ [A] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
217+ [A] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
218+ [A] compactEQ :: Int -> Stream m (MutArray a) -> Stream m (MutArray a)
219+ [D] cmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
220+ [A] byteEq :: MonadIO m => MutArray a -> MutArray a -> m Bool
221+ [A] byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
222+ [A] buildChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))
223+ [D] asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
224+ [A] appendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
225+ [A] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
226+ [A] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
227+[D] Streamly.Internal.Data.Array.Stream
228+ [C] interposeSuffix
229+ [O] interposeSuffix :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
230+ [N] interposeSuffix :: forall m a. (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
231+ [D] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
232+ [D] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
233+ [C] concatRev
234+ [O] concatRev :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
235+ [N] concatRev :: forall m a. (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
236+ [D] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))
237+[C] Streamly.Internal.Data.Array.Generic
238+ [A] createOf :: MonadIO m => Int -> Fold m a (Array a)
239+ [A] create :: MonadIO m => Fold m a (Array a)
240+[C] Streamly.Internal.Data.Array
241+ [R] ArrayUnsafe
242+ [D] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
243+ [D] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
244+ [A] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
245+ [A] unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
246+ [A] unsafeCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
247+ [D] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a
248+ [D] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a
249+ [C] splice
250+ [O] splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)
251+ [N] splice :: MonadIO m => Array a -> Array a -> m (Array a)
252+ [A] slicerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Array a)
253+ [A] sliceIndexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Int, Int)
254+ [D] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
255+ [D] pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a)
256+ [D] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
257+ [D] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
258+ [A] pinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
259+ [A] pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
260+ [A] pinnedCompactLE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
261+ [A] parseBreakChunksK :: forall m a b. (MonadIO m, Unbox a) => Parser a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
262+ [D] nil :: Array a
263+ [A] lPinnedCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()
264+ [A] lCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()
265+ [A] interposeSuffix :: forall m a. (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
266+ [A] interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
267+ [A] intercalateSuffix :: (Monad m, Unbox a) => Array a -> Stream m (Array a) -> Stream m a
268+ [A] indexReaderFromThenTo :: Unfold m (Int, Int, Int, Array a) a
269+ [A] indexReader :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a
270+ [A] indexFinder :: (a -> Bool) -> Unfold Identity (Array a) Int
271+ [D] getSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Array a)
272+ [R] getIndicesFromThenTo :: Unfold m (Int, Int, Int, Array a) a
273+ [D] getIndices :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a
274+ [D] genSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Int, Int)
275+ [D] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)
276+ [D] fromStreamD :: forall m a. (MonadIO m, Unbox a) => Stream m a -> m (Array a)
277+ [A] fromPureStreamN :: Unbox a => Int -> Stream Identity a -> Array a
278+ [A] fromPtrN :: Int -> Ptr Word8 -> Array Word8
279+ [A] fromChunksK :: (MonadIO m, Unbox a) => StreamK m (Array a) -> m (Array a)
280+ [A] fromChunks :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)
281+ [A] fromByteStr :: Ptr Word8 -> Array Word8
282+ [A] foldChunks :: (MonadIO m, Unbox a) => Fold m a b -> Stream m (Array a) -> m b
283+ [A] foldBreakChunksK :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a))
284+ [A] foldBreakChunks :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> Stream m (Array a) -> m (b, Stream m (Array a))
285+ [D] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
286+ [D] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a
287+ [C] findIndicesOf
288+ [O] findIndicesOf :: (a -> Bool) -> Unfold Identity (Array a) Int
289+ [N] findIndicesOf :: (a -> Bool) -> Array a -> Stream Identity Int
290+ [A] fPinnedCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
291+ [A] fCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
292+ [A] empty :: Array a
293+ [A] createWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
294+ [A] createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
295+ [A] create :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
296+ [A] concatRev :: forall m a. (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
297+ [A] concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
298+ [A] compactOnByteSuffix :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
299+ [A] compactOnByte :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
300+ [A] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
301+ [A] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
302+ [A] byteEq :: Array a -> Array a -> Bool
303+ [A] byteCmp :: Array a -> Array a -> Ordering
304+ [A] buildChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))
305+ [D] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))
306+ [D] asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
core/docs/Changelog.mdnew file+97
@@ -0,0 +1,97 @@
1+# Changelog
2+
3+## 0.2.2 (Jan 2024)
4+
5+* Add fixities `infixr 5` for `cons` and `consM` functions.
6+* Fix a bug in Array `Eq` instance when the type is a sum type with
7+ differently sized constructors.
8+* lpackArraysChunksOf, compact, writeChunksWith, putChunksWith now take the
9+ buffer size in number of array elements instead of bytes.
10+
11+## 0.2.1 (Dec 2023)
12+
13+* Make the serialization of the unit constructor deterministic.
14+* Expose `pinnedSerialize` & `deserialize` via `Streamly.Data.Array`.
15+
16+## 0.2.0 (Nov 2023)
17+
18+See [0.1.0-0.2.0 API Changelog](https://github.com/composewell/streamly/blob/streamly-0.10.0/core/docs/ApiChangelogs/0.1.0-0.2.0.txt)
19+for a full list of API changes in this release. Only a few significant
20+changes are mentioned here.
21+
22+### Breaking Changes
23+
24+* `ParserK` in `Streamly.Data.ParserK` is not implicitly specialized
25+ to arrays anymore. To adapt to the new code, change `ParserK a m
26+ b` to `ParserK (Array a) m b` where the `Array` type comes from
27+ `Streamly.Data.Array`. This change also affected the signatures of
28+ `parseChunks` and `parseBreakChunks`.
29+* Changed the signature of 'Streamly.Data.Stream.handle' to make the
30+ exception handler monadic.
31+* Behavior change: Exceptions are now rethrown promptly in `bracketIO`.
32+
33+### Enhancements
34+
35+* __Serialization__: Added a `Streamly.Data.MutByteArray` module with a
36+ `Serialize` type class for fast binary serialization. The Data.Array
37+ module supplies the `serialize` and `deserialize` operations for arrays.
38+* __Unpinned Arrays__: Unboxed arrays are now created unpinned by default,
39+ they were created pinned earlier. During IO operations, unpinned arrays
40+ are automatically copied to pinned memory. When arrays are directly
41+ passed to IO operations programmers can choose to create them pinned to
42+ avoid a copy. To create pinned arrays, use the internal APIs with the
43+ `pinned*` prefix.
44+* StreamK now supports native exception handling routines (handle, bracketIO).
45+ Earlier we had to convert it to the `Stream` type for exception handling.
46+
47+### Deprecations
48+
49+See [0.1.0-0.2.0 API Changelog](https://github.com/composewell/streamly/blob/streamly-0.10.0/core/docs/ApiChangelogs/0.1.0-0.2.0.txt)
50+for a full list of deprecations.
51+
52+### Internal API Changes
53+
54+* Fold constructor has changed, added a `final` field to support
55+ finalization and cleanup of a chain of folds. The `extract` field is
56+ now used only for mapping the fold internal state to fold result for
57+ scanning purposes. If your fold does not require cleanup you can just use
58+ your existing `extract` function as `final` as well to adapt to this change.
59+* Many low level internal modules have been removed, they are entirely
60+ exported from higher level internal modules. If you were importing any
61+ of the missing low level modules then import the higher level modules instead.
62+* Internal module changes:
63+ * Streamly.Internal.Serialize.FromBytes -> Streamly.Internal.Data.Binary.Parser
64+ * Streamly.Internal.Serialize.ToBytes -> Streamly.Internal.Data.Binary.Stream
65+ * Streamly.Internal.Data.Unbox is now exported via Streamly.Internal.Data.Serialize
66+ * Streamly.Internal.Data.IORef.Unboxed is now exported via Streamly.Internal.Data.Serialize
67+
68+## 0.1.0 (March 2023)
69+
70+Also see [streamly-core-0.1.0 API Changelog](https://github.com/composewell/streamly/blob/streamly-0.10.0/core/docs/ApiChangelogs/0.1.0.txt) or
71+https://hackage.haskell.org/package/streamly-core-0.1.0/docs/docs/ApiChangelogs/0.1.0.txt
72+
73+`streamly` package is split into two packages, (1) `streamly-core` that
74+has only GHC boot library depdendecies, and (2) `streamly` that contains
75+higher level operations (including concurrent ones) with additional
76+dependencies.
77+
78+* Moved the following modules from `streamly` package to the
79+ `streamly-core` package:
80+ * Streamly.Console.Stdio
81+ * Streamly.Data.Fold
82+ * Streamly.Data.Unfold
83+ * Streamly.FileSystem.Handle
84+ * Streamly.Unicode.Stream
85+* Added the following new modules:
86+ * Streamly.Data.Array
87+ * Streamly.Data.Array.Generic
88+ * Streamly.Data.MutArray
89+ * Streamly.Data.MutArray.Generic
90+ * Streamly.Data.Parser
91+ * Streamly.Data.ParserK
92+ * Streamly.Data.Stream
93+ * Streamly.Data.StreamK
94+ * Streamly.FileSystem.Dir
95+ * Streamly.FileSystem.File
96+ * Streamly.Unicode.Parser
97+ * Streamly.Unicode.String
core/docs/Readme.mdnew file+1
@@ -0,0 +1 @@
1+Please refer to the "streamly" package for tutorials and other documentation.
core/src/DocTestDataArray.hsnew file+22
@@ -0,0 +1,22 @@
1+{- $setup
2+>>> :m
3+>>> :set -XFlexibleContexts
4+>>> :set -XMagicHash
5+>>> import Data.Function ((&))
6+>>> import Data.Functor.Identity (Identity(..))
7+>>> import System.IO.Unsafe (unsafePerformIO)
8+
9+>>> import Streamly.Data.Array (Array)
10+>>> import Streamly.Data.Stream (Stream)
11+
12+>>> import qualified Streamly.Data.Array as Array
13+>>> import qualified Streamly.Data.Fold as Fold
14+>>> import qualified Streamly.Data.ParserK as ParserK
15+>>> import qualified Streamly.Data.Stream as Stream
16+>>> import qualified Streamly.Data.StreamK as StreamK
17+
18+For APIs that have not been released yet.
19+
20+>>> import qualified Streamly.Internal.Data.Array as Array
21+>>> import qualified Streamly.Internal.Data.Stream as Stream
22+-}
core/src/DocTestDataFold.hsnew file+27
@@ -0,0 +1,27 @@
1+{- $setup
2+>>> :m
3+>>> :set -XFlexibleContexts
4+>>> import Control.Monad (void)
5+>>> import qualified Data.Foldable as Foldable
6+>>> import Data.Function ((&))
7+>>> import Data.Functor.Identity (Identity, runIdentity)
8+>>> import Data.IORef (newIORef, readIORef, writeIORef)
9+>>> import Data.Maybe (fromJust, isJust)
10+>>> import Data.Monoid (Endo(..), Last(..), Sum(..))
11+
12+>>> import Streamly.Data.Array (Array)
13+>>> import Streamly.Data.Fold (Fold, Tee(..))
14+>>> import Streamly.Data.Stream (Stream)
15+
16+>>> import qualified Streamly.Data.Array as Array
17+>>> import qualified Streamly.Data.Fold as Fold
18+>>> import qualified Streamly.Data.MutArray as MutArray
19+>>> import qualified Streamly.Data.Parser as Parser
20+>>> import qualified Streamly.Data.Stream as Stream
21+>>> import qualified Streamly.Data.StreamK as StreamK
22+>>> import qualified Streamly.Data.Unfold as Unfold
23+
24+For APIs that have not been released yet.
25+
26+>>> import qualified Streamly.Internal.Data.Fold as Fold
27+-}
core/src/DocTestDataMutArray.hsnew file+10
@@ -0,0 +1,10 @@
1+{- $setup
2+>>> :m
3+>>> import qualified Streamly.Data.Fold as Fold
4+>>> import qualified Streamly.Data.MutArray as MutArray
5+>>> import qualified Streamly.Data.Stream as Stream
6+
7+For APIs that have not been released yet.
8+
9+>>> import Streamly.Internal.Data.MutArray as MutArray
10+-}
core/src/DocTestDataMutArrayGeneric.hsnew file+10
@@ -0,0 +1,10 @@
1+{- $setup
2+>>> :m
3+>>> import qualified Streamly.Data.Fold as Fold
4+>>> import qualified Streamly.Data.MutArray.Generic as MutArray
5+>>> import qualified Streamly.Data.Stream as Stream
6+
7+For APIs that have not been released yet.
8+
9+>>> import Streamly.Internal.Data.MutArray.Generic as MutArray
10+-}
core/src/DocTestDataParser.hsnew file+20
@@ -0,0 +1,20 @@
1+{- $setup
2+>>> :m
3+>>> import Control.Applicative ((<|>))
4+>>> import Data.Bifunctor (second)
5+>>> import Data.Char (isSpace)
6+>>> import qualified Data.Foldable as Foldable
7+>>> import qualified Data.Maybe as Maybe
8+
9+>>> import Streamly.Data.Fold (Fold)
10+>>> import Streamly.Data.Parser (Parser)
11+
12+>>> import qualified Streamly.Data.Fold as Fold
13+>>> import qualified Streamly.Data.Parser as Parser
14+>>> import qualified Streamly.Data.Stream as Stream
15+
16+For APIs that have not been released yet.
17+
18+>>> import qualified Streamly.Internal.Data.Fold as Fold
19+>>> import qualified Streamly.Internal.Data.Parser as Parser
20+-}
core/src/DocTestDataParserK.hsnew file+15
@@ -0,0 +1,15 @@
1+{- $setup
2+>>> :m
3+>>> import Control.Applicative ((<|>))
4+>>> import Data.Char (isDigit, isAlpha)
5+
6+>>> import Streamly.Data.Parser (Parser)
7+>>> import Streamly.Data.ParserK (ParserK)
8+
9+>>> import qualified Streamly.Data.Parser as Parser
10+>>> import qualified Streamly.Data.ParserK as ParserK
11+
12+For APIs that have not been released yet.
13+
14+>>> import qualified Streamly.Internal.Data.ParserK as ParserK
15+-}
core/src/DocTestDataStream.hsnew file+39
@@ -0,0 +1,39 @@
1+{- $setup
2+
3+>>> :m
4+>>> import Control.Concurrent (threadDelay)
5+>>> import Control.Monad (void)
6+>>> import Control.Monad.IO.Class (MonadIO (liftIO))
7+>>> import Control.Monad.Trans.Class (lift)
8+>>> import Control.Monad.Trans.Identity (runIdentityT)
9+>>> import Data.Char (isSpace)
10+>>> import Data.Either (fromLeft, fromRight, isLeft, isRight, either)
11+>>> import Data.Maybe (fromJust, isJust)
12+>>> import Data.Function (fix, (&))
13+>>> import Data.Functor.Identity (runIdentity)
14+>>> import Data.IORef
15+>>> import Data.Semigroup (cycle1)
16+>>> import GHC.Exts (Ptr (Ptr))
17+>>> import System.IO (stdout, hSetBuffering, BufferMode(LineBuffering))
18+
19+>>> hSetBuffering stdout LineBuffering
20+>>> effect n = print n >> return n
21+
22+>>> import Streamly.Data.Stream (Stream)
23+>>> import qualified Streamly.Data.Array as Array
24+>>> import qualified Streamly.Data.Fold as Fold
25+>>> import qualified Streamly.Data.Stream as Stream
26+>>> import qualified Streamly.Data.StreamK as StreamK
27+>>> import qualified Streamly.Data.Unfold as Unfold
28+>>> import qualified Streamly.Data.Parser as Parser
29+>>> import qualified Streamly.FileSystem.Dir as Dir
30+
31+For APIs that have not been released yet.
32+
33+>>> import qualified Streamly.Internal.Data.Fold as Fold
34+>>> import qualified Streamly.Internal.Data.Parser as Parser
35+>>> import qualified Streamly.Internal.Data.Stream as Stream
36+>>> import qualified Streamly.Internal.Data.StreamK as StreamK
37+>>> import qualified Streamly.Internal.Data.Unfold as Unfold
38+>>> import qualified Streamly.Internal.FileSystem.Dir as Dir
39+-}
core/src/DocTestDataStreamK.hsnew file+21
@@ -0,0 +1,21 @@
1+{- $setup
2+
3+>>> :m
4+>>> import Control.Concurrent (threadDelay)
5+>>> import Data.Function (fix, (&))
6+>>> import Data.Semigroup (cycle1)
7+
8+>>> effect n = print n >> return n
9+
10+>>> import Streamly.Data.StreamK (StreamK)
11+>>> import qualified Streamly.Data.Fold as Fold
12+>>> import qualified Streamly.Data.Parser as Parser
13+>>> import qualified Streamly.Data.Stream as Stream
14+>>> import qualified Streamly.Data.StreamK as StreamK
15+>>> import qualified Streamly.FileSystem.Dir as Dir
16+
17+For APIs that have not been released yet.
18+
19+>>> import qualified Streamly.Internal.Data.StreamK as StreamK
20+>>> import qualified Streamly.Internal.FileSystem.Dir as Dir
21+-}
core/src/DocTestDataUnfold.hsnew file+12
@@ -0,0 +1,12 @@
1+{- $setup
2+
3+>>> :m
4+>>> import Streamly.Data.Unfold (Unfold)
5+>>> import qualified Streamly.Data.Fold as Fold
6+>>> import qualified Streamly.Data.Stream as Stream
7+>>> import qualified Streamly.Data.Unfold as Unfold
8+
9+For APIs that have not been released yet.
10+
11+>>> import qualified Streamly.Internal.Data.Unfold as Unfold
12+-}
core/src/DocTestFileSystemHandle.hsnew file+15
@@ -0,0 +1,15 @@
1+{- $setup
2+>>> :m
3+>>> import qualified Streamly.Data.Array as Array
4+>>> import qualified Streamly.FileSystem.Handle as Handle hiding (readChunks)
5+>>> import qualified Streamly.Data.Fold as Fold
6+>>> import qualified Streamly.Data.Stream as Stream
7+>>> import qualified Streamly.Data.Unfold as Unfold
8+
9+For APIs that have not been released yet.
10+
11+>>> import qualified Streamly.Internal.Data.Array as Array (unsafeCreateOf)
12+>>> import qualified Streamly.Internal.Data.Unfold as Unfold (first)
13+>>> import qualified Streamly.Internal.FileSystem.Handle as Handle
14+>>> import qualified Streamly.Internal.System.IO as IO (defaultChunkSize)
15+-}
core/src/DocTestUnicodeParser.hsnew file+9
@@ -0,0 +1,9 @@
1+{- $setup
2+>>> :m
3+>>> import qualified Streamly.Data.Stream as Stream
4+>>> import qualified Streamly.Unicode.Parser as Unicode
5+
6+For APIs that have not been released yet.
7+
8+>>> import qualified Streamly.Internal.Unicode.Parser as Unicode (number, mkDouble)
9+-}
core/src/DocTestUnicodeStream.hsnew file+12
@@ -0,0 +1,12 @@
1+{- $setup
2+>>> :m
3+
4+>>> import qualified Streamly.Data.Fold as Fold
5+>>> import qualified Streamly.Data.Stream as Stream
6+>>> import qualified Streamly.Unicode.Stream as Unicode
7+
8+For APIs that have not been released yet.
9+
10+>>> :set -XMagicHash
11+>>> import qualified Streamly.Internal.Unicode.Stream as Unicode
12+-}
core/src/DocTestUnicodeString.hsnew file+5
@@ -0,0 +1,5 @@
1+{- $setup
2+>>> :m
3+>>> :set -XQuasiQuotes
4+>>> import Streamly.Internal.Unicode.String
5+-}
core/src/Streamly/Console/Stdio.hs+1−27
@@ -24,33 +24,7 @@ module Streamly.Console.Stdio
2424 -- * Write (stderr)
2525 , writeErr
2626 , writeErrChunks
27−
28− -- * Deprecated
29− , read
30− , readChunks
3127 )
3228where
3329
34−import Control.Monad.IO.Class (MonadIO(..))
35−import Data.Word (Word8)
36−import Streamly.Internal.Data.Array.Type (Array)
37−import Streamly.Internal.Data.Unfold (Unfold)
38−
39−import Streamly.Internal.Console.Stdio hiding (read, readChunks)
40−import Prelude hiding (read)
41−
42−-- Same as 'reader'
43−--
44−-- @since 0.8.0
45−{-# DEPRECATED read "Please use 'reader' instead" #-}
46−{-# INLINE read #-}
47−read :: MonadIO m => Unfold m () Word8
48−read = reader
49−
50−-- Same as 'chunkReader'
51−--
52−-- @since 0.8.0
53−{-# DEPRECATED readChunks "Please use 'chunkReader' instead" #-}
54−{-# INLINE readChunks #-}
55−readChunks :: MonadIO m => Unfold m () (Array Word8)
56−readChunks = chunkReader
30+import Streamly.Internal.Console.Stdio
core/src/Streamly/Data/Array.hs+115−117
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.Array
34-- Copyright : (c) 2019 Composewell Technologies
@@ -7,163 +8,160 @@
78-- Stability : released
89-- Portability : GHC
910--
10−-- This module provides APIs to create and use unboxed immutable arrays. Once
11−-- created, their contents cannot be modified. Only types that are unboxable
12−-- via the 'Unbox' type class can be stored in these arrays. Note that the
13−-- array memory grows automatically when creating a new array, therefore, an
14−-- array can be created from a variable length stream.
15−--
16−-- See "Streamly.Data.Array.Generic" for arrays that work for boxed types i.e.
17−-- not requiring the 'Unbox' constraint.
18−-- See "Streamly.Data.MutArray" for arrays that can be mutated in-place..
19−--
20−-- = Folding Arrays
21−--
22−-- Convert array to stream, and fold the stream:
23−--
24−-- >>> fold f arr = Stream.unfold Array.reader arr & Stream.fold f
25−-- >>> fold Fold.sum (Array.fromList [1,2,3::Int])
26−-- 6
27−--
28−-- = Transforming Arrays
29−--
30−-- Convert array to stream, transform, and fold back to array:
31−--
32−-- >>> amap f arr = Stream.unfold Array.reader arr & fmap f & Stream.fold Array.write
33−-- >>> amap (+1) (Array.fromList [1,2,3::Int])
34−-- fromList [2,3,4]
35−--
36−-- = Pinned and Unpinned Arrays
37−--
38−-- The array type can use both pinned and unpinned memory under the hood.
39−-- Currently the array creation APIs create arrays in pinned memory but it will
40−-- change to unpinned in future releases. The change should not affect users
41−-- functionally unless they are directly accessing the internal memory of the
42−-- array via internal APIs. As of now unpinned arrays can be created using
43−-- unreleased APIs.
44−--
45−-- Unpinned arrays have the advantage of allowing automatic defragmentation of
46−-- the memory by GC. Whereas pinned arrays have the advantage of not requiring
47−-- a copy by GC. Normally you would want to use unpinned arrays. However, in
48−-- some cases, for example, for long lived large data storage, and for
49−-- interfacing with the operating system or foreign (non-Haskell) consumers you
50−-- may want to use pinned arrays.
51−--
52−-- = Creating Arrays from Non-IO Streams
53−--
54−-- Array creation folds require 'MonadIO' because they need to sequence effects
55−-- in IO streams. To operate on streams in pure Monads like 'Identity' you can
56−-- morph it to IO monad as follows:
57−--
58−-- The 'MonadIO' based folds can be morphed to 'Identity' stream folds:
59−--
60−-- >>> purely = Fold.morphInner (Identity . unsafePerformIO)
61−-- >>> Stream.fold (purely Array.write) $ Stream.fromList [1,2,3::Int]
62−-- Identity fromList [1,2,3]
63−--
64−-- Since it is a pure stream we can use 'unsafePerformIO' to extract the result
65−-- of fold from IO.
66−--
67−-- Alternatively, 'Identity' streams can be generalized to IO streams:
11+-- Unboxed immutable arrays with streaming interfaces.
6812--
69−-- >>> pure = Stream.fromList [1,2,3] :: Stream Identity Int
70−-- >>> generally = Stream.morphInner (return . runIdentity)
71−-- >>> Stream.fold Array.write (generally pure :: Stream IO Int)
72−-- fromList [1,2,3]
73−--
74−-- = Programming Tips
75−--
76−-- This module is designed to be imported qualified:
77−--
78−-- >>> import qualified Streamly.Data.Array as Array
13+-- Please refer to "Streamly.Internal.Data.Array" for functions that have not
14+-- yet been released.
7915--
80−-- Use @QuantifiedConstraints@ extension to avoid the 'Storable' constraint
81−-- when using the 'Unbox' constraint.
82−--
83−-- For experimental APIs see "Streamly.Internal.Data.Array".
16+-- For arrays that work on boxed types, not requiring the 'Unbox' constraint,
17+-- please refer to "Streamly.Data.Array.Generic". For arrays that can be
18+-- mutated in-place, please see "Streamly.Data.MutArray".
8419
8520module Streamly.Data.Array
8621 (
87− -- * Imports for Examples
22+ -- * Setup
23+ -- | To execute the code examples provided in this module in ghci, please
24+ -- run the following commands first.
25+ --
8826 -- $setup
8927
28+ -- * Overview
29+ -- $overview
30+
9031 -- * The Array Type
91− A.Array
32+ Array
33+
34+ -- * Pinning & Unpinning
35+ -- | Arrays are created unpinned by default unless pinned versions of
36+ -- creation APIs are used. Look for APIs with @pinned@ prefix in
37+ -- "Streamly.Internal.Data.Array" for some unreleased pinned creation APIs.
38+ -- If an array is to be sent to the OS without any further modification
39+ -- then it should be created pinned in the first place instead of pinning
40+ -- it later. Pinning an unpinned array has a copy overhead. OS interfacing
41+ -- APIs create a pinned array directly or convert an unpinned array to
42+ -- pinned array before sending it to the OS.
43+ , pin
44+ , unpin
45+ , isPinned
9246
9347 -- * Construction
9448 -- | When performance matters, the fastest way to generate an array is
95− -- 'writeN'. 'IsList' and 'IsString' instances can be
49+ -- 'createOf'. 'IsList' and 'IsString' instances can be
9650 -- used to conveniently construct arrays from literal values.
9751 -- 'OverloadedLists' extension or 'fromList' can be used to construct an
9852 -- array from a list literal. Similarly, 'OverloadedStrings' extension or
9953 -- 'fromList' can be used to construct an array from a string literal.
10054
101− -- Pure List APIs
102− , A.fromListN
103− , A.fromList
104−
105− -- Monadic APIs
106− , A.writeN -- drop new
107− , A.write -- full buffer
55+ -- ** From Stream
56+ , createOf
57+ , create
10858 , writeLastN -- drop old (ring buffer)
10959
110− -- * Conversion
60+ -- ** From List
61+ , fromListN
62+ , fromList
63+
64+ -- * To List
11165 -- 'GHC.Exts.toList' from "GHC.Exts" can be used to convert an array to a
11266 -- list.
113− , A.toList
67+ , toList
68+
69+ -- * To Stream
70+ , read
71+ , readRev
11472
11573 -- * Unfolds
116− , A.reader
117− , A.readerRev
74+ , reader
75+ , readerRev
11876
11977 -- * Casting
12078 , cast
12179 , asBytes
12280
12381 -- * Random Access
124− , A.length
82+ , length
12583 -- , (!!)
126− , A.getIndex
84+ , getIndex
85+
86+ -- * Serialization
87+ , pinnedSerialize
88+ , deserialize
12789
128− -- * Unbox Type Class
90+ -- * Re-exports
12991 , Unbox (..)
92+ , Serialize(..)
13093
13194 -- * Deprecated
132− , read
133− , readRev
95+ , writeN -- drop new
96+ , write -- full buffer
13497 )
13598where
13699
137100#include "inline.hs"
138101
139−import Streamly.Internal.Data.Unfold (Unfold)
140−import Streamly.Internal.Data.Array as A hiding (read, readRev)
102+import Streamly.Internal.Data.Array
103+import Streamly.Internal.Data.MutByteArray (Unbox(..), Serialize(..))
141104
142−import Streamly.Internal.Data.Unboxed (Unbox (..))
143−import Prelude hiding (read)
105+import Prelude hiding (read, length)
144106
145−-- $setup
146−-- >>> :m
147−-- >>> :set -XFlexibleContexts
148−-- >>> import Data.Function ((&))
149−-- >>> import Data.Functor.Identity (Identity(..))
150−-- >>> import Streamly.Data.Array (Array)
151−-- >>> import Streamly.Data.Stream (Stream)
152−-- >>> import System.IO.Unsafe (unsafePerformIO)
153−-- >>> import qualified Streamly.Data.Array as Array
154−-- >>> import qualified Streamly.Data.Fold as Fold
155−-- >>> import qualified Streamly.Data.Stream as Stream
107+#include "DocTestDataArray.hs"
156108
157−-- | Same as 'reader'
109+-- $overview
158110--
159−{-# DEPRECATED read "Please use 'reader' instead" #-}
160−{-# INLINE_NORMAL read #-}
161−read :: (Monad m, Unbox a) => Unfold m (Array a) a
162−read = reader
163−
164−-- | Same as 'readerRev'
111+-- This module provides APIs to create and use unboxed immutable arrays. Once
112+-- created, their contents cannot be modified. Only types that are unboxable
113+-- via the 'Unbox' type class can be stored in these arrays. Note that the
114+-- array memory grows automatically when creating a new array, therefore, an
115+-- array can be created from a variable length stream.
116+--
117+-- == Folding Arrays
118+--
119+-- Convert array to stream, and fold the stream:
165120--
166−{-# DEPRECATED readRev "Please use 'readerRev' instead" #-}
167−{-# INLINE_NORMAL readRev #-}
168−readRev :: (Monad m, Unbox a) => Unfold m (Array a) a
169−readRev = readerRev
121+-- >>> fold f arr = Array.read arr & Stream.fold f
122+-- >>> fold Fold.sum (Array.fromList [1,2,3::Int])
123+-- 6
124+--
125+-- == Transforming Arrays
126+--
127+-- Convert array to stream, transform, and fold back to array:
128+--
129+-- >>> amap f arr = Array.read arr & fmap f & Stream.fold (Array.createOf (Array.length arr))
130+-- >>> amap (+1) (Array.fromList [1,2,3::Int])
131+-- fromList [2,3,4]
132+--
133+-- == Pinned and Unpinned Arrays
134+--
135+-- The array type can use both pinned and unpinned memory under the hood. The
136+-- default array creation operations create unpinned arrays. IO operations
137+-- automatically copy an array to pinned memory if the array passed to it is
138+-- unpinned. Programmers can use appropriate pinned array generation APIs to
139+-- reduce the copying if it happens.
140+--
141+-- Unpinned arrays have the advantage of allowing automatic defragmentation of
142+-- the memory by GC. Whereas pinned arrays have the advantage of not requiring
143+-- a copy by GC. Normally you would want to use unpinned arrays. However, in
144+-- some cases, for example, for long lived large data storage, and for
145+-- interfacing with the operating system or foreign (non-Haskell) consumers you
146+-- may want to use pinned arrays.
147+--
148+-- == Creating Arrays from Non-IO Streams
149+--
150+-- Array creation folds require 'MonadIO' otherwise the compiler may
151+-- incorrectly share the array memory thinking it is pure.
152+--
153+-- See the 'fromPureStream' unreleased API to generate an array from an
154+-- Identity stream safely without using MonadIO constraint.
155+--
156+-- Note that 'Identity' streams can be generalized to IO streams:
157+--
158+-- >>> stream = Stream.fromList [1,2,3] :: Stream Identity Int
159+-- >>> pure2IO s = Stream.morphInner (return . runIdentity) s :: Stream IO Int
160+-- >>> Stream.fold Array.create (pure2IO stream)
161+-- fromList [1,2,3]
162+--
163+-- == Programming Tips
164+--
165+-- This module is designed to be imported qualified:
166+--
167+-- >>> import qualified Streamly.Data.Array as Array
core/src/Streamly/Data/Array/Generic.hs+19−11
@@ -15,29 +15,37 @@ module Streamly.Data.Array.Generic
1515 ( Array
1616
1717 -- * Construction
18− , A.fromListN
19− , A.fromList
18+ , fromListN
19+ , fromList
2020
2121 -- MonadicAPIs
22− , A.writeN
23− , A.write
22+ , createOf
23+ , create
24+
25+ -- * Conversion
26+ , toList
2427
2528 -- * Streams
26− , A.read
27− , A.readRev
29+ , read
30+ , readRev
2831
2932 -- * Unfolds
30− , A.reader
33+ , reader
34+ -- , A.readerRev
3135
3236 -- * Random Access
33− , A.length
37+ , length
38+ , getIndex
3439
3540 -- -- * Folding Arrays
3641 -- , A.streamFold
3742 -- , A.fold
43+
44+ -- * Deprecated
45+ , writeN
46+ , write
3847 )
3948where
4049
41−import Streamly.Internal.Data.Array.Generic (Array)
42−
43−import qualified Streamly.Internal.Data.Array.Generic as A
50+import Streamly.Internal.Data.Array.Generic
51+import Prelude hiding (length, read)
core/src/Streamly/Data/Fold.hs+90−51
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.Fold
34-- Copyright : (c) 2019 Composewell Technologies
@@ -6,31 +7,45 @@
67-- Stability : released
78-- Portability : GHC
89--
9−-- A 'Fold' is a sink or a consumer of a stream of values. The 'Fold' type
10−-- consists of an accumulator and an effectful action that absorbs a value into
11−-- the accumulator.
10+-- Fast, composable stream consumers with ability to terminate, supporting
11+-- stream fusion.
1212--
13−-- >>> import Data.Function ((&))
14−-- >>> import qualified Streamly.Data.Fold as Fold
15−-- >>> import qualified Streamly.Data.Stream as Stream
13+-- == Using Folds
1614--
17−-- For example, a 'sum' Fold represents adding the input to the accumulated
18−-- sum. A fold driver pushes values from a stream to the 'Fold' one at a time,
19−-- reducing the stream to a single value.
15+-- This module provides elementary folds and fold combinators that can be used
16+-- to consume a stream of data and reduce it to a final value, or transform it
17+-- in a stateful manner using scans. A data stream can be reduced into a stream
18+-- of folded data elements by folding segments of the stream. Fold combinators
19+-- can be used to compose multiple folds in parallel or to create a pipeline of
20+-- folds such that the next fold consumes the result of the previous fold. To
21+-- run these folds on a stream see 'Streamly.Data.Stream.fold',
22+-- 'Streamly.Data.Stream.scan', 'Streamly.Data.Stream.postscan',
23+-- 'Streamly.Data.Stream.scanMaybe', 'Streamly.Data.Stream.foldMany' and other
24+-- operations accepting 'Fold' type as argument "Streamly.Data.Stream".
25+--
26+-- == Reducing a Stream
27+--
28+-- A 'Fold' is a consumer of a stream of values. A fold driver (such as
29+-- 'Streamly.Data.Stream.fold') initializes the fold @accumulator@, runs the
30+-- fold @step@ function in a loop, processing the input stream one element at a
31+-- time and accumulating the result. The loop continues until the fold
32+-- terminates, at which point the accumulated result is returned.
33+--
34+-- For example, a 'sum' Fold represents a stream consumer that adds the values
35+-- in the input stream:
2036--
2137-- >>> Stream.fold Fold.sum $ Stream.fromList [1..100]
2238-- 5050
2339--
24−-- Conceptually, a 'Fold' is a data type that can mimic a strict left fold
25−-- ('Data.List.foldl') as well as lazy right fold ('Prelude.foldr'). The above
26−-- example is similar to a left fold using @(+)@ as the step and @0@ as the
27−-- initial value of the accumulator:
40+-- Conceptually, a 'Fold' is a data type that mimics a strict left fold
41+-- ('Data.List.foldl'). The above example is similar to a left fold using
42+-- @(+)@ as the step and @0@ as the initial value of the accumulator:
2843--
2944-- >>> Data.List.foldl' (+) 0 [1..100]
3045-- 5050
3146--
32−-- 'Fold's have an early termination capability e.g. the 'one' fold would
33−-- terminate on an infinite stream:
47+-- 'Fold's have an early termination capability e.g. the 'one' fold terminates
48+-- after consuming one element:
3449--
3550-- >>> Stream.fold Fold.one $ Stream.fromList [1..]
3651-- Just 1
@@ -47,6 +62,8 @@
4762-- >>> Stream.fold sumTwo $ Stream.fromList [1..100]
4863-- 3
4964--
65+-- == Parallel Composition
66+--
5067-- Folds can be combined to run in parallel on the same input. For example, to
5168-- compute the average of numbers in a stream without going through the stream
5269-- twice:
@@ -66,6 +83,8 @@
6683-- >>> Stream.fold f stream
6784-- ("Even 50","Odd 50")
6885--
86+-- == Sequential Composition
87+--
6988-- Terminating folds can be combined to parse the stream serially such that the
7089-- first fold consumes the input until it terminates and the second fold
7190-- consumes the rest of the input until it terminates:
@@ -74,6 +93,8 @@
7493-- >>> Stream.fold f $ Stream.fromList "header: hello\n"
7594-- ("header: ","hello\n")
7695--
96+-- == Splitting a Stream
97+--
7798-- A 'Fold' can be applied repeatedly on a stream to transform it to a stream
7899-- of fold results. To split a stream on newlines:
79100--
@@ -86,10 +107,7 @@
86107-- >>> Stream.fold (Fold.many f Fold.toList) $ Stream.fromList "Hello there!\nHow are you\n"
87108-- ["Hello there!\n","How are you\n"]
88109--
89−-- Please see "Streamly.Internal.Data.Fold" for additional @Pre-release@
90−-- functions.
91−--
92−-- = Folds vs. Streams
110+-- == Folds vs. Streams
93111--
94112-- We can often use streams or folds to achieve the same goal. However, streams
95113-- are more efficient in composition of producers (e.g.
@@ -125,12 +143,42 @@
125143-- Notice the similiarity in the definition of @f@ in both cases, the only
126144-- difference is the composition by @&@ vs @$@ and the use @lmap@ vs @map@, the
127145-- difference is due to output vs input side transformations.
146+--
147+-- == Fusion Limitations
148+--
149+-- Folds support stream fusion for generating loops comparable to the speed of
150+-- C. However, it has some limitations. For fusion to work, the folds must be
151+-- inlined, folds must be statically known and not generated dynamically, folds
152+-- should not be passed recursively.
153+--
154+-- Another limitation is due to the quadratic complexity causing slowdown when
155+-- too many nested compositions are used. Especially, the performance of the
156+-- Applicative instance and splitting operations (e.g. 'splitWith') degrades
157+-- quadratically (O(n^2)) when combined @n@ times, roughly 8 or less sequenced
158+-- operations are fine. For these cases folds can be converted to parsers and
159+-- then used as ParserK.
160+--
161+-- == Experimental APIs
162+--
163+-- Please refer to "Streamly.Internal.Data.Fold" for more functions that have
164+-- not yet been released.
128165
129166module Streamly.Data.Fold
130167 (
168+ -- * Setup
169+ -- | To execute the code examples provided in this module in ghci, please
170+ -- run the following commands first.
171+ --
172+ -- $setup
173+
174+ -- * Running A Fold
175+ drive
176+ -- XXX Should we have a stream returning function in fold module?
177+ -- , breakStream
178+
131179 -- * Fold Type
132180
133− Fold -- (..)
181+ , Fold -- (..)
134182 , Tee (..)
135183
136184 -- * Constructors
@@ -171,10 +219,6 @@ module Streamly.Data.Fold
171219 , toListRev
172220 , toSet
173221 , toIntSet
174− , toMap
175− , toMapIO
176− , demuxToMap
177− , demuxToMapIO
178222 , topBy
179223
180224 -- ** Non-Empty Accumulators
@@ -196,14 +240,8 @@ module Streamly.Data.Fold
196240 , uniqBy
197241 , nub
198242 , nubInt
199− , classify
200− , classifyIO
201− , demux
202− , demuxIO
203243
204244 -- ** Terminating Folds
205− -- | These are much like lazy right folds.
206−
207245 , one
208246 , null
209247 -- , satisfy
@@ -223,11 +261,6 @@ module Streamly.Data.Fold
223261 , and
224262 , or
225263
226− -- * Running A Fold
227− , drive
228− -- XXX Should we have a stream returning function in fold module?
229− -- , breakStream
230−
231264 -- * Incremental builders
232265 -- | Mutable arrays ("Streamly.Data.MutArray") are basic builders. You can
233266 -- use the 'Streamly.Data.MutArray.snoc' or
@@ -299,8 +332,11 @@ module Streamly.Data.Fold
299332 , takeEndBy
300333 , takeEndBy_
301334
302− -- ** Serial Append
335+ -- ** Splitting
303336 , splitWith
337+ , many
338+ , groupsOf
339+ -- , intervalsOf
304340
305341 -- ** Parallel Distribution
306342 -- | For applicative composition using distribution see
@@ -322,14 +358,21 @@ module Streamly.Data.Fold
322358 --, partitionByMinM
323359 --, partitionBy
324360
361+ -- ** Key-value Collectors
362+ , toMap
363+ , toMapIO
364+ , demuxToMap
365+ , demuxToMapIO
366+
367+ -- ** Key-value Scanners
368+ , classify
369+ , classifyIO
370+ , demux
371+ , demuxIO
372+
325373 -- ** Unzipping
326374 , unzip
327375
328− -- ** Splitting
329− , many
330− , groupsOf
331− -- , intervalsOf
332−
333376 -- ** Nesting
334377 , concatMap
335378
@@ -351,20 +394,16 @@ module Streamly.Data.Fold
351394where
352395
353396import Prelude
354− hiding (filter, drop, dropWhile, take, takeWhile, zipWith, foldr,
355− foldl, map, mapM_, sequence, all, any, sum, product, elem,
356− notElem, maximum, minimum, head, last, tail, length, null,
357− reverse, iterate, init, and, or, lookup, foldr1, (!!),
358− scanl, scanl1, replicate, concatMap, mconcat, foldMap, unzip,
397+ hiding (Foldable(..), filter, drop, dropWhile, take, takeWhile, zipWith,
398+ map, mapM_, sequence, all, any,
399+ notElem, head, last, tail,
400+ reverse, iterate, init, and, or, lookup, (!!),
401+ scanl, scanl1, replicate, concatMap, mconcat, unzip,
359402 span, splitAt, break, mapM, maybe)
360403
361404import Streamly.Internal.Data.Fold
362−import Streamly.Internal.Data.Fold.Container
363405
364−-- $setup
365−-- >>> import Data.Function ((&))
366−-- >>> import qualified Streamly.Data.Fold as Fold
367−-- >>> import qualified Streamly.Data.Stream as Stream
406+#include "DocTestDataFold.hs"
368407
369408--------------------------------------------------------------------------------
370409-- Deprecated
core/src/Streamly/Data/MutArray.hs+56−15
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.MutArray
34-- Copyright : (c) 2022 Composewell Technologies
@@ -7,47 +8,70 @@
78-- Stability : released
89-- Portability : GHC
910--
10−-- Mutable version of "Streamly.Data.Array". Please refer to that module for
11−-- general documentation. The contents of mutable ararys can be modified
12−-- in-place.
11+-- This module provides a mutable version of "Streamly.Data.Array". The
12+-- contents of a mutable array can be modified in-place. For general
13+-- documentation, please refer to the original module.
1314--
14−-- See "Streamly.Data.MutArray.Generic" for mutable arrays that work for boxed
15−-- types i.e. not requiring the 'Unbox' constraint.
15+-- Please refer to "Streamly.Internal.Data.MutArray" for functions that have
16+-- not yet been released.
17+--
18+-- For mutable arrays that work on boxed types, not requiring the 'Unbox'
19+-- constraint, please refer to "Streamly.Data.MutArray.Generic".
1620
1721module Streamly.Data.MutArray
1822 (
19− -- * Types
23+ -- * Setup
24+ -- | To execute the code examples provided in this module in ghci, please
25+ -- run the following commands first.
26+ --
27+ -- $setup
28+
29+ -- * Mutable Array Type
2030 MutArray
2131
2232 -- * Construction
2333
2434 -- Uninitialized Arrays
25− , new
26− , newPinned
35+ , emptyOf
36+ , pinnedEmptyOf
2737
2838 -- From containers
2939 , fromListN
3040 , fromList
31− , writeN -- drop new
32− , write -- full buffer
41+ , createOf
42+ , create
3343 -- writeLastN
3444
45+ -- * Pinning & Unpinning
46+ , pin
47+ , unpin
48+ , isPinned
49+
3550 -- * Appending elements
3651 , snoc
3752
3853 -- * Appending streams
39− , writeAppendN
40− , writeAppend
54+ , appendN
55+ , append
4156
4257 -- * Inplace mutation
4358 , putIndex
59+ , putIndexUnsafe
60+ , modifyIndex
61+ , modifyIndexUnsafe
62+ , modify
4463
4564 -- * Random access
4665 , getIndex
66+ , getIndexUnsafe
4767
4868 -- * Conversion
4969 , toList
5070
71+ -- * Streams
72+ , read
73+ , readRev
74+
5175 -- * Unfolds
5276 , reader
5377 , readerRev
@@ -59,11 +83,28 @@ module Streamly.Data.MutArray
5983 -- * Size
6084 , length
6185
62− -- * Unbox Type Class
86+ -- * Re-exports
6387 , Unbox (..)
88+
89+ -- * Deprecated
90+ , newPinned
91+ , new
92+ , pinnedNew
93+ , writeN
94+ , write
95+ , writeAppendN
96+ , writeAppend
6497 )
6598where
6699
67100import Prelude hiding (length, read)
68−import Streamly.Internal.Data.Array.Mut
69−import Streamly.Internal.Data.Unboxed (Unbox (..))
101+import Streamly.Internal.Data.MutArray
102+import Streamly.Internal.Data.Unbox (Unbox (..))
103+import Control.Monad.IO.Class (MonadIO)
104+
105+#include "DocTestDataMutArray.hs"
106+
107+{-# DEPRECATED newPinned "Please use pinnedNew instead." #-}
108+{-# INLINE newPinned #-}
109+newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
110+newPinned = pinnedNew
core/src/Streamly/Data/MutArray/Generic.hs+38−8
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.MutArray.Generic
34-- Copyright : (c) 2020 Composewell Technologies
@@ -12,29 +13,58 @@
1213--
1314module Streamly.Data.MutArray.Generic
1415(
16+ -- * Setup
17+ -- | To execute the code examples provided in this module in ghci, please
18+ -- run the following commands first.
19+ --
20+ -- $setup
21+
1522 -- * Type
1623 MutArray
1724
1825 -- * Construction
19− , writeN
26+ , emptyOf
27+ , fromListN
28+ , fromList
29+ , createOf
30+ , create
2031
2132 -- * Appending elements
22− , new
2333 , snoc
2434
35+ -- * Inplace mutation
36+ , putIndex
37+ , putIndexUnsafe
38+ , modifyIndex
39+ , modifyIndexUnsafe
40+ -- , modify
41+
42+ -- * Random reads
43+ , getIndex
44+ , getIndexUnsafe
45+
2546 -- * Conversion
2647 , toList
2748
49+ -- * Streams
50+ , read
51+ , readRev
52+
2853 -- * Unfolds
2954 , reader
55+ -- , readerRev
3056
31− -- * Random reads
32− , getIndex
57+ -- * Size
58+ , length
3359
34− -- * Inplace mutation
35− , putIndex
36− , modifyIndex
60+ -- * Deprecated
61+ , new
62+ , writeN
63+ , write
3764 )
3865where
3966
40−import Streamly.Internal.Data.Array.Generic.Mut.Type
67+import Streamly.Internal.Data.MutArray.Generic
68+import Prelude hiding (read, length)
69+
70+#include "DocTestDataMutArrayGeneric.hs"
core/src/Streamly/Data/MutByteArray.hsnew file+106
@@ -0,0 +1,106 @@
1+-- |
2+-- Module : Streamly.Data.MutByteArray
3+-- Copyright : (c) 2023 Composewell Technologies
4+-- License : BSD3-3-Clause
5+-- Maintainer : streamly@composewell.com
6+-- Portability : GHC
7+--
8+-- A low level byte Array type 'MutByteArray', along with type classes 'Unbox'
9+-- and 'Serialize' for fast binary serialization and deserialization of Haskell
10+-- values. Serialization, deserialization performance is similar to, and in
11+-- some cases many times better than the store package. Conceptually, the
12+-- 'Serialize' type class works in the same way as store.
13+--
14+-- Serialize instances are configurable to use constructor names (see
15+-- 'Streamly.Internal.Data.MutByteArray.encodeConstrNames'), record field names (see
16+-- 'Streamly.Internal.Data.MutByteArray.encodeRecordFields') instead of binary
17+-- encoded values. This is an experimental feature which allows JSON like
18+-- properties with faster speed. For example, you can change the order of
19+-- constructors or record fields without affecting serialized value.
20+--
21+-- Higher level unboxed array modules "Streamly.Data.Array" and
22+-- "Streamly.Data.MutArray" are built on top of this module. Unboxed arrays are
23+-- essentially serialized Haskell values. Array modules provide higher level
24+-- serialization routines like 'Streamly.Internal.Data.Array.pinnedSerialize'
25+-- and 'Streamly.Internal.Data.Array.deserialize' from the
26+-- "Streamly.Internal.Data.Array" module.
27+--
28+-- == Mutable Byte Array
29+--
30+-- 'MutByteArray' is a primitive mutable array in the IO monad. 'Unbox' and
31+-- 'Serialize' type classes use this primitive array to serialize data to and
32+-- deserialize it from. This array is used to build higher level unboxed
33+-- array types 'Streamly.Data.MutArray.MutArray' and 'Streamly.Data.Array.Array'.
34+--
35+-- == Using Unbox
36+--
37+-- The 'Unbox' type class is simple and used to serialize non-recursive fixed
38+-- size data types. This type class is primarily used to implement unboxed
39+-- arrays. Unboxed arrays are just a sequence of serialized fixed length
40+-- Haskell data types. Instances of this type class can be derived using
41+-- 'Generic' or template haskell based deriving functions provided in this
42+-- module.
43+--
44+-- Writing a data type to an array using the array creation routines in
45+-- "Streamly.Data.Array" or "Streamly.Data.MutArray" (e.g. @writeN@ or
46+-- @fromListN@), serializes the type to the array. Similarly, reading the data
47+-- type from the array deserializes it. You can also serialize and deserialize
48+-- directly to and from a 'MutByteArray', using the type class methods.
49+--
50+-- == Using Serialize
51+--
52+-- The 'Serialize' type class is a superset of the 'Unbox' type class, it can
53+-- serialize variable length data types as well e.g. Haskell lists. Use
54+-- 'deriveSerialize' to derive the instances of the type class automatically
55+-- and then use the type class methods to serialize and deserialize to and from
56+-- a 'MutByteArray'.
57+--
58+-- See 'Streamly.Internal.Data.Array.pinnedSerialize' and
59+-- 'Streamly.Internal.Data.Array.deserialize' for 'Array' type based
60+-- serialization.
61+--
62+-- == Comparing serialized values
63+--
64+-- When using the `Unbox` type class the same value may result in differing
65+-- serialized bytes because of unused uninitialized data in case of sum types.
66+-- Therefore, byte comparison of serialized values is not reliable.
67+--
68+-- However, the 'Serialize' type class guarantees that the serialized values
69+-- are always exactly the same and byte comparison of serialized is reliable.
70+--
71+module Streamly.Data.MutByteArray
72+ (
73+
74+ -- * Mutable Byte Array
75+ -- | The standard way to read from or write to a 'MutByteArray' is by using
76+ -- the 'Unbox' or 'Serialize' type class methods.
77+ MutByteArray
78+ , isPinned
79+ , pin
80+ , unpin
81+ , new
82+ , pinnedNew
83+
84+ -- * Unbox
85+ , Unbox(..)
86+ , deriveUnbox
87+
88+ -- * Serialize
89+ , Serialize(..)
90+
91+ -- ** Instance Config
92+ , SerializeConfig
93+ , inlineAddSizeTo
94+ , inlineSerializeAt
95+ , inlineDeserializeAt
96+
97+ -- ** Instance Deriving
98+ , deriveSerialize
99+ , deriveSerializeWith
100+ ) where
101+
102+--------------------------------------------------------------------------------
103+-- Imports
104+--------------------------------------------------------------------------------
105+
106+import Streamly.Internal.Data.MutByteArray
core/src/Streamly/Data/Parser.hs+123−24
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.Parser
34-- Copyright : (c) 2020 Composewell Technologies
@@ -6,23 +7,117 @@
67-- Stability : pre-release
78-- Portability : GHC
89--
9−-- Fast backtracking parsers with stream fusion and native streaming
10−-- capability. Parsers are just more powerful folds, folds and parsers can be
11−-- interconverted.
10+-- Parsers are stream consumers like folds with the following differences:
1211--
13−-- Note that these parsers do not report the error context (e.g. line number or
14−-- column). This may be supported in future.
12+-- * folds cannot fail but parsers can fail and backtrack.
13+-- * folds can be composed as a Tee but parsers cannot.
14+-- * folds can be used for scanning but parsers cannot.
15+-- * folds can be converted to parsers.
1516--
16−-- mtl instances are not provided. If the 'Parser' type is the top most layer
17−-- (which should be the case almost always) you can just use 'fromEffect' to
18−-- execute the lower layer monad effects.
17+-- This module implements parsers with stream fusion which compile to efficient
18+-- loops comparable to the speed of C.
1919--
20−-- == Performance Notes
20+-- == Using Parsers
2121--
22−-- This module is designed for fusion, inline the operations in this module for
23−-- fusion to occur, avoid using these operations in recursive calls, avoid
24−-- operations like 'sequence', 'asum' on these parsers. If you need these then
25−-- use the 'ParserK' module instead.
22+-- This module provides elementary parsers and parser combinators that can be
23+-- used to parse a stream of data. Additionally, all the folds from the
24+-- "Streamly.Data.Fold" module can be converted to parsers using 'fromFold'.
25+-- All the parsing functionality provided by popular parsing libraries, and
26+-- more is available. Also see "Streamly.Unicode.Parser" module for Char stream
27+-- parsers.
28+--
29+-- A data stream can be transformed to a stream of parsed data elements. Parser
30+-- combinators can be used to create a pipeline of folds or parsers such that
31+-- the next fold or parser consumes the result of the previous parser. See
32+-- 'Streamly.Data.Stream.parse' and 'Streamly.Data.Stream.parseMany' to run
33+-- these parsers on a stream.
34+--
35+-- == Parser vs ParserK
36+--
37+-- There are two functionally equivalent parsing modules,
38+-- "Streamly.Data.Parser" (this module) and "Streamly.Data.ParserK". The latter
39+-- is a CPS based wrapper over the former, and can be used for parsing in
40+-- general. "Streamly.Data.Parser" enables stream fusion and should be
41+-- preferred over "Streamly.Data.ParserK" for high performance stream parsing
42+-- use cases. However, there are a few cases where this module is not
43+-- suitable and ParserK should be used instead.
44+--
45+-- For static fusion, parser combinators have to use strict pattern matching on
46+-- arguments of type Parser. This leads to infinte loop when a parser is
47+-- defined recursively, due to strict evaluation of the recursive call. For
48+-- example, the following implementation loops infinitely because of the
49+-- recursive use of parser @p@ in the @*>@ combinator:
50+--
51+-- >>> import Streamly.Data.Parser (Parser)
52+-- >>> import qualified Streamly.Data.Fold as Fold
53+-- >>> import qualified Streamly.Data.Parser as Parser
54+-- >>> import qualified Streamly.Data.Stream as Stream
55+-- >>> import Control.Applicative ((<|>))
56+--
57+-- >>> :{
58+-- >>> p :: Monad m => Parser Char m String
59+-- >>> p = Parser.satisfy (== '(') *> p <|> Parser.fromFold Fold.toList
60+-- >>> :}
61+--
62+-- Use ParserK when recursive use is required:
63+--
64+-- >>> import Streamly.Data.ParserK (ParserK)
65+-- >>> import qualified Streamly.Data.StreamK as StreamK
66+-- >>> import qualified Streamly.Internal.Data.StreamK as StreamK (parse)
67+-- >>> import qualified Streamly.Internal.Data.ParserK as ParserK (adapt)
68+--
69+-- >>> :{
70+-- >>> p :: Monad m => ParserK Char m String
71+-- >>> p = ParserK.adapt (Parser.satisfy (== '(')) *> p <|> ParserK.adapt (Parser.fromFold Fold.toList)
72+-- >>> :}
73+--
74+-- >>> StreamK.parse p $ StreamK.fromStream $ Stream.fromList "hello"
75+-- Right "hello"
76+--
77+-- For this reason Applicative, Alternative or Monad compositions with
78+-- recursion cannot be used with the 'Parser' type. Alternative type class based
79+-- operations like 'asum' and Alternative based generic parser combinators use
80+-- recursion. Similarly, Applicative type class based operations like
81+-- 'Prelude.sequence' use recursion. Custom implementations of many such
82+-- operations are provided in this module (e.g. 'some', 'many'), and those
83+-- should be used instead.
84+--
85+-- Another limitation of Parser type is due to the quadratic complexity causing
86+-- slowdown when too many nested compositions are used. Especially Applicative,
87+-- Monad, Alternative instances, and sequenced parsing operations (e.g. nested
88+-- 'one', and 'splitWith') degrade the performance quadratically (O(n^2)) when
89+-- combined @n@ times, roughly 8 or less sequenced parsers are fine. READ THE
90+-- DOCS OF APPLICATIVE, MONAD AND ALTERNATIVE INSTANCES.
91+--
92+-- == Streaming Parsers
93+--
94+-- With 'Streamly.Data.ParserK.ParserK' you can use the generic Alternative
95+-- type class based parsers from the
96+-- <https://hackage.haskell.org/package/parser-combinators parser-combinators>
97+-- library or similar. However, we recommend that you use the equivalent
98+-- functionality from this module for better performance and for streaming
99+-- behavior.
100+--
101+-- Firstly, the combinators in this module are faster due to stream fusion.
102+-- Secondly, these are streaming in nature as the results can be passed
103+-- directly to other stream consumers (folds or parsers). The Alternative type
104+-- class based parsers would end up buffering all the results in lists before
105+-- they can be consumed.
106+--
107+-- When recursion or heavy nesting is needed use ParserK.
108+--
109+-- == Error Reporting
110+--
111+-- These parsers do not report the error context (e.g. line number or column).
112+-- This may be supported in future.
113+--
114+-- == Monad Transformer Stack
115+--
116+-- 'MonadTrans' instance is not provided. If the 'Parser' type is the top most
117+-- layer (which should be the case almost always) you can just use 'fromEffect'
118+-- to execute the lower layer monad effects.
119+--
120+-- == Parser vs ParserK Implementation
26121--
27122-- The 'Parser' type represents a stream consumer by composing state as data
28123-- which enables stream fusion. Stream fusion generates a tight loop without
@@ -31,25 +126,27 @@
31126-- pipeline statically. Therefore, the operations in this module must be
32127-- inlined and must not be used recursively to allow for stream fusion.
33128--
34−-- Using the 'Parser' type parsing operations like 'one', 'splitWith' etc.
35−-- degrade quadratically (O(n^2)) when combined many times. If you need to
36−-- combine these operations, say more than 50 times in a single loop, then you
37−-- should use the continuation style parser type 'ParserK' instead. Also, if
38−-- you need to use these operations in a recursive loop you should use
39−-- 'ParserK' instead.
40−--
41129-- The 'ParserK' type represents a stream consumer by composing function calls,
42130-- therefore, a function call overhead is incurred at each composition. It is
43131-- quite fast in general but may be a few times slower than a fused parser.
44132-- However, it allows for scalable dynamic composition especially parsers can
45133-- be used in recursive calls. Using the 'ParserK' type operations like
46134-- 'splitWith' provide linear (O(n)) performance with respect to the number of
47−-- compositions..
135+-- compositions.
48136--
49−-- 'Parser' and 'ParserK' types can be interconverted.
137+-- == Experimental APIs
138+--
139+-- Please refer to "Streamly.Internal.Data.Parser" for functions that have not
140+-- yet been released.
50141--
51142module Streamly.Data.Parser
52143 (
144+ -- * Setup
145+ -- | To execute the code examples provided in this module in ghci, please
146+ -- run the following commands first.
147+ --
148+ -- $setup
149+
53150 -- * Parser Type
54151 Parser
55152
@@ -121,8 +218,8 @@ module Streamly.Data.Parser
121218
122219 -- ** Grouping
123220 , groupBy
124− -- , groupByRolling
125− -- , groupByRollingEither
221+ , groupByRolling
222+ , groupByRollingEither
126223
127224 -- ** Framing
128225 -- , wordFramedBy
@@ -146,3 +243,5 @@ where
146243
147244import Streamly.Internal.Data.Parser
148245import Prelude hiding (dropWhile, takeWhile, filter)
246+
247+#include "DocTestDataParser.hs"
core/src/Streamly/Data/ParserK.hs+107−12
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.ParserK
34-- Copyright : (c) 2023 Composewell Technologies
@@ -6,39 +7,133 @@
67-- Stability : pre-release
78-- Portability : GHC
89--
9−-- Parsers using Continuation Passing Style (CPS). See notes in
10−-- "Streamly.Data.Parser" module to know when to use this module.
10+-- See the general notes about parsing in the "Streamly.Data.Parser" module.
11+-- This module implements a using Continuation Passing Style (CPS) wrapper over
12+-- the "Streamly.Data.Parser" module. It is as fast or faster than attoparsec.
1113--
12−-- To run a 'ParserK' convert it to a 'Parser' and then run it.
14+-- == Parser vs ParserK
15+--
16+-- 'ParserK' is preferred over 'Streamly.Data.Parser.Parser' when extensive
17+-- applicative, alternative and monadic composition is required, or when
18+-- recursive or dynamic composition of parsers is required. The
19+-- 'Streamly.Data.Parser.Parser' type fuses statically and creates efficient
20+-- loops whereas 'ParserK' uses function call based composition and has
21+-- comparatively larger runtime overhead but it is better suited to the
22+-- specific use cases mentioned above. 'ParserK' also allows to efficient parse
23+-- a stream of arrays, it can also break the input stream into a parse result
24+-- and remaining stream so that the stream can be parsed independently in
25+-- segments.
26+--
27+-- == Using ParserK
28+--
29+-- All the parsers from the "Streamly.Data.Parser" module can be adapted to
30+-- ParserK using the 'Streamly.Data.ParserK.adaptC',
31+-- 'Streamly.Internal.Data.ParserK.adapt', and
32+-- 'Streamly.Internal.Data.ParserK.adaptCG' combinators.
33+--
34+-- 'Streamly.Data.StreamK.parseChunks' runs a parser on a stream of unboxed
35+-- arrays, this is the preferred and most efficient way to parse chunked input.
36+-- The more general 'Streamly.Data.StreamK.parseBreakChunks' function returns
37+-- the remaining stream as well along with the parse result. There are
38+-- 'Streamly.Internal.Data.StreamK.parseChunksGeneric',
39+-- 'Streamly.Internal.Data.StreamK.parseBreakChunksGeneric' as well to run
40+-- parsers on boxed arrays. 'Streamly.Internal.Data.StreamK.parse',
41+-- 'Streamly.Internal.Data.StreamK.parseBreak' run parsers on a stream of
42+-- individual elements instead of stream of arrays.
43+--
44+-- == Monadic Composition
45+--
46+-- Monad composition can be used for lookbehind parsers, we can dynamically
47+-- compose new parsers based on the results of the previously parsed values.
48+--
49+-- If we have to parse "a9" or "9a" but not "99" or "aa" we can use the
50+-- following non-monadic, backtracking parser:
51+--
52+-- >>> digits p1 p2 = ((:) <$> p1 <*> ((:) <$> p2 <*> pure []))
53+-- >>> :{
54+-- backtracking :: Monad m => ParserK Char m String
55+-- backtracking = ParserK.adapt $
56+-- digits (Parser.satisfy isDigit) (Parser.satisfy isAlpha)
57+-- <|>
58+-- digits (Parser.satisfy isAlpha) (Parser.satisfy isDigit)
59+-- :}
60+--
61+-- We know that if the first parse resulted in a digit at the first place then
62+-- the second parse is going to fail. However, we waste that information and
63+-- parse the first character again in the second parse only to know that it is
64+-- not an alphabetic char. By using lookbehind in a 'Monad' composition we can
65+-- avoid redundant work:
66+--
67+-- >>> data DigitOrAlpha = Digit Char | Alpha Char
68+--
69+-- >>> :{
70+-- lookbehind :: Monad m => ParserK Char m String
71+-- lookbehind = do
72+-- x1 <- ParserK.adapt $
73+-- Digit <$> Parser.satisfy isDigit
74+-- <|> Alpha <$> Parser.satisfy isAlpha
75+-- -- Note: the parse depends on what we parsed already
76+-- x2 <- ParserK.adapt $
77+-- case x1 of
78+-- Digit _ -> Parser.satisfy isAlpha
79+-- Alpha _ -> Parser.satisfy isDigit
80+-- return $ case x1 of
81+-- Digit x -> [x,x2]
82+-- Alpha x -> [x,x2]
83+-- :}
84+--
85+-- == Experimental APIs
86+--
87+-- Please refer to "Streamly.Internal.Data.ParserK" for functions that have
88+-- not yet been released.
1389--
1490module Streamly.Data.ParserK
1591 (
92+ -- * Setup
93+ -- | To execute the code examples provided in this module in ghci, please
94+ -- run the following commands first.
95+ --
96+ -- $setup
97+
1698 -- * Parser Type
1799 ParserK
18100
19101 -- * Parsers
20102 -- ** Conversions
21− , fromFold
22− , fromParser
103+ , adapt
104+ , adaptC
105+ , adaptCG
23106 -- , toParser
24107
25108 -- ** Without Input
26109 , fromPure
27110 , fromEffect
28111 , die
112+
113+ -- * Deprecated
114+ , fromFold
115+ , fromParser
29116 )
30117
31118where
32119
33120import Control.Monad.IO.Class (MonadIO)
34121import Streamly.Internal.Data.Fold (Fold)
35−import Streamly.Internal.Data.Unboxed (Unbox)
36−import qualified Streamly.Internal.Data.Parser.ParserD as ParserD
122+import Streamly.Internal.Data.Unbox (Unbox)
123+import Streamly.Internal.Data.Array (Array)
124+import qualified Streamly.Internal.Data.Parser as ParserD
37125
38−import Streamly.Internal.Data.Parser.ParserK.Type
126+import Streamly.Internal.Data.ParserK.Type
39127
40−-- | Convert a 'Fold' to a 'ParserK'.
41−--
128+#include "DocTestDataParserK.hs"
129+
130+{-# DEPRECATED fromFold "Please use \"ParserK.adaptC . Parser.fromFold\" instead." #-}
42131{-# INLINE fromFold #-}
43−fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK a m b
44−fromFold = fromParser . ParserD.fromFold
132+fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK (Array a) m b
133+fromFold = adaptC . ParserD.fromFold
134+
135+{-# DEPRECATED fromParser "Please use \"adaptC\" instead." #-}
136+{-# INLINE fromParser #-}
137+fromParser ::
138+ (MonadIO m, Unbox a) => ParserD.Parser a m b -> ParserK (Array a) m b
139+fromParser = adaptC
core/src/Streamly/Data/Stream.hs+344−122
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.Stream
34-- Copyright : (c) 2017 Composewell Technologies
@@ -7,99 +8,55 @@
78-- Stability : released
89-- Portability : GHC
910--
10−-- To run examples in this module:
11+-- Streams represented as state machines, that fuse together when composed
12+-- statically, eliminating function calls or intermediate constructor
13+-- allocations - generating tight, efficient loops. Suitable for high
14+-- performance looping operations.
1115--
12−-- >>> import qualified Streamly.Data.Fold as Fold
13−-- >>> import qualified Streamly.Data.Stream as Stream
16+-- If you need to call these operations recursively in a loop (i.e. composed
17+-- dynamically) then it is recommended to use the continuation passing style
18+-- (CPS) stream operations from the "Streamly.Data.StreamK" module. 'Stream'
19+-- and 'StreamK' types are interconvertible. See more details in the
20+-- documentation below regarding 'Stream' vs 'StreamK'.
1421--
15−-- We will add some more imports in the examples as needed.
22+-- Please refer to "Streamly.Internal.Data.Stream" for more functions that have
23+-- not yet been released.
1624--
17−-- For effectful streams we will use the following IO action:
18−--
19−-- >>> effect n = print n >> return n
20−--
21−-- = Overview
22−--
23−-- Streamly is a framework for modular data flow based programming and
24−-- declarative concurrency. Powerful stream fusion framework in streamly
25−-- allows high performance combinatorial programming even when using byte level
26−-- streams. Streamly API is similar to Haskell lists.
27−--
28−-- == Console Echo Example
29−--
30−-- In the following example, 'repeatM' generates an infinite stream of 'String'
31−-- by repeatedly performing the 'getLine' IO action. 'mapM' then applies
32−-- 'putStrLn' on each element in the stream converting it to stream of '()'.
33−-- Finally, 'drain' folds the stream to IO discarding the () values, thus
34−-- producing only effects.
35−--
36−-- >>> import Data.Function ((&))
37−--
38−-- >>> :{
39−-- echo =
40−-- Stream.repeatM getLine -- Stream IO String
41−-- & Stream.mapM putStrLn -- Stream IO ()
42−-- & Stream.fold Fold.drain -- IO ()
43−-- :}
44−--
45−-- This is a console echo program. It is an example of a declarative loop
46−-- written using streaming combinators. Compare it with an imperative @while@
47−-- loop.
48−--
49−-- Hopefully, this gives you an idea how we can program declaratively by
50−-- representing loops using streams. In this module, you can find all
51−-- "Data.List" like functions and many more powerful combinators to perform
52−-- common programming tasks.
53−--
54−-- == Performance Notes
55−--
56−-- The 'Stream' type represents a stream by composing state as data which
57−-- enables stream fusion. Stream fusion generates a tight loop without any
58−-- constructor allocations between the stages, providing C like performance for
59−-- the loop. Stream fusion works when multiple functions are combined in a
60−-- pipeline statically. Therefore, the operations in this module must be
61−-- inlined and must not be used recursively to allow for stream fusion.
62−--
63−-- Using the 'Stream' type binary stream construction operations like 'cons',
64−-- 'append' etc. degrade quadratically (O(n^2)) when combined many times. If
65−-- you need to combine these operations, say more than 50 times in a single
66−-- loop, then you should use the continuation style stream type 'StreamK'
67−-- instead. Also, if you need to use these operations in a recursive loop you
68−-- should use 'StreamK' instead.
69−--
70−-- The 'StreamK' type represents a stream by composing function calls,
71−-- therefore, a function call overhead is incurred at each composition. It is
72−-- quite fast in general but may be a few times slower than a fused stream.
73−-- However, it allows for scalable dynamic composition and control flow
74−-- manipulation. Using the 'StreamK' type binary operations like 'cons' and
75−-- 'append' provide linear (O(n)) performance.
76−--
77−-- 'Stream' and 'StreamK' types can be interconverted.
78−--
79−-- == Useful Idioms
80−--
81−-- >>> fromListM = Stream.sequence . Stream.fromList
82−-- >>> fromIndices f = fmap f $ Stream.enumerateFrom 0
83−--
84−-- Also see "Streamly.Internal.Data.Stream" module for many more @Pre-release@
85−-- combinators. See the <https://github.com/composewell/streamly-examples>
25+-- Checkout the <https://github.com/composewell/streamly-examples>
8626-- repository for many more real world examples of stream programming.
87−--
27+
8828module Streamly.Data.Stream
8929 (
30+ -- * Setup
31+ -- | To execute the code examples provided in this module in ghci, please
32+ -- run the following commands first.
33+ --
34+ -- $setup
35+
36+ -- * Overview
37+ -- $overview
38+
39+ -- * The Stream Type
9040 Stream
41+
9142 -- * Construction
9243 -- | Functions ending in the general shape @b -> Stream m a@.
9344 --
94− -- See also: "Streamly.Internal.Data.Stream.Generate" for
95− -- @Pre-release@ functions.
45+ -- Useful Idioms:
46+ --
47+ -- >>> fromIndices f = fmap f $ Stream.enumerateFrom 0
48+ -- >>> fromIndicesM f = Stream.mapM f $ Stream.enumerateFrom 0
49+ -- >>> fromListM = Stream.sequence . Stream.fromList
50+ -- >>> fromFoldable = StreamK.toStream . StreamK.fromFoldable
51+ -- >>> fromFoldableM = Stream.sequence . fromFoldable
9652
9753 -- ** Primitives
98− -- | Primitives to construct a stream from pure values or monadic actions.
99− -- All other stream construction and generation combinators described later
100− -- can be expressed in terms of these primitives. However, the special
101− -- versions provided in this module can be much more efficient in most
102− -- cases. Users can create custom combinators using these primitives.
54+ -- | A fused 'Stream' is never constructed using these primitives, they are
55+ -- typically generated by converting containers like list into streams, or
56+ -- generated using custom functions provided in this module. The 'cons'
57+ -- primitive in this module has a rare use in fusing a small number of
58+ -- elements. On the other hand, it is common to construct 'StreamK' stream
59+ -- using the StreamK.'StreamK.cons' primitive.
10360 , nil
10461 , nilM
10562 , cons
@@ -113,6 +70,15 @@ module Streamly.Data.Stream
11370
11471 -- ** From Values
11572 -- | Generate a monadic stream from a seed value or values.
73+ --
74+ -- Non-empty pure streams can be cycled using repeat and unfold:
75+ --
76+ -- >>> cycle = Stream.unfoldMany Unfold.fromList . Stream.repeat
77+ --
78+ -- Non-empty StreamK can be cycled using append:
79+ --
80+ -- >>> cycle xs = let ys = xs `StreamK.append` ys in ys
81+ --
11682 , fromPure
11783 , fromEffect
11884 , repeat
@@ -157,8 +123,6 @@ module Streamly.Data.Stream
157123 -- | Functions ending in the general shape @Stream m a -> m b@ or @Stream m
158124 -- a -> m (b, Stream m a)@
159125 --
160− -- See also: "Streamly.Internal.Data.Stream.Eliminate" for @Pre-release@
161− -- functions.
162126
163127-- EXPLANATION: In imperative terms a fold can be considered as a loop over the stream
164128-- that reduces the stream to a single value.
@@ -257,12 +221,57 @@ module Streamly.Data.Stream
257221 -- operations like mapping a function over the stream.
258222 , foldrM
259223 , foldr
224+ -- foldr1
260225
261226 -- ** Specific Folds
262− -- | Usually you can use the folds in "Streamly.Data.Fold". However, some
263− -- folds that may be commonly used or may have an edge in performance in
264− -- some cases are provided here.
265− -- , drain
227+ -- | Streams are folded using folds in "Streamly.Data.Fold". Here are some
228+ -- idioms and equivalents of Data.List APIs using folds:
229+ --
230+ -- >>> foldlM' f a = Stream.fold (Fold.foldlM' f a)
231+ -- >>> foldl1' f = Stream.fold (Fold.foldl1' f)
232+ -- >>> foldl' f a = Stream.fold (Fold.foldl' f a)
233+ -- >>> drain = Stream.fold Fold.drain
234+ -- >>> mapM_ f = Stream.fold (Fold.drainMapM f)
235+ -- >>> length = Stream.fold Fold.length
236+ -- >>> genericLength = Stream.fold Fold.lengthGeneric
237+ -- >>> head = Stream.fold Fold.one
238+ -- >>> last = Stream.fold Fold.latest
239+ -- >>> null = Stream.fold Fold.null
240+ -- >>> and = Stream.fold Fold.and
241+ -- >>> or = Stream.fold Fold.or
242+ -- >>> any p = Stream.fold (Fold.any p)
243+ -- >>> all p = Stream.fold (Fold.all p)
244+ -- >>> sum = Stream.fold Fold.sum
245+ -- >>> product = Stream.fold Fold.product
246+ -- >>> maximum = Stream.fold Fold.maximum
247+ -- >>> maximumBy cmp = Stream.fold (Fold.maximumBy cmp)
248+ -- >>> minimum = Stream.fold Fold.minimum
249+ -- >>> minimumBy cmp = Stream.fold (Fold.minimumBy cmp)
250+ -- >>> elem x = Stream.fold (Fold.elem x)
251+ -- >>> notElem x = Stream.fold (Fold.notElem x)
252+ -- >>> lookup x = Stream.fold (Fold.lookup x)
253+ -- >>> find p = Stream.fold (Fold.find p)
254+ -- >>> (!?) i = Stream.fold (Fold.index i)
255+ -- >>> genericIndex i = Stream.fold (Fold.indexGeneric i)
256+ -- >>> elemIndex x = Stream.fold (Fold.elemIndex x)
257+ -- >>> findIndex p = Stream.fold (Fold.findIndex p)
258+ --
259+ -- Some equivalents of Data.List APIs from the Stream module:
260+ --
261+ -- >>> head = fmap (fmap fst) . Stream.uncons
262+ -- >>> tail = fmap (fmap snd) . Stream.uncons
263+ -- >>> tail = Stream.tail -- unreleased API
264+ -- >>> init = Stream.init -- unreleased API
265+ --
266+ -- A Stream based toList fold implementation is provided below because it
267+ -- has a better performance compared to the fold.
268+
269+ -- Functions in Data.List, missing here:
270+ -- unsnoc = Stream.parseBreak (Parser.init Fold.toList)
271+ -- genericTake
272+ -- genericDrop
273+ -- genericSplitAt
274+ -- genericReplicate
266275 , toList
267276
268277 -- * Mapping
@@ -290,8 +299,6 @@ module Streamly.Data.Stream
290299 -- * Scanning
291300 -- | Stateful one-to-one transformations.
292301 --
293− -- See also: "Streamly.Internal.Data.Stream.Transform" for
294− -- @Pre-release@ functions.
295302
296303 {-
297304 -- ** Left scans
@@ -307,9 +314,26 @@ module Streamly.Data.Stream
307314 -}
308315
309316 -- ** Scanning By 'Fold'
317+ -- | Useful idioms:
318+ --
319+ -- >>> scanl' f z = Stream.scan (Fold.foldl' f z)
320+ -- >>> scanlM' f z = Stream.scan (Fold.foldlM' f z)
321+ -- >>> postscanl' f z = Stream.postscan (Fold.foldl' f z)
322+ -- >>> postscanlM' f z = Stream.postscan (Fold.foldlM' f z)
323+ -- >>> scanl1' f = Stream.catMaybes . Stream.scan (Fold.foldl1' f)
324+ -- >>> scanl1M' f = Stream.catMaybes . Stream.scan (Fold.foldlM1' f)
310325 , scan
311326 , postscan
312327 -- XXX postscan1 can be implemented using Monoids or Refolds.
328+ -- The following scans from Data.List are not provided.
329+ -- XXX scanl
330+ -- XXX scanl1
331+ -- XXX scanr
332+ -- XXX scanr1
333+ -- XXX mapAccumL
334+ -- XXX mapAccumR
335+ -- XXX inits
336+ -- XXX tails
313337
314338 -- ** Specific scans
315339 -- Indexing can be considered as a special type of zipping where we zip a
@@ -318,6 +342,8 @@ module Streamly.Data.Stream
318342
319343 -- * Insertion
320344 -- | Add elements to the stream.
345+ --
346+ -- >>> insert = Stream.insertBy compare
321347
322348 -- Inserting elements is a special case of interleaving/merging streams.
323349 , insertBy
@@ -352,6 +378,16 @@ module Streamly.Data.Stream
352378 -- filtering folds (folds returning a 'Maybe' type) in
353379 -- "Streamly.Internal.Data.Fold" can be used along with 'scanMaybe' to
354380 -- perform stateful filtering operations in general.
381+ --
382+ -- Idioms and equivalents of Data.List APIs:
383+ --
384+ -- >>> deleteBy cmp x = Stream.scanMaybe (Fold.deleteBy cmp x)
385+ -- >>> deleteBy = Stream.deleteBy -- unreleased API
386+ -- >>> delete = deleteBy (==)
387+ -- >>> findIndices p = Stream.scanMaybe (Fold.findIndices p)
388+ -- >>> elemIndices a = findIndices (== a)
389+ -- >>> uniq = Stream.scanMaybe (Fold.uniqBy (==))
390+ -- >>> partition p = Stream.fold (Fold.partition Fold.toList Fold.toList) . fmap (if p then Left else Right)
355391 , scanMaybe
356392 , take
357393 , takeWhile
@@ -359,6 +395,8 @@ module Streamly.Data.Stream
359395 , drop
360396 , dropWhile
361397 , dropWhileM
398+ -- XXX write to an array in reverse and then read in reverse
399+ -- > dropWhileEnd = reverse . dropWhile p . reverse
362400
363401 -- XXX These are available as scans in folds. We need to check the
364402 -- performance though. If these are common and we need convenient stream
@@ -380,34 +418,42 @@ module Streamly.Data.Stream
380418 -- , elemIndices
381419
382420 -- * Combining Two Streams
421+ -- | Note that these operations are suitable for statically fusing a few
422+ -- streams, they have a quadratic O(n^2) time complexity wrt to the number
423+ -- of streams. If you want to compose many streams dynamically using binary
424+ -- combining operations see the corresponding operations in
425+ -- "Streamly.Data.StreamK".
426+ --
427+ -- When fusing more than two streams it is more efficient if the binary
428+ -- operations are composed as a balanced tree rather than a right
429+ -- associative or left associative one e.g.:
430+ --
431+ -- >>> s1 = Stream.fromList [1,2] `Stream.append` Stream.fromList [3,4]
432+ -- >>> s2 = Stream.fromList [4,5] `Stream.append` Stream.fromList [6,7]
433+ -- >>> s = s1 `Stream.append` s2
434+
383435 -- ** Appending
436+ -- | Equivalent of Data.List append:
437+ --
438+ -- >>> (++) = Stream.append
384439 , append
385440
386441 -- ** Interleaving
387− -- | When interleaving more than two streams you may want to interleave
388− -- them pairwise creating a balanced binary merge tree.
389442 , interleave
390443
391444 -- ** Merging
392− -- | When merging more than two streams you may want to merging them
393− -- pairwise creating a balanced binary merge tree.
394− --
395− -- Merging of @n@ streams can be performed by combining the streams pair
396− -- wise using 'mergeMapWith' to give O(n * log n) time complexity. If used
397− -- with 'concatMapWith' it will have O(n^2) performance.
398−
399445 , mergeBy
400446 , mergeByM
401447
402448 -- ** Zipping
403− -- | When zipping more than two streams you may want to zip them
404− -- pairwise creating a balanced binary tree.
449+ -- | Idioms and equivalents of Data.List APIs:
405450 --
406− -- Zipping of @n@ streams can be performed by combining the streams pair
407− -- wise using 'mergeMapWith' with O(n * log n) time complexity. If used
408− -- with 'concatMapWith' it will have O(n^2) performance.
451+ -- >>> zip = Stream.zipWith (,)
452+ -- >>> unzip = Stream.fold (Fold.unzip Fold.toList Fold.toList)
409453 , zipWith
410454 , zipWithM
455+ -- XXX zipWith3,4,5,6,7
456+ -- XXX unzip3,4,5,6,7
411457 -- , ZipStream (..)
412458
413459 -- ** Cross Product
@@ -440,51 +486,109 @@ module Streamly.Data.Stream
440486 -- One dimension loops are just a special case of nested loops. For
441487 -- example, 'concatMap' can degenerate to a simple map operation:
442488 --
443− -- > map f m = S.concatMap (\x -> S.fromPure (f x)) m
489+ -- >>> map f m = Stream.concatMap (\x -> Stream.fromPure (f x)) m
444490 --
445491 -- Similarly, 'concatMap' can perform filtering by mapping an element to a
446492 -- 'nil' stream:
447493 --
448− -- > filter p m = S.concatMap (\x -> if p x then S.fromPure x else S.nil) m
494+ -- >>> filter p m = Stream.concatMap (\x -> if p x then Stream.fromPure x else Stream.nil) m
449495 --
496+ -- Idioms and equivalents of Data.List APIs:
497+ --
498+ -- >>> concat = Stream.concatMap id
499+ -- >>> unlines = Stream.interposeSuffix '\n'
500+ -- >>> unlines = Stream.intercalateSuffix Unfold.fromList "\n"
501+ -- >>> unwords = Stream.interpose ' '
502+ -- >>> unwords = Stream.intercalate Unfold.fromList " "
450503
451504 , concatEffect
452505 , concatMap
453506 , concatMapM
454507
455508 -- * Repeated Fold
509+ -- | Idioms and equivalents of Data.List APIs:
510+ --
511+ -- >>> groupsOf n = Stream.foldMany (Fold.take n Fold.toList)
512+ -- >>> groupBy eq = Stream.groupsWhile eq Fold.toList
513+ -- >>> groupBy eq = Stream.parseMany (Parser.groupBy eq Fold.toList)
514+ -- >>> groupsByRolling eq = Stream.parseMany (Parser.groupByRolling eq Fold.toList)
515+ -- >>> groups = groupBy (==)
456516 , foldMany -- XXX Rename to foldRepeat
517+ , groupsOf
457518 , parseMany
458− , Array.chunksOf
519+
520+ -- * Splitting
521+ -- | Idioms and equivalents of Data.List APIs:
522+ --
523+ -- >>> splitWithSuffix p f = Stream.foldMany (Fold.takeEndBy p f)
524+ -- >>> splitOnSuffix p f = Stream.foldMany (Fold.takeEndBy_ p f)
525+ -- >>> lines = splitOnSuffix (== '\n')
526+ -- >>> words = Stream.wordsBy isSpace
527+ -- >>> splitAt n = Stream.fold (Fold.splitAt n Fold.toList Fold.toList)
528+ -- >>> span p = Parser.splitWith (,) (Parser.takeWhile p Fold.toList) (Parser.fromFold Fold.toList)
529+ -- >>> break p = span (not . p)
530+ , splitOn
531+ , wordsBy
459532
460533 -- * Buffered Operations
461534 -- | Operations that require buffering of the stream.
462535 -- Reverse is essentially a left fold followed by an unfold.
536+ --
537+ -- Idioms and equivalents of Data.List APIs:
538+ --
539+ -- >>> nub = Stream.fold Fold.toList . Stream.scanMaybe Fold.nub
540+ -- >>> nub = Stream.ordNub -- unreleased API
541+ -- >>> sortBy = StreamK.sortBy
542+ -- >>> sortOn f = StreamK.sortOn -- unreleased API
543+ -- >>> deleteFirstsBy = Stream.deleteFirstsBy -- unreleased
544+ -- >>> (\\) = Stream.deleteFirstsBy (==) -- unreleased
545+ -- >>> intersectBy = Stream.intersectBy -- unreleased
546+ -- >>> intersect = Stream.intersectBy (==) -- unreleased
547+ -- >>> unionBy = Stream.unionBy -- unreleased
548+ -- >>> union = Stream.unionBy (==) -- unreleased
549+ --
463550 , reverse
551+ -- XXX transpose: write the streams to arrays and then stream transposed.
552+ -- XXX subsequences
553+ -- XXX permutations
554+ -- , nub
555+ -- , ordNub
556+ -- , nubBy
464557
465558 -- * Multi-Stream folds
466559 -- | Operations that consume multiple streams at the same time.
467560 , eqBy
468561 , cmpBy
469562 , isPrefixOf
563+ , isInfixOf
564+ -- , isSuffixOf
565+ -- , isSuffixOfUnbox
470566 , isSubsequenceOf
471567
472568 -- trimming sequences
473− , stripPrefix
569+ -- , stripPrefix
570+ -- , stripSuffix
571+ -- , stripSuffixUnbox
474572
475573 -- Exceptions and resource management depend on the "exceptions" package
476574 -- XXX We can have IO Stream operations not depending on "exceptions"
477575 -- in Exception.Base
478576
479577 -- * Exceptions
480− -- | Most of these combinators inhibit stream fusion, therefore, when
578+ -- | Note that the stream exception handling routines catch and handle
579+ -- exceptions only in the stream generation steps and not in the consumer
580+ -- of the stream. For example, if we are folding or parsing a stream - any
581+ -- exceptions in the fold or parse steps won't be observed by the stream
582+ -- exception handlers. Exceptions in the fold or parse steps can be handled
583+ -- using the fold or parse exception handling routines. You can wrap the
584+ -- stream elimination function in the monad exception handler to observe
585+ -- exceptions in the stream as well as the consumer.
586+ --
587+ -- Most of these combinators inhibit stream fusion, therefore, when
481588 -- possible, they should be called in an outer loop to mitigate the cost.
482589 -- For example, instead of calling them on a stream of chars call them on a
483590 -- stream of arrays before flattening it to a stream of chars.
484591 --
485− -- See also: "Streamly.Internal.Data.Stream.Exception" for
486− -- @Pre-release@ functions.
487−
488592 , onException
489593 , handle
490594
@@ -492,8 +596,19 @@ module Streamly.Data.Stream
492596 -- | 'bracket' is the most general resource management operation, all other
493597 -- operations can be expressed using it. These functions have IO suffix
494598 -- because the allocation and cleanup functions are IO actions. For
495− -- generalized allocation and cleanup functions see the functions without
599+ -- generalized allocation and cleanup functions, see the functions without
496600 -- the IO suffix in the "streamly" package.
601+ --
602+ -- Note that these operations bracket the stream generation only, they do
603+ -- not cover the stream consumer. This means if an exception occurs in
604+ -- the consumer of the stream (e.g. in a fold or parse step) then the
605+ -- exception won't be observed by the stream resource handlers, in that
606+ -- case the resource cleanup handler runs when the stream is garbage
607+ -- collected.
608+ --
609+ -- Monad level resource management can always be used around the stream
610+ -- elimination functions, such a function can observe exceptions in both
611+ -- the stream and its consumer.
497612 , before
498613 , afterIO
499614 , finallyIO
@@ -507,18 +622,125 @@ module Streamly.Data.Stream
507622 , runReaderT
508623 , runStateT
509624
510− -- -- * Stream Types
511− -- $serial
512− -- , Interleave
513− -- , Zip
625+ -- XXX Arrays could be different types, therefore, this should be in
626+ -- specific array module. Or maybe we should abstract over array types.
627+ -- * Stream of Arrays
628+ , Array.chunksOf
514629 )
515630where
516631
517−import qualified Streamly.Internal.Data.Array.Type as Array
518−import Streamly.Internal.Data.Stream.StreamD
632+import Streamly.Internal.Data.Stream
519633import Prelude
520634 hiding (filter, drop, dropWhile, take, takeWhile, zipWith, foldr,
521− foldl, map, mapM, mapM_, sequence, all, any, sum, product, elem,
522− notElem, maximum, minimum, head, last, tail, length, null,
523− reverse, iterate, init, and, or, lookup, foldr1, (!!),
524− scanl, scanl1, repeat, replicate, concatMap, span)
635+ mapM, sequence, reverse, iterate, foldr1, repeat, replicate,
636+ concatMap)
637+
638+import qualified Streamly.Internal.Data.Array.Type as Array
639+
640+#include "DocTestDataStream.hs"
641+
642+-- $overview
643+--
644+-- Streamly is a framework for modular data flow based programming and
645+-- declarative concurrency. Powerful stream fusion framework in streamly
646+-- allows high performance combinatorial programming even when using byte level
647+-- streams. Streamly API is similar to Haskell lists.
648+--
649+-- == Console Echo Example
650+--
651+-- In the following example, 'repeatM' generates an infinite stream of 'String'
652+-- by repeatedly performing the 'getLine' IO action. 'mapM' then applies
653+-- 'putStrLn' on each element in the stream converting it to stream of '()'.
654+-- Finally, 'drain' folds the stream to IO discarding the () values, thus
655+-- producing only effects.
656+--
657+-- >>> import Data.Function ((&))
658+--
659+-- >>> :{
660+-- echo =
661+-- Stream.repeatM getLine -- Stream IO String
662+-- & Stream.mapM putStrLn -- Stream IO ()
663+-- & Stream.fold Fold.drain -- IO ()
664+-- :}
665+--
666+-- This is a console echo program. It is an example of a declarative loop
667+-- written using streaming combinators. Compare it with an imperative @while@
668+-- loop.
669+--
670+-- Hopefully, this gives you an idea how we can program declaratively by
671+-- representing loops using streams. In this module, you can find all
672+-- "Data.List" like functions and many more powerful combinators to perform
673+-- common programming tasks.
674+--
675+-- == Stream Fusion
676+--
677+-- The fused 'Stream' type in this module employs stream fusion for C-like
678+-- performance when looping over data. It represents the stream as a state
679+-- machine using an explicit state, and a step function working on the state. A
680+-- typical stream operation consumes elements from the previous state machine
681+-- in a stream pipeline, transforms the elements and yields new values for the
682+-- next stage to consume. The stream operations are modular and represent a
683+-- single task, they have no knowledge of previous or next operation on the
684+-- elements.
685+--
686+-- A typical stream pipeline consists of a stream producer, several stream
687+-- transformation operations and a stream consumer. All these operations taken
688+-- together form a closed loop processing the stream elements. Elements are
689+-- transferred between stages using a boxed data constructor. However, all the
690+-- stages of the pipeline are fused together by GHC, eliminating the boxing of
691+-- intermediate constructors, and thus forming a tight C like loop without any
692+-- boxed data being used in the loop.
693+--
694+-- Stream fusion works effectively when:
695+--
696+-- * the stream pipeline is composed statically (known at compile time)
697+-- * all the operations forming the loop are inlined
698+-- * the loop is not recursively defined, recursion breaks inlining
699+--
700+-- If these conditions cannot be met, the CPS style stream type 'StreamK' may
701+-- turn out to be a better choice than the fused stream type 'Stream'.
702+--
703+-- == Stream vs StreamK
704+--
705+-- The fused stream model avoids constructor allocations and function call
706+-- overheads. However, the stream is represented as a state machine, and to
707+-- generate stream elements it has to navigate the decision tree of the state
708+-- machine. Moreover, the state machine is cranked for each element in the
709+-- stream. This performs extremely well when the number of states are limited.
710+-- The state machine starts getting expensive as the number of states increase.
711+-- For example, generating a stream from a list requires a single state and is
712+-- very efficient, even if it has millions of elements. However, using 'cons'
713+-- to construct a million element stream would be a disaster.
714+--
715+-- A typical worst case scenario for fused stream model is a large number of
716+-- `cons` or `append` operations. A few static `cons` or `append` operations
717+-- are very fast and much faster than a CPS style stream because CPS involves a
718+-- function call for each element whereas fused stream involves a few
719+-- conditional branches in the state machine. However, constructing a large
720+-- stream using `cons` introduces as many states in the state machine as the
721+-- number of elements. If we compose `cons` as a balanced binary tree it will
722+-- take @n * log n@ time to navigate the tree, and @n * n@ if it is a right
723+-- associative composition.
724+--
725+-- Operations like 'cons' or 'append'; are typically recursively called to
726+-- construct a lazy infinite stream. For such use cases the CPS style 'StreamK'
727+-- should be used. CPS streams do not have a state machine that needs to be
728+-- cranked for each element, past state has no effect on the future element
729+-- processing. However, CPS incurs a function call overhead for each element
730+-- processed, the overhead could be large compared to a fused state machine
731+-- even if it has many states. However, because of its linear performance
732+-- characterstics, after a certain threshold of stream compositions the CPS
733+-- stream would perform much better than the quadratic fused stream operations.
734+--
735+-- As a general guideline, you need to use 'StreamK' when you have to use
736+-- 'cons', 'append' or other operations having quadratic complexity at a large
737+-- scale. Typically, in such cases you need to compose the stream recursively,
738+-- by calling an operation in a loop. The decision to compose the stream is
739+-- taken at run time rather than statically at compile time.
740+--
741+-- Typically you would compose a 'StreamK' of chunks of data so that the
742+-- StreamK overhead is not high, and then process the chunks using 'Stream' by
743+-- using statically fused stream pipeline operations on the chunks.
744+--
745+-- 'Stream' and 'StreamK' types can be interconverted. See
746+-- "Streamly.Data.StreamK" module for conversion operations.
core/src/Streamly/Data/Stream/StreamDK.hsdeleted−505
@@ -1,505 +0,0 @@
1−-- |
2−-- Module : Streamly.Data.Stream.StreamDK
3−-- Copyright : (c) 2017 Composewell Technologies
4−--
5−-- License : BSD3
6−-- Maintainer : streamly@composewell.com
7−-- Stability : released
8−-- Portability : GHC
9−--
10−-- To run examples in this module:
11−--
12−-- >>> import qualified Streamly.Data.Fold as Fold
13−-- >>> import qualified Streamly.Data.Stream.StreamDK as Stream
14−--
15−-- We will add some more imports in the examples as needed.
16−--
17−-- For effectful streams we will use the following IO action:
18−--
19−-- >>> effect n = print n >> return n
20−--
21−-- = Overview
22−--
23−-- Streamly is a framework for modular data flow based programming and
24−-- declarative concurrency. Powerful stream fusion framework in streamly
25−-- allows high performance combinatorial programming even when using byte level
26−-- streams. Streamly API is similar to Haskell lists.
27−--
28−-- Streams can be constructed like lists, except that they use 'nil' instead of
29−-- '[]' and 'cons' instead of ':'.
30−--
31−-- `cons` adds a pure value at the head of the stream:
32−--
33−-- >>> import Streamly.Data.Stream.StreamDK (Stream, cons, consM, nil)
34−-- >>> stream = 1 `cons` 2 `cons` nil :: Stream IO Int
35−-- >>> Stream.fold Fold.toList stream -- IO [Int]
36−-- [1,2]
37−--
38−-- `consM` adds an effect at the head of the stream:
39−--
40−-- >>> stream = effect 1 `consM` effect 2 `consM` nil
41−-- >>> Stream.fold Fold.toList stream
42−-- 1
43−-- 2
44−-- [1,2]
45−--
46−-- == Console Echo Example
47−--
48−-- In the following example, 'repeatM' generates an infinite stream of 'String'
49−-- by repeatedly performing the 'getLine' IO action. 'mapM' then applies
50−-- 'putStrLn' on each element in the stream converting it to stream of '()'.
51−-- Finally, 'drain' folds the stream to IO discarding the () values, thus
52−-- producing only effects.
53−--
54−-- >>> import Data.Function ((&))
55−--
56−-- >>> :{
57−-- echo =
58−-- Stream.repeatM getLine -- Stream IO String
59−-- & Stream.mapM putStrLn -- Stream IO ()
60−-- & Stream.fold Fold.drain -- IO ()
61−-- :}
62−--
63−-- This is a console echo program. It is an example of a declarative loop
64−-- written using streaming combinators. Compare it with an imperative @while@
65−-- loop.
66−--
67−-- Hopefully, this gives you an idea how we can program declaratively by
68−-- representing loops using streams. In this module, you can find all
69−-- "Data.List" like functions and many more powerful combinators to perform
70−-- common programming tasks.
71−--
72−-- == Useful Idioms
73−--
74−-- >>> fromListM = Stream.sequence . Stream.fromList
75−-- >>> fromFoldableM = Stream.sequence . Stream.fromFoldable
76−-- >>> fromIndices f = fmap f $ Stream.enumerateFrom 0
77−--
78−-- Also see "Streamly.Internal.Data.Stream.StreamDK" module for many more @Pre-release@
79−-- combinators. See the <https://github.com/composewell/streamly-examples>
80−-- repository for many more real world examples of stream programming.
81−--
82−-- == Performance Notes
83−--
84−-- Operations annotated as /CPS/ force the use of continuation passing style
85−-- streams. Therefore, such operations are not subjected to stream fusion.
86−-- However, for some of these operations you can find fusible alternatives in
87−-- the internal modules, which are perfectly fine to use but you need to
88−-- understand the implications especially the O(n^2) nature of those
89−-- operations..
90−--
91−module Streamly.Data.Stream.StreamDK
92− (
93− Stream
94− -- * Construction
95− -- | Functions ending in the general shape @b -> Stream m a@.
96− --
97− -- See also: "Streamly.Internal.Data.Stream.Generate" for
98− -- @Pre-release@ functions.
99−
100− -- ** Primitives
101− -- | Primitives to construct a stream from pure values or monadic actions.
102− -- All other stream construction and generation combinators described later
103− -- can be expressed in terms of these primitives. However, the special
104− -- versions provided in this module can be much more efficient in most
105− -- cases. Users can create custom combinators using these primitives.
106− , nil
107− , nilM
108− , cons
109− , consM
110− -- , cons2 -- fused version
111− -- , consM2 -- fused version
112−
113− -- ** Unfolding
114− -- | 'unfoldrM' is the most general way of generating a stream efficiently.
115− -- All other generation operations can be expressed using it.
116− , unfoldr
117− , unfoldrM
118−
119− -- ** From Values
120− -- | Generate a monadic stream from a seed value or values.
121− , fromPure
122− , fromEffect
123− , repeat
124− , repeatM
125− , replicate
126− , replicateM
127−
128− -- Note: Using enumeration functions e.g. 'Prelude.enumFromThen' turns out
129− -- to be slightly faster than the idioms like @[from, then..]@.
130− --
131− -- ** Enumeration
132− -- | We can use the 'Enum' type class to enumerate a type producing a list
133− -- and then convert it to a stream:
134− --
135− -- @
136− -- 'fromList' $ 'Prelude.enumFromThen' from then
137− -- @
138− --
139− -- However, this is not particularly efficient.
140− -- The 'Enumerable' type class provides corresponding functions that
141− -- generate a stream instead of a list, efficiently.
142−
143− , Enumerable (..)
144− , enumerate
145− , enumerateTo
146−
147− -- ** Iteration
148− , iterate
149− , iterateM
150−
151− -- ** From Containers
152− -- | Convert an input structure, container or source into a stream. All of
153− -- these can be expressed in terms of primitives.
154− , fromList
155− , fromFoldable
156−
157− -- ** From Unfolds
158− -- | Most of the above stream generation operations can also be expressed
159− -- using the corresponding unfolds in the "Streamly.Data.Unfold" module.
160− , unfold -- XXX rename to fromUnfold?
161−
162− -- * Elimination
163− -- | Functions ending in the general shape @Stream m a -> m b@ or @Stream m
164− -- a -> m (b, Stream m a)@
165− --
166− -- See also: "Streamly.Internal.Data.Stream.Eliminate" for @Pre-release@
167− -- functions.
168−
169−-- EXPLANATION: In imperative terms a fold can be considered as a loop over the stream
170−-- that reduces the stream to a single value.
171−-- Left and right folds both use a fold function @f@ and an identity element
172−-- @z@ (@zero@) to deconstruct a recursive data structure and reconstruct a
173−-- new data structure. The new structure may be a recursive construction (a
174−-- container) or a non-recursive single value reduction of the original
175−-- structure.
176−--
177−-- Both right and left folds are mathematical duals of each other, they are
178−-- functionally equivalent. Operationally, a left fold on a left associated
179−-- structure behaves exactly in the same way as a right fold on a right
180−-- associated structure. Similarly, a left fold on a right associated structure
181−-- behaves in the same way as a right fold on a left associated structure.
182−-- However, the behavior of a right fold on a right associated structure is
183−-- operationally different (even though functionally equivalent) than a left
184−-- fold on the same structure.
185−--
186−-- On right associated structures like Haskell @cons@ lists or Streamly
187−-- streams, a lazy right fold is naturally suitable for lazy recursive
188−-- reconstruction of a new structure, while a strict left fold is naturally
189−-- suitable for efficient reduction. In right folds control is in the hand of
190−-- the @puller@ whereas in left folds the control is in the hand of the
191−-- @pusher@.
192−--
193−-- The behavior of right and left folds are described in detail in the
194−-- individual fold's documentation. To illustrate the two folds for right
195−-- associated @cons@ lists:
196−--
197−-- > foldr :: (a -> b -> b) -> b -> [a] -> b
198−-- > foldr f z [] = z
199−-- > foldr f z (x:xs) = x `f` foldr f z xs
200−-- >
201−-- > foldl :: (b -> a -> b) -> b -> [a] -> b
202−-- > foldl f z [] = z
203−-- > foldl f z (x:xs) = foldl f (z `f` x) xs
204−--
205−-- @foldr@ is conceptually equivalent to:
206−--
207−-- > foldr f z [] = z
208−-- > foldr f z [x] = f x z
209−-- > foldr f z xs = foldr f (foldr f z (tail xs)) [head xs]
210−--
211−-- @foldl@ is conceptually equivalent to:
212−--
213−-- > foldl f z [] = z
214−-- > foldl f z [x] = f z x
215−-- > foldl f z xs = foldl f (foldl f z (init xs)) [last xs]
216−--
217−-- Left and right folds are duals of each other.
218−--
219−-- @
220−-- foldr f z xs = foldl (flip f) z (reverse xs)
221−-- foldl f z xs = foldr (flip f) z (reverse xs)
222−-- @
223−--
224−-- More generally:
225−--
226−-- @
227−-- foldr f z xs = foldl g id xs z where g k x = k . f x
228−-- foldl f z xs = foldr g id xs z where g x k = k . flip f x
229−-- @
230−--
231−
232−-- NOTE: Folds are inherently serial as each step needs to use the result of
233−-- the previous step. However, it is possible to fold parts of the stream in
234−-- parallel and then combine the results using a monoid.
235−
236− -- ** Primitives
237− -- Consuming a part of the stream and returning the rest. Functions
238− -- ending in the general shape @Stream m a -> m (b, Stream m a)@
239− , uncons
240−
241− -- ** Folding
242− -- XXX Need to have a general parse operation here which can be used to
243− -- express all others.
244− , fold -- XXX rename to run? We can have a Stream.run and Fold.run.
245− -- XXX fold1 can be achieved using Monoids or Refolds.
246− -- XXX We can call this just "break" and parseBreak as "munch"
247− , foldBreak
248−
249− -- XXX should we have a Fold returning function in stream module?
250− -- , foldAdd
251− -- , buildl
252−
253− -- ** Parsing
254− , parse
255− , parseBreak
256−
257− -- -- ** Lazy Right Folds
258− -- Consuming a stream to build a right associated expression, suitable
259− -- for lazy evaluation. Evaluation of the input happens when the output of
260− -- the fold is evaluated, the fold output is a lazy thunk.
261− --
262− -- This is suitable for stream transformation operations, for example,
263− -- operations like mapping a function over the stream.
264− -- , foldrM
265− -- , foldr
266−
267− -- * Mapping
268− -- | Stateless one-to-one transformations. Use 'fmap' for mapping a pure
269− -- function on a stream.
270−
271− -- EXPLANATION:
272− -- In imperative terms a map operation can be considered as a loop over
273− -- the stream that transforms the stream into another stream by performing
274− -- an operation on each element of the stream.
275− --
276− -- 'map' is the least powerful transformation operation with strictest
277− -- guarantees. A map, (1) is a stateless loop which means that no state is
278− -- allowed to be carried from one iteration to another, therefore,
279− -- operations on different elements are guaranteed to not affect each
280− -- other, (2) is a strictly one-to-one transformation of stream elements
281− -- which means it guarantees that no elements can be added or removed from
282− -- the stream, it can merely transform them.
283− , sequence
284− , mapM
285− -- , trace -- XXX Use "tracing" map instead?
286− , tap
287− , delay
288−
289− -- * Scanning
290− -- | Stateful one-to-one transformations.
291− --
292− -- See also: "Streamly.Internal.Data.Stream.Transform" for
293− -- @Pre-release@ functions.
294− , scan
295− , postscan
296− -- XXX postscan1 can be implemented using Monoids or Refolds.
297− -- Indexing can be considered as a special type of zipping where we zip a
298− -- stream with an index stream.
299− , indexed
300−
301− -- * Insertion
302− -- | Add elements to the stream.
303−
304− -- Inserting elements is a special case of interleaving/merging streams.
305− , insertBy
306− , intersperseM
307− , intersperseM_
308− , intersperse
309−
310− -- * Filtering
311− -- | Remove elements from the stream.
312−
313− -- ** Stateless Filters
314− -- | 'mapMaybeM' is the most general stateless filtering operation. All
315− -- other filtering operations can be expressed using it.
316−
317− -- EXPLANATION:
318− -- In imperative terms a filter over a stream corresponds to a loop with a
319− -- @continue@ clause for the cases when the predicate fails.
320−
321− , mapMaybe
322− , mapMaybeM
323− , filter
324− , filterM
325−
326− -- Filter and concat
327− , catMaybes
328− , catLefts
329− , catRights
330− , catEithers
331−
332− -- ** Stateful Filters
333− -- | 'scanMaybe' is the most general stateful filtering operation. The
334− -- filtering folds (folds returning a 'Maybe' type) in
335− -- "Streamly.Internal.Data.Fold" can be used along with 'scanMaybe' to
336− -- perform stateful filtering operations in general.
337− , scanMaybe
338− , take
339− , takeWhile
340− , takeWhileM
341− , drop
342− , dropWhile
343− , dropWhileM
344−
345− -- XXX These are available as scans in folds. We need to check the
346− -- performance though. If these are common and we need convenient stream
347− -- ops then we can expose these.
348−
349− -- , deleteBy
350− -- , uniq
351− -- , uniqBy
352−
353− -- -- ** Sampling
354− -- , strideFromThen
355−
356− -- -- ** Searching
357− -- Finding the presence or location of an element, a sequence of elements
358− -- or another stream within a stream.
359−
360− -- -- ** Searching Elements
361− -- , findIndices
362− -- , elemIndices
363−
364− -- * Combining Two Streams
365− -- ** Appending
366− , append
367−
368− -- ** Interleaving
369− , interleave
370− -- , interleave2
371−
372− -- ** Merging
373− -- | Merging of @n@ streams can be performed by combining the streams pair
374− -- wise using 'mergeMapWith' to give O(n * log n) time complexity. If used
375− -- with 'concatMapWith' it will have O(n^2) performance.
376−
377− , mergeBy
378− , mergeByM
379− -- , mergeBy2
380− -- , mergeByM2
381−
382− -- ** Zipping
383− -- | Zipping of @n@ streams can be performed by combining the streams pair
384− -- wise using 'mergeMapWith' with O(n * log n) time complexity. If used
385− -- with 'concatMapWith' it will have O(n^2) performance.
386− , zipWith
387− , zipWithM
388− -- , zipWith2
389− -- , zipWithM2
390− , ZipStream (..)
391−
392− -- ** Cross Product
393− -- XXX The argument order in this operation is such that it seems we are
394− -- transforming the first stream using the second stream because the second
395− -- stream is evaluated many times or buffered and better be finite, first
396− -- stream could potentially be infinite. In the tradition of using the
397− -- transformed stream at the end we can have a flipped version called
398− -- "crossMap" or "nestWith".
399− , crossWith
400− -- , cross
401− -- , joinInner
402− , CrossStream (..)
403−
404− -- * Unfold Each
405− , unfoldMany
406− , intercalate
407− , intercalateSuffix
408−
409− -- * Stream of streams
410− -- | Stream operations like map and filter represent loop processing in
411− -- imperative programming terms. Similarly, the imperative concept of
412− -- nested loops are represented by streams of streams. The 'concatMap'
413− -- operation represents nested looping.
414− -- A 'concatMap' operation loops over the input stream and then for each
415− -- element of the input stream generates another stream and then loops over
416− -- that inner stream as well producing effects and generating a single
417− -- output stream.
418− --
419− -- One dimension loops are just a special case of nested loops. For
420− -- example, 'concatMap' can degenerate to a simple map operation:
421− --
422− -- > map f m = S.concatMap (\x -> S.fromPure (f x)) m
423− --
424− -- Similarly, 'concatMap' can perform filtering by mapping an element to a
425− -- 'nil' stream:
426− --
427− -- > filter p m = S.concatMap (\x -> if p x then S.fromPure x else S.nil) m
428− --
429−
430− , concatEffect
431− , concatMapWith
432− , concatMap
433− , concatMapM
434− , mergeMapWith
435−
436− -- * Repeated Fold
437− , foldMany -- XXX Rename to foldRepeat
438− , parseMany
439− , chunksOf
440−
441− -- * Buffered Operations
442− -- | Operations that require buffering of the stream.
443− -- Reverse is essentially a left fold followed by an unfold.
444− , reverse
445− , sortBy
446−
447− -- * Multi-Stream folds
448− -- | Operations that consume multiple streams at the same time.
449− , eqBy
450− , cmpBy
451− , isPrefixOf
452− , isSubsequenceOf
453−
454− -- trimming sequences
455− , stripPrefix
456−
457− -- Exceptions and resource management depend on the "exceptions" package
458− -- XXX We can have IO Stream operations not depending on "exceptions"
459− -- in Exception.Base
460−
461− -- * Exceptions
462− -- | Most of these combinators inhibit stream fusion, therefore, when
463− -- possible, they should be called in an outer loop to mitigate the cost.
464− -- For example, instead of calling them on a stream of chars call them on a
465− -- stream of arrays before flattening it to a stream of chars.
466− --
467− -- See also: "Streamly.Internal.Data.Stream.Exception" for
468− -- @Pre-release@ functions.
469−
470− , onException
471− , handle
472−
473− -- * Resource Management
474− -- | 'bracket' is the most general resource management operation, all other
475− -- operations can be expressed using it. These functions have IO suffix
476− -- because the allocation and cleanup functions are IO actions. For
477− -- generalized allocation and cleanup functions see the functions without
478− -- the IO suffix in the "streamly" package.
479− , before
480− , afterIO
481− , finallyIO
482− , bracketIO
483− , bracketIO3
484−
485− -- * Transforming Inner Monad
486−
487− , morphInner
488− , liftInner
489− , runReaderT
490− , runStateT
491−
492− -- -- * Stream Types
493− -- $serial
494− -- , Interleave
495− -- , Zip
496− )
497−where
498−
499−import Streamly.Internal.Data.Stream.StreamDK
500−import Prelude
501− hiding (filter, drop, dropWhile, take, takeWhile, zipWith, foldr,
502− foldl, map, mapM, mapM_, sequence, all, any, sum, product, elem,
503− notElem, maximum, minimum, head, last, tail, length, null,
504− reverse, iterate, init, and, or, lookup, foldr1, (!!),
505− scanl, scanl1, repeat, replicate, concatMap, span)
core/src/Streamly/Data/Stream/Zip.hsdeleted−16
@@ -1,16 +0,0 @@
1−-- |
2−-- Module : Streamly.Data.Stream.Zip
3−-- Copyright : (c) 2017 Composewell Technologies
4−--
5−-- License : BSD3
6−-- Maintainer : streamly@composewell.com
7−-- Stability : released
8−-- Portability : GHC
9−--
10−module Streamly.Data.Stream.Zip
11− (
12− ZipStream (..)
13− )
14−where
15−
16−import Streamly.Internal.Data.Stream.Zip
core/src/Streamly/Data/StreamK.hs+94−21
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Data.StreamK
34-- Copyright : (c) 2017 Composewell Technologies
@@ -7,29 +8,33 @@
78-- Stability : released
89-- Portability : GHC
910--
10−-- Streams using Continuation Passing Style (CPS). See notes in "Data.Stream"
11−-- module to know when to use this module.
11+-- Streams represented as chains of functions calls using Continuation Passing
12+-- Style (CPS), suitable for dynamically composing potentially large number of
13+-- streams.
1214--
13−-- 'StreamK' operations have more overhead than 'Stream' operations, however,
14−-- 'Stream' operations fuse only when the pipeline is statically composed, is
15−-- not too large, and does not involve recursion. For such cases, a typical
16−-- example is creating a large or infinite stream by appending, 'StreamK'
17−-- should be used.
15+-- Unlike the statically fused operations in "Streamly.Data.Stream", StreamK
16+-- operations are less efficient, involving a function call overhead for each
17+-- element, but they exhibit linear O(n) time complexity wrt to the number of
18+-- stream compositions. Therefore, they are suitable for dynamically composing
19+-- streams e.g. appending potentially infinite streams in recursive loops.
20+-- While fused streams can be used to efficiently process elements as small as
21+-- a single byte, CPS streams are typically used on bigger chunks of data to
22+-- avoid the larger overhead per element. For more details See the @Stream vs
23+-- StreamK@ section in the "Streamly.Data.Stream" module.
1824--
19−-- You can use operations from "Streamly.Data.Stream" for StreamK as well by
20−-- converting StreamK to Stream, and vice-versa. Most of the time converting to
21−-- 'Stream' is better than using native StreamK operations, however in certain
22−-- cases using native StreamK operations may work better. Using 'Stream'
23−-- operations are especially when multiple contiguous operations can fuse
24−-- together.
25−--
26−-- There are no native exception handling operations in the StreamK module,
27−-- please use 'toStream' to convert to 'Stream' type and use exception
28−-- handling operations from "Streamly.Data.Stream".
25+-- In addition to the combinators in this module, you can use operations from
26+-- "Streamly.Data.Stream" for StreamK as well by converting StreamK to Stream
27+-- ('toStream'), and vice-versa ('fromStream'). Please refer to
28+-- "Streamly.Internal.Data.StreamK" for more functions that have not yet been
29+-- released.
2930--
30−-- See "Streamly.Internal.Data.Stream.StreamK" for more native StreamK
31−-- operations.
31+-- For documentation see the corresponding combinators in
32+-- "Streamly.Data.Stream". Documentation has been omitted in this module unless
33+-- there is a difference worth mentioning or if the combinator does not exist
34+-- in "Streamly.Data.Stream".
3235
36+-- Notes:
37+--
3338-- primitive/open loop operations that can be used recursively e.g. uncons,
3439-- foldBreak, parseBreak should not be converted from StreamD for use in
3540-- StreamK, instead native StreamK impl should be used.
@@ -43,10 +48,25 @@
4348--
4449module Streamly.Data.StreamK
4550 (
51+ -- * Setup
52+ -- | To execute the code examples provided in this module in ghci, please
53+ -- run the following commands first.
54+ --
55+ -- $setup
56+
57+ -- * Overview
58+ -- $overview
59+
60+ -- * Type
4661 StreamK
4762
4863 -- * Construction
4964 -- ** Primitives
65+ -- | Primitives to construct a stream from pure values or monadic actions.
66+ -- All other stream construction and generation combinators described later
67+ -- can be expressed in terms of these primitives. However, the special
68+ -- versions provided in this module can be much more efficient in some
69+ -- cases. Users can create custom combinators using these primitives.
5070 , nil
5171 , nilM
5272 , cons
@@ -57,6 +77,8 @@ module Streamly.Data.StreamK
5777 , fromEffect
5878
5979 -- ** From Stream
80+ -- | Please note that 'Stream' type does not observe any exceptions from
81+ -- the consumer of the stream whereas 'StreamK' does.
6082 , fromStream
6183 , toStream
6284
@@ -73,7 +95,8 @@ module Streamly.Data.StreamK
7395 -- , foldBreak
7496
7597 -- ** Parsing
76− -- , parseBreak
98+ , parse
99+ , parseBreak
77100 , parseBreakChunks
78101 , parseChunks
79102
@@ -83,6 +106,11 @@ module Streamly.Data.StreamK
83106 , take
84107
85108 -- * Combining Two Streams
109+ -- | Unlike the operations in "Streamly.Data.Stream", these operations can
110+ -- be used to dynamically compose large number of streams e.g. using the
111+ -- 'concatMapWith' and 'mergeMapWith' operations. They have a linear O(n)
112+ -- time complexity wrt to the number of streams being composed.
113+
86114 -- ** Appending
87115 , append
88116
@@ -106,6 +134,12 @@ module Streamly.Data.StreamK
106134 -- , CrossStreamK (..)
107135
108136 -- * Stream of streams
137+ -- | Some useful idioms:
138+ --
139+ -- >>> concatFoldableWith f = Prelude.foldr f StreamK.nil
140+ -- >>> concatMapFoldableWith f g = Prelude.foldr (f . g) StreamK.nil
141+ -- >>> concatForFoldableWith f xs g = Prelude.foldr (f . g) StreamK.nil xs
142+ --
109143 , concatEffect
110144 -- , concatMap
111145 , concatMapWith
@@ -114,8 +148,47 @@ module Streamly.Data.StreamK
114148 -- * Buffered Operations
115149 , reverse
116150 , sortBy
151+
152+ -- * Exceptions
153+ -- | Please note that 'Stream' type does not observe any exceptions from
154+ -- the consumer of the stream whereas 'StreamK' does.
155+ , handle
156+
157+ -- * Resource Management
158+ -- | Please note that 'Stream' type does not observe any exceptions from
159+ -- the consumer of the stream whereas 'StreamK' does.
160+ , bracketIO
117161 )
118162where
119163
120−import Streamly.Internal.Data.Stream.StreamK
164+import Streamly.Internal.Data.StreamK
121165import Prelude hiding (reverse, zipWith, mapM, dropWhile, take)
166+
167+#include "DocTestDataStreamK.hs"
168+
169+-- $overview
170+--
171+-- Continuation passing style (CPS) stream implementation. The 'K' in 'StreamK'
172+-- stands for Kontinuation.
173+--
174+-- StreamK can be constructed like lists, except that they use 'nil' instead of
175+-- '[]' and 'cons' instead of ':'.
176+--
177+-- `cons` adds a pure value at the head of the stream:
178+--
179+-- >>> import Streamly.Data.StreamK (StreamK, cons, consM, nil)
180+-- >>> stream = 1 `cons` 2 `cons` nil :: StreamK IO Int
181+--
182+-- You can use operations from "Streamly.Data.Stream" for StreamK as well by
183+-- converting StreamK to Stream ('toStream'), and vice-versa ('fromStream').
184+--
185+-- >>> Stream.fold Fold.toList $ StreamK.toStream stream -- IO [Int]
186+-- [1,2]
187+--
188+-- `consM` adds an effect at the head of the stream:
189+--
190+-- >>> stream = effect 1 `consM` effect 2 `consM` nil
191+-- >>> Stream.fold Fold.toList $ StreamK.toStream stream
192+-- 1
193+-- 2
194+-- [1,2]
core/src/Streamly/Data/Unfold.hs+98−85
@@ -1,4 +1,4 @@
1−#include "inline.hs"
1+{-# LANGUAGE CPP #-}
22
33-- |
44-- Module : Streamly.Data.Unfold
@@ -8,13 +8,104 @@
88-- Stability : released
99-- Portability : GHC
1010--
11+-- Fast, composable stream producers with ability to terminate, supporting
12+-- nested stream fusion. Nested stream operations like
13+-- 'Streamly.Data.Stream.concatMap' in the "Streamly.Data.Stream" module do not
14+-- fuse, however, the 'Streamly.Data.Stream.unfoldMany' operation, using the
15+-- 'Unfold' type, is a fully fusible alternative to
16+-- 'Streamly.Data.Stream.concatMap'.
17+--
18+-- Please refer to "Streamly.Internal.Data.Unfold" for more functions that have
19+-- not yet been released.
20+--
21+-- Exception combinators are not exposed, we would like to encourage the use of
22+-- 'Stream' type instead whenever exception handling is required. We can
23+-- consider exposing the unfold exception functions if there is a compelling
24+-- use case to use unfolds instead of stream.
25+
26+module Streamly.Data.Unfold
27+ (
28+ -- * Setup
29+ -- | To execute the code examples provided in this module in ghci, please
30+ -- run the following commands first.
31+ --
32+ -- $setup
33+
34+ -- * Overview
35+ -- $overview
36+
37+ -- * Unfold Type
38+ Unfold
39+
40+ -- * Unfolds
41+ -- One to one correspondence with
42+ -- "Streamly.Internal.Data.Stream.Generate"
43+
44+ -- ** Basic Constructors
45+ , unfoldrM
46+ , unfoldr
47+ , function
48+ , functionM
49+
50+ -- ** Generators
51+ -- | Generate a monadic stream from a seed.
52+ , repeatM
53+ , replicateM
54+ , iterateM
55+
56+ -- ** Enumeration
57+ , Enumerable (..)
58+
59+ -- ** From Containers
60+ , fromList
61+ , fromListM
62+ , fromStream
63+
64+ -- * Combinators
65+ -- ** Mapping on Input
66+ , lmap
67+ , lmapM
68+ , first
69+ , second
70+
71+ -- ** Mapping on Output
72+ , mapM
73+
74+ -- ** Filtering
75+ , takeWhileM
76+ , takeWhile
77+ , take
78+ , filter
79+ , filterM
80+ , drop
81+ , dropWhile
82+ , dropWhileM
83+
84+ -- ** Zipping
85+ , zipWith
86+
87+ -- ** Cross Product
88+ , crossWith
89+
90+ -- ** Nesting
91+ , many
92+
93+ )
94+where
95+
96+import Prelude hiding
97+ ( concat, map, mapM, takeWhile, take, filter, const, drop, dropWhile
98+ , zipWith
99+ )
100+import Streamly.Internal.Data.Unfold
101+
102+#include "DocTestDataUnfold.hs"
103+
104+-- $overview
105+--
11106-- An 'Unfold' is a source or a producer of a stream of values. It takes a
12107-- seed value as an input and unfolds it into a sequence of values.
13108--
14−-- >>> import qualified Streamly.Data.Fold as Fold
15−-- >>> import qualified Streamly.Data.Unfold as Unfold
16−-- >>> import qualified Streamly.Internal.Data.Stream as Stream
17−--
18109-- For example, the 'fromList' Unfold generates a stream of values from a
19110-- supplied list. Unfolds can be converted to 'Streamly.Internal.Data.Stream'
20111-- using the 'Stream.unfold' operation.
@@ -58,7 +149,7 @@
58149-- Please see "Streamly.Internal.Data.Unfold" for additional @Pre-release@
59150-- functions.
60151--
61−-- = Creating New Unfolds
152+-- == Creating New Unfolds
62153--
63154-- There are many commonly used unfolds provided in this module. However, you
64155-- can always create your own as well. An 'Unfold' is just a data
@@ -95,7 +186,7 @@
95186-- >>> Data.List.unfoldr f [1,2,3]
96187-- [1,2,3]
97188--
98−-- = Unfolds vs. Streams
189+-- == Unfolds vs. Streams
99190--
100191-- The 'Unfold' abstraction for representing streams was introduced in Streamly
101192-- to provide C like performance for nested looping of streams. 'Unfold' and
@@ -140,81 +231,3 @@
140231-- streams are written, it is easy to adapt a stream to an unfold. If you are
141232-- writing an unfold you can convert it to stream for free using
142233-- 'Stream.unfold'.
143−
144−-- What makes streams less efficient is also what makes them more conveient to
145−-- use and powerful. The stream data type (Stream m a) bundles the state along
146−-- with the stream generator function making it opaque, whereas an unfold
147−-- exposes the state (Unfold m s a) to the user. This allows the Unfold to be
148−-- unfolded (inlined) inside a nested loop without having to bundle the state
149−-- and the generator together, the stream state can be saved and passed
150−-- independent of the generator function. On the other hand in a stream type we
151−-- have to bundle the stream state and the generator function together to save
152−-- the stream. This makes it inefficient because it requires boxing and
153−-- constructor allocation. However, this makes streams more convenient as we do
154−-- not need to pass around the state/seed separately.
155−--
156−module Streamly.Data.Unfold
157− (
158− -- * Unfold Type
159− Unfold
160−
161− -- * Unfolds
162− -- One to one correspondence with
163− -- "Streamly.Internal.Data.Stream.Generate"
164−
165− -- ** Basic Constructors
166− , unfoldrM
167− , unfoldr
168− , function
169− , functionM
170−
171− -- ** Generators
172− -- | Generate a monadic stream from a seed.
173− , repeatM
174− , replicateM
175− , iterateM
176−
177− -- ** From Containers
178− , fromList
179− , fromListM
180− , fromStream
181−
182− -- * Combinators
183− -- ** Mapping on Input
184− , lmap
185− , lmapM
186−
187− -- ** Mapping on Output
188− , mapM
189−
190− -- ** Filtering
191− , takeWhileM
192− , takeWhile
193− , take
194− , filter
195− , filterM
196− , drop
197− , dropWhile
198− , dropWhileM
199−
200− -- ** Zipping
201− , zipWith
202−
203− -- ** Cross Product
204− , crossWith
205−
206− -- ** Nesting
207− , many
208−
209− -- Exception combinators are not exposed, we would like to encourage the
210− -- use of Stream type instead where exception handling is required. We can
211− -- consider exposing the unfold exception functions if there is a
212− -- compelling use case to use unfolds instead of stream.
213− )
214−where
215−
216−import Prelude hiding
217− ( concat, map, mapM, takeWhile, take, filter, const, drop, dropWhile
218− , zipWith
219− )
220−import Streamly.Internal.Data.Unfold
core/src/Streamly/FileSystem/Handle.hs+15−29
@@ -1,4 +1,4 @@
1−#include "inline.hs"
1+{-# LANGUAGE CPP #-}
22
33-- |
44-- Module : Streamly.FileSystem.Handle
@@ -40,6 +40,12 @@
4040--
4141module Streamly.FileSystem.Handle
4242 (
43+ -- * Setup
44+ -- | To execute the code examples provided in this module in ghci, please
45+ -- run the following commands first.
46+ --
47+ -- $setup
48+
4349 -- * Singleton IO
4450 -- | Read or write a single buffer.
4551 getChunk
@@ -75,13 +81,13 @@ module Streamly.FileSystem.Handle
7581 -- position of the file handle. The stream ends as soon as EOF is
7682 -- encountered.
7783
78− -- -- *** Streams
79− -- , read
80− -- , readWith
81− -- , readChunks
82− -- , readChunksWith
84+ -- *** Streams
85+ , read
86+ , readWith
87+ , readChunks
88+ , readChunksWith
8389
84− -- -- *** Unfolds
90+ -- *** Unfolds
8591 , reader
8692 , readerWith
8793 , chunkReader
@@ -98,34 +104,14 @@ module Streamly.FileSystem.Handle
98104 , writeChunks
99105
100106 -- * Deprecated
101− , read
102107 , readWithBufferOf
103− , readChunks
104108 , readChunksWithBufferOf
105109 , writeChunksWithBufferOf
106110 , writeWithBufferOf
107111 )
108112where
109113
110−import Control.Monad.IO.Class (MonadIO(..))
111−import Data.Word (Word8)
112−import Streamly.Internal.Data.Array.Type (Array)
113−import Streamly.Internal.Data.Unfold.Type (Unfold)
114−import System.IO (Handle)
115−
116−import Streamly.Internal.FileSystem.Handle hiding (read, readChunks)
114+import Streamly.Internal.FileSystem.Handle
117115import Prelude hiding (read)
118116
119−-- | Same as 'reader'
120−--
121−{-# DEPRECATED read "Please use 'reader' instead" #-}
122−{-# INLINE read #-}
123−read :: MonadIO m => Unfold m Handle Word8
124−read = reader
125−
126−-- | Same as 'chunkReader'
127−--
128−{-# DEPRECATED readChunks "Please use 'chunkReader' instead" #-}
129−{-# INLINE readChunks #-}
130−readChunks :: MonadIO m => Unfold m Handle (Array Word8)
131−readChunks = chunkReader
117+#include "DocTestFileSystemHandle.hs"
core/src/Streamly/Internal/Console/Stdio.hs+2−2
@@ -47,12 +47,12 @@ import System.IO (stdin, stdout, stderr)
4747import Prelude hiding (read)
4848
4949import Streamly.Internal.Data.Array.Type (Array(..))
50−import Streamly.Internal.Data.Stream.StreamD (Stream)
50+import Streamly.Internal.Data.Stream (Stream)
5151import Streamly.Internal.Data.Unfold (Unfold)
5252import Streamly.Internal.Data.Fold (Fold)
5353
5454import qualified Streamly.Internal.Data.Array as Array
55−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
55+import qualified Streamly.Internal.Data.Stream as Stream
5656 (intersperseMSuffix)
5757import qualified Streamly.Internal.Data.Unfold as Unfold
5858import qualified Streamly.Internal.FileSystem.Handle as Handle
core/src/Streamly/Internal/Data/Array.hs+644−187
@@ -1,88 +1,48 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Internal.Data.Array
34-- Copyright : (c) 2019 Composewell Technologies
4−--
55-- License : BSD3
66-- Maintainer : streamly@composewell.com
77-- Stability : experimental
88-- Portability : GHC
99--
10−-- To summarize:
11−--
12−-- * Arrays are finite and fixed in size
13−-- * provide /O(1)/ access to elements
14−-- * store only data and not functions
15−-- * provide efficient IO interfacing
16−--
17−-- 'Foldable' instance is not provided because the implementation would be much
18−-- less efficient compared to folding via streams. 'Semigroup' and 'Monoid'
19−-- instances should be used with care; concatenating arrays using binary
20−-- operations can be highly inefficient. Instead, use
21−-- 'Streamly.Internal.Data.Stream.Chunked.toArray' to concatenate N
22−-- arrays at once.
23−--
24−-- Each array is one pointer visible to the GC. Too many small arrays (e.g.
25−-- single byte) are only as good as holding those elements in a Haskell list.
26−-- However, small arrays can be compacted into large ones to reduce the
27−-- overhead. To hold 32GB memory in 32k sized buffers we need 1 million arrays
28−-- if we use one array for each chunk. This is still significant to add
29−-- pressure to GC.
30−
3110module Streamly.Internal.Data.Array
3211 (
33− Array
12+ -- * Setup
13+ -- $setup
3414
35− -- * Construction
15+ -- * Design Notes
16+ -- $design
3617
37− -- Pure List APIs
38− , A.fromListN
39− , A.fromList
40−
41− -- Stream Folds
42− , fromStreamN
43− , fromStream
18+ -- * The Array Type
19+ module Streamly.Internal.Data.Array.Type
4420
21+ -- * Construction
4522 -- Monadic Folds
46− , A.writeN -- drop new
47− , A.writeNAligned
48− , A.write -- full buffer
4923 , writeLastN
5024
51− -- * Elimination
52− -- ** Conversion
53− , A.toList
54−
55− -- ** Streams
56− , A.read
57− , A.readRev
58−
59− -- ** Unfolds
60− , reader
61− , readerUnsafe
62− , A.readerRev
63− , producer -- experimental
64−
6525 -- * Random Access
6626 -- , (!!)
6727 , getIndex
68− , A.unsafeIndex -- XXX Rename to getIndexUnsafe??
6928 , getIndexRev
70− , last -- XXX getIndexLast?
71− , getIndices
72− , getIndicesFromThenTo
29+ , last -- XXX getLastIndex?
7330 -- , getIndicesFrom -- read from a given position to the end of file
7431 -- , getIndicesUpto -- read from beginning up to the given position
7532 -- , getIndicesFromTo
7633 -- , getIndicesFromRev -- read from a given position to the beginning of file
7734 -- , getIndicesUptoRev -- read from end to the given position in file
35+ , indexReader
36+ , indexReaderFromThenTo
7837
7938 -- * Size
80− , length
8139 , null
8240
8341 -- * Search
8442 , binarySearch
8543 , findIndicesOf
44+ -- getIndicesOf
45+ , indexFinder -- see splitOn
8646 -- , findIndexOf
8747 -- , find
8848
@@ -90,156 +50,134 @@ module Streamly.Internal.Data.Array
9050 , cast
9151 , asBytes
9252 , castUnsafe
93− , asPtrUnsafe
9453 , asCStringUnsafe
95− , A.unsafeFreeze -- asImmutableUnsafe?
96− , A.unsafeThaw -- asMutableUnsafe?
9754
9855 -- * Subarrays
9956 , getSliceUnsafe
10057 -- , getSlice
101− , genSlicesFromLen
102− , getSlicesFromLen
58+ , sliceIndexerFromLen
59+ , slicerFromLen
10360 , splitOn
10461
10562 -- * Streaming Operations
10663 , streamTransform
10764
108− -- ** Folding
65+ -- * Folding
10966 , streamFold
11067 , fold
11168
69+ -- * Stream of Arrays
70+
71+ -- XXX these are probably not very useful to have in this module as we can
72+ -- express these idiomatically using streams.
73+ , interpose
74+ , interposeSuffix
75+ , intercalateSuffix
76+
77+ , compactLE
78+ , pinnedCompactLE
79+ , compactOnByte
80+ , compactOnByteSuffix
81+
82+ , foldBreakChunks
83+ , foldChunks
84+ , foldBreakChunksK
85+ , parseBreakChunksK
86+
87+ -- * Serialization
88+ , encodeAs
89+ , serialize
90+ , pinnedSerialize
91+ , deserialize
92+
11293 -- * Deprecated
113− , A.toStream
114− , A.toStreamRev
94+ , genSlicesFromLen
95+ , getSlicesFromLen
96+ , getIndices
11597 )
11698where
11799
100+#include "assert.hs"
118101#include "inline.hs"
119102#include "ArrayMacros.h"
120103
121−import Control.Exception (assert)
122−import Control.Monad (when)
123104import Control.Monad.IO.Class (MonadIO(..))
105+-- import Data.Bifunctor (first)
106+-- import Data.Either (fromRight)
124107import Data.Functor.Identity (Identity)
125108import Data.Proxy (Proxy(..))
126109import Data.Word (Word8)
127110import Foreign.C.String (CString)
128111import Foreign.Ptr (castPtr)
129112import Foreign.Storable (Storable)
130−import Streamly.Internal.Data.Unboxed
131− ( Unbox
132− , peekWith
133− , sizeOf
134− )
113+import GHC.Types (SPEC(..))
114+import Streamly.Internal.Data.Unbox (Unbox(..))
135115import Prelude hiding (length, null, last, map, (!!), read, concat)
136116
137−import Streamly.Internal.Data.Array.Mut.Type (ArrayUnsafe(..))
138−import Streamly.Internal.Data.Array.Type
139− (Array(..), length, asPtrUnsafe)
117+import Streamly.Internal.Data.MutByteArray.Type (PinnedState(..), MutByteArray)
118+import Streamly.Internal.Data.Serialize.Type (Serialize)
140119import Streamly.Internal.Data.Fold.Type (Fold(..))
141−import Streamly.Internal.Data.Producer.Type (Producer(..))
142−import Streamly.Internal.Data.Stream.StreamD (Stream)
143−import Streamly.Internal.Data.Tuple.Strict (Tuple3Fused'(..))
120+import Streamly.Internal.Data.Parser (Parser(..), Initial(..), ParseError(..))
121+import Streamly.Internal.Data.Stream (Stream(..))
122+import Streamly.Internal.Data.StreamK (StreamK)
123+import Streamly.Internal.Data.SVar.Type (adaptState, defState)
124+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3Fused'(..))
144125import Streamly.Internal.Data.Unfold.Type (Unfold(..))
145126import Streamly.Internal.System.IO (unsafeInlineIO)
146127
147−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
148−import qualified Streamly.Internal.Data.Array.Mut as MA
149−import qualified Streamly.Internal.Data.Array.Type as A
128+import qualified Streamly.Internal.Data.Fold.Type as Fold
129+import qualified Streamly.Internal.Data.Serialize.Type as Serialize
130+import qualified Streamly.Internal.Data.MutByteArray.Type as MBA
131+import qualified Streamly.Internal.Data.MutArray as MA
150132import qualified Streamly.Internal.Data.Fold as FL
151−import qualified Streamly.Internal.Data.Producer.Type as Producer
152−import qualified Streamly.Internal.Data.Producer as Producer
153−import qualified Streamly.Internal.Data.Ring.Unboxed as RB
154−import qualified Streamly.Internal.Data.Stream.StreamD as D
155−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
133+import qualified Streamly.Internal.Data.Ring as RB
134+import qualified Streamly.Internal.Data.Parser as Parser
135+-- import qualified Streamly.Internal.Data.ParserK as ParserK
136+import qualified Streamly.Internal.Data.Stream as D
137+import qualified Streamly.Internal.Data.Stream as Stream
138+import qualified Streamly.Internal.Data.StreamK as StreamK
156139import qualified Streamly.Internal.Data.Unfold as Unfold
140+import qualified Prelude
157141
158−-------------------------------------------------------------------------------
159−-- Construction
160−-------------------------------------------------------------------------------
142+import Streamly.Internal.Data.Array.Type
161143
162−-- | Create an 'Array' from the first N elements of a stream. The array is
163−-- allocated to size N, if the stream terminates before N elements then the
164−-- array may hold less than N elements.
165−--
166−-- /Pre-release/
167−{-# INLINE fromStreamN #-}
168−fromStreamN :: (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)
169−fromStreamN n m = do
170− when (n < 0) $ error "writeN: negative write count specified"
171− A.fromStreamDN n m
144+#include "DocTestDataArray.hs"
172145
173−-- | Create an 'Array' from a stream. This is useful when we want to create a
174−-- single array from a stream of unknown size. 'writeN' is at least twice
175−-- as efficient when the size is already known.
146+-- $design
176147--
177−-- Note that if the input stream is too large memory allocation for the array
178−-- may fail. When the stream size is not known, `chunksOf` followed by
179−-- processing of indvidual arrays in the resulting stream should be preferred.
148+-- To summarize:
180149--
181−-- /Pre-release/
182−{-# INLINE fromStream #-}
183−fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (Array a)
184−fromStream = Stream.fold A.write
185−-- write m = A.fromStreamD $ D.fromStreamK m
150+-- * Arrays are finite and fixed in size
151+-- * provide /O(1)/ access to elements
152+-- * store only data and not functions
153+-- * provide efficient IO interfacing
154+--
155+-- 'Foldable' instance is not provided because the implementation would be much
156+-- less efficient compared to folding via streams. 'Semigroup' and 'Monoid'
157+-- instances should be used with care; concatenating arrays using binary
158+-- operations can be highly inefficient. Instead, use
159+-- 'Streamly.Internal.Data.Stream.Chunked.toArray' to concatenate N
160+-- arrays at once.
161+--
162+-- Each array is one pointer visible to the GC. Too many small arrays (e.g.
163+-- single byte) are only as good as holding those elements in a Haskell list.
164+-- However, small arrays can be compacted into large ones to reduce the
165+-- overhead. To hold 32GB memory in 32k sized buffers we need 1 million arrays
166+-- if we use one array for each chunk. This is still significant to add
167+-- pressure to GC.
186168
187169-------------------------------------------------------------------------------
188170-- Elimination
189171-------------------------------------------------------------------------------
190172
191−{-# INLINE_NORMAL producer #-}
192−producer :: forall m a. (Monad m, Unbox a) => Producer m (Array a) a
193−producer =
194− Producer.translate A.unsafeThaw A.unsafeFreeze
195− $ MA.producerWith (return . unsafeInlineIO)
196−
197−-- | Unfold an array into a stream.
198−--
199−{-# INLINE_NORMAL reader #-}
200−reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
201−reader = Producer.simplify producer
202−
203−-- | Unfold an array into a stream, does not check the end of the array, the
204−-- user is responsible for terminating the stream within the array bounds. For
205−-- high performance application where the end condition can be determined by
206−-- a terminating fold.
207−--
208−-- Written in the hope that it may be faster than "read", however, in the case
209−-- for which this was written, "read" proves to be faster even though the core
210−-- generated with unsafeRead looks simpler.
211−--
212−-- /Pre-release/
213−--
214−{-# INLINE_NORMAL readerUnsafe #-}
215−readerUnsafe :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
216−readerUnsafe = Unfold step inject
217− where
218−
219− inject (Array contents start end) =
220− return (ArrayUnsafe contents end start)
221−
222− {-# INLINE_LATE step #-}
223− step (ArrayUnsafe contents end p) = do
224− -- unsafeInlineIO allows us to run this in Identity monad for pure
225− -- toList/foldr case which makes them much faster due to not
226− -- accumulating the list and fusing better with the pure consumers.
227− --
228− -- This should be safe as the array contents are guaranteed to be
229− -- evaluated/written to before we peek at them.
230− let !x = unsafeInlineIO $ peekWith contents p
231− let !p1 = INDEX_NEXT(p,a)
232− return $ D.Yield x (ArrayUnsafe contents end p1)
233−
234173-- |
235174--
236−-- >>> import qualified Streamly.Internal.Data.Array.Type as Array
237175-- >>> null arr = Array.byteLength arr == 0
238176--
239177-- /Pre-release/
240178{-# INLINE null #-}
241179null :: Array a -> Bool
242−null arr = A.byteLength arr == 0
180+null arr = byteLength arr == 0
243181
244182-- | Like 'getIndex' but indexes the array in reverse from the end.
245183--
@@ -251,12 +189,11 @@ getIndexRev i arr =
251189 $ do
252190 let elemPtr = RINDEX_OF(arrEnd arr, i, a)
253191 if i >= 0 && elemPtr >= arrStart arr
254− then Just <$> peekWith (arrContents arr) elemPtr
192+ then Just <$> peekAt elemPtr (arrContents arr)
255193 else return Nothing
256194
257195-- |
258196--
259−-- >>> import qualified Streamly.Internal.Data.Array as Array
260197-- >>> last arr = Array.getIndexRev arr 0
261198--
262199-- /Pre-release/
@@ -268,6 +205,8 @@ last = getIndexRev 0
268205-- Folds with Array as the container
269206-------------------------------------------------------------------------------
270207
208+-- XXX We should generate this from Ring.
209+
271210-- | @writeLastN n@ folds a maximum of @n@ elements from the end of the input
272211-- stream to an 'Array'.
273212--
@@ -276,7 +215,7 @@ writeLastN ::
276215 (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)
277216writeLastN n
278217 | n <= 0 = fmap (const mempty) FL.drain
279− | otherwise = A.unsafeFreeze <$> Fold step initial done
218+ | otherwise = unsafeFreeze <$> Fold step initial done done
280219
281220 where
282221
@@ -289,11 +228,9 @@ writeLastN n
289228 in fmap f $ liftIO $ RB.new n
290229
291230 done (Tuple3Fused' rb rh i) = do
292− arr <- liftIO $ MA.newPinned n
293− foldFunc i rh snoc' arr rb
294−
295− -- XXX We should write a read unfold for ring.
296− snoc' b a = liftIO $ MA.snocUnsafe b a
231+ arr <- MA.new n
232+ -- XXX We should write a read unfold for ring.
233+ foldFunc i rh MA.snocUnsafe arr rb
297234
298235 foldFunc i
299236 | i < n = RB.unsafeFoldRingM
@@ -319,19 +256,26 @@ binarySearch = undefined
319256-- compared to streams by using SIMD instructions.
320257-- We can also return a bit array instead.
321258
259+-- Can use SIMD.
260+
322261-- | Perform a linear search to find all the indices where a given element is
323262-- present in an array.
324263--
325264-- /Unimplemented/
326−findIndicesOf :: (a -> Bool) -> Unfold Identity (Array a) Int
327−findIndicesOf = undefined
265+indexFinder :: (a -> Bool) -> Unfold Identity (Array a) Int
266+indexFinder = undefined
267+
268+-- |
269+-- /Unimplemented/
270+findIndicesOf :: (a -> Bool) -> Array a -> Stream Identity Int
271+findIndicesOf p = Stream.unfold (indexFinder p)
328272
329273{-
330274findIndexOf :: (a -> Bool) -> Array a -> Maybe Int
331−findIndexOf p = Unfold.fold Fold.one . Stream.unfold (findIndicesOf p)
275+findIndexOf p = Unfold.fold Fold.one . Stream.unfold (indexFinder p)
332276
333277find :: (a -> Bool) -> Array a -> Bool
334−find = Unfold.fold Fold.null . Stream.unfold (findIndicesOf p)
278+find = Unfold.fold Fold.null . Stream.unfold (indexFinder p)
335279-}
336280
337281-------------------------------------------------------------------------------
@@ -373,29 +317,45 @@ splitOn :: (Monad m, Unbox a) =>
373317 (a -> Bool) -> Array a -> Stream m (Array a)
374318splitOn predicate arr =
375319 fmap (\(i, len) -> getSliceUnsafe i len arr)
376− $ D.sliceOnSuffix predicate (A.toStreamD arr)
320+ $ D.indexOnSuffix predicate (read arr)
377321
322+{-# INLINE sliceIndexerFromLen #-}
323+sliceIndexerFromLen :: forall m a. (Monad m, Unbox a)
324+ => Int -- ^ from index
325+ -> Int -- ^ length of the slice
326+ -> Unfold m (Array a) (Int, Int)
327+sliceIndexerFromLen from len =
328+ Unfold.lmap unsafeThaw (MA.sliceIndexerFromLen from len)
329+
330+{-# DEPRECATED genSlicesFromLen "Please use sliceIndexerFromLen instead." #-}
378331{-# INLINE genSlicesFromLen #-}
379332genSlicesFromLen :: forall m a. (Monad m, Unbox a)
380333 => Int -- ^ from index
381334 -> Int -- ^ length of the slice
382335 -> Unfold m (Array a) (Int, Int)
383−genSlicesFromLen from len =
384− Unfold.lmap A.unsafeThaw (MA.genSlicesFromLen from len)
336+genSlicesFromLen = sliceIndexerFromLen
385337
386338-- | Generate a stream of slices of specified length from an array, starting
387339-- from the supplied array index. The last slice may be shorter than the
388340-- requested length.
389341--
390342-- /Pre-release//
343+{-# INLINE slicerFromLen #-}
344+slicerFromLen :: forall m a. (Monad m, Unbox a)
345+ => Int -- ^ from index
346+ -> Int -- ^ length of the slice
347+ -> Unfold m (Array a) (Array a)
348+slicerFromLen from len =
349+ fmap unsafeFreeze
350+ $ Unfold.lmap unsafeThaw (MA.slicerFromLen from len)
351+
352+{-# DEPRECATED getSlicesFromLen "Please use slicerFromLen instead." #-}
391353{-# INLINE getSlicesFromLen #-}
392354getSlicesFromLen :: forall m a. (Monad m, Unbox a)
393355 => Int -- ^ from index
394356 -> Int -- ^ length of the slice
395357 -> Unfold m (Array a) (Array a)
396−getSlicesFromLen from len =
397− fmap A.unsafeFreeze
398− $ Unfold.lmap A.unsafeThaw (MA.getSlicesFromLen from len)
358+getSlicesFromLen = slicerFromLen
399359
400360-------------------------------------------------------------------------------
401361-- Random reads and writes
@@ -413,7 +373,7 @@ getIndex i arr =
413373 $ do
414374 let elemPtr = INDEX_OF(arrStart arr, i, a)
415375 if i >= 0 && INDEX_VALID(elemPtr, arrEnd arr, a)
416− then Just <$> peekWith (arrContents arr) elemPtr
376+ then Just <$> peekAt elemPtr (arrContents arr)
417377 else return Nothing
418378
419379-- | Given a stream of array indices, read the elements on those indices from
@@ -425,19 +385,25 @@ getIndex i arr =
425385-- @
426386-- read =
427387-- let u = lmap (\arr -> (0, length arr - 1)) Unfold.enumerateFromTo
428−-- in Unfold.lmap f (getIndices arr)
388+-- in Unfold.lmap f (indexReader arr)
429389--
430390-- readRev =
431391-- let i = length arr - 1
432−-- in Unfold.lmap f (getIndicesFromThenTo i (i - 1) 0)
392+-- in Unfold.lmap f (indexReaderFromThenTo i (i - 1) 0)
433393-- @
434394--
435395-- /Pre-release/
396+{-# INLINE indexReader #-}
397+indexReader :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a
398+indexReader m =
399+ let unf = MA.indexReaderWith (return . unsafeInlineIO) m
400+ in Unfold.lmap unsafeThaw unf
401+
402+-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold
403+{-# DEPRECATED getIndices "Please use getIndices instead." #-}
436404{-# INLINE getIndices #-}
437405getIndices :: (Monad m, Unbox a) => Stream m Int -> Unfold m (Array a) a
438−getIndices m =
439− let unf = MA.getIndicesD (return . unsafeInlineIO) m
440− in Unfold.lmap A.unsafeThaw unf
406+getIndices = indexReader
441407
442408-- | Unfolds @(from, then, to, array)@ generating a finite stream whose first
443409-- element is the array value from the index @from@ and the successive elements
@@ -453,9 +419,9 @@ getIndices m =
453419-- @
454420--
455421-- /Unimplemented/
456−{-# INLINE getIndicesFromThenTo #-}
457−getIndicesFromThenTo :: Unfold m (Int, Int, Int, Array a) a
458−getIndicesFromThenTo = undefined
422+{-# INLINE indexReaderFromThenTo #-}
423+indexReaderFromThenTo :: Unfold m (Int, Int, Int, Array a) a
424+indexReaderFromThenTo = undefined
459425
460426-------------------------------------------------------------------------------
461427-- Transform via stream operations
@@ -472,7 +438,7 @@ getIndicesFromThenTo = undefined
472438{-# INLINE runPipe #-}
473439runPipe :: (MonadIO m, Unbox a, Unbox b)
474440 => Pipe m a b -> Array a -> m (Array b)
475−runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)
441+runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (read arr)
476442-}
477443
478444-- XXX For transformations that cannot change the number of elements e.g. "map"
@@ -486,7 +452,7 @@ runPipe f arr = P.runPipe (toArrayMinChunk (length arr)) $ f (A.read arr)
486452streamTransform :: forall m a b. (MonadIO m, Unbox a, Unbox b)
487453 => (Stream m a -> Stream m b) -> Array a -> m (Array b)
488454streamTransform f arr =
489− Stream.fold (A.writeWith (length arr)) $ f (A.read arr)
455+ Stream.fold (createWith (length arr)) $ f (read arr)
490456
491457-------------------------------------------------------------------------------
492458-- Casts
@@ -520,13 +486,15 @@ asBytes = castUnsafe
520486--
521487cast :: forall a b. (Unbox b) => Array a -> Maybe (Array b)
522488cast arr =
523− let len = A.byteLength arr
489+ let len = byteLength arr
524490 r = len `mod` SIZE_OF(b)
525491 in if r /= 0
526492 then Nothing
527493 else Just $ castUnsafe arr
528494
529−-- | Convert an array of any type into a null terminated CString Ptr.
495+-- | Convert an array of any type into a null terminated CString Ptr. If the
496+-- array is unpinned it is first converted to a pinned array which requires a
497+-- copy.
530498--
531499-- /Unsafe/
532500--
@@ -536,9 +504,9 @@ cast arr =
536504--
537505asCStringUnsafe :: Array a -> (CString -> IO b) -> IO b
538506asCStringUnsafe arr act = do
539− -- XXX Ensure a pinned allocation here.
540− let arr1 = asBytes arr <> A.fromList [0]
541− asPtrUnsafe arr1 $ \ptr -> act (castPtr ptr)
507+ let arr1 = asBytes arr <> fromList [0]
508+ -- unsafePinnedAsPtr makes sure the array is pinned
509+ unsafePinnedAsPtr arr1 $ \ptr -> act (castPtr ptr)
542510
543511-------------------------------------------------------------------------------
544512-- Folds
@@ -551,11 +519,500 @@ asCStringUnsafe arr act = do
551519-- /Pre-release/
552520{-# INLINE fold #-}
553521fold :: forall m a b. (Monad m, Unbox a) => Fold m a b -> Array a -> m b
554−fold f arr = Stream.fold f (A.read arr)
522+fold f arr = Stream.fold f (read arr)
555523
556524-- | Fold an array using a stream fold operation.
557525--
558526-- /Pre-release/
559527{-# INLINE streamFold #-}
560528streamFold :: (Monad m, Unbox a) => (Stream m a -> m b) -> Array a -> m b
561−streamFold f arr = f (A.read arr)
529+streamFold f arr = f (read arr)
530+
531+--------------------------------------------------------------------------------
532+-- Serialization
533+--------------------------------------------------------------------------------
534+
535+{-# INLINE encodeAs #-}
536+encodeAs :: forall a. Serialize a => PinnedState -> a -> Array Word8
537+encodeAs ps a =
538+ unsafeInlineIO $ do
539+ let len = Serialize.addSizeTo 0 a
540+ mbarr <- MBA.newBytesAs ps len
541+ off <- Serialize.serializeAt 0 mbarr a
542+ assertM(len == off)
543+ pure $ Array mbarr 0 off
544+
545+-- |
546+-- Properties:
547+-- 1. Identity: @deserialize . serialize == id@
548+-- 2. Encoded equivalence: @serialize a == serialize a@
549+{-# INLINE serialize #-}
550+serialize :: Serialize a => a -> Array Word8
551+serialize = encodeAs Unpinned
552+
553+-- | Serialize a Haskell type to a pinned byte array. The array is allocated
554+-- using pinned memory so that it can be used directly in OS APIs for writing
555+-- to file or sending over the network.
556+--
557+-- Properties:
558+-- 1. Identity: @deserialize . pinnedSerialize == id@
559+-- 2. Encoded equivalence: @pinnedSerialize a == pinnedSerialize a@
560+{-# INLINE pinnedSerialize #-}
561+pinnedSerialize :: Serialize a => a -> Array Word8
562+pinnedSerialize = encodeAs Pinned
563+
564+-- | Decode a Haskell type from a byte array containing its serialized
565+-- representation.
566+{-# INLINE deserialize #-}
567+deserialize :: Serialize a => Array Word8 -> a
568+deserialize arr@(Array {..}) = unsafeInlineIO $ do
569+ let lenArr = length arr
570+ (off, val) <-
571+ Serialize.deserializeAt arrStart arrContents (arrStart + lenArr)
572+ assertM(off == arrStart + lenArr)
573+ pure val
574+
575+-------------------------------------------------------------------------------
576+-- Streams of Arrays
577+-------------------------------------------------------------------------------
578+
579+-- TODO: efficiently compare two streams of arrays. Two streams can have chunks
580+-- of different sizes, we can handle that in the stream comparison abstraction.
581+-- This could be useful e.g. to fast compare whether two files differ.
582+
583+-- | Insert the given element between arrays and flatten.
584+--
585+-- >>> interpose x = Stream.interpose x Array.reader
586+--
587+{-# INLINE interpose #-}
588+interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
589+interpose x = D.interpose x reader
590+
591+data FlattenState s =
592+ OuterLoop s
593+ | InnerLoop s !MutByteArray !Int !Int
594+
595+-- | Insert the given element after each array and flatten. This is similar to
596+-- unlines.
597+--
598+-- >>> interposeSuffix x = Stream.interposeSuffix x Array.reader
599+--
600+{-# INLINE_NORMAL interposeSuffix #-}
601+interposeSuffix :: forall m a. (Monad m, Unbox a)
602+ => a -> Stream m (Array a) -> Stream m a
603+-- This does not require MonadIO constraint.
604+-- interposeSuffix x = D.interposeSuffix x reader
605+interposeSuffix sep (D.Stream step state) = D.Stream step' (OuterLoop state)
606+
607+ where
608+
609+ {-# INLINE_LATE step' #-}
610+ step' gst (OuterLoop st) = do
611+ r <- step (adaptState gst) st
612+ return $ case r of
613+ D.Yield Array{..} s ->
614+ D.Skip (InnerLoop s arrContents arrStart arrEnd)
615+ D.Skip s -> D.Skip (OuterLoop s)
616+ D.Stop -> D.Stop
617+
618+ step' _ (InnerLoop st _ p end) | p == end =
619+ return $ D.Yield sep $ OuterLoop st
620+
621+ step' _ (InnerLoop st contents p end) = do
622+ x <- pure $ unsafeInlineIO $ peekAt p contents
623+ return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
624+
625+-- | Insert the given array after each array and flatten.
626+--
627+-- >>> intercalateSuffix = Stream.intercalateSuffix Array.reader
628+--
629+{-# INLINE intercalateSuffix #-}
630+intercalateSuffix :: (Monad m, Unbox a)
631+ => Array a -> Stream m (Array a) -> Stream m a
632+intercalateSuffix = D.intercalateSuffix reader
633+
634+-- | @compactLE n@ coalesces adjacent arrays in the input stream
635+-- only if the combined size would be less than or equal to n.
636+--
637+-- Generates unpinned arrays irrespective of the pinning status of input
638+-- arrays.
639+{-# INLINE_NORMAL compactLE #-}
640+compactLE :: (MonadIO m, Unbox a)
641+ => Int -> Stream m (Array a) -> Stream m (Array a)
642+compactLE n stream =
643+ D.map unsafeFreeze $ MA.compactLE n $ D.map unsafeThaw stream
644+
645+-- | Pinned version of 'compactLE'.
646+{-# INLINE_NORMAL pinnedCompactLE #-}
647+pinnedCompactLE :: (MonadIO m, Unbox a)
648+ => Int -> Stream m (Array a) -> Stream m (Array a)
649+pinnedCompactLE n stream =
650+ D.map unsafeFreeze $ MA.pinnedCompactLE n $ D.map unsafeThaw stream
651+
652+-- | Split a stream of arrays on a given separator byte, dropping the separator
653+-- and coalescing all the arrays between two separators into a single array.
654+--
655+{-# INLINE compactOnByte #-}
656+compactOnByte
657+ :: (MonadIO m)
658+ => Word8
659+ -> Stream m (Array Word8)
660+ -> Stream m (Array Word8)
661+compactOnByte byte =
662+ fmap unsafeFreeze . MA.compactOnByte byte . fmap unsafeThaw
663+
664+-- | Like 'compactOnByte' considers the separator in suffix position instead of
665+-- infix position.
666+{-# INLINE compactOnByteSuffix #-}
667+compactOnByteSuffix
668+ :: (MonadIO m)
669+ => Word8
670+ -> Stream m (Array Word8)
671+ -> Stream m (Array Word8)
672+compactOnByteSuffix byte =
673+ fmap unsafeFreeze . MA.compactOnByteSuffix byte . fmap unsafeThaw
674+
675+-------------------------------------------------------------------------------
676+-- Folding Streams of Arrays
677+-------------------------------------------------------------------------------
678+
679+-- XXX This should not be used for breaking a stream as the D.cons used in
680+-- reconstructing the stream could be very bad for performance. This can only
681+-- be useful in folding without breaking.
682+{-# INLINE_NORMAL foldBreakChunks #-}
683+foldBreakChunks :: forall m a b. (MonadIO m, Unbox a) =>
684+ Fold m a b -> Stream m (Array a) -> m (b, Stream m (Array a))
685+foldBreakChunks (Fold fstep initial _ final) stream@(Stream step state) = do
686+ res <- initial
687+ case res of
688+ Fold.Partial fs -> go SPEC state fs
689+ Fold.Done fb -> return $! (fb, stream)
690+
691+ where
692+
693+ {-# INLINE go #-}
694+ go !_ st !fs = do
695+ r <- step defState st
696+ case r of
697+ Stream.Yield (Array contents start end) s ->
698+ let fp = Tuple' end contents
699+ in goArray SPEC s fp start fs
700+ Stream.Skip s -> go SPEC s fs
701+ Stream.Stop -> do
702+ b <- final fs
703+ return (b, D.nil)
704+
705+ goArray !_ s (Tuple' end _) !cur !fs
706+ | cur == end = do
707+ go SPEC s fs
708+ goArray !_ st fp@(Tuple' end contents) !cur !fs = do
709+ x <- liftIO $ peekAt cur contents
710+ res <- fstep fs x
711+ let next = INDEX_NEXT(cur,a)
712+ case res of
713+ Fold.Done b -> do
714+ let arr = Array contents next end
715+ return $! (b, D.cons arr (D.Stream step st))
716+ Fold.Partial fs1 -> goArray SPEC st fp next fs1
717+
718+-- This may be more robust wrt fusion compared to unfoldMany?
719+
720+-- | Fold a stream of arrays using a 'Fold'. This is equivalent to the
721+-- following:
722+--
723+-- >>> foldChunks f = Stream.fold f . Stream.unfoldMany Array.reader
724+--
725+foldChunks :: (MonadIO m, Unbox a) => Fold m a b -> Stream m (Array a) -> m b
726+foldChunks f s = fmap fst (foldBreakChunks f s)
727+-- foldStream f = Stream.fold f . Stream.unfoldMany reader
728+
729+-- | Fold a stream of arrays using a 'Fold' and return the remaining stream.
730+--
731+-- The following alternative to this function allows composing the fold using
732+-- the parser Monad:
733+--
734+-- @
735+-- foldBreakStreamK f s =
736+-- fmap (first (fromRight undefined))
737+-- $ StreamK.parseBreakChunks (ParserK.adaptC (Parser.fromFold f)) s
738+-- @
739+--
740+-- We can compare perf and remove this one or define it in terms of that.
741+--
742+foldBreakChunksK :: forall m a b. (MonadIO m, Unbox a) =>
743+ Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a))
744+{-
745+foldBreakChunksK f s =
746+ fmap (first (fromRight undefined))
747+ $ StreamK.parseBreakChunks (ParserK.adaptC (Parser.fromFold f)) s
748+-}
749+foldBreakChunksK (Fold fstep initial _ final) stream = do
750+ res <- initial
751+ case res of
752+ Fold.Partial fs -> go fs stream
753+ Fold.Done fb -> return (fb, stream)
754+
755+ where
756+
757+ {-# INLINE go #-}
758+ go !fs st = do
759+ let stop = (, StreamK.nil) <$> final fs
760+ single a = yieldk a StreamK.nil
761+ yieldk (Array contents start end) r =
762+ let fp = Tuple' end contents
763+ in goArray fs r fp start
764+ in StreamK.foldStream defState yieldk single stop st
765+
766+ goArray !fs st (Tuple' end _) !cur
767+ | cur == end = do
768+ go fs st
769+ goArray !fs st fp@(Tuple' end contents) !cur = do
770+ x <- liftIO $ peekAt cur contents
771+ res <- fstep fs x
772+ let next = INDEX_NEXT(cur,a)
773+ case res of
774+ Fold.Done b -> do
775+ let arr = Array contents next end
776+ return $! (b, StreamK.cons arr st)
777+ Fold.Partial fs1 -> goArray fs1 st fp next
778+
779+{-
780+-- This can be generalized to any type provided it can be unfolded to a stream
781+-- and it can be combined using a semigroup operation.
782+--
783+{-# INLINE_NORMAL parseBreakD #-}
784+parseBreakD ::
785+ forall m a b. (MonadIO m, MonadThrow m, Unbox a)
786+ => PRD.Parser a m b
787+ -> D.Stream m (Array.Array a)
788+ -> m (b, D.Stream m (Array.Array a))
789+parseBreakD
790+ (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do
791+
792+ res <- initial
793+ case res of
794+ PRD.IPartial s -> go SPEC state (List []) s
795+ PRD.IDone b -> return (b, stream)
796+ PRD.IError err -> throwM $ ParseError err
797+
798+ where
799+
800+ -- "backBuf" contains last few items in the stream that we may have to
801+ -- backtrack to.
802+ --
803+ -- XXX currently we are using a dumb list based approach for backtracking
804+ -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.
805+ -- That will allow us more efficient random back and forth movement.
806+ go !_ st backBuf !pst = do
807+ r <- step defState st
808+ case r of
809+ D.Yield (Array contents start end) s ->
810+ gobuf SPEC s backBuf
811+ (Tuple' end contents) start pst
812+ D.Skip s -> go SPEC s backBuf pst
813+ D.Stop -> do
814+ b <- extract pst
815+ return (b, D.nil)
816+
817+ -- Use strictness on "cur" to keep it unboxed
818+ gobuf !_ s backBuf (Tuple' end _) !cur !pst
819+ | cur == end = do
820+ go SPEC s backBuf pst
821+ gobuf !_ s backBuf fp@(Tuple' end contents) !cur !pst = do
822+ x <- liftIO $ peekByteIndex contents cur
823+ pRes <- pstep pst x
824+ let next = INDEX_NEXT(cur,a)
825+ case pRes of
826+ PR.Partial 0 pst1 ->
827+ gobuf SPEC s (List []) fp next pst1
828+ PR.Partial n pst1 -> do
829+ assert (n <= Prelude.length (x:getList backBuf)) (return ())
830+ let src0 = Prelude.take n (x:getList backBuf)
831+ arr0 = A.fromListN n (Prelude.reverse src0)
832+ arr1 = Array contents next end
833+ src = arr0 <> arr1
834+ let !(Array cont1 start end1) = src
835+ fp1 = Tuple' end1 cont1
836+ gobuf SPEC s (List []) fp1 start pst1
837+ PR.Continue 0 pst1 ->
838+ gobuf SPEC s (List (x:getList backBuf)) fp next pst1
839+ PR.Continue n pst1 -> do
840+ assert (n <= Prelude.length (x:getList backBuf)) (return ())
841+ let (src0, buf1) = splitAt n (x:getList backBuf)
842+ arr0 = A.fromListN n (Prelude.reverse src0)
843+ arr1 = Array contents next end
844+ src = arr0 <> arr1
845+ let !(Array cont1 start end1) = src
846+ fp1 = Tuple' end1 cont1
847+ gobuf SPEC s (List buf1) fp1 start pst1
848+ PR.Done 0 b -> do
849+ let arr = Array contents next end
850+ return (b, D.cons arr (D.Stream step s))
851+ PR.Done n b -> do
852+ assert (n <= Prelude.length (x:getList backBuf)) (return ())
853+ let src0 = Prelude.take n (x:getList backBuf)
854+ -- XXX create the array in reverse instead
855+ arr0 = A.fromListN n (Prelude.reverse src0)
856+ arr1 = Array contents next end
857+ -- XXX Use StreamK to avoid adding arbitrary layers of
858+ -- constructors every time.
859+ str = D.cons arr0 (D.cons arr1 (D.Stream step s))
860+ return (b, str)
861+ PR.Error err -> throwM $ ParseError err
862+-}
863+
864+-- | Parse an array stream using the supplied 'Parser'. Returns the parse
865+-- result and the unconsumed stream. Throws 'ParseError' if the parse fails.
866+--
867+-- The following alternative to this function allows composing the parser using
868+-- the parser Monad:
869+--
870+-- >>> parseBreakStreamK p = StreamK.parseBreakChunks (ParserK.adaptC p)
871+--
872+-- We can compare perf and remove this one or define it in terms of that.
873+--
874+-- /Internal/
875+--
876+{-# INLINE_NORMAL parseBreakChunksK #-}
877+parseBreakChunksK ::
878+ forall m a b. (MonadIO m, Unbox a)
879+ => Parser a m b
880+ -> StreamK m (Array a)
881+ -> m (Either ParseError b, StreamK m (Array a))
882+-- parseBreakStreamK p = StreamK.parseBreakChunks (ParserK.adaptC p)
883+parseBreakChunksK (Parser pstep initial extract) stream = do
884+ res <- initial
885+ case res of
886+ IPartial s -> go s stream []
887+ IDone b -> return (Right b, stream)
888+ IError err -> return (Left (ParseError err), stream)
889+
890+ where
891+
892+ -- "backBuf" contains last few items in the stream that we may have to
893+ -- backtrack to.
894+ --
895+ -- XXX currently we are using a dumb list based approach for backtracking
896+ -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.
897+ -- That will allow us more efficient random back and forth movement.
898+ go !pst st backBuf = do
899+ let stop = goStop pst backBuf -- (, K.nil) <$> extract pst
900+ single a = yieldk a StreamK.nil
901+ yieldk arr r = goArray pst backBuf r arr
902+ in StreamK.foldStream defState yieldk single stop st
903+
904+ -- Use strictness on "cur" to keep it unboxed
905+ goArray !pst backBuf st (Array _ cur end) | cur == end = go pst st backBuf
906+ goArray !pst backBuf st (Array contents cur end) = do
907+ x <- liftIO $ peekAt cur contents
908+ pRes <- pstep pst x
909+ let next = INDEX_NEXT(cur,a)
910+ case pRes of
911+ Parser.Partial 0 s ->
912+ goArray s [] st (Array contents next end)
913+ Parser.Partial n s -> do
914+ assert (n <= Prelude.length (x:backBuf)) (return ())
915+ let src0 = Prelude.take n (x:backBuf)
916+ arr0 = fromListN n (Prelude.reverse src0)
917+ arr1 = Array contents next end
918+ src = arr0 <> arr1
919+ goArray s [] st src
920+ Parser.Continue 0 s ->
921+ goArray s (x:backBuf) st (Array contents next end)
922+ Parser.Continue n s -> do
923+ assert (n <= Prelude.length (x:backBuf)) (return ())
924+ let (src0, buf1) = Prelude.splitAt n (x:backBuf)
925+ arr0 = fromListN n (Prelude.reverse src0)
926+ arr1 = Array contents next end
927+ src = arr0 <> arr1
928+ goArray s buf1 st src
929+ Parser.Done 0 b -> do
930+ let arr = Array contents next end
931+ return (Right b, StreamK.cons arr st)
932+ Parser.Done n b -> do
933+ assert (n <= Prelude.length (x:backBuf)) (return ())
934+ let src0 = Prelude.take n (x:backBuf)
935+ -- XXX Use fromListRevN once implemented
936+ -- arr0 = A.fromListRevN n src0
937+ arr0 = fromListN n (Prelude.reverse src0)
938+ arr1 = Array contents next end
939+ str = StreamK.cons arr0 (StreamK.cons arr1 st)
940+ return (Right b, str)
941+ Parser.Error err -> do
942+ let n = Prelude.length backBuf
943+ arr0 = fromListN n (Prelude.reverse backBuf)
944+ arr1 = Array contents cur end
945+ str = StreamK.cons arr0 (StreamK.cons arr1 stream)
946+ return (Left (ParseError err), str)
947+
948+ -- This is a simplified goArray
949+ goExtract !pst backBuf (Array _ cur end)
950+ | cur == end = goStop pst backBuf
951+ goExtract !pst backBuf (Array contents cur end) = do
952+ x <- liftIO $ peekAt cur contents
953+ pRes <- pstep pst x
954+ let next = INDEX_NEXT(cur,a)
955+ case pRes of
956+ Parser.Partial 0 s ->
957+ goExtract s [] (Array contents next end)
958+ Parser.Partial n s -> do
959+ assert (n <= Prelude.length (x:backBuf)) (return ())
960+ let src0 = Prelude.take n (x:backBuf)
961+ arr0 = fromListN n (Prelude.reverse src0)
962+ arr1 = Array contents next end
963+ src = arr0 <> arr1
964+ goExtract s [] src
965+ Parser.Continue 0 s ->
966+ goExtract s backBuf (Array contents next end)
967+ Parser.Continue n s -> do
968+ assert (n <= Prelude.length (x:backBuf)) (return ())
969+ let (src0, buf1) = Prelude.splitAt n (x:backBuf)
970+ arr0 = fromListN n (Prelude.reverse src0)
971+ arr1 = Array contents next end
972+ src = arr0 <> arr1
973+ goExtract s buf1 src
974+ Parser.Done 0 b -> do
975+ let arr = Array contents next end
976+ return (Right b, StreamK.fromPure arr)
977+ Parser.Done n b -> do
978+ assert (n <= Prelude.length backBuf) (return ())
979+ let src0 = Prelude.take n backBuf
980+ -- XXX Use fromListRevN once implemented
981+ -- arr0 = A.fromListRevN n src0
982+ arr0 = fromListN n (Prelude.reverse src0)
983+ arr1 = Array contents next end
984+ str = StreamK.cons arr0 (StreamK.fromPure arr1)
985+ return (Right b, str)
986+ Parser.Error err -> do
987+ let n = Prelude.length backBuf
988+ arr0 = fromListN n (Prelude.reverse backBuf)
989+ arr1 = Array contents cur end
990+ str = StreamK.cons arr0 (StreamK.cons arr1 stream)
991+ return (Left (ParseError err), str)
992+
993+ -- This is a simplified goExtract
994+ {-# INLINE goStop #-}
995+ goStop !pst backBuf = do
996+ pRes <- extract pst
997+ case pRes of
998+ Parser.Partial _ _ -> error "Bug: parseBreak: Partial in extract"
999+ Parser.Continue 0 s ->
1000+ goStop s backBuf
1001+ Parser.Continue n s -> do
1002+ assert (n <= Prelude.length backBuf) (return ())
1003+ let (src0, buf1) = Prelude.splitAt n backBuf
1004+ arr = fromListN n (Prelude.reverse src0)
1005+ goExtract s buf1 arr
1006+ Parser.Done 0 b ->
1007+ return (Right b, StreamK.nil)
1008+ Parser.Done n b -> do
1009+ assert (n <= Prelude.length backBuf) (return ())
1010+ let src0 = Prelude.take n backBuf
1011+ -- XXX Use fromListRevN once implemented
1012+ -- arr0 = A.fromListRevN n src0
1013+ arr0 = fromListN n (Prelude.reverse src0)
1014+ return (Right b, StreamK.fromPure arr0)
1015+ Parser.Error err -> do
1016+ let n = Prelude.length backBuf
1017+ arr0 = fromListN n (Prelude.reverse backBuf)
1018+ return (Left (ParseError err), StreamK.fromPure arr0)
core/src/Streamly/Internal/Data/Array/Generic.hs+148−181
@@ -4,7 +4,6 @@
44--
55-- License : BSD-3-Clause
66-- Maintainer : streamly@composewell.com
7−-- Stability : pre-release
87-- Portability : GHC
98--
109module Streamly.Internal.Data.Array.Generic
@@ -12,25 +11,26 @@ module Streamly.Internal.Data.Array.Generic
1211
1312 -- * Construction
1413 , nil
15− , writeN
16− , write
14+ , createOf
15+ , create
16+ , writeWith
1717 , writeLastN
1818
19− , fromStreamDN
20− , fromStreamD
2119 , fromStreamN
2220 , fromStream
21+ , fromPureStream
22+ , fromByteStr#
2323
2424 , fromListN
2525 , fromList
2626
27+ , chunksOf
28+
2729 -- * Elimination
2830 , length
2931 , reader
3032
3133 , toList
32− , readStreamD
33− , readRevStreamD
3434 , read
3535 , readRev
3636
@@ -41,36 +41,42 @@ module Streamly.Internal.Data.Array.Generic
4141
4242 -- * Random Access
4343 , getIndexUnsafe
44+ , getIndex
45+ , getSliceUnsafe
4446 , strip
45− , putIndices
47+
48+ -- * Deprecated
49+ , writeN
50+ , write
4651 )
4752where
4853
4954#include "inline.hs"
5055
51−import Control.Monad (when, replicateM)
52−import Control.Monad.IO.Class (liftIO, MonadIO)
56+import Control.Monad (replicateM)
57+import Control.Monad.IO.Class (MonadIO)
58+import Data.Functor.Identity (Identity(..))
59+import Data.Word (Word8)
5360import GHC.Base (MutableArray#, RealWorld)
61+import GHC.Exts (Addr#)
5462import GHC.IO (unsafePerformIO)
5563import Text.Read (readPrec)
5664
5765import Streamly.Internal.Data.Fold.Type (Fold(..))
58−import Streamly.Internal.Data.Stream.StreamD.Type (Stream)
59−import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
66+import Streamly.Internal.Data.Stream.Type (Stream)
6067import Streamly.Internal.Data.Unfold.Type (Unfold(..))
6168import Streamly.Internal.System.IO (unsafeInlineIO)
6269
63−import qualified Streamly.Internal.Data.Array.Generic.Mut.Type as MArray
70+import qualified Streamly.Internal.Data.MutArray.Generic as MArray
6471import qualified Streamly.Internal.Data.Fold.Type as FL
6572import qualified Streamly.Internal.Data.Producer.Type as Producer
6673import qualified Streamly.Internal.Data.Producer as Producer
67−import qualified Streamly.Internal.Data.Ring as RB
68−import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
69−import qualified Streamly.Internal.Data.Stream.StreamD.Generate as D
74+import qualified Streamly.Internal.Data.Ring.Generic as RB
75+import qualified Streamly.Internal.Data.Stream.Type as D
76+import qualified Streamly.Internal.Data.Stream.Generate as D
7077import qualified Text.ParserCombinators.ReadPrec as ReadPrec
7178
72−import Data.IORef
73−import Prelude hiding (foldr, length, read)
79+import Prelude hiding (Foldable(..), read)
7480
7581-------------------------------------------------------------------------------
7682-- Array Data Type
@@ -96,73 +102,79 @@ unsafeThaw (Array cont# arrS arrL) = MArray.MutArray cont# arrS arrL arrL
96102
97103{-# NOINLINE nil #-}
98104nil :: Array a
99−nil = unsafePerformIO $ do
100− marr <- MArray.new 0
101− return $ unsafeFreeze marr
105+nil = unsafePerformIO $ unsafeFreeze <$> MArray.nil
102106
103107-------------------------------------------------------------------------------
104108-- Construction - Folds
105109-------------------------------------------------------------------------------
106110
107−{-# INLINE_NORMAL writeN #-}
111+{-# INLINE_NORMAL createOf #-}
112+createOf :: MonadIO m => Int -> Fold m a (Array a)
113+createOf = fmap unsafeFreeze <$> MArray.createOf
114+
115+-- XXX Deprecate in major
116+-- {-# DEPRECATED writeN "Please use createOf instead." #-}
117+{-# INLINE writeN #-}
108118writeN :: MonadIO m => Int -> Fold m a (Array a)
109−writeN = fmap unsafeFreeze <$> MArray.writeN
119+writeN = createOf
120+
121+{-# INLINE_NORMAL writeWith #-}
122+writeWith :: MonadIO m => Int -> Fold m a (Array a)
123+writeWith elemCount = unsafeFreeze <$> MArray.createWith elemCount
124+
125+-- | Fold the whole input to a single array.
126+--
127+-- /Caution! Do not use this on infinite streams./
128+--
129+{-# INLINE create #-}
130+create :: MonadIO m => Fold m a (Array a)
131+create = fmap unsafeFreeze MArray.create
110132
111−{-# INLINE_NORMAL write #-}
133+-- XXX Deprecate in major
134+-- {-# DEPRECATED write "Please use create instead." #-}
135+{-# INLINE write #-}
112136write :: MonadIO m => Fold m a (Array a)
113−write = Fold step initial extract
114− where
115− initial = do
116− marr <- liftIO $ MArray.new 0
117− return $ FL.Partial (Tuple3' marr 0 0)
118− step (Tuple3' marr i capacity) x
119− | i == capacity =
120− let newCapacity = max (capacity * 2) 1
121− in do newMarr <- liftIO $ MArray.realloc newCapacity marr
122− marr1 <- liftIO $ MArray.snocUnsafe newMarr x
123− return $ FL.Partial $ Tuple3' marr1 (i + 1) newCapacity
124− | otherwise = do
125− marr1 <- liftIO $ MArray.snocUnsafe marr x
126− return $ FL.Partial $ Tuple3' marr1 (i + 1) capacity
127− extract (Tuple3' marr _ _) =
128− return $ unsafeFreeze marr
137+write = create
138+
139+fromPureStream :: Stream Identity a -> Array a
140+fromPureStream x =
141+ unsafePerformIO $ fmap (unsafeFreeze) (MArray.fromPureStream x)
142+-- fromPureStream = runIdentity . D.fold (unsafeMakePure write)
143+-- fromPureStream = fromList . runIdentity . D.toList
144+
145+fromByteStr# :: Addr# -> Array Word8
146+fromByteStr# addr = fromPureStream (D.fromByteStr# addr)
129147
130148-------------------------------------------------------------------------------
131−-- Construction - from streams
149+-- Stream Ops
132150-------------------------------------------------------------------------------
133151
134−{-# INLINE_NORMAL fromStreamDN #-}
135−fromStreamDN :: MonadIO m => Int -> D.Stream m a -> m (Array a)
136−fromStreamDN limit str = do
137− marr <- liftIO $ MArray.new (max limit 0)
138− i <-
139− D.foldlM'
140− (\i x -> i `seq` liftIO $ MArray.putIndexUnsafe i marr x >> return (i + 1))
141− (return 0) $
142− D.take limit str
143− return $ unsafeFreeze $ marr { MArray.arrLen = i }
144−
145−{-# INLINE fromStreamD #-}
146−fromStreamD :: MonadIO m => D.Stream m a -> m (Array a)
147−fromStreamD = D.fold write
152+{-# INLINE_NORMAL chunksOf #-}
153+chunksOf :: forall m a. MonadIO m
154+ => Int -> Stream m a -> Stream m (Array a)
155+chunksOf n strm = fmap unsafeFreeze $ MArray.chunksOf n strm
156+
157+-------------------------------------------------------------------------------
158+-- Construction - from streams
159+-------------------------------------------------------------------------------
148160
149161{-# INLINE fromStreamN #-}
150162fromStreamN :: MonadIO m => Int -> Stream m a -> m (Array a)
151−fromStreamN n m = do
152− when (n < 0) $ error "fromStreamN: negative write count specified"
153− fromStreamDN n m
163+fromStreamN n = D.fold (writeN n)
154164
155165{-# INLINE fromStream #-}
156166fromStream :: MonadIO m => Stream m a -> m (Array a)
157−fromStream = fromStreamD
167+fromStream = D.fold write
168+
169+-- XXX Consider foldr/build fusion in toList/fromList
158170
159171{-# INLINABLE fromListN #-}
160172fromListN :: Int -> [a] -> Array a
161−fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
173+fromListN n xs = unsafePerformIO $ fromStreamN n $ D.fromList xs
162174
163175{-# INLINABLE fromList #-}
164176fromList :: [a] -> Array a
165−fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
177+fromList xs = unsafePerformIO $ fromStream $ D.fromList xs
166178
167179-------------------------------------------------------------------------------
168180-- Elimination - Unfolds
@@ -191,25 +203,18 @@ toList arr = loop 0
191203
192204 len = length arr
193205 loop i | i == len = []
194− loop i = getIndexUnsafe arr i : loop (i + 1)
195−
196−{-# INLINE_NORMAL readStreamD #-}
197−readStreamD :: MonadIO m => Array a -> D.Stream m a
198−readStreamD = MArray.toStreamD . unsafeThaw
199−
200−{-# INLINE_NORMAL readRevStreamD #-}
201−readRevStreamD :: Monad m => Array a -> D.Stream m a
202−readRevStreamD arr@Array{..} =
203− D.map (getIndexUnsafe arr)
204− $ D.enumerateFromThenToIntegral (arrLen - 1) (arrLen - 2) 0
206+ loop i = getIndexUnsafe i arr : loop (i + 1)
205207
206−{-# INLINE_EARLY read #-}
207−read :: MonadIO m => Array a -> Stream m a
208−read = readStreamD
208+{-# INLINE_NORMAL read #-}
209+read :: Monad m => Array a -> Stream m a
210+read arr@Array{..} =
211+ D.map (`getIndexUnsafe` arr) $ D.enumerateFromToIntegral 0 (arrLen - 1)
209212
210−{-# INLINE_EARLY readRev #-}
213+{-# INLINE_NORMAL readRev #-}
211214readRev :: Monad m => Array a -> Stream m a
212−readRev = readRevStreamD
215+readRev arr@Array{..} =
216+ D.map (`getIndexUnsafe` arr)
217+ $ D.enumerateFromThenToIntegral (arrLen - 1) (arrLen - 2) 0
213218
214219-------------------------------------------------------------------------------
215220-- Elimination - using Folds
@@ -217,18 +222,18 @@ readRev = readRevStreamD
217222
218223{-# INLINE_NORMAL foldl' #-}
219224foldl' :: (b -> a -> b) -> b -> Array a -> b
220−foldl' f z arr = unsafePerformIO $ D.foldl' f z $ readStreamD arr
225+foldl' f z arr = unsafePerformIO $ D.foldl' f z $ read arr
221226
222227{-# INLINE_NORMAL foldr #-}
223228foldr :: (a -> b -> b) -> b -> Array a -> b
224−foldr f z arr = unsafePerformIO $ D.foldr f z $ readStreamD arr
229+foldr f z arr = unsafePerformIO $ D.foldr f z $ read arr
225230
226231{-# INLINE fold #-}
227−fold :: MonadIO m => Fold m a b -> Array a -> m b
228−fold f arr = D.fold f (readStreamD arr)
232+fold :: Monad m => Fold m a b -> Array a -> m b
233+fold f arr = D.fold f (read arr)
229234
230235{-# INLINE streamFold #-}
231−streamFold :: MonadIO m => (Stream m a -> m b) -> Array a -> m b
236+streamFold :: Monad m => (Stream m a -> m b) -> Array a -> m b
232237streamFold f arr = f (read arr)
233238
234239-------------------------------------------------------------------------------
@@ -240,134 +245,96 @@ streamFold f arr = f (read arr)
240245--
241246-- @since 0.8.0
242247{-# INLINE getIndexUnsafe #-}
243−getIndexUnsafe :: Array a -> Int -> a
244−getIndexUnsafe arr i =
248+getIndexUnsafe :: Int -> Array a -> a
249+getIndexUnsafe i arr =
245250 unsafePerformIO $ MArray.getIndexUnsafe i (unsafeThaw arr)
246251
252+-- | Lookup the element at the given index. Index starts from 0.
253+--
254+{-# INLINE getIndex #-}
255+getIndex :: Int -> Array a -> Maybe a
256+getIndex i arr@Array {..} =
257+ if i >= 0 && i < arrLen
258+ then Just $ getIndexUnsafe i arr
259+ else Nothing
260+
261+-- >>> import qualified Streamly.Data.Stream as Stream
262+-- >>> import qualified Streamly.Data.Fold as Fold
263+-- >>> import qualified Streamly.Internal.Data.Array.Generic as Array
264+-- >>> import Data.Function ((&))
265+-- >>> :{
266+-- Stream.fromList [1,2,3,4,5::Int]
267+-- & Stream.scan (Array.writeLastN 2)
268+-- & Stream.fold Fold.toList
269+-- :}
270+-- [fromList [],fromList [1],fromList [1,2],fromList [2,3],fromList [3,4],fromList [4,5]]
271+--
247272{-# INLINE writeLastN #-}
248273writeLastN :: MonadIO m => Int -> Fold m a (Array a)
249−writeLastN n
250− | n <= 0 = fmap (const nil) FL.drain
251− | otherwise = Fold step initial done
274+writeLastN n = FL.rmapM f (RB.writeLastN n)
252275
253276 where
254277
255− initial = do
256− rb <- liftIO $ RB.createRing n
257− return $ FL.Partial $ Tuple' rb (0 :: Int)
278+ f rb = do
279+ arr <- RB.copyToMutArray 0 n rb
280+ return $ unsafeFreeze arr
258281
259− step (Tuple' rb rh) x = do
260− liftIO $ RB.unsafeInsertRing rb rh x
261− return $ FL.Partial $ Tuple' rb (rh + 1)
262−
263− done (Tuple' rb rh) = do
264− arr' <- liftIO $ MArray.new (min rh n)
265− ref <- liftIO $ readIORef $ RB.ringHead rb
266− if rh < n
267− then
268− MArray.putSliceUnsafe (RB.arr rb) 0 arr' 0 ref
269− else do
270− MArray.putSliceUnsafe (RB.arr rb) ref arr' 0 (n - ref)
271− MArray.putSliceUnsafe (RB.arr rb) 0 arr' (n - ref) ref
272− return $ unsafeFreeze arr'
273−
274−sliceUnsafe :: Int -> Int -> Array a -> Array a
275−sliceUnsafe offset len (Array cont off1 _) = Array cont (off1 + offset) len
282+{-# INLINE getSliceUnsafe #-}
283+getSliceUnsafe :: Int -> Int -> Array a -> Array a
284+getSliceUnsafe offset len (Array cont off1 _) = Array cont (off1 + offset) len
276285
277286-- XXX This is not efficient as it copies the array. We should support array
278287-- slicing so that we can just refer to the underlying array memory instead of
279288-- copying.
280−--
289+
281290-- | Truncate the array at the beginning and end as long as the predicate
282−-- holds true.
291+-- holds true. Returns a slice of the original array.
292+{-# INLINE strip #-}
283293strip :: (a -> Bool) -> Array a -> Array a
284−strip p arr =
285− let lastIndex = length arr - 1
286− indexR = getIndexR lastIndex -- last predicate failing index
287− in if indexR == -1
288− then nil
289− else
290− let indexL = getIndexL 0 -- first predicate failing index
291− in if indexL == 0 && indexR == lastIndex
292− then arr
293− else unsafeFreeze $ unsafePerformIO $ do
294− let newLen = indexR - indexL + 1
295− arrThawed = unsafeThaw (sliceUnsafe indexL newLen arr)
296− MArray.clone arrThawed
297−
298− where
299−
300− getIndexR idx
301− | idx < 0 = idx
302− | otherwise =
303− if p (getIndexUnsafe arr idx) then getIndexR (idx - 1) else idx
304−
305− getIndexL idx = if p (getIndexUnsafe arr idx)
306− then getIndexL (idx + 1)
307− else idx
308−
309−-- | Write an input stream of (index, value) pairs to an array. Throws an
310−-- error if any index is out of bounds.
311−--
312−-- /Pre-release/
313−{-# INLINE putIndices #-}
314−putIndices :: MonadIO m
315− => Array a -> Fold m (Int, a) ()
316−putIndices arr = FL.rmapM (\ _ -> return ()) (FL.foldlM' step initial)
317−
318− where
319−
320− initial = return $ unsafeThaw arr
321−
322− step marr (i, x) = do
323− MArray.putIndexUnsafe i marr x
324− return marr
294+strip p arr = unsafeFreeze $ unsafePerformIO $ MArray.strip p (unsafeThaw arr)
325295
326296-------------------------------------------------------------------------------
327297-- Instances
328298-------------------------------------------------------------------------------
329299
330300instance Eq a => Eq (Array a) where
331− a1 == a2 = lenA1 == lenA2 && loop (lenA1 - 1)
301+ {-# INLINE (==) #-}
302+ arr1 == arr2 =
303+ unsafeInlineIO $! unsafeThaw arr1 `MArray.eq` unsafeThaw arr2
332304
333− where
305+instance Ord a => Ord (Array a) where
306+ {-# INLINE compare #-}
307+ compare arr1 arr2 =
308+ unsafeInlineIO $! unsafeThaw arr1 `MArray.cmp` unsafeThaw arr2
334309
335− lenA1 = length a1
336− lenA2 = length a2
310+ -- Default definitions defined in base do not have an INLINE on them, so we
311+ -- replicate them here with an INLINE.
312+ {-# INLINE (<) #-}
313+ x < y = case compare x y of { LT -> True; _ -> False }
337314
338− loop i
339− | i < 0 = True
340− | otherwise =
341− let v1 = getIndexUnsafe a1 i
342− v2 = getIndexUnsafe a2 i
343− in v1 == v2 && loop (i - 1)
315+ {-# INLINE (<=) #-}
316+ x <= y = case compare x y of { GT -> False; _ -> True }
344317
345−instance Ord a => Ord (Array a) where
346− compare a1 a2 =
347− case compare lenA1 lenA2 of
348− LT -> LT
349− GT -> GT
350− EQ -> loop 0
351−
352− where
353−
354− lenA1 = length a1
355− lenA2 = length a2
356−
357− loop i
358− | i >= lenA1 = EQ
359− | otherwise =
360− let v1 = getIndexUnsafe a1 i
361− v2 = getIndexUnsafe a2 i
362− in case compare v1 v2 of
363− LT -> LT
364− GT -> GT
365− EQ -> loop (i + 1)
318+ {-# INLINE (>) #-}
319+ x > y = case compare x y of { GT -> True; _ -> False }
320+
321+ {-# INLINE (>=) #-}
322+ x >= y = case compare x y of { LT -> False; _ -> True }
323+
324+ -- These two default methods use '<=' rather than 'compare'
325+ -- because the latter is often more expensive
326+ {-# INLINE max #-}
327+ max x y = if x <= y then y else x
328+
329+ {-# INLINE min #-}
330+ min x y = if x <= y then x else y
366331
367332instance Show a => Show (Array a) where
333+ {-# INLINE show #-}
368334 show arr = "fromList " ++ show (toList arr)
369335
370336instance Read a => Read (Array a) where
337+ {-# INLINE readPrec #-}
371338 readPrec = do
372339 fromListWord <- replicateM 9 ReadPrec.get
373340 if fromListWord == "fromList "
core/src/Streamly/Internal/Data/Array/Mut.hsdeleted−100
@@ -1,100 +0,0 @@
1−#include "inline.hs"
2−
3−-- |
4−-- Module : Streamly.Internal.Data.Array.Mut
5−-- Copyright : (c) 2020 Composewell Technologies
6−-- License : BSD-3-Clause
7−-- Maintainer : streamly@composewell.com
8−-- Stability : experimental
9−-- Portability : GHC
10−--
11−-- Unboxed pinned mutable array type for 'Unboxed' types with an option to use
12−-- foreign (non-GHC) memory allocators. Fulfils the following goals:
13−--
14−-- * Random access (array)
15−-- * Efficient storage (unboxed)
16−-- * Performance (unboxed access)
17−-- * Performance - in-place operations (mutable)
18−-- * Performance - GC (pinned, mutable)
19−-- * interfacing with OS (pinned)
20−-- * Fragmentation control (foreign allocators)
21−--
22−-- Stream and Fold APIs allow easy, efficient and convenient operations on
23−-- arrays.
24−
25−module Streamly.Internal.Data.Array.Mut
26− (
27− module Streamly.Internal.Data.Array.Mut.Type
28− , splitOn
29− , genSlicesFromLen
30− , getSlicesFromLen
31− , fromStream
32− )
33−where
34−
35−import Control.Monad.IO.Class (MonadIO(..))
36−import Streamly.Internal.Data.Unboxed (Unbox)
37−import Streamly.Internal.Data.Stream.StreamD (Stream)
38−import Streamly.Internal.Data.Unfold.Type (Unfold(..))
39−
40−import qualified Streamly.Internal.Data.Stream.StreamD as D
41−import qualified Streamly.Internal.Data.Unfold as Unfold
42−
43−import Prelude hiding (foldr, length, read, splitAt)
44−import Streamly.Internal.Data.Array.Mut.Type
45−
46−-- | Split the array into a stream of slices using a predicate. The element
47−-- matching the predicate is dropped.
48−--
49−-- /Pre-release/
50−{-# INLINE splitOn #-}
51−splitOn :: (MonadIO m, Unbox a) =>
52− (a -> Bool) -> MutArray a -> Stream m (MutArray a)
53−splitOn predicate arr =
54− fmap (\(i, len) -> getSliceUnsafe i len arr)
55− $ D.sliceOnSuffix predicate (toStreamD arr)
56−
57−-- | Generate a stream of array slice descriptors ((index, len)) of specified
58−-- length from an array, starting from the supplied array index. The last slice
59−-- may be shorter than the requested length depending on the array length.
60−--
61−-- /Pre-release/
62−{-# INLINE genSlicesFromLen #-}
63−genSlicesFromLen :: forall m a. (Monad m, Unbox a)
64− => Int -- ^ from index
65− -> Int -- ^ length of the slice
66− -> Unfold m (MutArray a) (Int, Int)
67−genSlicesFromLen from len =
68− let fromThenTo n = (from, from + len, n - 1)
69− mkSlice n i = return (i, min len (n - i))
70− in Unfold.lmap length
71− $ Unfold.mapM2 mkSlice
72− $ Unfold.lmap fromThenTo Unfold.enumerateFromThenTo
73−
74−-- | Generate a stream of slices of specified length from an array, starting
75−-- from the supplied array index. The last slice may be shorter than the
76−-- requested length depending on the array length.
77−--
78−-- /Pre-release/
79−{-# INLINE getSlicesFromLen #-}
80−getSlicesFromLen :: forall m a. (Monad m, Unbox a)
81− => Int -- ^ from index
82− -> Int -- ^ length of the slice
83− -> Unfold m (MutArray a) (MutArray a)
84−getSlicesFromLen from len =
85− let mkSlice arr (i, n) = return $ getSliceUnsafe i n arr
86− in Unfold.mapM2 mkSlice (genSlicesFromLen from len)
87−
88−-- | Create an 'Array' from a stream. This is useful when we want to create a
89−-- single array from a stream of unknown size. 'writeN' is at least twice
90−-- as efficient when the size is already known.
91−--
92−-- Note that if the input stream is too large memory allocation for the array
93−-- may fail. When the stream size is not known, `chunksOf` followed by
94−-- processing of indvidual arrays in the resulting stream should be preferred.
95−--
96−-- /Pre-release/
97−{-# INLINE fromStream #-}
98−fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
99−fromStream = fromStreamD
100−-- fromStream (Stream m) = P.fold write m
core/src/Streamly/Internal/Data/Array/Mut/Stream.hsdeleted−323
@@ -1,323 +0,0 @@
1−-- |
2−-- Module : Streamly.Internal.Data.Array.Mut.Stream
3−-- Copyright : (c) 2019 Composewell Technologies
4−-- License : BSD3-3-Clause
5−-- Maintainer : streamly@composewell.com
6−-- Stability : experimental
7−-- Portability : GHC
8−--
9−-- Combinators to efficiently manipulate streams of mutable arrays.
10−--
11−module Streamly.Internal.Data.Array.Mut.Stream
12− (
13− -- * Generation
14− chunksOf
15−
16− -- * Compaction
17− , packArraysChunksOf
18− , SpliceState (..)
19− , lpackArraysChunksOf
20− , compact
21− , compactLE
22− , compactEQ
23− , compactGE
24− )
25−where
26−
27−#include "inline.hs"
28−#include "ArrayMacros.h"
29−
30−import Control.Monad.IO.Class (MonadIO(..))
31−import Control.Monad (when)
32−import Data.Bifunctor (first)
33−import Data.Proxy (Proxy(..))
34−import Streamly.Internal.Data.Unboxed (Unbox, sizeOf)
35−import Streamly.Internal.Data.Array.Mut.Type (MutArray(..))
36−import Streamly.Internal.Data.Fold.Type (Fold(..))
37−import Streamly.Internal.Data.Parser (ParseError)
38−import Streamly.Internal.Data.Stream.StreamD.Type (Stream)
39−import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
40−
41−import qualified Streamly.Internal.Data.Array.Mut.Type as MArray
42−import qualified Streamly.Internal.Data.Fold.Type as FL
43−import qualified Streamly.Internal.Data.Stream.StreamD as D
44−import qualified Streamly.Internal.Data.Parser.ParserD as ParserD
45−
46−-- | @chunksOf n stream@ groups the elements in the input stream into arrays of
47−-- @n@ elements each.
48−--
49−-- Same as the following but may be more efficient:
50−--
51−-- > chunksOf n = Stream.foldMany (MArray.writeN n)
52−--
53−-- /Pre-release/
54−{-# INLINE chunksOf #-}
55−chunksOf :: (MonadIO m, Unbox a)
56− => Int -> Stream m a -> Stream m (MutArray a)
57−chunksOf = MArray.chunksOf
58−
59−-------------------------------------------------------------------------------
60−-- Compact
61−-------------------------------------------------------------------------------
62−
63−data SpliceState s arr
64− = SpliceInitial s
65− | SpliceBuffering s arr
66− | SpliceYielding arr (SpliceState s arr)
67− | SpliceFinish
68−
69−-- XXX This can be removed once compactLEFold/compactLE are implemented.
70−--
71−-- | This mutates the first array (if it has space) to append values from the
72−-- second one. This would work for immutable arrays as well because an
73−-- immutable array never has space so a new array is allocated instead of
74−-- mutating it.
75−--
76−-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
77−-- maximum specified size. Note that if a single array is bigger than the
78−-- specified size we do not split it to fit. When we coalesce multiple arrays
79−-- if the size would exceed the specified size we do not coalesce therefore the
80−-- actual array size may be less than the specified chunk size.
81−--
82−-- @since 0.7.0
83−{-# INLINE_NORMAL packArraysChunksOf #-}
84−packArraysChunksOf :: (MonadIO m, Unbox a)
85− => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
86−packArraysChunksOf n (D.Stream step state) =
87− D.Stream step' (SpliceInitial state)
88−
89− where
90−
91− {-# INLINE_LATE step' #-}
92− step' gst (SpliceInitial st) = do
93− when (n <= 0) $
94− -- XXX we can pass the module string from the higher level API
95− error $ "Streamly.Internal.Data.Array.Mut.Type.packArraysChunksOf: the size of "
96− ++ "arrays [" ++ show n ++ "] must be a natural number"
97− r <- step gst st
98− case r of
99− D.Yield arr s -> return $
100− let len = MArray.byteLength arr
101− in if len >= n
102− then D.Skip (SpliceYielding arr (SpliceInitial s))
103− else D.Skip (SpliceBuffering s arr)
104− D.Skip s -> return $ D.Skip (SpliceInitial s)
105− D.Stop -> return D.Stop
106−
107− step' gst (SpliceBuffering st buf) = do
108− r <- step gst st
109− case r of
110− D.Yield arr s -> do
111− let len = MArray.byteLength buf + MArray.byteLength arr
112− if len > n
113− then return $
114− D.Skip (SpliceYielding buf (SpliceBuffering s arr))
115− else do
116− buf' <- if MArray.byteCapacity buf < n
117− then liftIO $ MArray.realloc n buf
118− else return buf
119− buf'' <- MArray.splice buf' arr
120− return $ D.Skip (SpliceBuffering s buf'')
121− D.Skip s -> return $ D.Skip (SpliceBuffering s buf)
122− D.Stop -> return $ D.Skip (SpliceYielding buf SpliceFinish)
123−
124− step' _ SpliceFinish = return D.Stop
125−
126− step' _ (SpliceYielding arr next) = return $ D.Yield arr next
127−
128−-- XXX Remove this once compactLEFold is implemented
129−-- lpackArraysChunksOf = Fold.many compactLEFold
130−--
131−{-# INLINE_NORMAL lpackArraysChunksOf #-}
132−lpackArraysChunksOf :: (MonadIO m, Unbox a)
133− => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
134−lpackArraysChunksOf n (Fold step1 initial1 extract1) =
135− Fold step initial extract
136−
137− where
138−
139− initial = do
140− when (n <= 0) $
141− -- XXX we can pass the module string from the higher level API
142− error $ "Streamly.Internal.Data.Array.Mut.Type.packArraysChunksOf: the size of "
143− ++ "arrays [" ++ show n ++ "] must be a natural number"
144−
145− r <- initial1
146− return $ first (Tuple' Nothing) r
147−
148− extract (Tuple' Nothing r1) = extract1 r1
149− extract (Tuple' (Just buf) r1) = do
150− r <- step1 r1 buf
151− case r of
152− FL.Partial rr -> extract1 rr
153− FL.Done _ -> return ()
154−
155− step (Tuple' Nothing r1) arr =
156− let len = MArray.byteLength arr
157− in if len >= n
158− then do
159− r <- step1 r1 arr
160− case r of
161− FL.Done _ -> return $ FL.Done ()
162− FL.Partial s -> do
163− extract1 s
164− res <- initial1
165− return $ first (Tuple' Nothing) res
166− else return $ FL.Partial $ Tuple' (Just arr) r1
167−
168− step (Tuple' (Just buf) r1) arr = do
169− let len = MArray.byteLength buf + MArray.byteLength arr
170− buf' <- if MArray.byteCapacity buf < len
171− then liftIO $ MArray.realloc (max n len) buf
172− else return buf
173− buf'' <- MArray.splice buf' arr
174−
175− -- XXX this is common in both the equations of step
176− if len >= n
177− then do
178− r <- step1 r1 buf''
179− case r of
180− FL.Done _ -> return $ FL.Done ()
181− FL.Partial s -> do
182− extract1 s
183− res <- initial1
184− return $ first (Tuple' Nothing) res
185− else return $ FL.Partial $ Tuple' (Just buf'') r1
186−
187−-- XXX Same as compactLE, to be removed once that is implemented.
188−--
189−-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
190−-- maximum specified size in bytes.
191−--
192−-- /Internal/
193−{-# INLINE compact #-}
194−compact :: (MonadIO m, Unbox a)
195− => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
196−compact = packArraysChunksOf
197−
198−-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
199−-- maximum specified size. Note that if a single array is bigger than the
200−-- specified size we do not split it to fit. When we coalesce multiple arrays
201−-- if the size would exceed the specified size we do not coalesce therefore the
202−-- actual array size may be less than the specified chunk size.
203−--
204−-- /Internal/
205−{-# INLINE_NORMAL compactLEParserD #-}
206−compactLEParserD ::
207− forall m a. (MonadIO m, Unbox a)
208− => Int -> ParserD.Parser (MutArray a) m (MutArray a)
209−compactLEParserD n = ParserD.Parser step initial extract
210−
211− where
212−
213− nBytes = n * SIZE_OF(a)
214−
215− initial =
216− return
217− $ if n <= 0
218− then error
219− $ functionPath
220− ++ ": the size of arrays ["
221− ++ show n ++ "] must be a natural number"
222− else ParserD.IPartial Nothing
223−
224− step Nothing arr =
225− return
226− $ let len = MArray.byteLength arr
227− in if len >= nBytes
228− then ParserD.Done 0 arr
229− else ParserD.Partial 0 (Just arr)
230− step (Just buf) arr =
231− let len = MArray.byteLength buf + MArray.byteLength arr
232− in if len > nBytes
233− then return $ ParserD.Done 1 buf
234− else do
235− buf1 <-
236− if MArray.byteCapacity buf < nBytes
237− then liftIO $ MArray.realloc nBytes buf
238− else return buf
239− buf2 <- MArray.splice buf1 arr
240− return $ ParserD.Partial 0 (Just buf2)
241−
242− extract Nothing = return $ ParserD.Done 0 MArray.nil
243− extract (Just buf) = return $ ParserD.Done 0 buf
244−
245− functionPath =
246− "Streamly.Internal.Data.Array.Mut.Stream.compactLEParserD"
247−
248−-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
249−-- minimum specified size. Note that if all the arrays in the stream together
250−-- are smaller than the specified size the resulting array will be smaller than
251−-- the specified size. When we coalesce multiple arrays if the size would exceed
252−-- the specified size we stop coalescing further.
253−--
254−-- /Internal/
255−{-# INLINE_NORMAL compactGEFold #-}
256−compactGEFold ::
257− forall m a. (MonadIO m, Unbox a)
258− => Int -> FL.Fold m (MutArray a) (MutArray a)
259−compactGEFold n = Fold step initial extract
260−
261− where
262−
263− nBytes = n * SIZE_OF(a)
264−
265− initial =
266− return
267− $ if n < 0
268− then error
269− $ functionPath
270− ++ ": the size of arrays ["
271− ++ show n ++ "] must be a natural number"
272− else FL.Partial Nothing
273−
274− step Nothing arr =
275− return
276− $ let len = MArray.byteLength arr
277− in if len >= nBytes
278− then FL.Done arr
279− else FL.Partial (Just arr)
280− step (Just buf) arr = do
281− let len = MArray.byteLength buf + MArray.byteLength arr
282− buf1 <-
283− if MArray.byteCapacity buf < len
284− then liftIO $ MArray.realloc (max len nBytes) buf
285− else return buf
286− buf2 <- MArray.splice buf1 arr
287− if len >= n
288− then return $ FL.Done buf2
289− else return $ FL.Partial (Just buf2)
290−
291− extract Nothing = return MArray.nil
292− extract (Just buf) = return buf
293−
294− functionPath =
295− "Streamly.Internal.Data.Array.Mut.Stream.compactGEFold"
296−
297−-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
298−-- maximum specified size in bytes.
299−--
300−-- /Internal/
301−compactLE :: (MonadIO m, Unbox a) =>
302− Int -> Stream m (MutArray a) -> Stream m (Either ParseError (MutArray a))
303−compactLE n = D.parseManyD (compactLEParserD n)
304−
305−-- | Like 'compactLE' but generates arrays of exactly equal to the size
306−-- specified except for the last array in the stream which could be shorter.
307−--
308−-- /Unimplemented/
309−{-# INLINE compactEQ #-}
310−compactEQ :: -- (MonadIO m, Unbox a) =>
311− Int -> Stream m (MutArray a) -> Stream m (MutArray a)
312−compactEQ _n _xs = undefined
313− -- IsStream.fromStreamD $ D.foldMany (compactEQFold n) (IsStream.toStreamD xs)
314−
315−-- | Like 'compactLE' but generates arrays of size greater than or equal to the
316−-- specified except for the last array in the stream which could be shorter.
317−--
318−-- /Internal/
319−{-# INLINE compactGE #-}
320−compactGE ::
321− (MonadIO m, Unbox a)
322− => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
323−compactGE n = D.foldMany (compactGEFold n)
core/src/Streamly/Internal/Data/Stream/Chunked.hs → core/src/Streamly/Internal/Data/Array/Stream.hsrenamed+91−581
@@ -1,24 +1,32 @@
1+{-# OPTIONS_GHC -Wno-deprecations #-}
12-- |
2−-- Module : Streamly.Internal.Data.Stream.Chunked
3+-- Module : Streamly.Internal.Data.Array.Stream
34-- Copyright : (c) 2019 Composewell Technologies
45-- License : BSD3-3-Clause
56-- Maintainer : streamly@composewell.com
6−-- Stability : pre-release
77-- Portability : GHC
88--
99-- Combinators to efficiently manipulate streams of immutable arrays.
1010--
11−module Streamly.Internal.Data.Stream.Chunked
11+-- We can either push these in the MutArray module with a "chunks" prefix or
12+-- keep this as a separate module and release it.
13+--
14+module Streamly.Internal.Data.Array.Stream
15+{-# DEPRECATED "Please use \"Streamly.Internal.Data.Array\" instead." #-}
1216 (
1317 -- * Creation
14− chunksOf
18+ Array.chunksOf
19+ , Array.pinnedChunksOf
20+ , Array.bufferChunks
1521
1622 -- * Flattening to elements
17− , concat
18− , concatRev
19− , interpose
20− , interposeSuffix
21− , intercalateSuffix
23+ , Array.concat
24+ , Array.flattenArrays
25+ , Array.concatRev
26+ , Array.flattenArraysRev
27+ , Array.interpose
28+ , Array.interposeSuffix
29+ , Array.intercalateSuffix
2230 , unlines
2331
2432 -- * Elimination
@@ -27,24 +35,27 @@ module Streamly.Internal.Data.Stream.Chunked
2735 -- can flatten the stream to byte stream and use that. But if we want the
2836 -- remaining stream to be a chunk stream then this could be handy. But it
2937 -- could also be implemented using parseBreak.
30− , foldBreak -- StreamK.foldBreakChunks
38+ , foldBreak
3139 , foldBreakD
32− -- The byte level parseBreak cannot work efficiently. Because the stream
33− -- will have to be a StreamK for backtracking, StreamK at byte level would
34− -- not be efficient.
35− , parseBreak -- StreamK.parseBreakChunks
40+ -- This is chunked parseBreak. A byte level parseBreak cannot work
41+ -- efficiently. Because the stream will have to be a StreamK for
42+ -- backtracking, StreamK at byte level would not be efficient.
43+ -- parseBreak p = K.parseBreakChunks (ParserK.adaptC p)
44+ , parseBreak
3645 -- , parseBreakD
3746 -- , foldManyChunks
3847 -- , parseManyChunks
48+ , K.parseBreakChunks
49+ , K.parseChunks
3950
4051 -- ** Array Folds
41− -- XXX Use Parser.Chunked instead, need only chunkedParseBreak,
52+ -- XXX Use parseBreakChunks/parseChunks instead
4253 -- foldBreak can be implemented using parseBreak. Use StreamK.
4354 , runArrayFold
4455 , runArrayFoldBreak
4556 -- , parseArr
46− , runArrayParserDBreak -- StreamK.chunkedParseBreak
47− , runArrayFoldMany -- StreamK.chunkedParseMany
57+ , runArrayParserDBreak -- StreamK.parseBreakChunks
58+ , runArrayFoldMany
4859
4960 , toArray
5061
@@ -68,9 +79,11 @@ where
6879import Data.Bifunctor (second)
6980import Control.Exception (assert)
7081import Control.Monad.IO.Class (MonadIO(..))
82+-- import Data.Bifunctor (first)
83+-- import Data.Either (fromRight)
7184import Data.Proxy (Proxy(..))
7285import Data.Word (Word8)
73−import Streamly.Internal.Data.Unboxed (Unbox, peekWith, sizeOf)
86+import Streamly.Internal.Data.Unbox (Unbox(..))
7487import Fusion.Plugin.Types (Fuse(..))
7588import GHC.Exts (SpecConstrAnnotation(..))
7689import GHC.Types (SPEC(..))
@@ -78,151 +91,37 @@ import Prelude hiding (null, last, (!!), read, concat, unlines)
7891
7992import Streamly.Data.Fold (Fold)
8093import Streamly.Internal.Data.Array.Type (Array(..))
81−import Streamly.Internal.Data.Array.Mut.Type (MutArray)
8294import Streamly.Internal.Data.Fold.Chunked (ChunkFold(..))
8395import Streamly.Internal.Data.Parser (ParseError(..))
84−import Streamly.Internal.Data.Stream.StreamD (Stream)
85−import Streamly.Internal.Data.Stream.StreamK (StreamK, fromStream, toStream)
96+import Streamly.Internal.Data.Stream (Stream)
97+import Streamly.Internal.Data.StreamK (StreamK, fromStream, toStream)
8698import Streamly.Internal.Data.SVar.Type (adaptState, defState)
87−import Streamly.Internal.Data.Array.Mut.Type
88− (allocBytesToElemCount)
89−import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
9099
91−import qualified Streamly.Data.Fold as FL
92100import qualified Streamly.Internal.Data.Array as A
93101import qualified Streamly.Internal.Data.Array as Array
94−import qualified Streamly.Internal.Data.Array.Type as A
95−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
96−import qualified Streamly.Internal.Data.Array.Mut.Stream as AS
97−import qualified Streamly.Internal.Data.Fold.Type as FL (Fold(..), Step(..))
98102import qualified Streamly.Internal.Data.Parser as PR
99−import qualified Streamly.Internal.Data.Parser.ParserD as PRD
103+import qualified Streamly.Internal.Data.Parser as PRD
100104 (Parser(..), Initial(..))
101−import qualified Streamly.Internal.Data.Stream.StreamD as D
102−import qualified Streamly.Internal.Data.Stream.StreamK as K
105+-- import qualified Streamly.Internal.Data.ParserK as ParserK
106+import qualified Streamly.Internal.Data.Stream as D
107+import qualified Streamly.Internal.Data.StreamK as K
103108
104109-- XXX Since these are immutable arrays MonadIO constraint can be removed from
105110-- most places.
106111
107−-------------------------------------------------------------------------------
108−-- Generation
109−-------------------------------------------------------------------------------
110−
111−-- | @chunksOf n stream@ groups the elements in the input stream into arrays of
112−-- @n@ elements each.
113−--
114−-- > chunksOf n = Stream.groupsOf n (Array.writeN n)
115−--
116−-- /Pre-release/
117−{-# INLINE chunksOf #-}
118−chunksOf :: (MonadIO m, Unbox a)
119− => Int -> Stream m a -> Stream m (Array a)
120−chunksOf = A.chunksOf
121−
122−-------------------------------------------------------------------------------
123−-- Append
124−-------------------------------------------------------------------------------
125−
126−-- XXX efficiently compare two streams of arrays. Two streams can have chunks
127−-- of different sizes, we can handle that in the stream comparison abstraction.
128−-- This could be useful e.g. to fast compare whether two files differ.
129−
130−-- | Convert a stream of arrays into a stream of their elements.
131−--
132−-- Same as the following:
133−--
134−-- > concat = Stream.unfoldMany Array.read
135−--
136−-- @since 0.7.0
137−{-# INLINE concat #-}
138−concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
139−-- concat m = fromStreamD $ A.flattenArrays (toStreamD m)
140−-- concat m = fromStreamD $ D.concatMap A.toStreamD (toStreamD m)
141−concat = D.unfoldMany A.reader
142−
143−-- | Convert a stream of arrays into a stream of their elements reversing the
144−-- contents of each array before flattening.
145−--
146−-- > concatRev = Stream.unfoldMany Array.readerRev
147−--
148−-- @since 0.7.0
149−{-# INLINE concatRev #-}
150−concatRev :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
151−-- concatRev m = fromStreamD $ A.flattenArraysRev (toStreamD m)
152−concatRev = D.unfoldMany A.readerRev
153−
154112-------------------------------------------------------------------------------
155113-- Intersperse and append
156114-------------------------------------------------------------------------------
157115
158−-- | Flatten a stream of arrays after inserting the given element between
159−-- arrays.
160−--
161−-- /Pre-release/
162−{-# INLINE interpose #-}
163−interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
164−interpose x = D.interpose x A.reader
165−
166−{-# INLINE intercalateSuffix #-}
167−intercalateSuffix :: (Monad m, Unbox a)
168− => Array a -> Stream m (Array a) -> Stream m a
169−intercalateSuffix = D.intercalateSuffix A.reader
170−
171−-- | Flatten a stream of arrays appending the given element after each
172−-- array.
173−--
174−-- @since 0.7.0
175−{-# INLINE interposeSuffix #-}
176−interposeSuffix :: (Monad m, Unbox a)
177− => a -> Stream m (Array a) -> Stream m a
178−-- interposeSuffix x = fromStreamD . A.unlines x . toStreamD
179−interposeSuffix x = D.interposeSuffix x A.reader
180−
181−data FlattenState s =
182− OuterLoop s
183− | InnerLoop s !MA.MutableByteArray !Int !Int
184−
185−-- XXX This is a special case of interposeSuffix, can be removed.
186−-- XXX Remove monadIO constraint
187116{-# INLINE_NORMAL unlines #-}
188117unlines :: forall m a. (MonadIO m, Unbox a)
189118 => a -> D.Stream m (Array a) -> D.Stream m a
190−unlines sep (D.Stream step state) = D.Stream step' (OuterLoop state)
191− where
192− {-# INLINE_LATE step' #-}
193− step' gst (OuterLoop st) = do
194− r <- step (adaptState gst) st
195− return $ case r of
196− D.Yield Array{..} s ->
197− D.Skip (InnerLoop s arrContents arrStart arrEnd)
198− D.Skip s -> D.Skip (OuterLoop s)
199− D.Stop -> D.Stop
200−
201− step' _ (InnerLoop st _ p end) | p == end =
202− return $ D.Yield sep $ OuterLoop st
203−
204− step' _ (InnerLoop st contents p end) = do
205− x <- liftIO $ peekWith contents p
206− return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
119+unlines = Array.interposeSuffix
207120
208121-------------------------------------------------------------------------------
209122-- Compact
210123-------------------------------------------------------------------------------
211124
212−-- XXX These would not be needed once we implement compactLEFold, see
213−-- module Streamly.Internal.Data.Array.Mut.Stream
214−--
215−-- XXX Note that this thaws immutable arrays for appending, that may be
216−-- problematic if multiple users do the same thing, however, immutable arrays
217−-- would usually have no capacity to append, therefore, a copy will be forced
218−-- anyway. Confirm this. We can forcefully trim the array capacity before thaw
219−-- to ensure this.
220−{-# INLINE_NORMAL packArraysChunksOf #-}
221−packArraysChunksOf :: (MonadIO m, Unbox a)
222− => Int -> D.Stream m (Array a) -> D.Stream m (Array a)
223−packArraysChunksOf n str =
224− D.map A.unsafeFreeze $ AS.packArraysChunksOf n $ D.map A.unsafeThaw str
225−
226125-- XXX instead of writing two different versions of this operation, we should
227126-- write it as a pipe.
228127--
@@ -230,8 +129,7 @@ packArraysChunksOf n str =
230129{-# INLINE_NORMAL lpackArraysChunksOf #-}
231130lpackArraysChunksOf :: (MonadIO m, Unbox a)
232131 => Int -> Fold m (Array a) () -> Fold m (Array a) ()
233−lpackArraysChunksOf n fld =
234− FL.lmap A.unsafeThaw $ AS.lpackArraysChunksOf n (FL.lmap A.unsafeFreeze fld)
132+lpackArraysChunksOf = Array.lCompactGE
235133
236134-- | Coalesce adjacent arrays in incoming stream to form bigger arrays of a
237135-- maximum specified size in bytes.
@@ -240,68 +138,19 @@ lpackArraysChunksOf n fld =
240138{-# INLINE compact #-}
241139compact :: (MonadIO m, Unbox a)
242140 => Int -> Stream m (Array a) -> Stream m (Array a)
243−compact = packArraysChunksOf
141+compact = Array.compactLE
244142
245−-------------------------------------------------------------------------------
246−-- Split
247−-------------------------------------------------------------------------------
248−
249−data SplitState s arr
250− = Initial s
251− | Buffering s arr
252− | Splitting s arr
253− | Yielding arr (SplitState s arr)
254− | Finishing
255−
256−-- | Split a stream of arrays on a given separator byte, dropping the separator
257−-- and coalescing all the arrays between two separators into a single array.
143+-- | Given a stream of arrays, splice them all together to generate a single
144+-- array. The stream must be /finite/.
258145--
259146-- @since 0.7.0
260−{-# INLINE_NORMAL _splitOn #-}
261−_splitOn
262− :: MonadIO m
263− => Word8
264− -> D.Stream m (Array Word8)
265− -> D.Stream m (Array Word8)
266−_splitOn byte (D.Stream step state) = D.Stream step' (Initial state)
267−
268− where
269−
270− {-# INLINE_LATE step' #-}
271− step' gst (Initial st) = do
272− r <- step gst st
273− case r of
274− D.Yield arr s -> do
275− (arr1, marr2) <- A.breakOn byte arr
276− return $ case marr2 of
277− Nothing -> D.Skip (Buffering s arr1)
278− Just arr2 -> D.Skip (Yielding arr1 (Splitting s arr2))
279− D.Skip s -> return $ D.Skip (Initial s)
280− D.Stop -> return D.Stop
281−
282− step' gst (Buffering st buf) = do
283− r <- step gst st
284− case r of
285− D.Yield arr s -> do
286− (arr1, marr2) <- A.breakOn byte arr
287− buf' <- A.splice buf arr1
288− return $ case marr2 of
289− Nothing -> D.Skip (Buffering s buf')
290− Just x -> D.Skip (Yielding buf' (Splitting s x))
291− D.Skip s -> return $ D.Skip (Buffering s buf)
292− D.Stop -> return $
293− if A.byteLength buf == 0
294− then D.Stop
295− else D.Skip (Yielding buf Finishing)
296−
297− step' _ (Splitting st buf) = do
298− (arr1, marr2) <- A.breakOn byte buf
299− return $ case marr2 of
300− Nothing -> D.Skip $ Buffering st arr1
301− Just arr2 -> D.Skip $ Yielding arr1 (Splitting st arr2)
147+{-# INLINE toArray #-}
148+toArray :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)
149+toArray = Array.fromChunks
302150
303− step' _ (Yielding arr next) = return $ D.Yield arr next
304− step' _ Finishing = return D.Stop
151+-------------------------------------------------------------------------------
152+-- Split
153+-------------------------------------------------------------------------------
305154
306155-- XXX Remove MonadIO constraint.
307156-- | Split a stream of arrays on a given separator byte, dropping the separator
@@ -314,7 +163,7 @@ splitOn
314163 => Word8
315164 -> Stream m (Array Word8)
316165 -> Stream m (Array Word8)
317−splitOn byte = D.splitInnerBy (A.breakOn byte) A.splice
166+splitOn = Array.compactOnByte
318167
319168{-# INLINE splitOnSuffix #-}
320169splitOnSuffix
@@ -322,8 +171,7 @@ splitOnSuffix
322171 => Word8
323172 -> Stream m (Array Word8)
324173 -> Stream m (Array Word8)
325−-- splitOn byte s = fromStreamD $ A.splitOn byte $ toStreamD s
326−splitOnSuffix byte = D.splitInnerBySuffix (A.breakOn byte) A.splice
174+splitOnSuffix = Array.compactOnByteSuffix
327175
328176-------------------------------------------------------------------------------
329177-- Elimination - Running folds
@@ -332,77 +180,24 @@ splitOnSuffix byte = D.splitInnerBySuffix (A.breakOn byte) A.splice
332180{-# INLINE_NORMAL foldBreakD #-}
333181foldBreakD :: forall m a b. (MonadIO m, Unbox a) =>
334182 Fold m a b -> D.Stream m (Array a) -> m (b, D.Stream m (Array a))
335−foldBreakD (FL.Fold fstep initial extract) stream@(D.Stream step state) = do
336− res <- initial
337− case res of
338− FL.Partial fs -> go SPEC state fs
339− FL.Done fb -> return $! (fb, stream)
340−
341− where
342−
343− {-# INLINE go #-}
344− go !_ st !fs = do
345− r <- step defState st
346− case r of
347− D.Yield (Array contents start end) s ->
348− let fp = Tuple' end contents
349− in goArray SPEC s fp start fs
350− D.Skip s -> go SPEC s fs
351− D.Stop -> do
352− b <- extract fs
353− return (b, D.nil)
354−
355− goArray !_ s (Tuple' end _) !cur !fs
356− | cur == end = do
357− go SPEC s fs
358− goArray !_ st fp@(Tuple' end contents) !cur !fs = do
359− x <- liftIO $ peekWith contents cur
360− res <- fstep fs x
361− let next = INDEX_NEXT(cur,a)
362− case res of
363− FL.Done b -> do
364− let arr = Array contents next end
365− return $! (b, D.cons arr (D.Stream step st))
366− FL.Partial fs1 -> goArray SPEC st fp next fs1
367−
368−{-# INLINE_NORMAL foldBreakK #-}
369−foldBreakK :: forall m a b. (MonadIO m, Unbox a) =>
370− Fold m a b -> K.StreamK m (Array a) -> m (b, K.StreamK m (Array a))
371−foldBreakK (FL.Fold fstep initial extract) stream = do
372− res <- initial
373− case res of
374− FL.Partial fs -> go fs stream
375− FL.Done fb -> return (fb, stream)
376−
377− where
378−
379− {-# INLINE go #-}
380− go !fs st = do
381− let stop = (, K.nil) <$> extract fs
382− single a = yieldk a K.nil
383− yieldk (Array contents start end) r =
384− let fp = Tuple' end contents
385− in goArray fs r fp start
386− in K.foldStream defState yieldk single stop st
387−
388− goArray !fs st (Tuple' end _) !cur
389− | cur == end = do
390− go fs st
391− goArray !fs st fp@(Tuple' end contents) !cur = do
392− x <- liftIO $ peekWith contents cur
393− res <- fstep fs x
394− let next = INDEX_NEXT(cur,a)
395− case res of
396− FL.Done b -> do
397− let arr = Array contents next end
398− return $! (b, K.cons arr st)
399− FL.Partial fs1 -> goArray fs1 st fp next
183+foldBreakD = Array.foldBreakChunks
400184
401185-- | Fold an array stream using the supplied 'Fold'. Returns the fold result
402186-- and the unconsumed stream.
403187--
404188-- > foldBreak f = runArrayFoldBreak (ChunkFold.fromFold f)
405189--
190+-- Instead of using this we can adapt the fold to ParserK and use
191+-- parseBreakChunks instead. ParserK allows composing using Monad as well.
192+--
193+-- @
194+-- foldBreak f s =
195+-- fmap (first (fromRight undefined))
196+-- $ K.parseBreakChunks (ParserK.adaptC (PR.fromFold f)) s
197+-- @
198+--
199+-- We can compare perf and remove this one or define it in terms of that.
200+--
406201-- /Internal/
407202--
408203{-# INLINE_NORMAL foldBreak #-}
@@ -411,14 +206,20 @@ foldBreak ::
411206 => Fold m a b
412207 -> StreamK m (A.Array a)
413208 -> m (b, StreamK m (A.Array a))
209+foldBreak = Array.foldBreakChunksK
210+--
414211-- foldBreak f s = fmap fromStreamD <$> foldBreakD f (toStreamD s)
415−foldBreak = foldBreakK
212+--
213+-- foldBreak f s =
214+-- fmap (first (fromRight undefined))
215+-- $ K.parseBreakChunks (ParserK.adaptC (PR.fromFold f)) s
216+--
416217-- If foldBreak performs better than runArrayFoldBreak we can use a rewrite
417218-- rule to rewrite runArrayFoldBreak to fold.
418219-- foldBreak f = runArrayFoldBreak (ChunkFold.fromFold f)
419220
420221-------------------------------------------------------------------------------
421−-- Fold to a single Array
222+-- Elimination - running element parsers
422223-------------------------------------------------------------------------------
423224
424225-- When we have to take an array partially, take the last part of the array.
@@ -464,320 +265,22 @@ splitAtArrayListRev n ls
464265 arr1 = Array contents end1 end
465266 in ([arr1], arr2:xs)
466267
467−-------------------------------------------------------------------------------
468−-- Fold to a single Array
469−-------------------------------------------------------------------------------
470−
471−-- XXX Both of these implementations of splicing seem to perform equally well.
472−-- We need to perform benchmarks over a range of sizes though.
473−
474−-- CAUTION! length must more than equal to lengths of all the arrays in the
475−-- stream.
476−{-# INLINE spliceArraysLenUnsafe #-}
477−spliceArraysLenUnsafe :: (MonadIO m, Unbox a)
478− => Int -> Stream m (MutArray a) -> m (MutArray a)
479−spliceArraysLenUnsafe len buffered = do
480− arr <- liftIO $ MA.newPinned len
481− D.foldlM' MA.spliceUnsafe (return arr) buffered
482−
483−{-# INLINE _spliceArrays #-}
484−_spliceArrays :: (MonadIO m, Unbox a)
485− => Stream m (Array a) -> m (Array a)
486−_spliceArrays s = do
487− buffered <- D.foldr K.cons K.nil s
488− len <- K.fold FL.sum (fmap Array.length buffered)
489− arr <- liftIO $ MA.newPinned len
490− final <- D.foldlM' writeArr (return arr) (toStream buffered)
491− return $ A.unsafeFreeze final
492−
493− where
494−
495− writeArr dst arr = MA.spliceUnsafe dst (A.unsafeThaw arr)
496−
497−{-# INLINE _spliceArraysBuffered #-}
498−_spliceArraysBuffered :: (MonadIO m, Unbox a)
499− => Stream m (Array a) -> m (Array a)
500−_spliceArraysBuffered s = do
501− buffered <- D.foldr K.cons K.nil s
502− len <- K.fold FL.sum (fmap Array.length buffered)
503− A.unsafeFreeze <$>
504− spliceArraysLenUnsafe len (fmap A.unsafeThaw (toStream buffered))
505−
506−{-# INLINE spliceArraysRealloced #-}
507−spliceArraysRealloced :: forall m a. (MonadIO m, Unbox a)
508− => Stream m (Array a) -> m (Array a)
509−spliceArraysRealloced s = do
510− let n = allocBytesToElemCount (undefined :: a) (4 * 1024)
511− idst = liftIO $ MA.newPinned n
512−
513− arr <- D.foldlM' MA.spliceExp idst (fmap A.unsafeThaw s)
514− liftIO $ A.unsafeFreeze <$> MA.rightSize arr
515−
516−-- XXX This should just be "fold A.write"
517−--
518−-- | Given a stream of arrays, splice them all together to generate a single
519−-- array. The stream must be /finite/.
520−--
521−-- @since 0.7.0
522−{-# INLINE toArray #-}
523−toArray :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)
524−toArray = spliceArraysRealloced
525−-- spliceArrays = _spliceArraysBuffered
526−
527−-- exponentially increasing sizes of the chunks upto the max limit.
528−-- XXX this will be easier to implement with parsers/terminating folds
529−-- With this we should be able to reduce the number of chunks/allocations.
530−-- The reallocation/copy based toArray can also be implemented using this.
531−--
532−{-
533−{-# INLINE toArraysInRange #-}
534−toArraysInRange :: (MonadIO m, Unbox a)
535− => Int -> Int -> Fold m (Array a) b -> Fold m a b
536−toArraysInRange low high (Fold step initial extract) =
537−-}
538−
539−{-
540−-- | Fold the input to a pure buffered stream (List) of arrays.
541−{-# INLINE _toArraysOf #-}
542−_toArraysOf :: (MonadIO m, Unbox a)
543− => Int -> Fold m a (Stream Identity (Array a))
544−_toArraysOf n = FL.groupsOf n (A.writeNF n) FL.toStream
545−-}
546−
547−-------------------------------------------------------------------------------
548−-- Elimination - running element parsers
549−-------------------------------------------------------------------------------
550−
551268-- GHC parser does not accept {-# ANN type [] NoSpecConstr #-}, so we need
552269-- to make a newtype.
553270{-# ANN type List NoSpecConstr #-}
554271newtype List a = List {getList :: [a]}
555272
556−{-
557−-- This can be generalized to any type provided it can be unfolded to a stream
558−-- and it can be combined using a semigroup operation.
559−--
560−-- XXX This should be written using CPS (as parseK) if we want it to scale wrt
561−-- to the number of times it can be called on the same stream.
562−{-# INLINE_NORMAL parseBreakD #-}
563−parseBreakD ::
564− forall m a b. (MonadIO m, MonadThrow m, Unbox a)
565− => PRD.Parser a m b
566− -> D.Stream m (Array.Array a)
567− -> m (b, D.Stream m (Array.Array a))
568−parseBreakD
569− (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do
570−
571− res <- initial
572− case res of
573− PRD.IPartial s -> go SPEC state (List []) s
574− PRD.IDone b -> return (b, stream)
575− PRD.IError err -> throwM $ ParseError err
576−
577− where
578−
579− -- "backBuf" contains last few items in the stream that we may have to
580− -- backtrack to.
581− --
582− -- XXX currently we are using a dumb list based approach for backtracking
583− -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.
584− -- That will allow us more efficient random back and forth movement.
585− go !_ st backBuf !pst = do
586− r <- step defState st
587− case r of
588− D.Yield (Array contents start end) s ->
589− gobuf SPEC s backBuf
590− (Tuple' end contents) start pst
591− D.Skip s -> go SPEC s backBuf pst
592− D.Stop -> do
593− b <- extract pst
594− return (b, D.nil)
595−
596− -- Use strictness on "cur" to keep it unboxed
597− gobuf !_ s backBuf (Tuple' end _) !cur !pst
598− | cur == end = do
599− go SPEC s backBuf pst
600− gobuf !_ s backBuf fp@(Tuple' end contents) !cur !pst = do
601− x <- liftIO $ peekWith contents cur
602− pRes <- pstep pst x
603− let next = INDEX_NEXT(cur,a)
604− case pRes of
605− PR.Partial 0 pst1 ->
606− gobuf SPEC s (List []) fp next pst1
607− PR.Partial n pst1 -> do
608− assert (n <= Prelude.length (x:getList backBuf)) (return ())
609− let src0 = Prelude.take n (x:getList backBuf)
610− arr0 = A.fromListN n (Prelude.reverse src0)
611− arr1 = Array contents next end
612− src = arr0 <> arr1
613− let !(Array cont1 start end1) = src
614− fp1 = Tuple' end1 cont1
615− gobuf SPEC s (List []) fp1 start pst1
616− PR.Continue 0 pst1 ->
617− gobuf SPEC s (List (x:getList backBuf)) fp next pst1
618− PR.Continue n pst1 -> do
619− assert (n <= Prelude.length (x:getList backBuf)) (return ())
620− let (src0, buf1) = splitAt n (x:getList backBuf)
621− arr0 = A.fromListN n (Prelude.reverse src0)
622− arr1 = Array contents next end
623− src = arr0 <> arr1
624− let !(Array cont1 start end1) = src
625− fp1 = Tuple' end1 cont1
626− gobuf SPEC s (List buf1) fp1 start pst1
627− PR.Done 0 b -> do
628− let arr = Array contents next end
629− return (b, D.cons arr (D.Stream step s))
630− PR.Done n b -> do
631− assert (n <= Prelude.length (x:getList backBuf)) (return ())
632− let src0 = Prelude.take n (x:getList backBuf)
633− -- XXX create the array in reverse instead
634− arr0 = A.fromListN n (Prelude.reverse src0)
635− arr1 = Array contents next end
636− -- XXX Use StreamK to avoid adding arbitrary layers of
637− -- constructors every time.
638− str = D.cons arr0 (D.cons arr1 (D.Stream step s))
639− return (b, str)
640− PR.Error err -> throwM $ ParseError err
641−-}
642−
643−{-# INLINE_NORMAL parseBreakK #-}
644−parseBreakK ::
645− forall m a b. (MonadIO m, Unbox a)
646− => PRD.Parser a m b
647− -> K.StreamK m (Array.Array a)
648− -> m (Either ParseError b, K.StreamK m (Array.Array a))
649−parseBreakK (PRD.Parser pstep initial extract) stream = do
650− res <- initial
651− case res of
652− PRD.IPartial s -> go s stream []
653− PRD.IDone b -> return (Right b, stream)
654− PRD.IError err -> return (Left (ParseError err), stream)
655−
656− where
657−
658− -- "backBuf" contains last few items in the stream that we may have to
659− -- backtrack to.
660− --
661− -- XXX currently we are using a dumb list based approach for backtracking
662− -- buffer. This can be replaced by a sliding/ring buffer using Data.Array.
663− -- That will allow us more efficient random back and forth movement.
664− go !pst st backBuf = do
665− let stop = goStop pst backBuf -- (, K.nil) <$> extract pst
666− single a = yieldk a K.nil
667− yieldk arr r = goArray pst backBuf r arr
668− in K.foldStream defState yieldk single stop st
669−
670− -- Use strictness on "cur" to keep it unboxed
671− goArray !pst backBuf st (Array _ cur end) | cur == end = go pst st backBuf
672− goArray !pst backBuf st (Array contents cur end) = do
673− x <- liftIO $ peekWith contents cur
674− pRes <- pstep pst x
675− let next = INDEX_NEXT(cur,a)
676− case pRes of
677− PR.Partial 0 s ->
678− goArray s [] st (Array contents next end)
679− PR.Partial n s -> do
680− assert (n <= Prelude.length (x:backBuf)) (return ())
681− let src0 = Prelude.take n (x:backBuf)
682− arr0 = A.fromListN n (Prelude.reverse src0)
683− arr1 = Array contents next end
684− src = arr0 <> arr1
685− goArray s [] st src
686− PR.Continue 0 s ->
687− goArray s (x:backBuf) st (Array contents next end)
688− PR.Continue n s -> do
689− assert (n <= Prelude.length (x:backBuf)) (return ())
690− let (src0, buf1) = splitAt n (x:backBuf)
691− arr0 = A.fromListN n (Prelude.reverse src0)
692− arr1 = Array contents next end
693− src = arr0 <> arr1
694− goArray s buf1 st src
695− PR.Done 0 b -> do
696− let arr = Array contents next end
697− return (Right b, K.cons arr st)
698− PR.Done n b -> do
699− assert (n <= Prelude.length (x:backBuf)) (return ())
700− let src0 = Prelude.take n (x:backBuf)
701− -- XXX Use fromListRevN once implemented
702− -- arr0 = A.fromListRevN n src0
703− arr0 = A.fromListN n (Prelude.reverse src0)
704− arr1 = Array contents next end
705− str = K.cons arr0 (K.cons arr1 st)
706− return (Right b, str)
707− PR.Error err -> do
708− let str = K.cons (Array contents cur end) stream
709− return (Left (ParseError err), str)
710−
711− -- This is a simplified goArray
712− goExtract !pst backBuf (Array _ cur end)
713− | cur == end = goStop pst backBuf
714− goExtract !pst backBuf (Array contents cur end) = do
715− x <- liftIO $ peekWith contents cur
716− pRes <- pstep pst x
717− let next = INDEX_NEXT(cur,a)
718− case pRes of
719− PR.Partial 0 s ->
720− goExtract s [] (Array contents next end)
721− PR.Partial n s -> do
722− assert (n <= Prelude.length (x:backBuf)) (return ())
723− let src0 = Prelude.take n (x:backBuf)
724− arr0 = A.fromListN n (Prelude.reverse src0)
725− arr1 = Array contents next end
726− src = arr0 <> arr1
727− goExtract s [] src
728− PR.Continue 0 s ->
729− goExtract s backBuf (Array contents next end)
730− PR.Continue n s -> do
731− assert (n <= Prelude.length (x:backBuf)) (return ())
732− let (src0, buf1) = splitAt n (x:backBuf)
733− arr0 = A.fromListN n (Prelude.reverse src0)
734− arr1 = Array contents next end
735− src = arr0 <> arr1
736− goExtract s buf1 src
737− PR.Done 0 b -> do
738− let arr = Array contents next end
739− return (Right b, K.fromPure arr)
740− PR.Done n b -> do
741− assert (n <= Prelude.length backBuf) (return ())
742− let src0 = Prelude.take n backBuf
743− -- XXX Use fromListRevN once implemented
744− -- arr0 = A.fromListRevN n src0
745− arr0 = A.fromListN n (Prelude.reverse src0)
746− arr1 = Array contents next end
747− str = K.cons arr0 (K.fromPure arr1)
748− return (Right b, str)
749− PR.Error err -> do
750− let str = K.fromPure (Array contents cur end)
751− return (Left (ParseError err), str)
752−
753− -- This is a simplified goExtract
754− {-# INLINE goStop #-}
755− goStop !pst backBuf = do
756− pRes <- extract pst
757− case pRes of
758− PR.Partial _ _ -> error "Bug: parseBreak: Partial in extract"
759− PR.Continue 0 s ->
760− goStop s backBuf
761− PR.Continue n s -> do
762− assert (n <= Prelude.length backBuf) (return ())
763− let (src0, buf1) = splitAt n backBuf
764− arr = A.fromListN n (Prelude.reverse src0)
765− goExtract s buf1 arr
766− PR.Done 0 b ->
767− return (Right b, K.nil)
768− PR.Done n b -> do
769− assert (n <= Prelude.length backBuf) (return ())
770− let src0 = Prelude.take n backBuf
771− -- XXX Use fromListRevN once implemented
772− -- arr0 = A.fromListRevN n src0
773− arr0 = A.fromListN n (Prelude.reverse src0)
774− return (Right b, K.fromPure arr0)
775− PR.Error err ->
776− return (Left (ParseError err), K.nil)
777−
778273-- | Parse an array stream using the supplied 'Parser'. Returns the parse
779274-- result and the unconsumed stream. Throws 'ParseError' if the parse fails.
780275--
276+-- >> parseBreak p = K.parseBreakChunks (ParserK.adaptC p)
277+--
278+-- This is redundant and we can just use parseBreakChunks, as ParserK can be
279+-- composed using Monad. The only advantage of this is that we do not need to
280+-- adapt.
281+--
282+-- We can compare perf and remove this one or define it in terms of that.
283+--
781284-- /Internal/
782285--
783286{-# INLINE_NORMAL parseBreak #-}
@@ -790,7 +293,8 @@ parseBreak ::
790293parseBreak p s =
791294 fmap fromStreamD <$> parseBreakD (PRD.fromParserK p) (toStreamD s)
792295-}
793−parseBreak = parseBreakK
296+parseBreak = Array.parseBreakChunksK
297+-- parseBreak p = K.parseBreakChunks (ParserK.adaptC p)
794298
795299-------------------------------------------------------------------------------
796300-- Elimination - Running Array Folds and parsers
@@ -867,7 +371,9 @@ runArrayParserDBreak
867371 src = Prelude.reverse src0 ++ xs
868372 return (Right b, D.append (D.fromList src) (D.Stream step s))
869373 PR.Error err -> do
870− let strm = D.append (D.fromList (x:xs)) (D.Stream step s)
374+ let src0 = x:getList backBuf
375+ src = Prelude.reverse src0 ++ x:xs
376+ strm = D.append (D.fromList src) (D.Stream step s)
871377 return (Left (ParseError err), strm)
872378
873379 -- This is a simplified gobuf
@@ -902,8 +408,10 @@ runArrayParserDBreak
902408 let src0 = takeArrayListRev n (x:getList backBuf)
903409 src = Prelude.reverse src0 ++ xs
904410 return (Right b, D.fromList src)
905− PR.Error err ->
906− return (Left (ParseError err), D.fromList (x:xs))
411+ PR.Error err -> do
412+ let src0 = getList backBuf
413+ src = Prelude.reverse src0 ++ x:xs
414+ return (Left (ParseError err), D.fromList src)
907415
908416 -- This is a simplified goExtract
909417 {-# INLINE goStop #-}
@@ -928,8 +436,10 @@ runArrayParserDBreak
928436 let src0 = takeArrayListRev n (getList backBuf)
929437 src = Prelude.reverse src0
930438 return (Right b, D.fromList src)
931− PR.Error err ->
932− return (Left (ParseError err), D.nil)
439+ PR.Error err -> do
440+ let src0 = getList backBuf
441+ src = Prelude.reverse src0
442+ return (Left (ParseError err), D.fromList src)
933443
934444{-
935445-- | Parse an array stream using the supplied 'Parser'. Returns the parse
core/src/Streamly/Internal/Data/Array/Type.hs+653−102
@@ -1,76 +1,158 @@
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE TypeFamilies #-}
3+-- Must come after TypeFamilies, otherwise it is re-enabled.
4+-- MonoLocalBinds enabled by TypeFamilies causes perf regressions in general.
5+{-# LANGUAGE NoMonoLocalBinds #-}
16-- |
27-- Module : Streamly.Internal.Data.Array.Type
38-- Copyright : (c) 2020 Composewell Technologies
4−--
59-- License : BSD3-3-Clause
610-- Maintainer : streamly@composewell.com
711-- Stability : experimental
812-- Portability : GHC
913--
10−-- See notes in "Streamly.Internal.Data.Array.Mut.Type"
14+-- See notes in "Streamly.Internal.Data.MutArray.Type"
1115--
16+
1217module Streamly.Internal.Data.Array.Type
1318 (
19+ -- ** Type
1420 -- $arrayNotes
1521 Array (..)
16− , asPtrUnsafe
1722
18− -- * Freezing and Thawing
23+ -- ** Conversion
24+ -- *** Mutable and Immutable
1925 , unsafeFreeze
2026 , unsafeFreezeWithShrink
2127 , unsafeThaw
2228
23− -- * Pinning and Unpinning
29+ -- *** Pinned and Unpinned
2430 , pin
2531 , unpin
32+ , isPinned
2633
27− -- * Construction
28− , splice
34+ -- *** Casting
35+ , unsafePinnedAsPtr
2936
30− , fromList
37+ -- ** Construction
38+ , empty
39+
40+ -- *** Cloning
41+ -- XXX Why would we clone an immutable array?
42+ , clone
43+ , pinnedClone
44+
45+ -- *** Slicing
46+ -- | Get a subarray without copying
47+ , splitAt
48+ , breakOn -- XXX requires MonadIO
49+
50+ -- *** Stream Folds
51+ , unsafeMakePure
52+ , createOf
53+ , pinnedCreateOf
54+ , unsafeCreateOf
55+ , unsafePinnedCreateOf
56+ , create
57+ , pinnedCreate
58+ , createWith
59+
60+ -- *** From containers
3161 , fromListN
32− , fromListRev
62+ , pinnedFromListN
63+ , fromList
64+ , pinnedFromList
3365 , fromListRevN
34− , fromStreamDN
35− , fromStreamD
66+ , fromListRev
67+ , fromStreamN
68+ , fromStream
69+ , fromPureStreamN
70+ , fromPureStream
71+ , fromByteStr#
72+ , fromByteStr
73+ , fromPtrN
74+ , fromChunks
75+ , fromChunksK
76+
77+ -- ** Reading
78+
79+ -- *** Indexing
80+ , unsafeIndexIO -- XXX unsafeGetIndexIO
81+ , getIndexUnsafe -- XXX unsafeGetIndex
82+
83+ -- *** To Streams
84+ , read
85+ , readRev
86+ , toStreamK
87+ , toStreamKRev
3688
37− -- * Split
38− , breakOn
89+ -- *** To Containers
90+ , toList
3991
40− -- * Elimination
41− , unsafeIndexIO
42− , unsafeIndex -- getIndexUnsafe
43− , byteLength
92+ -- *** Unfolds
93+ , producer -- experimental
94+ , readerUnsafe
95+ , reader
96+ , readerRev
97+
98+ -- *** Size
4499 , length
100+ , byteLength
45101
102+ -- ** Folding
46103 , foldl'
47104 , foldr
48− , splitAt
105+ , byteCmp
106+ , byteEq
107+
108+ -- ** Appending
109+ , splice -- XXX requires MonadIO
49110
111+ -- ** Streams of arrays
112+ -- *** Chunk
113+ -- | Group a stream into arrays.
114+ , chunksOf
115+ , pinnedChunksOf
116+ , buildChunks
117+
118+ -- *** Split
119+ -- | Split an array into slices.
120+
121+ -- *** Concat
122+ -- | Append the arrays in a stream to form a stream of elements.
123+ , concat
124+ , concatRev
125+
126+ -- *** Compact
127+ -- | Append the arrays in a stream to form a stream of larger arrays.
128+ , fCompactGE
129+ , fPinnedCompactGE
130+ , lCompactGE
131+ , lPinnedCompactGE
132+ , compactGE
133+
134+ -- ** Deprecated
135+ , asPtrUnsafe
136+ , unsafeIndex
137+ , bufferChunks
138+ , flattenArrays
139+ , flattenArraysRev
140+ , fromArrayStreamK
141+ , fromStreamDN
142+ , fromStreamD
50143 , toStreamD
51144 , toStreamDRev
52− , toStreamK
53− , toStreamKRev
54145 , toStream
55146 , toStreamRev
56− , read
57− , readRev
58− , readerRev
59− , toList
60−
61− -- * Folds
147+ , nil
62148 , writeWith
63149 , writeN
150+ , pinnedWriteN
64151 , writeNUnsafe
65− , MA.ArrayUnsafe (..)
66− , writeNAligned
152+ , pinnedWriteNUnsafe
153+ , pinnedWriteNAligned
67154 , write
68−
69− -- * Streams of arrays
70− , chunksOf
71− , bufferChunks
72− , flattenArrays
73− , flattenArraysRev
155+ , pinnedWrite
74156 )
75157where
76158
@@ -78,42 +160,60 @@ where
78160#include "inline.hs"
79161
80162import Control.Exception (assert)
81−import Control.Monad (replicateM)
163+import Control.Monad (replicateM, when)
82164import Control.Monad.IO.Class (MonadIO(..))
83165import Data.Functor.Identity (Identity(..))
166+import Data.Int (Int8, Int16, Int32, Int64)
84167import Data.Proxy (Proxy(..))
85−import Data.Word (Word8)
168+import Data.Word (Word8, Word16, Word32, Word64)
86169import GHC.Base (build)
87−import GHC.Exts (IsList, IsString(..))
170+import GHC.Exts (IsList, IsString(..), Addr#)
88171
89172import GHC.IO (unsafePerformIO)
90173import GHC.Ptr (Ptr(..))
91−import Streamly.Internal.Data.Array.Mut.Type (MutArray(..), MutableByteArray)
174+import Streamly.Internal.Data.Producer.Type (Producer(..))
175+import Streamly.Internal.Data.MutArray.Type (MutArray(..))
176+import Streamly.Internal.Data.MutByteArray.Type (MutByteArray)
92177import Streamly.Internal.Data.Fold.Type (Fold(..))
93−import Streamly.Internal.Data.Stream.StreamD.Type (Stream)
94−import Streamly.Internal.Data.Unboxed (Unbox, peekWith, sizeOf)
178+import Streamly.Internal.Data.Stream.Type (Stream)
179+import Streamly.Internal.Data.StreamK.Type (StreamK)
180+import Streamly.Internal.Data.Unbox (Unbox(..))
95181import Streamly.Internal.Data.Unfold.Type (Unfold(..))
96182import Text.Read (readPrec)
97183
98−import Prelude hiding (length, foldr, read, unlines, splitAt)
184+import Prelude hiding (Foldable(..), concat, read, unlines, splitAt)
99185
100186import qualified GHC.Exts as Exts
101−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
102−import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
103−import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
104−import qualified Streamly.Internal.Data.Unboxed as Unboxed
187+import qualified Streamly.Internal.Data.Fold.Type as Fold
188+import qualified Streamly.Internal.Data.MutArray.Type as MA
189+import qualified Streamly.Internal.Data.Stream.Type as D
190+import qualified Streamly.Internal.Data.StreamK.Type as K
191+import qualified Streamly.Internal.Data.MutByteArray.Type as Unboxed
192+import qualified Streamly.Internal.Data.Producer as Producer
105193import qualified Streamly.Internal.Data.Unfold.Type as Unfold
106194import qualified Text.ParserCombinators.ReadPrec as ReadPrec
107195
108196import Streamly.Internal.System.IO (unsafeInlineIO, defaultChunkSize)
109197
198+#include "DocTestDataArray.hs"
199+
200+-------------------------------------------------------------------------------
201+-- Notes
202+-------------------------------------------------------------------------------
203+
204+-- IMPORTANT:
205+
206+-- We need to be careful while using unsafePerformIO when array creation is
207+-- involved.
208+--
209+-- * We need to make sure the unsafe IO line does not float out of the binding.
210+-- * The order of the IO actions should be sane. For example, `touch` after `f`.
211+--
212+-- Assume the unsafe IO action floats up. If it makes sense given this
213+-- assumption, it's probably OK to use usafe IO.
110214--
111−-- $setup
112−-- >>> :m
113−-- >>> :set -XMagicHash
114−-- >>> import Prelude hiding (length, foldr, read, unlines, splitAt)
115−-- >>> import Streamly.Data.Stream as Stream
116−-- >>> import Streamly.Internal.Data.Array as Array
215+-- A general approach should be never to use unsafe IO where Array creation is
216+-- involved or touch is involved.
117217
118218-------------------------------------------------------------------------------
119219-- Array Data Type
@@ -132,7 +232,7 @@ data Array a =
132232#endif
133233 -- All offsets are in terms of bytes from the start of arraycontents
134234 Array
135− { arrContents :: {-# UNPACK #-} !MutableByteArray
235+ { arrContents :: {-# UNPACK #-} !MutByteArray
136236 , arrStart :: {-# UNPACK #-} !Int -- offset
137237 , arrEnd :: {-# UNPACK #-} !Int -- offset + len
138238 }
@@ -143,14 +243,20 @@ data Array a =
143243
144244-- | Use an @Array a@ as @Ptr a@.
145245--
146−-- See 'MA.asPtrUnsafe' in the Mutable array module for more details.
246+-- See 'MA.unsafePinnedAsPtr' in the Mutable array module for more details.
147247--
148248-- /Unsafe/
149249--
150250-- /Pre-release/
151251--
252+{-# INLINE unsafePinnedAsPtr #-}
253+unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
254+unsafePinnedAsPtr arr = MA.unsafePinnedAsPtr (unsafeThaw arr)
255+
256+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}
257+{-# INLINE asPtrUnsafe #-}
152258asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
153−asPtrUnsafe arr = MA.asPtrUnsafe (unsafeThaw arr)
259+asPtrUnsafe = unsafePinnedAsPtr
154260
155261-------------------------------------------------------------------------------
156262-- Freezing and Thawing
@@ -197,23 +303,35 @@ unsafeThaw (Array ac as ae) = MutArray ac as ae ae
197303-- Pinning & Unpinning
198304-------------------------------------------------------------------------------
199305
306+-- | Return a copy of the 'Array' in pinned memory if unpinned, else return the
307+-- original array.
200308{-# INLINE pin #-}
201309pin :: Array a -> IO (Array a)
202310pin = fmap unsafeFreeze . MA.pin . unsafeThaw
203311
312+-- | Return a copy of the 'Array' in unpinned memory if pinned, else return the
313+-- original array.
204314{-# INLINE unpin #-}
205315unpin :: Array a -> IO (Array a)
206316unpin = fmap unsafeFreeze . MA.unpin . unsafeThaw
207317
318+-- | Return 'True' if the array is allocated in pinned memory.
319+{-# INLINE isPinned #-}
320+isPinned :: Array a -> Bool
321+isPinned = MA.isPinned . unsafeThaw
322+
208323-------------------------------------------------------------------------------
209324-- Construction
210325-------------------------------------------------------------------------------
211326
212−-- Splice two immutable arrays creating a new array.
327+-- | Copy two immutable arrays into a new array. If you want to splice more
328+-- than two arrays then this operation would be highly inefficient because it
329+-- would make a copy on every splice operation, instead use the
330+-- 'fromChunksK' operation to combine n immutable arrays.
213331{-# INLINE splice #-}
214−splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a)
332+splice :: MonadIO m => Array a -> Array a -> m (Array a)
215333splice arr1 arr2 =
216− unsafeFreeze <$> MA.splice (unsafeThaw arr1) (unsafeThaw arr2)
334+ unsafeFreeze <$> MA.spliceCopy (unsafeThaw arr1) (unsafeThaw arr2)
217335
218336-- | Create an 'Array' from the first N elements of a list. The array is
219337-- allocated to size N, if the list terminates before N elements then the
@@ -223,6 +341,12 @@ splice arr1 arr2 =
223341fromListN :: Unbox a => Int -> [a] -> Array a
224342fromListN n xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListN n xs
225343
344+-- | Like 'fromListN' but creates a pinned array.
345+{-# INLINABLE pinnedFromListN #-}
346+pinnedFromListN :: Unbox a => Int -> [a] -> Array a
347+pinnedFromListN n xs =
348+ unsafePerformIO $ unsafeFreeze <$> MA.pinnedFromListN n xs
349+
226350-- | Create an 'Array' from the first N elements of a list in reverse order.
227351-- The array is allocated to size N, if the list terminates before N elements
228352-- then the array may hold less than N elements.
@@ -238,6 +362,11 @@ fromListRevN n xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListRevN n xs
238362fromList :: Unbox a => [a] -> Array a
239363fromList xs = unsafePerformIO $ unsafeFreeze <$> MA.fromList xs
240364
365+-- | Like 'fromList' but creates a pinned array.
366+{-# INLINE pinnedFromList #-}
367+pinnedFromList :: Unbox a => [a] -> Array a
368+pinnedFromList xs = unsafePerformIO $ unsafeFreeze <$> MA.pinnedFromList xs
369+
241370-- | Create an 'Array' from a list in reverse order. The list must be of finite
242371-- size.
243372--
@@ -246,24 +375,83 @@ fromList xs = unsafePerformIO $ unsafeFreeze <$> MA.fromList xs
246375fromListRev :: Unbox a => [a] -> Array a
247376fromListRev xs = unsafePerformIO $ unsafeFreeze <$> MA.fromListRev xs
248377
249−{-# INLINE_NORMAL fromStreamDN #-}
378+-- | Create an 'Array' from the first N elements of a stream. The array is
379+-- allocated to size N, if the stream terminates before N elements then the
380+-- array may hold less than N elements.
381+--
382+-- >>> fromStreamN n = Stream.fold (Array.writeN n)
383+--
384+-- /Pre-release/
385+{-# INLINE_NORMAL fromStreamN #-}
386+fromStreamN :: (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a)
387+fromStreamN n m = do
388+ when (n < 0) $ error "writeN: negative write count specified"
389+ unsafeFreeze <$> MA.fromStreamN n m
390+-- fromStreamN n = D.fold (writeN n)
391+
392+{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
250393fromStreamDN :: forall m a. (MonadIO m, Unbox a)
251394 => Int -> D.Stream m a -> m (Array a)
252−fromStreamDN limit str = unsafeFreeze <$> MA.fromStreamDN limit str
395+fromStreamDN = fromStreamN
253396
397+-- | Create an 'Array' from a stream. This is useful when we want to create a
398+-- single array from a stream of unknown size. 'writeN' is at least twice
399+-- as efficient when the size is already known.
400+--
401+-- >>> fromStream = Stream.fold Array.write
402+--
403+-- Note that if the input stream is too large memory allocation for the array
404+-- may fail. When the stream size is not known, `chunksOf` followed by
405+-- processing of indvidual arrays in the resulting stream should be preferred.
406+--
407+-- /Pre-release/
254408{-# INLINE_NORMAL fromStreamD #-}
409+fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (Array a)
410+fromStream = D.fold write
411+-- fromStreamD str = unsafeFreeze <$> MA.fromStream str
412+
413+{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
255414fromStreamD :: forall m a. (MonadIO m, Unbox a)
256415 => D.Stream m a -> m (Array a)
257−fromStreamD str = unsafeFreeze <$> MA.fromStreamD str
416+fromStreamD = fromStream
417+
418+-------------------------------------------------------------------------------
419+-- Cloning
420+-------------------------------------------------------------------------------
421+
422+{-# INLINE clone #-}
423+clone ::
424+ ( MonadIO m
425+#ifdef DEVBUILD
426+ , Unbox a
427+#endif
428+ )
429+ => Array a -> m (Array a)
430+clone = fmap unsafeFreeze . MA.clone . unsafeThaw
431+
432+{-# INLINE pinnedClone #-}
433+pinnedClone ::
434+ ( MonadIO m
435+#ifdef DEVBUILD
436+ , Unbox a
437+#endif
438+ )
439+ => Array a -> m (Array a)
440+pinnedClone = fmap unsafeFreeze . MA.pinnedClone . unsafeThaw
258441
259442-------------------------------------------------------------------------------
260443-- Streams of arrays
261444-------------------------------------------------------------------------------
262445
263−{-# INLINE bufferChunks #-}
446+{-# INLINE buildChunks #-}
447+buildChunks :: (MonadIO m, Unbox a) =>
448+ D.Stream m a -> m (K.StreamK m (Array a))
449+buildChunks m = D.foldr K.cons K.nil $ chunksOf defaultChunkSize m
450+
451+{-# DEPRECATED bufferChunks "Please use buildChunks instead." #-}
264452bufferChunks :: (MonadIO m, Unbox a) =>
265453 D.Stream m a -> m (K.StreamK m (Array a))
266−bufferChunks m = D.foldr K.cons K.nil $ chunksOf defaultChunkSize m
454+bufferChunks = buildChunks
267455
268456-- | @chunksOf n stream@ groups the elements in the input stream into arrays of
269457-- @n@ elements each.
@@ -278,27 +466,106 @@ chunksOf :: forall m a. (MonadIO m, Unbox a)
278466 => Int -> D.Stream m a -> D.Stream m (Array a)
279467chunksOf n str = D.map unsafeFreeze $ MA.chunksOf n str
280468
281−-- | Use the "read" unfold instead.
282−--
283−-- @flattenArrays = unfoldMany read@
469+-- | Like 'chunksOf' but creates pinned arrays.
470+{-# INLINE_NORMAL pinnedChunksOf #-}
471+pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
472+ => Int -> D.Stream m a -> D.Stream m (Array a)
473+pinnedChunksOf n str = D.map unsafeFreeze $ MA.pinnedChunksOf n str
474+
475+-- | Convert a stream of arrays into a stream of their elements.
284476--
285−-- We can try this if there are any fusion issues in the unfold.
477+-- >>> concat = Stream.unfoldMany Array.reader
286478--
287−{-# INLINE_NORMAL flattenArrays #-}
479+{-# INLINE_NORMAL concat #-}
480+concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a
481+-- XXX this requires MonadIO whereas the unfoldMany version does not
482+concat = MA.concatWith (pure . unsafeInlineIO) . D.map unsafeThaw
483+-- concat = D.unfoldMany reader
484+
485+{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
486+{-# INLINE flattenArrays #-}
288487flattenArrays :: forall m a. (MonadIO m, Unbox a)
289488 => D.Stream m (Array a) -> D.Stream m a
290−flattenArrays = MA.flattenArrays . D.map unsafeThaw
489+flattenArrays = concat
291490
292−-- | Use the "readRev" unfold instead.
293−--
294−-- @flattenArrays = unfoldMany readRev@
491+-- | Convert a stream of arrays into a stream of their elements reversing the
492+-- contents of each array before flattening.
295493--
296−-- We can try this if there are any fusion issues in the unfold.
494+-- >>> concatRev = Stream.unfoldMany Array.readerRev
297495--
298−{-# INLINE_NORMAL flattenArraysRev #-}
496+{-# INLINE_NORMAL concatRev #-}
497+concatRev :: forall m a. (Monad m, Unbox a)
498+ => D.Stream m (Array a) -> D.Stream m a
499+-- XXX this requires MonadIO whereas the unfoldMany version does not
500+concatRev = MA.concatRevWith (pure . unsafeInlineIO) . D.map unsafeThaw
501+-- concatRev = D.unfoldMany readerRev
502+
503+{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
504+{-# INLINE flattenArraysRev #-}
299505flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
300506 => D.Stream m (Array a) -> D.Stream m a
301−flattenArraysRev = MA.flattenArraysRev . D.map unsafeThaw
507+flattenArraysRev = concatRev
508+
509+-------------------------------------------------------------------------------
510+-- Compact
511+-------------------------------------------------------------------------------
512+
513+-- XXX Note that this thaws immutable arrays for appending, that may be
514+-- problematic if multiple users do the same thing, however, thawed immutable
515+-- arrays would have no capacity to append, therefore, a copy will be forced
516+-- anyway.
517+
518+-- | Fold @fCompactGE n@ coalesces adjacent arrays in the input stream
519+-- until the size becomes greater than or equal to n.
520+--
521+-- Generates unpinned arrays irrespective of the pinning status of input
522+-- arrays.
523+{-# INLINE_NORMAL fCompactGE #-}
524+fCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
525+fCompactGE n = fmap unsafeFreeze $ Fold.lmap unsafeThaw $ MA.fCompactGE n
526+
527+-- | PInned version of 'fCompactGE'.
528+{-# INLINE_NORMAL fPinnedCompactGE #-}
529+fPinnedCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
530+fPinnedCompactGE n =
531+ fmap unsafeFreeze $ Fold.lmap unsafeThaw $ MA.fPinnedCompactGE n
532+
533+-- | @compactGE n stream@ coalesces adjacent arrays in the @stream@ until
534+-- the size becomes greater than or equal to @n@.
535+--
536+-- >>> compactGE n = Stream.foldMany (Array.fCompactGE n)
537+--
538+-- Generates unpinned arrays irrespective of the pinning status of input
539+-- arrays.
540+{-# INLINE compactGE #-}
541+compactGE ::
542+ (MonadIO m, Unbox a)
543+ => Int -> Stream m (Array a) -> Stream m (Array a)
544+compactGE n stream =
545+ D.map unsafeFreeze $ MA.compactGE n $ D.map unsafeThaw stream
546+
547+-- | Like 'compactGE' but for transforming folds instead of stream.
548+--
549+-- >>> lCompactGE n = Fold.many (Array.fCompactGE n)
550+--
551+-- Generates unpinned arrays irrespective of the pinning status of input
552+-- arrays.
553+{-# INLINE_NORMAL lCompactGE #-}
554+lCompactGE :: (MonadIO m, Unbox a)
555+ => Int -> Fold m (Array a) () -> Fold m (Array a) ()
556+lCompactGE n fld =
557+ Fold.lmap unsafeThaw $ MA.lCompactGE n (Fold.lmap unsafeFreeze fld)
558+
559+-- | Pinned version of 'lCompactGE'.
560+{-# INLINE_NORMAL lPinnedCompactGE #-}
561+lPinnedCompactGE :: (MonadIO m, Unbox a)
562+ => Int -> Fold m (Array a) () -> Fold m (Array a) ()
563+lPinnedCompactGE n fld =
564+ Fold.lmap unsafeThaw $ MA.lPinnedCompactGE n (Fold.lmap unsafeFreeze fld)
565+
566+-------------------------------------------------------------------------------
567+-- Splitting
568+-------------------------------------------------------------------------------
302569
303570-- Drops the separator byte
304571{-# INLINE breakOn #-}
@@ -320,9 +587,14 @@ unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a
320587unsafeIndexIO i arr = MA.getIndexUnsafe i (unsafeThaw arr)
321588
322589-- | Return element at the specified index without checking the bounds.
590+{-# INLINE_NORMAL getIndexUnsafe #-}
591+getIndexUnsafe :: forall a. Unbox a => Int -> Array a -> a
592+getIndexUnsafe i arr = let !r = unsafeInlineIO $ unsafeIndexIO i arr in r
593+
594+{-# DEPRECATED unsafeIndex "Please use 'getIndexUnsafe' instead" #-}
323595{-# INLINE_NORMAL unsafeIndex #-}
324596unsafeIndex :: forall a. Unbox a => Int -> Array a -> a
325−unsafeIndex i arr = let !r = unsafeInlineIO $ unsafeIndexIO i arr in r
597+unsafeIndex = getIndexUnsafe
326598
327599-- | /O(1)/ Get the byte length of the array.
328600--
@@ -337,24 +609,68 @@ byteLength = MA.byteLength . unsafeThaw
337609length :: Unbox a => Array a -> Int
338610length arr = MA.length (unsafeThaw arr)
339611
612+{-# INLINE_NORMAL producer #-}
613+producer :: forall m a. (Monad m, Unbox a) => Producer m (Array a) a
614+producer =
615+ Producer.translate unsafeThaw unsafeFreeze
616+ $ MA.producerWith (return . unsafeInlineIO)
617+
618+-- | Unfold an array into a stream.
619+--
620+{-# INLINE_NORMAL reader #-}
621+reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
622+reader = Producer.simplify producer
623+
624+-- | Unfold an array into a stream, does not check the end of the array, the
625+-- user is responsible for terminating the stream within the array bounds. For
626+-- high performance application where the end condition can be determined by
627+-- a terminating fold.
628+--
629+-- Written in the hope that it may be faster than "read", however, in the case
630+-- for which this was written, "read" proves to be faster even though the core
631+-- generated with unsafeRead looks simpler.
632+--
633+-- /Pre-release/
634+--
635+{-# INLINE_NORMAL readerUnsafe #-}
636+readerUnsafe :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
637+readerUnsafe = Unfold step inject
638+ where
639+
640+ inject (Array contents start end) =
641+ return (MA.ArrayUnsafe contents end start)
642+
643+ {-# INLINE_LATE step #-}
644+ step (MA.ArrayUnsafe contents end p) = do
645+ -- unsafeInlineIO allows us to run this in Identity monad for pure
646+ -- toList/foldr case which makes them much faster due to not
647+ -- accumulating the list and fusing better with the pure consumers.
648+ --
649+ -- This should be safe as the array contents are guaranteed to be
650+ -- evaluated/written to before we peek at them.
651+ let !x = unsafeInlineIO $ peekAt p contents
652+ let !p1 = INDEX_NEXT(p,a)
653+ return $ D.Yield x (MA.ArrayUnsafe contents end p1)
654+
340655-- | Unfold an array into a stream in reverse order.
341656--
342657{-# INLINE_NORMAL readerRev #-}
343658readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
344659readerRev = Unfold.lmap unsafeThaw $ MA.readerRevWith (return . unsafeInlineIO)
345660
661+{-# DEPRECATED toStreamD "Please use 'read' instead." #-}
346662{-# INLINE_NORMAL toStreamD #-}
347663toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> D.Stream m a
348−toStreamD arr = MA.toStreamDWith (return . unsafeInlineIO) (unsafeThaw arr)
664+toStreamD = read
349665
350666{-# INLINE toStreamK #-}
351667toStreamK :: forall m a. (Monad m, Unbox a) => Array a -> K.StreamK m a
352668toStreamK arr = MA.toStreamKWith (return . unsafeInlineIO) (unsafeThaw arr)
353669
670+{-# DEPRECATED toStreamDRev "Please use 'readRev' instead." #-}
354671{-# INLINE_NORMAL toStreamDRev #-}
355672toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> D.Stream m a
356−toStreamDRev arr =
357− MA.toStreamDRevWith (return . unsafeInlineIO) (unsafeThaw arr)
673+toStreamDRev = readRev
358674
359675{-# INLINE toStreamKRev #-}
360676toStreamKRev :: forall m a. (Monad m, Unbox a) => Array a -> K.StreamK m a
@@ -366,7 +682,7 @@ toStreamKRev arr =
366682-- /Pre-release/
367683{-# INLINE_EARLY read #-}
368684read :: (Monad m, Unbox a) => Array a -> Stream m a
369−read = toStreamD
685+read arr = MA.toStreamWith (return . unsafeInlineIO) (unsafeThaw arr)
370686
371687-- | Same as 'read'
372688--
@@ -383,7 +699,7 @@ toStream = read
383699-- /Pre-release/
384700{-# INLINE_EARLY readRev #-}
385701readRev :: (Monad m, Unbox a) => Array a -> Stream m a
386−readRev = toStreamDRev
702+readRev arr = MA.toStreamRevWith (return . unsafeInlineIO) (unsafeThaw arr)
387703
388704-- | Same as 'readRev'
389705--
@@ -407,6 +723,7 @@ foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr
407723-- | Create two slices of an array without copying the original array. The
408724-- specified index @i@ is the first index of the second slice.
409725--
726+{-# INLINE splitAt #-}
410727splitAt :: Unbox a => Int -> Array a -> (Array a, Array a)
411728splitAt i arr = (unsafeFreeze a, unsafeFreeze b)
412729 where
@@ -426,8 +743,8 @@ toListFB c n Array{..} = go arrStart
426743 -- accumulating the list and fusing better with the pure consumers.
427744 --
428745 -- This should be safe as the array contents are guaranteed to be
429− -- evaluated/written to before we peekWith at them.
430− let !x = unsafeInlineIO $ peekWith arrContents p
746+ -- evaluated/written to before we peekAt at them.
747+ let !x = unsafeInlineIO $ peekAt p arrContents
431748 in c x (go (INDEX_NEXT(p,a)))
432749
433750-- | Convert an 'Array' into a list.
@@ -440,47 +757,213 @@ toList s = build (\c n -> toListFB c n s)
440757-- Folds
441758-------------------------------------------------------------------------------
442759
443−-- | @writeN n@ folds a maximum of @n@ elements from the input stream to an
760+-- | @createOf n@ folds a maximum of @n@ elements from the input stream to an
444761-- 'Array'.
445762--
446−{-# INLINE_NORMAL writeN #-}
763+{-# INLINE_NORMAL createOf #-}
764+createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
765+createOf = fmap unsafeFreeze . MA.createOf
766+
767+-- XXX Deprecate in major
768+-- {-# DEPRECATED writeN "Please use createOf instead." #-}
769+{-# INLINE writeN #-}
447770writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
448−writeN = fmap unsafeFreeze . MA.writeN
771+writeN = createOf
449772
450−-- | @writeNAligned alignment n@ folds a maximum of @n@ elements from the input
773+-- | Like 'createOf' but creates a pinned array.
774+{-# INLINE_NORMAL pinnedCreateOf #-}
775+pinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
776+pinnedCreateOf = fmap unsafeFreeze . MA.pinnedCreateOf
777+
778+{-# DEPRECATED pinnedWriteN "Please use pinnedCreateOf instead." #-}
779+{-# INLINE pinnedWriteN #-}
780+pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
781+pinnedWriteN = pinnedCreateOf
782+
783+-- | @pinnedWriteNAligned alignment n@ folds a maximum of @n@ elements from the input
451784-- stream to an 'Array' aligned to the given size.
452785--
453786-- /Pre-release/
454787--
455−{-# INLINE_NORMAL writeNAligned #-}
456−writeNAligned :: forall m a. (MonadIO m, Unbox a)
788+{-# INLINE_NORMAL pinnedWriteNAligned #-}
789+{-# DEPRECATED pinnedWriteNAligned "To be removed." #-}
790+pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
457791 => Int -> Int -> Fold m a (Array a)
458−writeNAligned alignSize = fmap unsafeFreeze . MA.writeNAligned alignSize
792+pinnedWriteNAligned alignSize = fmap unsafeFreeze . MA.pinnedWriteNAligned alignSize
459793
460−-- | Like 'writeN' but does not check the array bounds when writing. The fold
794+-- | Like 'createOf' but does not check the array bounds when writing. The fold
461795-- driver must not call the step function more than 'n' times otherwise it will
462796-- corrupt the memory and crash. This function exists mainly because any
463797-- conditional in the step function blocks fusion causing 10x performance
464798-- slowdown.
465799--
466−{-# INLINE_NORMAL writeNUnsafe #-}
800+{-# INLINE_NORMAL unsafeCreateOf #-}
801+unsafeCreateOf :: forall m a. (MonadIO m, Unbox a)
802+ => Int -> Fold m a (Array a)
803+unsafeCreateOf n = unsafeFreeze <$> MA.unsafeCreateOf n
804+
805+{-# DEPRECATED writeNUnsafe "Please use unsafeCreateOf instead." #-}
806+{-# INLINE writeNUnsafe #-}
467807writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
468808 => Int -> Fold m a (Array a)
469−writeNUnsafe n = unsafeFreeze <$> MA.writeNUnsafe n
809+writeNUnsafe = unsafeCreateOf
470810
471−{-# INLINE_NORMAL writeWith #-}
811+{-# INLINE_NORMAL unsafePinnedCreateOf #-}
812+unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a)
813+ => Int -> Fold m a (Array a)
814+unsafePinnedCreateOf n = unsafeFreeze <$> MA.unsafePinnedCreateOf n
815+
816+{-# DEPRECATED pinnedWriteNUnsafe "Please use unsafePinnedCreateOf instead." #-}
817+{-# INLINE pinnedWriteNUnsafe #-}
818+pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
819+ => Int -> Fold m a (Array a)
820+pinnedWriteNUnsafe = unsafePinnedCreateOf
821+
822+{-# INLINE_NORMAL createWith #-}
823+createWith :: forall m a. (MonadIO m, Unbox a)
824+ => Int -> Fold m a (Array a)
825+-- createWith n = FL.rmapM spliceArrays $ toArraysOf n
826+createWith elemCount = unsafeFreeze <$> MA.createWith elemCount
827+
828+{-# DEPRECATED writeWith "Please use createWith instead." #-}
829+{-# INLINE writeWith #-}
472830writeWith :: forall m a. (MonadIO m, Unbox a)
473831 => Int -> Fold m a (Array a)
474−-- writeWith n = FL.rmapM spliceArrays $ toArraysOf n
475−writeWith elemCount = unsafeFreeze <$> MA.writeWith elemCount
832+writeWith = createWith
476833
477834-- | Fold the whole input to a single array.
478835--
479836-- /Caution! Do not use this on infinite streams./
480837--
838+{-# INLINE create #-}
839+create :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
840+create = fmap unsafeFreeze MA.create
841+
842+-- XXX Deprecate in major
843+-- {-# DEPRECATED write "Please use create instead." #-}
481844{-# INLINE write #-}
482845write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
483−write = fmap unsafeFreeze MA.write
846+write = create
847+
848+-- | Like 'create' but creates a pinned array.
849+{-# INLINE pinnedCreate #-}
850+pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
851+pinnedCreate = fmap unsafeFreeze MA.pinnedCreate
852+
853+{-# DEPRECATED pinnedWrite "Please use pinnedCreate instead." #-}
854+{-# INLINE pinnedWrite #-}
855+pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
856+pinnedWrite = pinnedCreate
857+
858+-- | Fold "step" has a dependency on "initial", and each step is dependent on
859+-- the previous invocation of step due to state passing, finally extract
860+-- depends on the result of step, therefore, as long as the fold is driven in
861+-- the correct order the operations would be correctly ordered. We need to
862+-- ensure that we strictly evaluate the previous step completely before the
863+-- next step.
864+--
865+-- To not share the same array we need to make sure that the result of
866+-- "initial" is not shared. Existential type ensures that it does not get
867+-- shared across different folds. However, if we invoke "initial" multiple
868+-- times for the same fold, there is a possiblity of sharing the two because
869+-- the compiler would consider it as a pure value. One such example is the
870+-- chunksOf combinator, or using an array creation fold with foldMany
871+-- combinator. Is there a proper way in GHC to tell it to not share a pure
872+-- expression in a particular case?
873+--
874+-- For this reason array creation folds have a MonadIO constraint. Pure folds
875+-- could be unsafe and dangerous. This is dangerous especially when used with
876+-- foldMany like operations.
877+--
878+-- >>> unsafePureWrite = Array.unsafeMakePure Array.write
879+--
880+{-# INLINE unsafeMakePure #-}
881+unsafeMakePure :: Monad m => Fold IO a b -> Fold m a b
882+unsafeMakePure (Fold step initial extract final) =
883+ Fold (\x a -> return $! unsafeInlineIO (step x a))
884+ (return $! unsafePerformIO initial)
885+ (\s -> return $! unsafeInlineIO $ extract s)
886+ (\s -> return $! unsafeInlineIO $ final s)
887+
888+{-# INLINE fromPureStreamN #-}
889+fromPureStreamN :: Unbox a => Int -> Stream Identity a -> Array a
890+fromPureStreamN n x =
891+ unsafePerformIO $ fmap unsafeFreeze (MA.fromPureStreamN n x)
892+
893+-- | Convert a pure stream in Identity monad to an immutable array.
894+--
895+-- Same as the following but with better performance:
896+--
897+-- >>> fromPureStream = Array.fromList . runIdentity . Stream.toList
898+--
899+fromPureStream :: Unbox a => Stream Identity a -> Array a
900+fromPureStream x = unsafePerformIO $ fmap (unsafeFreeze) (MA.fromPureStream x)
901+-- fromPureStream = runIdentity . D.fold (unsafeMakePure write)
902+-- fromPureStream = fromList . runIdentity . D.toList
903+
904+-- XXX This should be monadic.
905+
906+-- | Copy an immutable 'Ptr Word8' sequence into an array.
907+--
908+-- /Unsafe:/ The caller is responsible for safe addressing.
909+--
910+-- Note that this should be evaluated strictly to ensure that we do not hold
911+-- the reference to the pointer in a lazy thunk.
912+fromPtrN :: Int -> Ptr Word8 -> Array Word8
913+fromPtrN n addr = unsafePerformIO $ fmap unsafeFreeze (MA.fromPtrN n addr)
914+
915+-- XXX This should be monadic.
916+
917+-- | Copy a null terminated immutable 'Addr#' Word8 sequence into an array.
918+--
919+-- /Unsafe:/ The caller is responsible for safe addressing.
920+--
921+-- Note that this is completely safe when reading from Haskell string
922+-- literals because they are guaranteed to be NULL terminated:
923+--
924+-- >>> Array.toList $ Array.fromByteStr# "\1\2\3\0"#
925+-- [1,2,3]
926+--
927+-- Note that this should be evaluated strictly to ensure that we do not hold
928+-- the reference to the pointer in a lazy thunk.
929+fromByteStr# :: Addr# -> Array Word8
930+fromByteStr# addr = unsafePerformIO $ fmap unsafeFreeze (MA.fromByteStr# addr)
931+
932+-- XXX This should be monadic.
933+
934+-- | Note that this should be evaluated strictly to ensure that we do not hold
935+-- the reference to the pointer in a lazy thunk.
936+fromByteStr :: Ptr Word8 -> Array Word8
937+fromByteStr (Ptr addr#) = fromByteStr# addr#
938+
939+-- XXX implement fromChunks/fromChunkList instead?
940+
941+-- | Convert an array stream to an array. Note that this requires peak memory
942+-- that is double the size of the array stream.
943+--
944+{-# INLINE fromChunksK #-}
945+fromChunksK :: (MonadIO m, Unbox a) => StreamK m (Array a) -> m (Array a)
946+fromChunksK stream =
947+ -- We buffer the entire stream and then allocate the target array of the
948+ -- same size, thus requiring double the memory.
949+ fmap unsafeFreeze $ MA.fromChunksK $ fmap unsafeThaw stream
950+
951+{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
952+fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (Array a) -> m (Array a)
953+fromArrayStreamK = fromChunksK
954+
955+-- | Given a stream of arrays, splice them all together to generate a single
956+-- array. The stream must be /finite/.
957+--
958+{-# INLINE fromChunks #-}
959+fromChunks :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a)
960+fromChunks s =
961+ -- XXX Check which implementation is better
962+ -- This may also require double the memory as we double the space every
963+ -- time, when copying the last array we may have reallocated almost double
964+ -- the space required before we right size it.
965+ fmap unsafeFreeze $ MA.fromChunksRealloced (fmap unsafeThaw s)
966+ -- fromChunkStreamK $ D.toStreamK s
484967
485968-------------------------------------------------------------------------------
486969-- Instances
@@ -512,12 +995,66 @@ instance Unbox a => IsList (Array a) where
512995 {-# INLINE toList #-}
513996 toList = toList
514997
515−-- XXX we are assuming that Unboxed equality means element equality. This may
516−-- or may not be correct? arrcmp is 40% faster compared to stream equality.
517−instance (Unbox a, Eq a) => Eq (Array a) where
998+-- | Byte compare two arrays. Compare the length of the arrays. If the length
999+-- is equal, compare the lexicographical ordering of two underlying byte arrays
1000+-- otherwise return the result of length comparison.
1001+--
1002+-- /Unsafe/: Note that the 'Unbox' instance of sum types with constructors of
1003+-- different sizes may leave some memory uninitialized which can make byte
1004+-- comparison unreliable.
1005+--
1006+-- /Pre-release/
1007+{-# INLINE byteCmp #-}
1008+byteCmp :: Array a -> Array a -> Ordering
1009+byteCmp arr1 arr2 =
1010+ -- unsafePerformIO?
1011+ unsafeInlineIO $! unsafeThaw arr1 `MA.byteCmp` unsafeThaw arr2
1012+
1013+-- | Byte equality of two arrays.
1014+--
1015+-- >>> byteEq arr1 arr2 = (==) EQ $ Array.byteCmp arr1 arr2
1016+--
1017+-- /Unsafe/: See 'byteCmp'.
1018+{-# INLINE byteEq #-}
1019+byteEq :: Array a -> Array a -> Bool
1020+byteEq arr1 arr2 = (==) EQ $ byteCmp arr1 arr2
1021+
1022+#define MK_EQ_INSTANCE(typ) \
1023+instance {-# OVERLAPPING #-} Eq (Array typ) where { \
1024+; {-# INLINE (==) #-} \
1025+; (==) = byteEq \
1026+}
1027+
1028+MK_EQ_INSTANCE(Char)
1029+MK_EQ_INSTANCE(Word8)
1030+MK_EQ_INSTANCE(Word16)
1031+MK_EQ_INSTANCE(Word32)
1032+
1033+-- XXX The Word64 default instance should be as fast because we are comparing
1034+-- 64-bit at a time.
1035+MK_EQ_INSTANCE(Word64)
1036+MK_EQ_INSTANCE(Int)
1037+MK_EQ_INSTANCE(Int8)
1038+MK_EQ_INSTANCE(Int16)
1039+MK_EQ_INSTANCE(Int32)
1040+
1041+-- XXX The Int64 default instance should be as fast.
1042+MK_EQ_INSTANCE(Int64)
1043+
1044+-- | If the type allows a byte-by-byte comparison this instance can be
1045+-- overlapped by a more specific instance that uses 'byteCmp'. Byte comparison
1046+-- can be significantly faster.
1047+--
1048+instance {-# OVERLAPPABLE #-} (Unbox a, Eq a) => Eq (Array a) where
5181049 {-# INLINE (==) #-}
5191050 arr1 == arr2 =
520− (==) EQ $ unsafeInlineIO $! unsafeThaw arr1 `MA.cmp` unsafeThaw arr2
1051+ -- Does unboxed byte equality mean element equality?
1052+ -- XXX This is incorrect for sum types, as we may have some
1053+ -- uninitialized memory in that case. If we always initialize the
1054+ -- unused memory to zero we can use this.
1055+ -- Byte comparison is 40% faster compared to stream equality.
1056+ -- (==) EQ $ unsafeInlineIO $! unsafeThaw arr1 `MA.cmp` unsafeThaw arr2
1057+ (toStreamD arr1 :: Stream Identity a) == toStreamD arr2
5211058
5221059instance (Unbox a, Ord a) => Ord (Array a) where
5231060 {-# INLINE compare #-}
@@ -559,7 +1096,7 @@ _toStreamD_ size Array{..} = D.Stream step arrStart
5591096 {-# INLINE_LATE step #-}
5601097 step _ p | p == arrEnd = return D.Stop
5611098 step _ p = liftIO $ do
562− x <- peekWith arrContents p
1099+ x <- peekAt p arrContents
5631100 return $ D.Yield x (p + size)
5641101
5651102{-
@@ -582,15 +1119,29 @@ instance Foldable Array where
5821119-- Semigroup and Monoid
5831120-------------------------------------------------------------------------------
5841121
1122+-- XXX Deprecate and remove the Semigroup and Monoid instances because of
1123+-- potential misuse chances.
1124+
1125+-- | This should not be used for combining many or N arrays as it would copy
1126+-- the two arrays everytime to a new array. For coalescing multiple arrays use
1127+-- 'fromChunksK' instead.
5851128instance Unbox a => Semigroup (Array a) where
5861129 arr1 <> arr2 = unsafePerformIO $ splice arr1 arr2
5871130
1131+empty ::
1132+#ifdef DEVBUILD
1133+ Unbox a =>
1134+#endif
1135+ Array a
1136+empty = Array Unboxed.empty 0 0
1137+
1138+{-# DEPRECATED nil "Please use empty instead." #-}
5881139nil ::
5891140#ifdef DEVBUILD
5901141 Unbox a =>
5911142#endif
5921143 Array a
593−nil = Array Unboxed.nil 0 0
1144+nil = empty
5941145
5951146instance Unbox a => Monoid (Array a) where
5961147 mempty = nil
core/src/Streamly/Internal/Serialize/FromBytes.hs → core/src/Streamly/Internal/Data/Binary/Parser.hsrenamed+11−6
@@ -1,14 +1,19 @@
11-- |
2−-- Module : Streamly.Internal.Serialize.FromBytes
2+-- Module : Streamly.Internal.Data.Binary.Parser
33-- Copyright : (c) 2020 Composewell Technologies
44-- License : BSD-3-Clause
55-- Maintainer : streamly@composewell.com
6−-- Stability : pre-release
76-- Portability : GHC
87--
98-- Decode Haskell data types from byte streams.
9+--
10+-- It would be inefficient to use this to compose parsers for general algebraic
11+-- data types. For general deserialization of ADTs please use the Serialize
12+-- type class instances. The fastest way to deserialize byte streams
13+-- representing Haskell data types is to write them to arrays and deserialize
14+-- the array using the Serialize type class.
1015
11−module Streamly.Internal.Serialize.FromBytes
16+module Streamly.Internal.Data.Binary.Parser
1217 (
1318 -- * Type class
1419 FromBytes (..)
@@ -52,10 +57,10 @@ import Streamly.Internal.Data.Maybe.Strict (Maybe'(..))
5257import Streamly.Internal.Data.Tuple.Strict (Tuple' (..))
5358import qualified Streamly.Data.Array as A
5459import qualified Streamly.Internal.Data.Array as A
55− (unsafeIndex, castUnsafe)
60+ (getIndexUnsafe, castUnsafe)
5661import qualified Streamly.Internal.Data.Parser as PR
5762 (fromPure, either, satisfy, takeEQ)
58−import qualified Streamly.Internal.Data.Parser.ParserD as PRD
63+import qualified Streamly.Internal.Data.Parser as PRD
5964 (Parser(..), Initial(..), Step(..))
6065
6166-- Note: The () type does not need to have an on-disk representation in theory.
@@ -383,7 +388,7 @@ charLatin1 = fmap (chr . fromIntegral) word8
383388{-# INLINE word64host #-}
384389word64host :: MonadIO m => Parser Word8 m Word64
385390word64host =
386− fmap (A.unsafeIndex 0 . A.castUnsafe) $ PR.takeEQ 8 (A.writeN 8)
391+ fmap (A.getIndexUnsafe 0 . A.castUnsafe) $ PR.takeEQ 8 (A.writeN 8)
387392
388393-------------------------------------------------------------------------------
389394-- Type class
core/src/Streamly/Internal/Serialize/ToBytes.hs → core/src/Streamly/Internal/Data/Binary/Stream.hsrenamed+16−7
@@ -1,14 +1,23 @@
11-- |
2−-- Module : Streamly.Internal.Serialize.ToBytes
2+-- Module : Streamly.Internal.Data.Binary.Stream
33-- Copyright : (c) 2022 Composewell Technologies
44-- License : BSD-3-Clause
55-- Maintainer : streamly@composewell.com
6−-- Stability : pre-release
76-- Portability : GHC
87--
98-- Encode Haskell data types to byte streams.
9+--
10+-- The primary purpose of this module is to serialize primitive Haskell types
11+-- to streams for convenient byte by byte processing when such a need arises.
12+--
13+-- It would be inefficient to use this to build byte streams from algebraic
14+-- data types. For general serialization of ADTs please use the Serialize type
15+-- class instances. The fastest way to convert general Haskell types to byte
16+-- streams is to serialize them to an array and then stream the array.
17+
18+-- XXX remove unit, bool, ordering, and the type class as well
1019
11−module Streamly.Internal.Serialize.ToBytes
20+module Streamly.Internal.Data.Binary.Stream
1221 (
1322 -- * Type class
1423 ToBytes (..)
@@ -48,12 +57,12 @@ import Data.Char (ord)
4857import Data.Int (Int8, Int16, Int32, Int64)
4958import Data.Word (Word8, Word16, Word32, Word64)
5059import GHC.Float (castDoubleToWord64, castFloatToWord32)
51−import Streamly.Internal.Data.Stream.StreamD (Stream)
52−import Streamly.Internal.Data.Stream.StreamD (Step(..))
60+import Streamly.Internal.Data.Stream (Stream)
61+import Streamly.Internal.Data.Stream (Step(..))
5362import Streamly.Internal.Unicode.Stream (readCharUtf8)
5463
55−import qualified Streamly.Internal.Data.Stream.StreamD as Stream
56−import qualified Streamly.Internal.Data.Stream.StreamD as D
64+import qualified Streamly.Internal.Data.Stream as Stream
65+import qualified Streamly.Internal.Data.Stream as D
5766
5867-- XXX Use StreamD directly?
5968
core/src/Streamly/Internal/Data/Builder.hs+11−9
@@ -16,7 +16,9 @@ module Streamly.Internal.Data.Builder
1616 )
1717where
1818
19+#if !MIN_VERSION_base(4,18,0)
1920import Control.Applicative (liftA2)
21+#endif
2022
2123------------------------------------------------------------------------------
2224-- The Builder type
@@ -27,16 +29,16 @@ import Control.Applicative (liftA2)
2729-- or even a Fold. Unlike fold the step function is one-shot and not called in
2830-- a loop.
2931newtype Builder s m a =
30− Builder (s -> m (s, a))
32+ Builder (s -> m (a, s))
3133
3234-- | Maps a function on the output of the fold (the type @b@).
3335instance Functor m => Functor (Builder s m) where
3436 {-# INLINE fmap #-}
35− fmap f (Builder step1) = Builder (fmap (fmap f) . step1)
37+ fmap f (Builder step1) = Builder (fmap (\ (a, s) -> (f a, s)) . step1)
3638
3739{-# INLINE fromPure #-}
3840fromPure :: Applicative m => b -> Builder s m b
39−fromPure b = Builder (\s -> pure (s, b))
41+fromPure b = Builder (\s -> pure (b, s))
4042
4143-- | Chain the actions and zip the outputs.
4244{-# INLINE sequenceWith #-}
@@ -47,9 +49,9 @@ sequenceWith func (Builder stepL) (Builder stepR) = Builder step
4749 where
4850
4951 step s = do
50− (s1, x) <- stepL s
51− (s2, y) <- stepR s1
52− pure (s2, func x y)
52+ (x, s1) <- stepL s
53+ (y, s2) <- stepR s1
54+ pure (func x y, s2)
5355
5456instance Monad m => Applicative (Builder a m) where
5557 {-# INLINE pure #-}
@@ -74,7 +76,7 @@ instance Monad m => Monad (Builder a m) where
7476 where
7577
7678 step s = do
77− (s1, x) <- stepL s
79+ (x, s1) <- stepL s
7880 let Builder stepR = f x
79− (s2, y) <- stepR s1
80− pure (s2, y)
81+ (y, s2) <- stepR s1
82+ pure (y, s2)
core/src/Streamly/Internal/Data/Fold.hs+11−2594
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Internal.Data.Fold
34-- Copyright : (c) 2019 Composewell Technologies
@@ -15,2602 +16,18 @@ module Streamly.Internal.Data.Fold
1516 -- * Imports
1617 -- $setup
1718
18− -- * Fold Type
19− Step (..)
20− , Fold (..)
21− , Tee (..)
22−
23− -- * Constructors
24− -- | Which constructor to use?
25− --
26− -- * @foldl*@: If the fold never terminates i.e. does not use the 'Done'
27− -- constructor otherwise use the @foldt*@ variants.
28− -- * @*M@: Use the @M@ suffix variants if any of the step, initial, or
29− -- extract function is monadic, otherwise use the pure variants.
30− --
31− , foldl'
32− , foldlM'
33− , foldl1'
34− , foldlM1'
35− , foldt'
36− , foldtM'
37− , foldr'
38− , foldrM'
39−
40− -- * Mappers
41− -- | Monadic functions useful with mapM/lmapM on folds or streams.
42− , tracing
43− , trace
44−
45− -- * Folds
46−
47− -- ** Accumulators
48− -- *** Semigroups and Monoids
49− , sconcat
50− , mconcat
51− , foldMap
52− , foldMapM
53−
54− -- *** Reducers
55− , drain
56− , drainMapM
57− , the
58− , length
59− , lengthGeneric
60− , mean
61− , rollingHash
62− , defaultSalt
63− , rollingHashWithSalt
64− , rollingHashFirstN
65− -- , rollingHashLastN
66−
67− -- *** Saturating Reducers
68− -- | 'product' terminates if it becomes 0. Other folds can theoretically
69− -- saturate on bounded types, and therefore terminate, however, they will
70− -- run forever on unbounded types like Integer/Double.
71− , sum
72− , product
73− , maximumBy
74− , maximum
75− , minimumBy
76− , minimum
77−
78− -- *** Collectors
79− -- | Avoid using these folds in scalable or performance critical
80− -- applications, they buffer all the input in GC memory which can be
81− -- detrimental to performance if the input is large.
82− , toList
83− , toListRev
84− -- $toListRev
85− , toStream
86− , toStreamRev
87− , toStreamK
88− , toStreamKRev
89− , topBy
90− , top
91− , bottomBy
92− , bottom
93−
94− -- *** Scanners
95− -- | Stateful transformation of the elements. Useful in combination with
96− -- the 'scanMaybe' combinator. For scanners the result of the fold is
97− -- usually a transformation of the current element rather than an
98− -- aggregation of all elements till now.
99− , latest
100− -- , nthLast -- using Ring array
101− , indexingWith
102− , indexing
103− , indexingRev
104− , rollingMapM
105−
106− -- *** Filters
107− -- | Useful in combination with the 'scanMaybe' combinator.
108− , filtering
109− , deleteBy
110− , uniqBy
111− , uniq
112− , repeated
113− , findIndices
114− , elemIndices
115−
116− -- ** Terminating Folds
117− -- *** Empty folds
118− -- | Folds that return a result without consuming any input.
119− , fromPure
120− , fromEffect
121− , fromRefold
122−
123− -- *** Singleton folds
124− -- | Folds that terminate after consuming exactly one input element. All
125− -- these can be implemented in terms of the 'maybe' fold.
126− , one
127− , null -- XXX not very useful and could be problematic, remove it?
128− , satisfy
129− , maybe
130−
131− -- *** Multi folds
132− -- | Terminate after consuming one or more elements.
133− , drainN
134− -- , lastN
135− -- , (!!)
136− , indexGeneric
137− , index
138− , findM
139− , find
140− , lookup
141− , findIndex
142− , elemIndex
143− , elem
144− , notElem
145− , all
146− , any
147− , and
148− , or
149−
150− -- ** Trimmers
151− -- | Useful in combination with the 'scanMaybe' combinator.
152− , taking
153− , dropping
154− , takingEndByM
155− , takingEndBy
156− , takingEndByM_
157− , takingEndBy_
158− , droppingWhileM
159− , droppingWhile
160− , prune
161−
162− -- * Running A Fold
163− , drive
164− -- , breakStream
165−
166− -- * Building Incrementally
167− , extractM
168− , reduce
169− , close
170− , isClosed
171− , snoc
172− , snocl
173− , snocM
174− , snoclM
175−
176− , addOne
177− , addStream
178−
179− -- * Combinators
180− -- ** Utilities
181− , with
182−
183− -- ** Transforming the Monad
184− , morphInner
185− , generalizeInner
186−
187− -- ** Mapping on output
188− , rmapM
189−
190− -- ** Mapping on Input
191− , transform
192− , lmap
193− --, lsequence
194− , lmapM
195−
196− -- ** Sliding Window
197− , slide2
198−
199− -- ** Scanning Input
200− , scan
201− , scanMany
202− , postscan
203− , indexed
204−
205− -- ** Zipping Input
206− , zipStreamWithM
207− , zipStream
208−
209− -- ** Filtering Input
210− , catMaybes
211− , mapMaybeM
212− , mapMaybe
213− , scanMaybe
214− , filter
215− , filterM
216− , sampleFromthen
217−
218− -- Either streams
219− , catLefts
220− , catRights
221− , catEithers
222−
223− {-
224− -- ** Insertion
225− -- | Insertion adds more elements to the stream.
226−
227− , insertBy
228− , intersperseM
229−
230− -- ** Reordering
231− , reverse
232− -}
233−
234− -- ** Trimming
235− , take
236−
237− -- By elements
238− , takeEndBy
239− , takeEndBy_
240− , takeEndBySeq
241− , takeEndBySeq_
242− {-
243− , drop
244− , dropWhile
245− , dropWhileM
246− -}
247−
248− -- ** Serial Append
249− , splitWith
250− , split_
251− -- , tail
252− -- , init
253− , splitAt -- spanN
254− -- , splitIn -- sessionN
255−
256− -- ** Parallel Distribution
257− , teeWith
258− , tee
259− , teeWithFst
260− , teeWithMin
261− , distribute
262− -- , distributeFst
263− -- , distributeMin
264−
265− -- ** Unzipping
266− , unzip
267− -- These two can be expressed using lmap/lmapM and unzip
268− , unzipWith
269− , unzipWithM
270− , unzipWithFstM
271− , unzipWithMinM
272−
273− -- ** Parallel Alternative
274− , shortest
275− , longest
276−
277− -- ** Partitioning
278− , partitionByM
279− , partitionByFstM
280− , partitionByMinM
281− , partitionBy
282− , partition
283−
284− -- ** Splitting
285− , many
286− , manyPost
287− , groupsOf
288− , chunksBetween
289− , refoldMany
290− , refoldMany1
291− , intersperseWithQuotes
292−
293− -- ** Nesting
294− , unfoldMany
295− , concatSequence
296− , concatMap
297− , duplicate
298− , refold
299−
300− -- * Deprecated
301− , foldr
302− , drainBy
303− , last
304− , head
305− , sequence
306− , mapM
307− , variance
308− , stdDev
309− , serialWith
19+ module Streamly.Internal.Data.Fold.Type
20+ , module Streamly.Internal.Data.Fold.Tee
21+ , module Streamly.Internal.Data.Fold.Combinators
22+ , module Streamly.Internal.Data.Fold.Container
23+ , module Streamly.Internal.Data.Fold.Window
31024 )
31125where
31226
313−#include "inline.hs"
314−#include "ArrayMacros.h"
315−
316−import Control.Monad (void)
317−import Control.Monad.IO.Class (MonadIO(..))
318−import Data.Bifunctor (first)
319−import Data.Bits (shiftL, shiftR, (.|.), (.&.))
320−import Data.Either (isLeft, isRight, fromLeft, fromRight)
321−import Data.Int (Int64)
322−import Data.Proxy (Proxy(..))
323−import Data.Word (Word32)
324−import Foreign.Storable (Storable, peek)
325−import Streamly.Internal.Data.Array.Mut.Type (MutArray(..))
326−import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
327−import Streamly.Internal.Data.Pipe.Type (Pipe (..), PipeState(..))
328−import Streamly.Internal.Data.Unboxed (Unbox, sizeOf)
329−import Streamly.Internal.Data.Unfold.Type (Unfold(..))
330−import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
331−import Streamly.Internal.Data.Stream.StreamD.Type (Stream)
332−
333−import qualified Prelude
334−import qualified Streamly.Internal.Data.Array.Mut.Type as MA
335−import qualified Streamly.Internal.Data.Array.Type as Array
336−import qualified Streamly.Internal.Data.Fold.Window as FoldW
337−import qualified Streamly.Internal.Data.Pipe.Type as Pipe
338−import qualified Streamly.Internal.Data.Ring.Unboxed as Ring
339−import qualified Streamly.Internal.Data.Stream.StreamD.Type as StreamD
340−
341−import Prelude hiding
342− ( filter, foldl1, drop, dropWhile, take, takeWhile, zipWith
343− , foldl, foldr, map, mapM_, sequence, all, any, sum, product, elem
344− , notElem, maximum, minimum, head, last, tail, length, null
345− , reverse, iterate, init, and, or, lookup, (!!)
346− , scanl, scanl1, replicate, concatMap, mconcat, foldMap, unzip
347− , span, splitAt, break, mapM, zip, maybe)
348−import Streamly.Internal.Data.Fold.Type
27+import Streamly.Internal.Data.Fold.Combinators
28+import Streamly.Internal.Data.Fold.Container
34929import Streamly.Internal.Data.Fold.Tee
30+import Streamly.Internal.Data.Fold.Type
31+import Streamly.Internal.Data.Fold.Window
35032
351−-- $setup
352−-- >>> :m
353−-- >>> :set -package random
354−-- >>> import Control.Monad (void)
355−-- >>> import Data.Functor.Identity (Identity, runIdentity)
356−-- >>> import Data.Maybe (isJust)
357−-- >>> import Data.Monoid (Last(..), Sum(..))
358−-- >>> import Streamly.Data.Array (Array)
359−-- >>> import Streamly.Data.Fold (Fold)
360−-- >>> import Streamly.Data.Stream (Stream)
361−-- >>> import Data.IORef (newIORef, readIORef, writeIORef)
362−-- >>> import qualified Streamly.Data.Array as Array
363−-- >>> import qualified Streamly.Data.Fold as Fold
364−-- >>> import qualified Streamly.Data.Stream as Stream
365−-- >>> import qualified Streamly.Internal.Data.Array.Mut.Type as MA
366−-- >>> import qualified Streamly.Internal.Data.Fold as Fold
367−-- >>> import qualified Streamly.Internal.Data.Fold.Type as Fold
368−-- >>> import qualified Streamly.Internal.Data.Fold.Window as FoldW
369−-- >>> import qualified Streamly.Internal.Data.Parser as Parser
370−-- >>> import qualified Streamly.Internal.Data.Unfold as Unfold
371−-- >>> import Prelude hiding (break, map, span, splitAt)
372−
373−------------------------------------------------------------------------------
374−-- Running
375−------------------------------------------------------------------------------
376−
377−-- | Drive a fold using the supplied 'Stream', reducing the resulting
378−-- expression strictly at each step.
379−--
380−-- Definition:
381−--
382−-- >>> drive = flip Stream.fold
383−--
384−-- Example:
385−--
386−-- >>> Fold.drive (Stream.enumerateFromTo 1 100) Fold.sum
387−-- 5050
388−--
389−{-# INLINE drive #-}
390−drive :: Monad m => Stream m a -> Fold m a b -> m b
391−drive = flip StreamD.fold
392−
393−{-
394−-- | Like 'drive' but also returns the remaining stream. The resulting stream
395−-- would be 'Stream.nil' if the stream finished before the fold.
396−--
397−-- Definition:
398−--
399−-- >>> breakStream = flip Stream.foldBreak
400−--
401−-- /CPS/
402−--
403−{-# INLINE breakStreamK #-}
404−breakStreamK :: Monad m => StreamK m a -> Fold m a b -> m (b, StreamK m a)
405−breakStreamK strm fl = fmap f $ K.foldBreak fl (Stream.toStreamK strm)
406−
407− where
408−
409− f (b, str) = (b, Stream.fromStreamK str)
410−-}
411−
412−-- | Append a stream to a fold to build the fold accumulator incrementally. We
413−-- can repeatedly call 'addStream' on the same fold to continue building the
414−-- fold and finally use 'drive' to finish the fold and extract the result. Also
415−-- see the 'Streamly.Data.Fold.addOne' operation which is a singleton version
416−-- of 'addStream'.
417−--
418−-- Definitions:
419−--
420−-- >>> addStream stream = Fold.drive stream . Fold.duplicate
421−--
422−-- Example, build a list incrementally:
423−--
424−-- >>> :{
425−-- pure (Fold.toList :: Fold IO Int [Int])
426−-- >>= Fold.addOne 1
427−-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
428−-- >>= Fold.drive Stream.nil
429−-- >>= print
430−-- :}
431−-- [1,2,3,4]
432−--
433−-- This can be used as an O(n) list append compared to the O(n^2) @++@ when
434−-- used for incrementally building a list.
435−--
436−-- Example, build a stream incrementally:
437−--
438−-- >>> :{
439−-- pure (Fold.toStream :: Fold IO Int (Stream Identity Int))
440−-- >>= Fold.addOne 1
441−-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
442−-- >>= Fold.drive Stream.nil
443−-- >>= print
444−-- :}
445−-- fromList [1,2,3,4]
446−--
447−-- This can be used as an O(n) stream append compared to the O(n^2) @<>@ when
448−-- used for incrementally building a stream.
449−--
450−-- Example, build an array incrementally:
451−--
452−-- >>> :{
453−-- pure (Array.write :: Fold IO Int (Array Int))
454−-- >>= Fold.addOne 1
455−-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
456−-- >>= Fold.drive Stream.nil
457−-- >>= print
458−-- :}
459−-- fromList [1,2,3,4]
460−--
461−-- Example, build an array stream incrementally:
462−--
463−-- >>> :{
464−-- let f :: Fold IO Int (Stream Identity (Array Int))
465−-- f = Fold.groupsOf 2 (Array.writeN 3) Fold.toStream
466−-- in pure f
467−-- >>= Fold.addOne 1
468−-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
469−-- >>= Fold.drive Stream.nil
470−-- >>= print
471−-- :}
472−-- fromList [fromList [1,2],fromList [3,4]]
473−--
474−addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
475−addStream stream = drive stream . duplicate
476−
477−------------------------------------------------------------------------------
478−-- Transformations on fold inputs
479−------------------------------------------------------------------------------
480−
481−-- | Flatten the monadic output of a fold to pure output.
482−--
483−{-# DEPRECATED sequence "Use \"rmapM id\" instead" #-}
484−{-# INLINE sequence #-}
485−sequence :: Monad m => Fold m a (m b) -> Fold m a b
486−sequence = rmapM id
487−
488−-- | Map a monadic function on the output of a fold.
489−--
490−{-# DEPRECATED mapM "Use rmapM instead" #-}
491−{-# INLINE mapM #-}
492−mapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
493−mapM = rmapM
494−
495−-- |
496−-- >>> mapMaybeM f = Fold.lmapM f . Fold.catMaybes
497−--
498−{-# INLINE mapMaybeM #-}
499−mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Fold m b r -> Fold m a r
500−mapMaybeM f = lmapM f . catMaybes
501−
502−-- | @mapMaybe f fold@ maps a 'Maybe' returning function @f@ on the input of
503−-- the fold, filters out 'Nothing' elements, and return the values extracted
504−-- from 'Just'.
505−--
506−-- >>> mapMaybe f = Fold.lmap f . Fold.catMaybes
507−-- >>> mapMaybe f = Fold.mapMaybeM (return . f)
508−--
509−-- >>> f x = if even x then Just x else Nothing
510−-- >>> fld = Fold.mapMaybe f Fold.toList
511−-- >>> Stream.fold fld (Stream.enumerateFromTo 1 10)
512−-- [2,4,6,8,10]
513−--
514−{-# INLINE mapMaybe #-}
515−mapMaybe :: Monad m => (a -> Maybe b) -> Fold m b r -> Fold m a r
516−mapMaybe f = lmap f . catMaybes
517−
518−------------------------------------------------------------------------------
519−-- Transformations on fold inputs
520−------------------------------------------------------------------------------
521−
522−-- | Apply a monadic function on the input and return the input.
523−--
524−-- >>> Stream.fold (Fold.lmapM (Fold.tracing print) Fold.drain) $ (Stream.enumerateFromTo (1 :: Int) 2)
525−-- 1
526−-- 2
527−--
528−-- /Pre-release/
529−--
530−{-# INLINE tracing #-}
531−tracing :: Monad m => (a -> m b) -> (a -> m a)
532−tracing f x = void (f x) >> return x
533−
534−-- | Apply a monadic function to each element flowing through and discard the
535−-- results.
536−--
537−-- >>> Stream.fold (Fold.trace print Fold.drain) $ (Stream.enumerateFromTo (1 :: Int) 2)
538−-- 1
539−-- 2
540−--
541−-- >>> trace f = Fold.lmapM (Fold.tracing f)
542−--
543−-- /Pre-release/
544−{-# INLINE trace #-}
545−trace :: Monad m => (a -> m b) -> Fold m a r -> Fold m a r
546−trace f = lmapM (tracing f)
547−
548−-- rename to lpipe?
549−--
550−-- | Apply a transformation on a 'Fold' using a 'Pipe'.
551−--
552−-- /Pre-release/
553−{-# INLINE transform #-}
554−transform :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
555−transform (Pipe pstep1 pstep2 pinitial) (Fold fstep finitial fextract) =
556− Fold step initial extract
557−
558− where
559−
560− initial = first (Tuple' pinitial) <$> finitial
561−
562− step (Tuple' ps fs) x = do
563− r <- pstep1 ps x
564− go fs r
565−
566− where
567−
568− -- XXX use SPEC?
569− go acc (Pipe.Yield b (Consume ps')) = do
570− acc' <- fstep acc b
571− return
572− $ case acc' of
573− Partial s -> Partial $ Tuple' ps' s
574− Done b2 -> Done b2
575− go acc (Pipe.Yield b (Produce ps')) = do
576− acc' <- fstep acc b
577− r <- pstep2 ps'
578− case acc' of
579− Partial s -> go s r
580− Done b2 -> return $ Done b2
581− go acc (Pipe.Continue (Consume ps')) =
582− return $ Partial $ Tuple' ps' acc
583− go acc (Pipe.Continue (Produce ps')) = do
584− r <- pstep2 ps'
585− go acc r
586−
587− extract (Tuple' _ fs) = fextract fs
588−
589−{-# INLINE scanWith #-}
590−scanWith :: Monad m => Bool -> Fold m a b -> Fold m b c -> Fold m a c
591−scanWith isMany (Fold stepL initialL extractL) (Fold stepR initialR extractR) =
592− Fold step initial extract
593−
594− where
595−
596− {-# INLINE runStep #-}
597− runStep actionL sR = do
598− rL <- actionL
599− case rL of
600− Done bL -> do
601− rR <- stepR sR bL
602− case rR of
603− Partial sR1 ->
604− if isMany
605− then runStep initialL sR1
606− else Done <$> extractR sR1
607− Done bR -> return $ Done bR
608− Partial sL -> do
609− !b <- extractL sL
610− rR <- stepR sR b
611− return
612− $ case rR of
613− Partial sR1 -> Partial (sL, sR1)
614− Done bR -> Done bR
615−
616− initial = do
617− r <- initialR
618− case r of
619− Partial sR -> runStep initialL sR
620− Done b -> return $ Done b
621−
622− step (sL, sR) x = runStep (stepL sL x) sR
623−
624− extract = extractR . snd
625−
626−-- | Scan the input of a 'Fold' to change it in a stateful manner using another
627−-- 'Fold'. The scan stops as soon as the fold terminates.
628−--
629−-- /Pre-release/
630−{-# INLINE scan #-}
631−scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
632−scan = scanWith False
633−
634−-- XXX This does not fuse beacuse of the recursive step. Need to investigate.
635−--
636−-- | Scan the input of a 'Fold' to change it in a stateful manner using another
637−-- 'Fold'. The scan restarts with a fresh state if the fold terminates.
638−--
639−-- /Pre-release/
640−{-# INLINE scanMany #-}
641−scanMany :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
642−scanMany = scanWith True
643−
644−------------------------------------------------------------------------------
645−-- Filters
646−------------------------------------------------------------------------------
647−
648−-- | Returns the latest element omitting the first occurrence that satisfies
649−-- the given equality predicate.
650−--
651−-- Example:
652−--
653−-- >>> input = Stream.fromList [1,3,3,5]
654−-- >>> Stream.fold Fold.toList $ Stream.scanMaybe (Fold.deleteBy (==) 3) input
655−-- [1,3,5]
656−--
657−{-# INLINE_NORMAL deleteBy #-}
658−deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
659−deleteBy eq x0 = fmap extract $ foldl' step (Tuple' False Nothing)
660−
661− where
662−
663− step (Tuple' False _) x =
664− if eq x x0
665− then Tuple' True Nothing
666− else Tuple' False (Just x)
667− step (Tuple' True _) x = Tuple' True (Just x)
668−
669− extract (Tuple' _ x) = x
670−
671−-- | Provide a sliding window of length 2 elements.
672−--
673−-- See "Streamly.Internal.Data.Fold.Window".
674−--
675−{-# INLINE slide2 #-}
676−slide2 :: Monad m => Fold m (a, Maybe a) b -> Fold m a b
677−slide2 (Fold step1 initial1 extract1) = Fold step initial extract
678−
679− where
680−
681− initial =
682− first (Tuple' Nothing) <$> initial1
683−
684− step (Tuple' prev s) cur =
685− first (Tuple' (Just cur)) <$> step1 s (cur, prev)
686−
687− extract (Tuple' _ s) = extract1 s
688−
689−-- | Return the latest unique element using the supplied comparison function.
690−-- Returns 'Nothing' if the current element is same as the last element
691−-- otherwise returns 'Just'.
692−--
693−-- Example, strip duplicate path separators:
694−--
695−-- >>> input = Stream.fromList "//a//b"
696−-- >>> f x y = x == '/' && y == '/'
697−-- >>> Stream.fold Fold.toList $ Stream.scanMaybe (Fold.uniqBy f) input
698−-- "/a/b"
699−--
700−-- Space: @O(1)@
701−--
702−-- /Pre-release/
703−--
704−{-# INLINE uniqBy #-}
705−uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
706−uniqBy eq = rollingMap f
707−
708− where
709−
710− f pre curr =
711− case pre of
712− Nothing -> Just curr
713− Just x -> if x `eq` curr then Nothing else Just curr
714−
715−-- | See 'uniqBy'.
716−--
717−-- Definition:
718−--
719−-- >>> uniq = Fold.uniqBy (==)
720−--
721−{-# INLINE uniq #-}
722−uniq :: (Monad m, Eq a) => Fold m a (Maybe a)
723−uniq = uniqBy (==)
724−
725−-- | Strip all leading and trailing occurrences of an element passing a
726−-- predicate and make all other consecutive occurrences uniq.
727−--
728−-- >> prune p = Stream.dropWhileAround p $ Stream.uniqBy (x y -> p x && p y)
729−--
730−-- @
731−-- > Stream.prune isSpace (Stream.fromList " hello world! ")
732−-- "hello world!"
733−--
734−-- @
735−--
736−-- Space: @O(1)@
737−--
738−-- /Unimplemented/
739−{-# INLINE prune #-}
740−prune ::
741− -- (Monad m, Eq a) =>
742− (a -> Bool) -> Fold m a (Maybe a)
743−prune = error "Not implemented yet!"
744−
745−-- | Emit only repeated elements, once.
746−--
747−-- /Unimplemented/
748−repeated :: -- (Monad m, Eq a) =>
749− Fold m a (Maybe a)
750−repeated = error "Not implemented yet!"
751−
752−------------------------------------------------------------------------------
753−-- Left folds
754−------------------------------------------------------------------------------
755−
756−------------------------------------------------------------------------------
757−-- Run Effects
758−------------------------------------------------------------------------------
759−
760−-- |
761−-- Definitions:
762−--
763−-- >>> drainMapM f = Fold.lmapM f Fold.drain
764−-- >>> drainMapM f = Fold.foldMapM (void . f)
765−--
766−-- Drain all input after passing it through a monadic function. This is the
767−-- dual of mapM_ on stream producers.
768−--
769−{-# INLINE drainMapM #-}
770−drainMapM :: Monad m => (a -> m b) -> Fold m a ()
771−drainMapM f = lmapM f drain
772−
773−{-# DEPRECATED drainBy "Please use 'drainMapM' instead." #-}
774−{-# INLINE drainBy #-}
775−drainBy :: Monad m => (a -> m b) -> Fold m a ()
776−drainBy = drainMapM
777−
778−-- | Returns the latest element of the input stream, if any.
779−--
780−-- >>> latest = Fold.foldl1' (\_ x -> x)
781−-- >>> latest = fmap getLast $ Fold.foldMap (Last . Just)
782−--
783−{-# INLINE latest #-}
784−latest :: Monad m => Fold m a (Maybe a)
785−latest = foldl1' (\_ x -> x)
786−
787−{-# DEPRECATED last "Please use 'latest' instead." #-}
788−{-# INLINE last #-}
789−last :: Monad m => Fold m a (Maybe a)
790−last = latest
791−
792−-- | Terminates with 'Nothing' as soon as it finds an element different than
793−-- the previous one, returns 'the' element if the entire input consists of the
794−-- same element.
795−--
796−{-# INLINE the #-}
797−the :: (Monad m, Eq a) => Fold m a (Maybe a)
798−the = foldt' step initial id
799−
800− where
801−
802− initial = Partial Nothing
803−
804− step Nothing x = Partial (Just x)
805− step old@(Just x0) x =
806− if x0 == x
807− then Partial old
808− else Done Nothing
809−
810−------------------------------------------------------------------------------
811−-- To Summary
812−------------------------------------------------------------------------------
813−
814−-- | Like 'length', except with a more general 'Num' return value
815−--
816−-- Definition:
817−--
818−-- >>> lengthGeneric = fmap getSum $ Fold.foldMap (Sum . const 1)
819−-- >>> lengthGeneric = Fold.foldl' (\n _ -> n + 1) 0
820−--
821−-- /Pre-release/
822−{-# INLINE lengthGeneric #-}
823−lengthGeneric :: (Monad m, Num b) => Fold m a b
824−lengthGeneric = foldl' (\n _ -> n + 1) 0
825−
826−-- | Determine the length of the input stream.
827−--
828−-- Definition:
829−--
830−-- >>> length = Fold.lengthGeneric
831−-- >>> length = fmap getSum $ Fold.foldMap (Sum . const 1)
832−--
833−{-# INLINE length #-}
834−length :: Monad m => Fold m a Int
835−length = lengthGeneric
836−
837−
838−-- | Determine the sum of all elements of a stream of numbers. Returns additive
839−-- identity (@0@) when the stream is empty. Note that this is not numerically
840−-- stable for floating point numbers.
841−--
842−-- >>> sum = FoldW.cumulative FoldW.sum
843−--
844−-- Same as following but numerically stable:
845−--
846−-- >>> sum = Fold.foldl' (+) 0
847−-- >>> sum = fmap Data.Monoid.getSum $ Fold.foldMap Data.Monoid.Sum
848−--
849−{-# INLINE sum #-}
850−sum :: (Monad m, Num a) => Fold m a a
851−sum = FoldW.cumulative FoldW.sum
852−
853−-- | Determine the product of all elements of a stream of numbers. Returns
854−-- multiplicative identity (@1@) when the stream is empty. The fold terminates
855−-- when it encounters (@0@) in its input.
856−--
857−-- Same as the following but terminates on multiplication by @0@:
858−--
859−-- >>> product = fmap Data.Monoid.getProduct $ Fold.foldMap Data.Monoid.Product
860−--
861−{-# INLINE product #-}
862−product :: (Monad m, Num a, Eq a) => Fold m a a
863−product = foldt' step (Partial 1) id
864−
865− where
866−
867− step x a =
868− if a == 0
869− then Done 0
870− else Partial $ x * a
871−
872−------------------------------------------------------------------------------
873−-- To Summary (Maybe)
874−------------------------------------------------------------------------------
875−
876−-- | Determine the maximum element in a stream using the supplied comparison
877−-- function.
878−--
879−{-# INLINE maximumBy #-}
880−maximumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
881−maximumBy cmp = foldl1' max'
882−
883− where
884−
885− max' x y =
886− case cmp x y of
887− GT -> x
888− _ -> y
889−
890−-- | Determine the maximum element in a stream.
891−--
892−-- Definitions:
893−--
894−-- >>> maximum = Fold.maximumBy compare
895−-- >>> maximum = Fold.foldl1' max
896−--
897−-- Same as the following but without a default maximum. The 'Max' Monoid uses
898−-- the 'minBound' as the default maximum:
899−--
900−-- >>> maximum = fmap Data.Semigroup.getMax $ Fold.foldMap Data.Semigroup.Max
901−--
902−{-# INLINE maximum #-}
903−maximum :: (Monad m, Ord a) => Fold m a (Maybe a)
904−maximum = foldl1' max
905−
906−-- | Computes the minimum element with respect to the given comparison function
907−--
908−{-# INLINE minimumBy #-}
909−minimumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
910−minimumBy cmp = foldl1' min'
911−
912− where
913−
914− min' x y =
915− case cmp x y of
916− GT -> y
917− _ -> x
918−
919−-- | Determine the minimum element in a stream using the supplied comparison
920−-- function.
921−--
922−-- Definitions:
923−--
924−-- >>> minimum = Fold.minimumBy compare
925−-- >>> minimum = Fold.foldl1' min
926−--
927−-- Same as the following but without a default minimum. The 'Min' Monoid uses the
928−-- 'maxBound' as the default maximum:
929−--
930−-- >>> maximum = fmap Data.Semigroup.getMin $ Fold.foldMap Data.Semigroup.Min
931−--
932−{-# INLINE minimum #-}
933−minimum :: (Monad m, Ord a) => Fold m a (Maybe a)
934−minimum = foldl1' min
935−
936−------------------------------------------------------------------------------
937−-- To Summary (Statistical)
938−------------------------------------------------------------------------------
939−
940−-- | Compute a numerically stable arithmetic mean of all elements in the input
941−-- stream.
942−--
943−{-# INLINE mean #-}
944−mean :: (Monad m, Fractional a) => Fold m a a
945−mean = fmap done $ foldl' step begin
946−
947− where
948−
949− begin = Tuple' 0 0
950−
951− step (Tuple' x n) y =
952− let n1 = n + 1
953− in Tuple' (x + (y - x) / n1) n1
954−
955− done (Tuple' x _) = x
956−
957−-- | Compute a numerically stable (population) variance over all elements in
958−-- the input stream.
959−--
960−{-# DEPRECATED variance "Use the streamly-statistics package instead" #-}
961−{-# INLINE variance #-}
962−variance :: (Monad m, Fractional a) => Fold m a a
963−variance = fmap done $ foldl' step begin
964−
965− where
966−
967− begin = Tuple3' 0 0 0
968−
969− step (Tuple3' n mean_ m2) x = Tuple3' n' mean' m2'
970−
971− where
972−
973− n' = n + 1
974− mean' = (n * mean_ + x) / (n + 1)
975− delta = x - mean_
976− m2' = m2 + delta * delta * n / (n + 1)
977−
978− done (Tuple3' n _ m2) = m2 / n
979−
980−-- | Compute a numerically stable (population) standard deviation over all
981−-- elements in the input stream.
982−--
983−{-# DEPRECATED stdDev "Use the streamly-statistics package instead" #-}
984−{-# INLINE stdDev #-}
985−stdDev :: (Monad m, Floating a) => Fold m a a
986−stdDev = sqrt <$> variance
987−
988−-- | Compute an 'Int' sized polynomial rolling hash
989−--
990−-- > H = salt * k ^ n + c1 * k ^ (n - 1) + c2 * k ^ (n - 2) + ... + cn * k ^ 0
991−--
992−-- Where @c1@, @c2@, @cn@ are the elements in the input stream and @k@ is a
993−-- constant.
994−--
995−-- This hash is often used in Rabin-Karp string search algorithm.
996−--
997−-- See https://en.wikipedia.org/wiki/Rolling_hash
998−--
999−{-# INLINE rollingHashWithSalt #-}
1000−rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Fold m a Int64
1001−rollingHashWithSalt = foldl' step
1002−
1003− where
1004−
1005− k = 2891336453 :: Int64
1006−
1007− step cksum a = cksum * k + fromIntegral (fromEnum a)
1008−
1009−-- | A default salt used in the implementation of 'rollingHash'.
1010−{-# INLINE defaultSalt #-}
1011−defaultSalt :: Int64
1012−defaultSalt = -2578643520546668380
1013−
1014−-- | Compute an 'Int' sized polynomial rolling hash of a stream.
1015−--
1016−-- >>> rollingHash = Fold.rollingHashWithSalt Fold.defaultSalt
1017−--
1018−{-# INLINE rollingHash #-}
1019−rollingHash :: (Monad m, Enum a) => Fold m a Int64
1020−rollingHash = rollingHashWithSalt defaultSalt
1021−
1022−-- | Compute an 'Int' sized polynomial rolling hash of the first n elements of
1023−-- a stream.
1024−--
1025−-- >>> rollingHashFirstN n = Fold.take n Fold.rollingHash
1026−--
1027−-- /Pre-release/
1028−{-# INLINE rollingHashFirstN #-}
1029−rollingHashFirstN :: (Monad m, Enum a) => Int -> Fold m a Int64
1030−rollingHashFirstN n = take n rollingHash
1031−
1032−-- XXX Compare this with the implementation in Fold.Window, preferrably use the
1033−-- latter if performance is good.
1034−
1035−-- | Apply a function on every two successive elements of a stream. The first
1036−-- argument of the map function is the previous element and the second argument
1037−-- is the current element. When processing the very first element in the
1038−-- stream, the previous element is 'Nothing'.
1039−--
1040−-- /Pre-release/
1041−--
1042−{-# INLINE rollingMapM #-}
1043−rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Fold m a b
1044−rollingMapM f = Fold step initial extract
1045−
1046− where
1047−
1048− -- XXX We need just a postscan. We do not need an initial result here.
1049− -- Or we can supply a default initial result as an argument to rollingMapM.
1050− initial = return $ Partial (Nothing, error "Empty stream")
1051−
1052− step (prev, _) cur = do
1053− x <- f prev cur
1054− return $ Partial (Just cur, x)
1055−
1056− extract = return . snd
1057−
1058−-- |
1059−-- >>> rollingMap f = Fold.rollingMapM (\x y -> return $ f x y)
1060−--
1061−{-# INLINE rollingMap #-}
1062−rollingMap :: Monad m => (Maybe a -> a -> b) -> Fold m a b
1063−rollingMap f = rollingMapM (\x y -> return $ f x y)
1064−
1065−------------------------------------------------------------------------------
1066−-- Monoidal left folds
1067−------------------------------------------------------------------------------
1068−
1069−-- | Semigroup concat. Append the elements of an input stream to a provided
1070−-- starting value.
1071−--
1072−-- Definition:
1073−--
1074−-- >>> sconcat = Fold.foldl' (<>)
1075−--
1076−-- >>> semigroups = fmap Data.Monoid.Sum $ Stream.enumerateFromTo 1 10
1077−-- >>> Stream.fold (Fold.sconcat 10) semigroups
1078−-- Sum {getSum = 65}
1079−--
1080−{-# INLINE sconcat #-}
1081−sconcat :: (Monad m, Semigroup a) => a -> Fold m a a
1082−sconcat = foldl' (<>)
1083−
1084−-- | Monoid concat. Fold an input stream consisting of monoidal elements using
1085−-- 'mappend' and 'mempty'.
1086−--
1087−-- Definition:
1088−--
1089−-- >>> mconcat = Fold.sconcat mempty
1090−--
1091−-- >>> monoids = fmap Data.Monoid.Sum $ Stream.enumerateFromTo 1 10
1092−-- >>> Stream.fold Fold.mconcat monoids
1093−-- Sum {getSum = 55}
1094−--
1095−{-# INLINE mconcat #-}
1096−mconcat ::
1097− ( Monad m
1098− , Monoid a) => Fold m a a
1099−mconcat = sconcat mempty
1100−
1101−-- |
1102−-- Definition:
1103−--
1104−-- >>> foldMap f = Fold.lmap f Fold.mconcat
1105−--
1106−-- Make a fold from a pure function that folds the output of the function
1107−-- using 'mappend' and 'mempty'.
1108−--
1109−-- >>> sum = Fold.foldMap Data.Monoid.Sum
1110−-- >>> Stream.fold sum $ Stream.enumerateFromTo 1 10
1111−-- Sum {getSum = 55}
1112−--
1113−{-# INLINE foldMap #-}
1114−foldMap :: (Monad m, Monoid b) => (a -> b) -> Fold m a b
1115−foldMap f = lmap f mconcat
1116−
1117−-- |
1118−-- Definition:
1119−--
1120−-- >>> foldMapM f = Fold.lmapM f Fold.mconcat
1121−--
1122−-- Make a fold from a monadic function that folds the output of the function
1123−-- using 'mappend' and 'mempty'.
1124−--
1125−-- >>> sum = Fold.foldMapM (return . Data.Monoid.Sum)
1126−-- >>> Stream.fold sum $ Stream.enumerateFromTo 1 10
1127−-- Sum {getSum = 55}
1128−--
1129−{-# INLINE foldMapM #-}
1130−foldMapM :: (Monad m, Monoid b) => (a -> m b) -> Fold m a b
1131−foldMapM act = foldlM' step (pure mempty)
1132−
1133− where
1134−
1135− step m a = do
1136− m' <- act a
1137− return $! mappend m m'
1138−
1139−------------------------------------------------------------------------------
1140−-- To Containers
1141−------------------------------------------------------------------------------
1142−
1143−-- $toListRev
1144−-- This is more efficient than 'Streamly.Internal.Data.Fold.toList'. toList is
1145−-- exactly the same as reversing the list after 'toListRev'.
1146−
1147−-- | Buffers the input stream to a list in the reverse order of the input.
1148−--
1149−-- Definition:
1150−--
1151−-- >>> toListRev = Fold.foldl' (flip (:)) []
1152−--
1153−-- /Warning!/ working on large lists accumulated as buffers in memory could be
1154−-- very inefficient, consider using "Streamly.Array" instead.
1155−--
1156−
1157−-- xn : ... : x2 : x1 : []
1158−{-# INLINE toListRev #-}
1159−toListRev :: Monad m => Fold m a [a]
1160−toListRev = foldl' (flip (:)) []
1161−
1162−------------------------------------------------------------------------------
1163−-- Partial Folds
1164−------------------------------------------------------------------------------
1165−
1166−-- | A fold that drains the first n elements of its input, running the effects
1167−-- and discarding the results.
1168−--
1169−-- Definition:
1170−--
1171−-- >>> drainN n = Fold.take n Fold.drain
1172−--
1173−-- /Pre-release/
1174−{-# INLINE drainN #-}
1175−drainN :: Monad m => Int -> Fold m a ()
1176−drainN n = take n drain
1177−
1178−------------------------------------------------------------------------------
1179−-- To Elements
1180−------------------------------------------------------------------------------
1181−
1182−-- | Like 'index', except with a more general 'Integral' argument
1183−--
1184−-- /Pre-release/
1185−{-# INLINE indexGeneric #-}
1186−indexGeneric :: (Integral i, Monad m) => i -> Fold m a (Maybe a)
1187−indexGeneric i = foldt' step (Partial 0) (const Nothing)
1188−
1189− where
1190−
1191− step j a =
1192− if i == j
1193− then Done $ Just a
1194− else Partial (j + 1)
1195−
1196−-- | Return the element at the given index.
1197−--
1198−-- Definition:
1199−--
1200−-- >>> index = Fold.indexGeneric
1201−--
1202−{-# INLINE index #-}
1203−index :: Monad m => Int -> Fold m a (Maybe a)
1204−index = indexGeneric
1205−
1206−-- | Consume a single input and transform it using the supplied 'Maybe'
1207−-- returning function.
1208−--
1209−-- /Pre-release/
1210−--
1211−{-# INLINE maybe #-}
1212−maybe :: Monad m => (a -> Maybe b) -> Fold m a (Maybe b)
1213−maybe f = foldt' (const (Done . f)) (Partial Nothing) id
1214−
1215−-- | Consume a single element and return it if it passes the predicate else
1216−-- return 'Nothing'.
1217−--
1218−-- Definition:
1219−--
1220−-- >>> satisfy f = Fold.maybe (\a -> if f a then Just a else Nothing)
1221−--
1222−-- /Pre-release/
1223−{-# INLINE satisfy #-}
1224−satisfy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1225−satisfy f = maybe (\a -> if f a then Just a else Nothing)
1226−{-
1227−satisfy f = Fold step (return $ Partial ()) (const (return Nothing))
1228−
1229− where
1230−
1231− step () a = return $ Done $ if f a then Just a else Nothing
1232−-}
1233−
1234−-- Naming notes:
1235−--
1236−-- "head" and "next" are two alternative names for the same API. head sounds
1237−-- apt in the context of lists but next sounds more apt in the context of
1238−-- streams where we think in terms of generating and consuming the next element
1239−-- rather than taking the head of some static/persistent structure.
1240−--
1241−-- We also want to keep the nomenclature consistent across folds and parsers,
1242−-- "head" becomes even more unintuitive for parsers because there are two
1243−-- possible variants viz. peek and next.
1244−--
1245−-- Also, the "head" fold creates confusion in situations like
1246−-- https://github.com/composewell/streamly/issues/1404 where intuitive
1247−-- expectation from head is to consume the entire stream and just give us the
1248−-- head. There we want to convey the notion that we consume one element from
1249−-- the stream and stop. The name "one" already being used in parsers for this
1250−-- purpose sounds more apt from this perspective.
1251−--
1252−-- The source of confusion is perhaps due to the fact that some folds consume
1253−-- the entire stream and others terminate early. It may have been clearer if we
1254−-- had separate abstractions for the two use cases.
1255−
1256−-- XXX We can possibly use "head" for the purposes of reducing the entire
1257−-- stream to the head element i.e. take the head and drain the rest.
1258−
1259−-- | Take one element from the stream and stop.
1260−--
1261−-- Definition:
1262−--
1263−-- >>> one = Fold.maybe Just
1264−--
1265−-- This is similar to the stream 'Stream.uncons' operation.
1266−--
1267−{-# INLINE one #-}
1268−one :: Monad m => Fold m a (Maybe a)
1269−one = maybe Just
1270−
1271−-- | Extract the first element of the stream, if any.
1272−--
1273−-- >>> head = Fold.one
1274−--
1275−{-# DEPRECATED head "Please use \"one\" instead" #-}
1276−{-# INLINE head #-}
1277−head :: Monad m => Fold m a (Maybe a)
1278−head = one
1279−
1280−-- | Returns the first element that satisfies the given predicate.
1281−--
1282−-- /Pre-release/
1283−{-# INLINE findM #-}
1284−findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1285−findM predicate = Fold step (return $ Partial ()) (const $ return Nothing)
1286−
1287− where
1288−
1289− step () a =
1290− let f r =
1291− if r
1292− then Done (Just a)
1293− else Partial ()
1294− in f <$> predicate a
1295−
1296−-- | Returns the first element that satisfies the given predicate.
1297−--
1298−{-# INLINE find #-}
1299−find :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1300−find p = findM (return . p)
1301−
1302−-- | In a stream of (key-value) pairs @(a, b)@, return the value @b@ of the
1303−-- first pair where the key equals the given value @a@.
1304−--
1305−-- Definition:
1306−--
1307−-- >>> lookup x = fmap snd <$> Fold.find ((== x) . fst)
1308−--
1309−{-# INLINE lookup #-}
1310−lookup :: (Eq a, Monad m) => a -> Fold m (a,b) (Maybe b)
1311−lookup a0 = foldt' step (Partial ()) (const Nothing)
1312−
1313− where
1314−
1315− step () (a, b) =
1316− if a == a0
1317− then Done $ Just b
1318− else Partial ()
1319−
1320−-- | Returns the first index that satisfies the given predicate.
1321−--
1322−{-# INLINE findIndex #-}
1323−findIndex :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
1324−findIndex predicate = foldt' step (Partial 0) (const Nothing)
1325−
1326− where
1327−
1328− step i a =
1329− if predicate a
1330− then Done $ Just i
1331− else Partial (i + 1)
1332−
1333−-- | Returns the index of the latest element if the element satisfies the given
1334−-- predicate.
1335−--
1336−{-# INLINE findIndices #-}
1337−findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
1338−findIndices predicate =
1339− -- XXX implement by combining indexing and filtering scans
1340− fmap (either (const Nothing) Just) $ foldl' step (Left (-1))
1341−
1342− where
1343−
1344− step i a =
1345− if predicate a
1346− then Right (either id id i + 1)
1347− else Left (either id id i + 1)
1348−
1349−-- | Returns the index of the latest element if the element matches the given
1350−-- value.
1351−--
1352−-- Definition:
1353−--
1354−-- >>> elemIndices a = Fold.findIndices (== a)
1355−--
1356−{-# INLINE elemIndices #-}
1357−elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
1358−elemIndices a = findIndices (== a)
1359−
1360−-- | Returns the first index where a given value is found in the stream.
1361−--
1362−-- Definition:
1363−--
1364−-- >>> elemIndex a = Fold.findIndex (== a)
1365−--
1366−{-# INLINE elemIndex #-}
1367−elemIndex :: (Eq a, Monad m) => a -> Fold m a (Maybe Int)
1368−elemIndex a = findIndex (== a)
1369−
1370−------------------------------------------------------------------------------
1371−-- To Boolean
1372−------------------------------------------------------------------------------
1373−
1374−-- Similar to 'eof' parser, but the fold consumes and discards an input element
1375−-- when not at eof. XXX Remove or Rename to "eof"?
1376−
1377−-- | Consume one element, return 'True' if successful else return 'False'. In
1378−-- other words, test if the input is empty or not.
1379−--
1380−-- WARNING! It consumes one element if the stream is not empty. If that is not
1381−-- what you want please use the eof parser instead.
1382−--
1383−-- Definition:
1384−--
1385−-- >>> null = fmap isJust Fold.one
1386−--
1387−{-# INLINE null #-}
1388−null :: Monad m => Fold m a Bool
1389−null = foldt' (\() _ -> Done False) (Partial ()) (const True)
1390−
1391−-- | Returns 'True' if any element of the input satisfies the predicate.
1392−--
1393−-- Definition:
1394−--
1395−-- >>> any p = Fold.lmap p Fold.or
1396−--
1397−-- Example:
1398−--
1399−-- >>> Stream.fold (Fold.any (== 0)) $ Stream.fromList [1,0,1]
1400−-- True
1401−--
1402−{-# INLINE any #-}
1403−any :: Monad m => (a -> Bool) -> Fold m a Bool
1404−any predicate = foldt' step initial id
1405−
1406− where
1407−
1408− initial = Partial False
1409−
1410− step _ a =
1411− if predicate a
1412− then Done True
1413− else Partial False
1414−
1415−-- | Return 'True' if the given element is present in the stream.
1416−--
1417−-- Definition:
1418−--
1419−-- >>> elem a = Fold.any (== a)
1420−--
1421−{-# INLINE elem #-}
1422−elem :: (Eq a, Monad m) => a -> Fold m a Bool
1423−elem a = any (== a)
1424−
1425−-- | Returns 'True' if all elements of the input satisfy the predicate.
1426−--
1427−-- Definition:
1428−--
1429−-- >>> all p = Fold.lmap p Fold.and
1430−--
1431−-- Example:
1432−--
1433−-- >>> Stream.fold (Fold.all (== 0)) $ Stream.fromList [1,0,1]
1434−-- False
1435−--
1436−{-# INLINE all #-}
1437−all :: Monad m => (a -> Bool) -> Fold m a Bool
1438−all predicate = foldt' step initial id
1439−
1440− where
1441−
1442− initial = Partial True
1443−
1444− step _ a =
1445− if predicate a
1446− then Partial True
1447− else Done False
1448−
1449−-- | Returns 'True' if the given element is not present in the stream.
1450−--
1451−-- Definition:
1452−--
1453−-- >>> notElem a = Fold.all (/= a)
1454−--
1455−{-# INLINE notElem #-}
1456−notElem :: (Eq a, Monad m) => a -> Fold m a Bool
1457−notElem a = all (/= a)
1458−
1459−-- | Returns 'True' if all elements are 'True', 'False' otherwise
1460−--
1461−-- Definition:
1462−--
1463−-- >>> and = Fold.all (== True)
1464−--
1465−{-# INLINE and #-}
1466−and :: Monad m => Fold m Bool Bool
1467−and = all (== True)
1468−
1469−-- | Returns 'True' if any element is 'True', 'False' otherwise
1470−--
1471−-- Definition:
1472−--
1473−-- >>> or = Fold.any (== True)
1474−--
1475−{-# INLINE or #-}
1476−or :: Monad m => Fold m Bool Bool
1477−or = any (== True)
1478−
1479−------------------------------------------------------------------------------
1480−-- Grouping/Splitting
1481−------------------------------------------------------------------------------
1482−
1483−------------------------------------------------------------------------------
1484−-- Grouping without looking at elements
1485−------------------------------------------------------------------------------
1486−
1487−------------------------------------------------------------------------------
1488−-- Binary APIs
1489−------------------------------------------------------------------------------
1490−
1491−-- | @splitAt n f1 f2@ composes folds @f1@ and @f2@ such that first @n@
1492−-- elements of its input are consumed by fold @f1@ and the rest of the stream
1493−-- is consumed by fold @f2@.
1494−--
1495−-- >>> let splitAt_ n xs = Stream.fold (Fold.splitAt n Fold.toList Fold.toList) $ Stream.fromList xs
1496−--
1497−-- >>> splitAt_ 6 "Hello World!"
1498−-- ("Hello ","World!")
1499−--
1500−-- >>> splitAt_ (-1) [1,2,3]
1501−-- ([],[1,2,3])
1502−--
1503−-- >>> splitAt_ 0 [1,2,3]
1504−-- ([],[1,2,3])
1505−--
1506−-- >>> splitAt_ 1 [1,2,3]
1507−-- ([1],[2,3])
1508−--
1509−-- >>> splitAt_ 3 [1,2,3]
1510−-- ([1,2,3],[])
1511−--
1512−-- >>> splitAt_ 4 [1,2,3]
1513−-- ([1,2,3],[])
1514−--
1515−-- > splitAt n f1 f2 = Fold.splitWith (,) (Fold.take n f1) f2
1516−--
1517−-- /Internal/
1518−
1519−{-# INLINE splitAt #-}
1520−splitAt
1521− :: Monad m
1522− => Int
1523− -> Fold m a b
1524− -> Fold m a c
1525− -> Fold m a (b, c)
1526−splitAt n fld = splitWith (,) (take n fld)
1527−
1528−------------------------------------------------------------------------------
1529−-- Element Aware APIs
1530−------------------------------------------------------------------------------
1531−--
1532−------------------------------------------------------------------------------
1533−-- Binary APIs
1534−------------------------------------------------------------------------------
1535−
1536−{-# INLINE takingEndByM #-}
1537−takingEndByM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1538−takingEndByM p = Fold step initial (return . toMaybe)
1539−
1540− where
1541−
1542− initial = return $ Partial Nothing'
1543−
1544− step _ a = do
1545− r <- p a
1546− return
1547− $ if r
1548− then Done $ Just a
1549− else Partial $ Just' a
1550−
1551−-- |
1552−--
1553−-- >>> takingEndBy p = Fold.takingEndByM (return . p)
1554−--
1555−{-# INLINE takingEndBy #-}
1556−takingEndBy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1557−takingEndBy p = takingEndByM (return . p)
1558−
1559−{-# INLINE takingEndByM_ #-}
1560−takingEndByM_ :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1561−takingEndByM_ p = Fold step initial (return . toMaybe)
1562−
1563− where
1564−
1565− initial = return $ Partial Nothing'
1566−
1567− step _ a = do
1568− r <- p a
1569− return
1570− $ if r
1571− then Done Nothing
1572− else Partial $ Just' a
1573−
1574−-- |
1575−--
1576−-- >>> takingEndBy_ p = Fold.takingEndByM_ (return . p)
1577−--
1578−{-# INLINE takingEndBy_ #-}
1579−takingEndBy_ :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1580−takingEndBy_ p = takingEndByM_ (return . p)
1581−
1582−{-# INLINE droppingWhileM #-}
1583−droppingWhileM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1584−droppingWhileM p = Fold step initial (return . toMaybe)
1585−
1586− where
1587−
1588− initial = return $ Partial Nothing'
1589−
1590− step Nothing' a = do
1591− r <- p a
1592− return
1593− $ Partial
1594− $ if r
1595− then Nothing'
1596− else Just' a
1597− step _ a = return $ Partial $ Just' a
1598−
1599−-- |
1600−-- >>> droppingWhile p = Fold.droppingWhileM (return . p)
1601−--
1602−{-# INLINE droppingWhile #-}
1603−droppingWhile :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1604−droppingWhile p = droppingWhileM (return . p)
1605−
1606−-- Note: Keep this consistent with S.splitOn. In fact we should eliminate
1607−-- S.splitOn in favor of the fold.
1608−--
1609−-- XXX Use Fold.many instead once it is fixed.
1610−-- > Stream.splitOnSuffix p f = Stream.foldMany (Fold.takeEndBy_ p f)
1611−
1612−-- | Like 'takeEndBy' but drops the element on which the predicate succeeds.
1613−--
1614−-- Example:
1615−--
1616−-- >>> input = Stream.fromList "hello\nthere\n"
1617−-- >>> line = Fold.takeEndBy_ (== '\n') Fold.toList
1618−-- >>> Stream.fold line input
1619−-- "hello"
1620−--
1621−-- >>> Stream.fold Fold.toList $ Stream.foldMany line input
1622−-- ["hello","there"]
1623−--
1624−{-# INLINE takeEndBy_ #-}
1625−takeEndBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a b
1626−-- takeEndBy_ predicate = scanMaybe (takingEndBy_ predicate)
1627−takeEndBy_ predicate (Fold fstep finitial fextract) =
1628− Fold step finitial fextract
1629−
1630− where
1631−
1632− step s a =
1633− if not (predicate a)
1634− then fstep s a
1635− else Done <$> fextract s
1636−
1637−-- Note:
1638−-- > Stream.splitWithSuffix p f = Stream.foldMany (Fold.takeEndBy p f)
1639−
1640−-- | Take the input, stop when the predicate succeeds taking the succeeding
1641−-- element as well.
1642−--
1643−-- Example:
1644−--
1645−-- >>> input = Stream.fromList "hello\nthere\n"
1646−-- >>> line = Fold.takeEndBy (== '\n') Fold.toList
1647−-- >>> Stream.fold line input
1648−-- "hello\n"
1649−--
1650−-- >>> Stream.fold Fold.toList $ Stream.foldMany line input
1651−-- ["hello\n","there\n"]
1652−--
1653−{-# INLINE takeEndBy #-}
1654−takeEndBy :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a b
1655−-- takeEndBy predicate = scanMaybe (takingEndBy predicate)
1656−takeEndBy predicate (Fold fstep finitial fextract) =
1657− Fold step finitial fextract
1658−
1659− where
1660−
1661− step s a = do
1662− res <- fstep s a
1663− if not (predicate a)
1664− then return res
1665− else do
1666− case res of
1667− Partial s1 -> Done <$> fextract s1
1668− Done b -> return $ Done b
1669−
1670−------------------------------------------------------------------------------
1671−-- Binary splitting on a separator
1672−------------------------------------------------------------------------------
1673−
1674−data SplitOnSeqState acc a rb rh w ck =
1675− SplitOnSeqEmpty !acc
1676− | SplitOnSeqSingle !acc !a
1677− | SplitOnSeqWord !acc !Int !w
1678− | SplitOnSeqWordLoop !acc !w
1679− | SplitOnSeqKR !acc !Int !rb !rh
1680− | SplitOnSeqKRLoop !acc !ck !rb !rh
1681−
1682−-- XXX Need to add tests for takeEndBySeq, we have tests for takeEndBySeq_ .
1683−
1684−-- | Continue taking the input until the input sequence matches the supplied
1685−-- sequence, taking the supplied sequence as well. If the pattern is empty this
1686−-- acts as an identity fold.
1687−--
1688−-- >>> s = Stream.fromList "hello there. How are you?"
1689−-- >>> f = Fold.takeEndBySeq (Array.fromList "re") Fold.toList
1690−-- >>> Stream.fold f s
1691−-- "hello there"
1692−--
1693−-- >>> Stream.fold Fold.toList $ Stream.foldMany f s
1694−-- ["hello there",". How are"," you?"]
1695−--
1696−-- /Pre-release/
1697−{-# INLINE takeEndBySeq #-}
1698−takeEndBySeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) =>
1699− Array.Array a
1700− -> Fold m a b
1701− -> Fold m a b
1702−takeEndBySeq patArr (Fold fstep finitial fextract) =
1703− Fold step initial extract
1704−
1705− where
1706−
1707− patLen = Array.length patArr
1708−
1709− initial = do
1710− res <- finitial
1711− case res of
1712− Partial acc
1713− | patLen == 0 ->
1714− -- XXX Should we match nothing or everything on empty
1715− -- pattern?
1716− -- Done <$> fextract acc
1717− return $ Partial $ SplitOnSeqEmpty acc
1718− | patLen == 1 -> do
1719− pat <- liftIO $ Array.unsafeIndexIO 0 patArr
1720− return $ Partial $ SplitOnSeqSingle acc pat
1721− | SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
1722− return $ Partial $ SplitOnSeqWord acc 0 0
1723− | otherwise -> do
1724− (rb, rhead) <- liftIO $ Ring.new patLen
1725− return $ Partial $ SplitOnSeqKR acc 0 rb rhead
1726− Done b -> return $ Done b
1727−
1728− -- Word pattern related
1729− maxIndex = patLen - 1
1730−
1731− elemBits = SIZE_OF(a) * 8
1732−
1733− wordMask :: Word
1734− wordMask = (1 `shiftL` (elemBits * patLen)) - 1
1735−
1736− wordPat :: Word
1737− wordPat = wordMask .&. Array.foldl' addToWord 0 patArr
1738−
1739− addToWord wd a = (wd `shiftL` elemBits) .|. fromIntegral (fromEnum a)
1740−
1741− -- For Rabin-Karp search
1742− k = 2891336453 :: Word32
1743− coeff = k ^ patLen
1744−
1745− addCksum cksum a = cksum * k + fromIntegral (fromEnum a)
1746−
1747− deltaCksum cksum old new =
1748− addCksum cksum new - coeff * fromIntegral (fromEnum old)
1749−
1750− -- XXX shall we use a random starting hash or 1 instead of 0?
1751− -- XXX Need to keep this cached across fold calls in foldmany
1752− -- XXX We may need refold to inject the cached state instead of
1753− -- initializing the state every time.
1754− -- XXX Allocation of ring buffer should also be done once
1755− patHash = Array.foldl' addCksum 0 patArr
1756−
1757− step (SplitOnSeqEmpty s) x = do
1758− res <- fstep s x
1759− case res of
1760− Partial s1 -> return $ Partial $ SplitOnSeqEmpty s1
1761− Done b -> return $ Done b
1762− step (SplitOnSeqSingle s pat) x = do
1763− res <- fstep s x
1764− case res of
1765− Partial s1
1766− | pat /= x -> return $ Partial $ SplitOnSeqSingle s1 pat
1767− | otherwise -> Done <$> fextract s1
1768− Done b -> return $ Done b
1769− step (SplitOnSeqWord s idx wrd) x = do
1770− res <- fstep s x
1771− let wrd1 = addToWord wrd x
1772− case res of
1773− Partial s1
1774− | idx == maxIndex -> do
1775− if wrd1 .&. wordMask == wordPat
1776− then Done <$> fextract s1
1777− else return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1778− | otherwise ->
1779− return $ Partial $ SplitOnSeqWord s1 (idx + 1) wrd1
1780− Done b -> return $ Done b
1781− step (SplitOnSeqWordLoop s wrd) x = do
1782− res <- fstep s x
1783− let wrd1 = addToWord wrd x
1784− case res of
1785− Partial s1
1786− | wrd1 .&. wordMask == wordPat ->
1787− Done <$> fextract s1
1788− | otherwise ->
1789− return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1790− Done b -> return $ Done b
1791− step (SplitOnSeqKR s idx rb rh) x = do
1792− res <- fstep s x
1793− case res of
1794− Partial s1 -> do
1795− rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1796− if idx == maxIndex
1797− then do
1798− let fld = Ring.unsafeFoldRing (Ring.ringBound rb)
1799− let !ringHash = fld addCksum 0 rb
1800− if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1801− then Done <$> fextract s1
1802− else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1803− else
1804− return $ Partial $ SplitOnSeqKR s1 (idx + 1) rb rh1
1805− Done b -> return $ Done b
1806− step (SplitOnSeqKRLoop s cksum rb rh) x = do
1807− res <- fstep s x
1808− case res of
1809− Partial s1 -> do
1810− old <- liftIO $ peek rh
1811− rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1812− let ringHash = deltaCksum cksum old x
1813− if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1814− then Done <$> fextract s1
1815− else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1816− Done b -> return $ Done b
1817−
1818− extract state =
1819− let st =
1820− case state of
1821− SplitOnSeqEmpty s -> s
1822− SplitOnSeqSingle s _ -> s
1823− SplitOnSeqWord s _ _ -> s
1824− SplitOnSeqWordLoop s _ -> s
1825− SplitOnSeqKR s _ _ _ -> s
1826− SplitOnSeqKRLoop s _ _ _ -> s
1827− in fextract st
1828−
1829−-- | Like 'takeEndBySeq' but discards the matched sequence.
1830−--
1831−-- /Pre-release/
1832−--
1833−{-# INLINE takeEndBySeq_ #-}
1834−takeEndBySeq_ :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) =>
1835− Array.Array a
1836− -> Fold m a b
1837− -> Fold m a b
1838−takeEndBySeq_ patArr (Fold fstep finitial fextract) =
1839− Fold step initial extract
1840−
1841− where
1842−
1843− patLen = Array.length patArr
1844−
1845− initial = do
1846− res <- finitial
1847− case res of
1848− Partial acc
1849− | patLen == 0 ->
1850− -- XXX Should we match nothing or everything on empty
1851− -- pattern?
1852− -- Done <$> fextract acc
1853− return $ Partial $ SplitOnSeqEmpty acc
1854− | patLen == 1 -> do
1855− pat <- liftIO $ Array.unsafeIndexIO 0 patArr
1856− return $ Partial $ SplitOnSeqSingle acc pat
1857− -- XXX Need to add tests for this case
1858− | SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
1859− return $ Partial $ SplitOnSeqWord acc 0 0
1860− | otherwise -> do
1861− (rb, rhead) <- liftIO $ Ring.new patLen
1862− return $ Partial $ SplitOnSeqKR acc 0 rb rhead
1863− Done b -> return $ Done b
1864−
1865− -- Word pattern related
1866− maxIndex = patLen - 1
1867−
1868− elemBits = SIZE_OF(a) * 8
1869−
1870− wordMask :: Word
1871− wordMask = (1 `shiftL` (elemBits * patLen)) - 1
1872−
1873− elemMask :: Word
1874− elemMask = (1 `shiftL` elemBits) - 1
1875−
1876− wordPat :: Word
1877− wordPat = wordMask .&. Array.foldl' addToWord 0 patArr
1878−
1879− addToWord wd a = (wd `shiftL` elemBits) .|. fromIntegral (fromEnum a)
1880−
1881− -- For Rabin-Karp search
1882− k = 2891336453 :: Word32
1883− coeff = k ^ patLen
1884−
1885− addCksum cksum a = cksum * k + fromIntegral (fromEnum a)
1886−
1887− deltaCksum cksum old new =
1888− addCksum cksum new - coeff * fromIntegral (fromEnum old)
1889−
1890− -- XXX shall we use a random starting hash or 1 instead of 0?
1891− -- XXX Need to keep this cached across fold calls in foldMany
1892− -- XXX We may need refold to inject the cached state instead of
1893− -- initializing the state every time.
1894− -- XXX Allocation of ring buffer should also be done once
1895− patHash = Array.foldl' addCksum 0 patArr
1896−
1897− step (SplitOnSeqEmpty s) x = do
1898− res <- fstep s x
1899− case res of
1900− Partial s1 -> return $ Partial $ SplitOnSeqEmpty s1
1901− Done b -> return $ Done b
1902− step (SplitOnSeqSingle s pat) x = do
1903− if pat /= x
1904− then do
1905− res <- fstep s x
1906− case res of
1907− Partial s1 -> return $ Partial $ SplitOnSeqSingle s1 pat
1908− Done b -> return $ Done b
1909− else Done <$> fextract s
1910− step (SplitOnSeqWord s idx wrd) x = do
1911− let wrd1 = addToWord wrd x
1912− if idx == maxIndex
1913− then do
1914− if wrd1 .&. wordMask == wordPat
1915− then Done <$> fextract s
1916− else return $ Partial $ SplitOnSeqWordLoop s wrd1
1917− else return $ Partial $ SplitOnSeqWord s (idx + 1) wrd1
1918− step (SplitOnSeqWordLoop s wrd) x = do
1919− let wrd1 = addToWord wrd x
1920− old = (wordMask .&. wrd)
1921− `shiftR` (elemBits * (patLen - 1))
1922− res <- fstep s (toEnum $ fromIntegral old)
1923− case res of
1924− Partial s1
1925− | wrd1 .&. wordMask == wordPat ->
1926− Done <$> fextract s1
1927− | otherwise ->
1928− return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1929− Done b -> return $ Done b
1930− step (SplitOnSeqKR s idx rb rh) x = do
1931− rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1932− if idx == maxIndex
1933− then do
1934− let fld = Ring.unsafeFoldRing (Ring.ringBound rb)
1935− let !ringHash = fld addCksum 0 rb
1936− if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1937− then Done <$> fextract s
1938− else return $ Partial $ SplitOnSeqKRLoop s ringHash rb rh1
1939− else return $ Partial $ SplitOnSeqKR s (idx + 1) rb rh1
1940− step (SplitOnSeqKRLoop s cksum rb rh) x = do
1941− old <- liftIO $ peek rh
1942− res <- fstep s old
1943− case res of
1944− Partial s1 -> do
1945− rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1946− let ringHash = deltaCksum cksum old x
1947− if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1948− then Done <$> fextract s1
1949− else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1950− Done b -> return $ Done b
1951−
1952− -- XXX extract should return backtrack count as well. If the fold
1953− -- terminates early inside extract, we may still have buffered data
1954− -- remaining which will be lost if we do not communicate that to the
1955− -- driver.
1956− extract state = do
1957− let consumeWord s n wrd = do
1958− if n == 0
1959− then fextract s
1960− else do
1961− let old = elemMask .&. (wrd `shiftR` (elemBits * (n - 1)))
1962− r <- fstep s (toEnum $ fromIntegral old)
1963− case r of
1964− Partial s1 -> consumeWord s1 (n - 1) wrd
1965− Done b -> return b
1966−
1967− let consumeRing s n rb rh =
1968− if n == 0
1969− then fextract s
1970− else do
1971− old <- liftIO $ peek rh
1972− let rh1 = Ring.advance rb rh
1973− r <- fstep s old
1974− case r of
1975− Partial s1 -> consumeRing s1 (n - 1) rb rh1
1976− Done b -> return b
1977−
1978− case state of
1979− SplitOnSeqEmpty s -> fextract s
1980− SplitOnSeqSingle s _ -> fextract s
1981− SplitOnSeqWord s idx wrd -> consumeWord s idx wrd
1982− SplitOnSeqWordLoop s wrd -> consumeWord s patLen wrd
1983− SplitOnSeqKR s idx rb _ -> consumeRing s idx rb (Ring.startOf rb)
1984− SplitOnSeqKRLoop s _ rb rh -> consumeRing s patLen rb rh
1985−
1986−------------------------------------------------------------------------------
1987−-- Distributing
1988−------------------------------------------------------------------------------
1989−--
1990−-- | Distribute one copy of the stream to each fold and zip the results.
1991−--
1992−-- @
1993−-- |-------Fold m a b--------|
1994−-- ---stream m a---| |---m (b,c)
1995−-- |-------Fold m a c--------|
1996−-- @
1997−--
1998−-- Definition:
1999−--
2000−-- >>> tee = Fold.teeWith (,)
2001−--
2002−-- Example:
2003−--
2004−-- >>> t = Fold.tee Fold.sum Fold.length
2005−-- >>> Stream.fold t (Stream.enumerateFromTo 1.0 100.0)
2006−-- (5050.0,100)
2007−--
2008−{-# INLINE tee #-}
2009−tee :: Monad m => Fold m a b -> Fold m a c -> Fold m a (b,c)
2010−tee = teeWith (,)
2011−
2012−-- XXX use "List" instead of "[]"?, use Array for output to scale it to a large
2013−-- number of consumers? For polymorphic case a vector could be helpful. For
2014−-- Storables we can use arrays. Will need separate APIs for those.
2015−--
2016−-- | Distribute one copy of the stream to each fold and collect the results in
2017−-- a container.
2018−--
2019−-- @
2020−--
2021−-- |-------Fold m a b--------|
2022−-- ---stream m a---| |---m [b]
2023−-- |-------Fold m a b--------|
2024−-- | |
2025−-- ...
2026−-- @
2027−--
2028−-- >>> Stream.fold (Fold.distribute [Fold.sum, Fold.length]) (Stream.enumerateFromTo 1 5)
2029−-- [15,5]
2030−--
2031−-- >>> distribute = Prelude.foldr (Fold.teeWith (:)) (Fold.fromPure [])
2032−--
2033−-- This is the consumer side dual of the producer side 'sequence' operation.
2034−--
2035−-- Stops when all the folds stop.
2036−--
2037−{-# INLINE distribute #-}
2038−distribute :: Monad m => [Fold m a b] -> Fold m a [b]
2039−distribute = Prelude.foldr (teeWith (:)) (fromPure [])
2040−
2041−------------------------------------------------------------------------------
2042−-- Partitioning
2043−------------------------------------------------------------------------------
2044−
2045−{-# INLINE partitionByMUsing #-}
2046−partitionByMUsing :: Monad m =>
2047− ( (x -> y -> (x, y))
2048− -> Fold m (Either b c) x
2049− -> Fold m (Either b c) y
2050− -> Fold m (Either b c) (x, y)
2051− )
2052− -> (a -> m (Either b c))
2053− -> Fold m b x
2054− -> Fold m c y
2055− -> Fold m a (x, y)
2056−partitionByMUsing t f fld1 fld2 =
2057− let l = lmap (fromLeft undefined) fld1 -- :: Fold m (Either b c) x
2058− r = lmap (fromRight undefined) fld2 -- :: Fold m (Either b c) y
2059− in lmapM f (t (,) (filter isLeft l) (filter isRight r))
2060−
2061−-- | Partition the input over two folds using an 'Either' partitioning
2062−-- predicate.
2063−--
2064−-- @
2065−--
2066−-- |-------Fold b x--------|
2067−-- -----stream m a --> (Either b c)----| |----(x,y)
2068−-- |-------Fold c y--------|
2069−-- @
2070−--
2071−-- Example, send input to either fold randomly:
2072−--
2073−-- >>> import System.Random (randomIO)
2074−-- >>> randomly a = randomIO >>= \x -> return $ if x then Left a else Right a
2075−-- >>> f = Fold.partitionByM randomly Fold.length Fold.length
2076−-- >>> Stream.fold f (Stream.enumerateFromTo 1 100)
2077−-- ...
2078−--
2079−-- Example, send input to the two folds in a proportion of 2:1:
2080−--
2081−-- >>> :{
2082−-- proportionately m n = do
2083−-- ref <- newIORef $ cycle $ concat [replicate m Left, replicate n Right]
2084−-- return $ \a -> do
2085−-- r <- readIORef ref
2086−-- writeIORef ref $ tail r
2087−-- return $ Prelude.head r a
2088−-- :}
2089−--
2090−-- >>> :{
2091−-- main = do
2092−-- g <- proportionately 2 1
2093−-- let f = Fold.partitionByM g Fold.length Fold.length
2094−-- r <- Stream.fold f (Stream.enumerateFromTo (1 :: Int) 100)
2095−-- print r
2096−-- :}
2097−--
2098−-- >>> main
2099−-- (67,33)
2100−--
2101−--
2102−-- This is the consumer side dual of the producer side 'mergeBy' operation.
2103−--
2104−-- When one fold is done, any input meant for it is ignored until the other
2105−-- fold is also done.
2106−--
2107−-- Stops when both the folds stop.
2108−--
2109−-- /See also: 'partitionByFstM' and 'partitionByMinM'./
2110−--
2111−-- /Pre-release/
2112−{-# INLINE partitionByM #-}
2113−partitionByM :: Monad m
2114− => (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2115−partitionByM = partitionByMUsing teeWith
2116−
2117−-- | Similar to 'partitionByM' but terminates when the first fold terminates.
2118−--
2119−{-# INLINE partitionByFstM #-}
2120−partitionByFstM :: Monad m
2121− => (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2122−partitionByFstM = partitionByMUsing teeWithFst
2123−
2124−-- | Similar to 'partitionByM' but terminates when any fold terminates.
2125−--
2126−{-# INLINE partitionByMinM #-}
2127−partitionByMinM :: Monad m =>
2128− (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2129−partitionByMinM = partitionByMUsing teeWithMin
2130−
2131−-- Note: we could use (a -> Bool) instead of (a -> Either b c), but the latter
2132−-- makes the signature clearer as to which case belongs to which fold.
2133−-- XXX need to check the performance in both cases.
2134−
2135−-- | Same as 'partitionByM' but with a pure partition function.
2136−--
2137−-- Example, count even and odd numbers in a stream:
2138−--
2139−-- >>> :{
2140−-- let f = Fold.partitionBy (\n -> if even n then Left n else Right n)
2141−-- (fmap (("Even " ++) . show) Fold.length)
2142−-- (fmap (("Odd " ++) . show) Fold.length)
2143−-- in Stream.fold f (Stream.enumerateFromTo 1 100)
2144−-- :}
2145−-- ("Even 50","Odd 50")
2146−--
2147−-- /Pre-release/
2148−{-# INLINE partitionBy #-}
2149−partitionBy :: Monad m
2150− => (a -> Either b c) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2151−partitionBy f = partitionByM (return . f)
2152−
2153−-- | Compose two folds such that the combined fold accepts a stream of 'Either'
2154−-- and routes the 'Left' values to the first fold and 'Right' values to the
2155−-- second fold.
2156−--
2157−-- Definition:
2158−--
2159−-- >>> partition = Fold.partitionBy id
2160−--
2161−{-# INLINE partition #-}
2162−partition :: Monad m
2163− => Fold m b x -> Fold m c y -> Fold m (Either b c) (x, y)
2164−partition = partitionBy id
2165−
2166−{-
2167−-- | Send one item to each fold in a round-robin fashion. This is the consumer
2168−-- side dual of producer side 'mergeN' operation.
2169−--
2170−-- partitionN :: Monad m => [Fold m a b] -> Fold m a [b]
2171−-- partitionN fs = Fold step begin done
2172−-}
2173−
2174−------------------------------------------------------------------------------
2175−-- Unzipping
2176−------------------------------------------------------------------------------
2177−
2178−{-# INLINE unzipWithMUsing #-}
2179−unzipWithMUsing :: Monad m =>
2180− ( (x -> y -> (x, y))
2181− -> Fold m (b, c) x
2182− -> Fold m (b, c) y
2183− -> Fold m (b, c) (x, y)
2184− )
2185− -> (a -> m (b, c))
2186− -> Fold m b x
2187− -> Fold m c y
2188− -> Fold m a (x, y)
2189−unzipWithMUsing t f fld1 fld2 =
2190− let f1 = lmap fst fld1 -- :: Fold m (b, c) b
2191− f2 = lmap snd fld2 -- :: Fold m (b, c) c
2192− in lmapM f (t (,) f1 f2)
2193−
2194−-- | Like 'unzipWith' but with a monadic splitter function.
2195−--
2196−-- Definition:
2197−--
2198−-- >>> unzipWithM k f1 f2 = Fold.lmapM k (Fold.unzip f1 f2)
2199−--
2200−-- /Pre-release/
2201−{-# INLINE unzipWithM #-}
2202−unzipWithM :: Monad m
2203− => (a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2204−unzipWithM = unzipWithMUsing teeWith
2205−
2206−-- | Similar to 'unzipWithM' but terminates when the first fold terminates.
2207−--
2208−{-# INLINE unzipWithFstM #-}
2209−unzipWithFstM :: Monad m =>
2210− (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2211−unzipWithFstM = unzipWithMUsing teeWithFst
2212−
2213−-- | Similar to 'unzipWithM' but terminates when any fold terminates.
2214−--
2215−{-# INLINE unzipWithMinM #-}
2216−unzipWithMinM :: Monad m =>
2217− (a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2218−unzipWithMinM = unzipWithMUsing teeWithMin
2219−
2220−-- | Split elements in the input stream into two parts using a pure splitter
2221−-- function, direct each part to a different fold and zip the results.
2222−--
2223−-- Definitions:
2224−--
2225−-- >>> unzipWith f = Fold.unzipWithM (return . f)
2226−-- >>> unzipWith f fld1 fld2 = Fold.lmap f (Fold.unzip fld1 fld2)
2227−--
2228−-- This fold terminates when both the input folds terminate.
2229−--
2230−-- /Pre-release/
2231−{-# INLINE unzipWith #-}
2232−unzipWith :: Monad m
2233− => (a -> (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2234−unzipWith f = unzipWithM (return . f)
2235−
2236−-- | Send the elements of tuples in a stream of tuples through two different
2237−-- folds.
2238−--
2239−-- @
2240−--
2241−-- |-------Fold m a x--------|
2242−-- ---------stream of (a,b)--| |----m (x,y)
2243−-- |-------Fold m b y--------|
2244−--
2245−-- @
2246−--
2247−-- Definition:
2248−--
2249−-- >>> unzip = Fold.unzipWith id
2250−--
2251−-- This is the consumer side dual of the producer side 'zip' operation.
2252−--
2253−{-# INLINE unzip #-}
2254−unzip :: Monad m => Fold m a x -> Fold m b y -> Fold m (a,b) (x,y)
2255−unzip = unzipWith id
2256−
2257−------------------------------------------------------------------------------
2258−-- Combining streams and folds - Zipping
2259−------------------------------------------------------------------------------
2260−
2261−-- XXX These can be implemented using the fold scan, using the stream as a
2262−-- state.
2263−-- XXX Stream Skip state cannot be efficiently handled in folds but can be
2264−-- handled in parsers using the Continue facility. See zipWithM in the Parser
2265−-- module.
2266−--
2267−-- cmpBy, eqBy, isPrefixOf, isSubsequenceOf etc can be implemented using
2268−-- zipStream.
2269−
2270−-- | Zip a stream with the input of a fold using the supplied function.
2271−--
2272−-- /Unimplemented/
2273−--
2274−{-# INLINE zipStreamWithM #-}
2275−zipStreamWithM :: -- Monad m =>
2276− (a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
2277−zipStreamWithM = undefined
2278−
2279−-- | Zip a stream with the input of a fold.
2280−--
2281−-- >>> zip = Fold.zipStreamWithM (curry return)
2282−--
2283−-- /Unimplemented/
2284−--
2285−{-# INLINE zipStream #-}
2286−zipStream :: Monad m => Stream m a -> Fold m (a, b) x -> Fold m b x
2287−zipStream = zipStreamWithM (curry return)
2288−
2289−-- | Pair each element of a fold input with its index, starting from index 0.
2290−--
2291−{-# INLINE indexingWith #-}
2292−indexingWith :: Monad m => Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
2293−indexingWith i f = fmap toMaybe $ foldl' step initial
2294−
2295− where
2296−
2297− initial = Nothing'
2298−
2299− step Nothing' a = Just' (i, a)
2300− step (Just' (n, _)) a = Just' (f n, a)
2301−
2302−-- |
2303−-- >>> indexing = Fold.indexingWith 0 (+ 1)
2304−--
2305−{-# INLINE indexing #-}
2306−indexing :: Monad m => Fold m a (Maybe (Int, a))
2307−indexing = indexingWith 0 (+ 1)
2308−
2309−-- |
2310−-- >>> indexingRev n = Fold.indexingWith n (subtract 1)
2311−--
2312−{-# INLINE indexingRev #-}
2313−indexingRev :: Monad m => Int -> Fold m a (Maybe (Int, a))
2314−indexingRev n = indexingWith n (subtract 1)
2315−
2316−-- | Pair each element of a fold input with its index, starting from index 0.
2317−--
2318−-- >>> indexed = Fold.scanMaybe Fold.indexing
2319−--
2320−{-# INLINE indexed #-}
2321−indexed :: Monad m => Fold m (Int, a) b -> Fold m a b
2322−indexed = scanMaybe indexing
2323−
2324−-- | Change the predicate function of a Fold from @a -> b@ to accept an
2325−-- additional state input @(s, a) -> b@. Convenient to filter with an
2326−-- addiitonal index or time input.
2327−--
2328−-- >>> filterWithIndex = Fold.with Fold.indexed Fold.filter
2329−--
2330−-- @
2331−-- filterWithAbsTime = with timestamped filter
2332−-- filterWithRelTime = with timeIndexed filter
2333−-- @
2334−--
2335−-- /Pre-release/
2336−{-# INLINE with #-}
2337−with ::
2338− (Fold m (s, a) b -> Fold m a b)
2339− -> (((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b)
2340− -> (((s, a) -> c) -> Fold m a b -> Fold m a b)
2341−with f comb g = f . comb g . lmap snd
2342−
2343−-- XXX Implement as a filter
2344−-- sampleFromthen :: Monad m => Int -> Int -> Fold m a (Maybe a)
2345−
2346−-- | @sampleFromthen offset stride@ samples the element at @offset@ index and
2347−-- then every element at strides of @stride@.
2348−--
2349−{-# INLINE sampleFromthen #-}
2350−sampleFromthen :: Monad m => Int -> Int -> Fold m a b -> Fold m a b
2351−sampleFromthen offset size =
2352− with indexed filter (\(i, _) -> (i + offset) `mod` size == 0)
2353−
2354−------------------------------------------------------------------------------
2355−-- Nesting
2356−------------------------------------------------------------------------------
2357−
2358−-- | @concatSequence f t@ applies folds from stream @t@ sequentially and
2359−-- collects the results using the fold @f@.
2360−--
2361−-- /Unimplemented/
2362−--
2363−{-# INLINE concatSequence #-}
2364−concatSequence ::
2365− -- IsStream t =>
2366− Fold m b c -> t (Fold m a b) -> Fold m a c
2367−concatSequence _f _p = undefined
2368−
2369−-- | Group the input stream into groups of elements between @low@ and @high@.
2370−-- Collection starts in chunks of @low@ and then keeps doubling until we reach
2371−-- @high@. Each chunk is folded using the provided fold function.
2372−--
2373−-- This could be useful, for example, when we are folding a stream of unknown
2374−-- size to a stream of arrays and we want to minimize the number of
2375−-- allocations.
2376−--
2377−-- NOTE: this would be an application of "many" using a terminating fold.
2378−--
2379−-- /Unimplemented/
2380−--
2381−{-# INLINE chunksBetween #-}
2382−chunksBetween :: -- Monad m =>
2383− Int -> Int -> Fold m a b -> Fold m b c -> Fold m a c
2384−chunksBetween _low _high _f1 _f2 = undefined
2385−
2386−-- | A fold that buffers its input to a pure stream.
2387−--
2388−-- /Warning!/ working on large streams accumulated as buffers in memory could
2389−-- be very inefficient, consider using "Streamly.Data.Array" instead.
2390−--
2391−-- >>> toStream = fmap Stream.fromList Fold.toList
2392−--
2393−-- /Pre-release/
2394−{-# INLINE toStream #-}
2395−toStream :: (Monad m, Monad n) => Fold m a (Stream n a)
2396−toStream = fmap StreamD.fromList toList
2397−
2398−-- This is more efficient than 'toStream'. toStream is exactly the same as
2399−-- reversing the stream after toStreamRev.
2400−--
2401−-- | Buffers the input stream to a pure stream in the reverse order of the
2402−-- input.
2403−--
2404−-- >>> toStreamRev = fmap Stream.fromList Fold.toListRev
2405−--
2406−-- /Warning!/ working on large streams accumulated as buffers in memory could
2407−-- be very inefficient, consider using "Streamly.Data.Array" instead.
2408−--
2409−-- /Pre-release/
2410−
2411−-- xn : ... : x2 : x1 : []
2412−{-# INLINE toStreamRev #-}
2413−toStreamRev :: (Monad m, Monad n) => Fold m a (Stream n a)
2414−toStreamRev = fmap StreamD.fromList toListRev
2415−
2416−-- XXX This does not fuse. It contains a recursive step function. We will need
2417−-- a Skip input constructor in the fold type to make it fuse.
2418−--
2419−-- | Unfold and flatten the input stream of a fold.
2420−--
2421−-- @
2422−-- Stream.fold (unfoldMany u f) = Stream.fold f . Stream.unfoldMany u
2423−-- @
2424−--
2425−-- /Pre-release/
2426−{-# INLINE unfoldMany #-}
2427−unfoldMany :: Monad m => Unfold m a b -> Fold m b c -> Fold m a c
2428−unfoldMany (Unfold ustep inject) (Fold fstep initial extract) =
2429− Fold consume initial extract
2430−
2431− where
2432−
2433− {-# INLINE produce #-}
2434− produce fs us = do
2435− ures <- ustep us
2436− case ures of
2437− StreamD.Yield b us1 -> do
2438− fres <- fstep fs b
2439− case fres of
2440− Partial fs1 -> produce fs1 us1
2441− -- XXX What to do with the remaining stream?
2442− Done c -> return $ Done c
2443− StreamD.Skip us1 -> produce fs us1
2444− StreamD.Stop -> return $ Partial fs
2445−
2446− {-# INLINE_LATE consume #-}
2447− consume s a = inject a >>= produce s
2448−
2449−-- | Get the bottom most @n@ elements using the supplied comparison function.
2450−--
2451−{-# INLINE bottomBy #-}
2452−bottomBy :: (MonadIO m, Unbox a) =>
2453− (a -> a -> Ordering)
2454− -> Int
2455− -> Fold m a (MutArray a)
2456−bottomBy cmp n = Fold step initial extract
2457−
2458− where
2459−
2460− initial = do
2461− arr <- MA.newPinned n
2462− if n <= 0
2463− then return $ Done arr
2464− else return $ Partial (arr, 0)
2465−
2466− step (arr, i) x =
2467− if i < n
2468− then do
2469− arr' <- MA.snoc arr x
2470− MA.bubble cmp arr'
2471− return $ Partial (arr', i + 1)
2472− else do
2473− x1 <- MA.getIndexUnsafe (i - 1) arr
2474− case x `cmp` x1 of
2475− LT -> do
2476− MA.putIndexUnsafe (i - 1) arr x
2477− MA.bubble cmp arr
2478− return $ Partial (arr, i)
2479− _ -> return $ Partial (arr, i)
2480−
2481− extract = return . fst
2482−
2483−-- | Get the top @n@ elements using the supplied comparison function.
2484−--
2485−-- To get bottom n elements instead:
2486−--
2487−-- >>> bottomBy cmp = Fold.topBy (flip cmp)
2488−--
2489−-- Example:
2490−--
2491−-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2492−-- >>> Stream.fold (Fold.topBy compare 3) stream >>= MA.toList
2493−-- [17,11,9]
2494−--
2495−-- /Pre-release/
2496−--
2497−{-# INLINE topBy #-}
2498−topBy :: (MonadIO m, Unbox a) =>
2499− (a -> a -> Ordering)
2500− -> Int
2501− -> Fold m a (MutArray a)
2502−topBy cmp = bottomBy (flip cmp)
2503−
2504−-- | Fold the input stream to top n elements.
2505−--
2506−-- Definition:
2507−--
2508−-- >>> top = Fold.topBy compare
2509−--
2510−-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2511−-- >>> Stream.fold (Fold.top 3) stream >>= MA.toList
2512−-- [17,11,9]
2513−--
2514−-- /Pre-release/
2515−{-# INLINE top #-}
2516−top :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
2517−top = bottomBy $ flip compare
2518−
2519−-- | Fold the input stream to bottom n elements.
2520−--
2521−-- Definition:
2522−--
2523−-- >>> bottom = Fold.bottomBy compare
2524−--
2525−-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2526−-- >>> Stream.fold (Fold.bottom 3) stream >>= MA.toList
2527−-- [1,2,3]
2528−--
2529−-- /Pre-release/
2530−{-# INLINE bottom #-}
2531−bottom :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
2532−bottom = bottomBy compare
2533−
2534−------------------------------------------------------------------------------
2535−-- Interspersed parsing
2536−------------------------------------------------------------------------------
2537−
2538−data IntersperseQState fs ps =
2539− IntersperseQUnquoted !fs !ps
2540− | IntersperseQQuoted !fs !ps
2541− | IntersperseQQuotedEsc !fs !ps
2542−
2543−-- Useful for parsing CSV with quoting and escaping
2544−{-# INLINE intersperseWithQuotes #-}
2545−intersperseWithQuotes :: (Monad m, Eq a) =>
2546− a -> a -> a -> Fold m a b -> Fold m b c -> Fold m a c
2547−intersperseWithQuotes
2548− quote
2549− esc
2550− separator
2551− (Fold stepL initialL extractL)
2552− (Fold stepR initialR extractR) = Fold step initial extract
2553−
2554− where
2555−
2556− errMsg p status =
2557− error $ "intersperseWithQuotes: " ++ p ++ " parsing fold cannot "
2558− ++ status ++ " without input"
2559−
2560− {-# INLINE initL #-}
2561− initL mkState = do
2562− resL <- initialL
2563− case resL of
2564− Partial sL ->
2565− return $ Partial $ mkState sL
2566− Done _ ->
2567− errMsg "content" "succeed"
2568−
2569− initial = do
2570− res <- initialR
2571− case res of
2572− Partial sR -> initL (IntersperseQUnquoted sR)
2573− Done b -> return $ Done b
2574−
2575− {-# INLINE collect #-}
2576− collect nextS sR b = do
2577− res <- stepR sR b
2578− case res of
2579− Partial s ->
2580− initL (nextS s)
2581− Done c -> return (Done c)
2582−
2583− {-# INLINE process #-}
2584− process a sL sR nextState = do
2585− r <- stepL sL a
2586− case r of
2587− Partial s -> return $ Partial (nextState sR s)
2588− Done b -> collect nextState sR b
2589−
2590− {-# INLINE processQuoted #-}
2591− processQuoted a sL sR nextState = do
2592− r <- stepL sL a
2593− case r of
2594− Partial s -> return $ Partial (nextState sR s)
2595− Done _ -> error "Collecting fold finished inside quote"
2596−
2597− step (IntersperseQUnquoted sR sL) a
2598− | a == separator = do
2599− b <- extractL sL
2600− collect IntersperseQUnquoted sR b
2601− | a == quote = processQuoted a sL sR IntersperseQQuoted
2602− | otherwise = process a sL sR IntersperseQUnquoted
2603−
2604− step (IntersperseQQuoted sR sL) a
2605− | a == esc = processQuoted a sL sR IntersperseQQuotedEsc
2606− | a == quote = process a sL sR IntersperseQUnquoted
2607− | otherwise = processQuoted a sL sR IntersperseQQuoted
2608−
2609− step (IntersperseQQuotedEsc sR sL) a =
2610− processQuoted a sL sR IntersperseQQuoted
2611−
2612− extract (IntersperseQUnquoted sR _) = extractR sR
2613− extract (IntersperseQQuoted _ _) =
2614− error "intersperseWithQuotes: finished inside quote"
2615− extract (IntersperseQQuotedEsc _ _) =
2616− error "intersperseWithQuotes: finished inside quote, at escape char"
33+#include "DocTestDataFold.hs"
core/src/Streamly/Internal/Data/Fold/Chunked.hs+23−21
@@ -6,7 +6,7 @@
66-- Stability : experimental
77-- Portability : GHC
88--
9−-- Use "Streamly.Data.Parser.Chunked" instead.
9+-- Use "Streamly.Data.Parser" instead.
1010--
1111-- Fold a stream of foreign arrays. @Fold m a b@ in this module works
1212-- on a stream of "Array a" and produces an output of type @b@.
@@ -19,18 +19,19 @@
1919-- folds in Data.Fold to correctly work on an array stream as if it is an
2020-- element stream. For example:
2121--
22−-- >>> import qualified Streamly.Data.Fold as Fold
23−-- >>> import qualified Streamly.Internal.Data.Stream.Chunked as ArrayStream
24−-- >>> import qualified Streamly.Internal.Data.Fold.Chunked as ChunkFold
25−-- >>> import qualified Streamly.Data.Stream as Stream
26−-- >>> import qualified Streamly.Data.StreamK as StreamK
22+-- >> import qualified Streamly.Data.Fold as Fold
23+-- >> import qualified Streamly.Internal.Data.Array.Stream as ArrayStream
24+-- >> import qualified Streamly.Internal.Data.Fold.Chunked as ChunkFold
25+-- >> import qualified Streamly.Data.Stream as Stream
26+-- >> import qualified Streamly.Data.StreamK as StreamK
2727--
28−-- >>> f = ChunkFold.fromFold (Fold.take 7 Fold.toList)
29−-- >>> s = Stream.chunksOf 5 $ Stream.fromList "hello world"
30−-- >>> ArrayStream.runArrayFold f (StreamK.fromStream s)
28+-- >> f = ChunkFold.fromFold (Fold.take 7 Fold.toList)
29+-- >> s = Stream.chunksOf 5 $ Stream.fromList "hello world"
30+-- >> ArrayStream.runArrayFold f (StreamK.fromStream s)
3131-- Right "hello w"
3232--
3333module Streamly.Internal.Data.Fold.Chunked
34+ {-# DEPRECATED "Please use Streamly.Data.Parser instead." #-}
3435 (
3536 ChunkFold (..)
3637
@@ -58,22 +59,22 @@ where
5859
5960#include "ArrayMacros.h"
6061
62+#if !MIN_VERSION_base(4,18,0)
6163import Control.Applicative (liftA2)
64+#endif
6265import Control.Exception (assert)
6366import Control.Monad.IO.Class (MonadIO(..))
6467import Data.Bifunctor (first)
6568import Data.Proxy (Proxy(..))
66−import Streamly.Internal.Data.Unboxed (peekWith, sizeOf, Unbox)
69+import Streamly.Internal.Data.Unbox (Unbox(..))
6770import GHC.Types (SPEC(..))
68−import Streamly.Internal.Data.Array.Mut.Type (touch)
69−import Streamly.Internal.Data.Array.Type (Array(..))
70−import Streamly.Internal.Data.Parser.ParserD (Initial(..), Step(..))
71+import Streamly.Internal.Data.Array (Array(..))
72+import Streamly.Internal.Data.Parser (Initial(..), Step(..))
7173import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
7274
73−import qualified Streamly.Internal.Data.Array as Array
75+import qualified Streamly.Internal.Data.Array.Type as Array
7476import qualified Streamly.Internal.Data.Fold as Fold
75−import qualified Streamly.Internal.Data.Parser.ParserD as ParserD
76−import qualified Streamly.Internal.Data.Parser.ParserD.Type as ParserD
77+import qualified Streamly.Internal.Data.Parser as ParserD
7778import qualified Streamly.Internal.Data.Parser as Parser
7879
7980import Prelude hiding (concatMap, take)
@@ -102,8 +103,8 @@ newtype ChunkFold m a b = ChunkFold (ParserD.Parser (Array a) m b)
102103{-# INLINE fromFold #-}
103104fromFold :: forall m a b. (MonadIO m, Unbox a) =>
104105 Fold.Fold m a b -> ChunkFold m a b
105−fromFold (Fold.Fold fstep finitial fextract) =
106− ChunkFold (ParserD.Parser step initial (fmap (Done 0) . fextract))
106+fromFold (Fold.Fold fstep finitial _ ffinal) =
107+ ChunkFold (ParserD.Parser step initial extract)
107108
108109 where
109110
@@ -123,7 +124,7 @@ fromFold (Fold.Fold fstep finitial fextract) =
123124 assert (cur == end) (return ())
124125 return $ Partial 0 fs
125126 goArray !_ !cur !fs = do
126− x <- liftIO $ peekWith contents cur
127+ x <- liftIO $ peekAt cur contents
127128 res <- fstep fs x
128129 let elemSize = SIZE_OF(a)
129130 next = INDEX_NEXT(cur,a)
@@ -133,6 +134,8 @@ fromFold (Fold.Fold fstep finitial fextract) =
133134 Fold.Partial fs1 ->
134135 goArray SPEC next fs1
135136
137+ extract = fmap (Done 0) . ffinal
138+
136139-- | Convert an element 'ParserD.Parser' into an array stream fold. If the
137140-- parser fails the fold would throw an exception.
138141--
@@ -160,8 +163,7 @@ fromParserD (ParserD.Parser step1 initial1 extract1) =
160163 else return $ st (arrRem + n) fs1
161164
162165 goArray !_ !cur !fs = do
163− x <- liftIO $ peekWith contents cur
164− liftIO $ touch contents
166+ x <- liftIO $ peekAt cur contents
165167 res <- step1 fs x
166168 let elemSize = SIZE_OF(a)
167169 next = INDEX_NEXT(cur,a)
core/src/Streamly/Internal/Data/Fold/Combinators.hsnew file+2452
@@ -0,0 +1,2452 @@
1+{-# LANGUAGE CPP #-}
2+-- |
3+-- Module : Streamly.Internal.Data.Fold.Combinators
4+-- Copyright : (c) 2019 Composewell Technologies
5+-- (c) 2013 Gabriel Gonzalez
6+-- License : BSD3
7+-- Maintainer : streamly@composewell.com
8+-- Stability : experimental
9+-- Portability : GHC
10+--
11+-- See "Streamly.Data.Fold" for an overview and
12+-- "Streamly.Internal.Data.Fold.Type" for design notes.
13+
14+module Streamly.Internal.Data.Fold.Combinators
15+ (
16+ -- * Mappers
17+ -- | Monadic functions useful with mapM/lmapM on folds or streams.
18+ tracing
19+ , trace
20+
21+ -- * Folds
22+
23+ -- ** Accumulators
24+ -- *** Semigroups and Monoids
25+ , sconcat
26+ , mconcat
27+ , foldMap
28+ , foldMapM
29+
30+ -- *** Reducers
31+ , drainMapM
32+ , the
33+ , mean
34+ , rollingHash
35+ , defaultSalt
36+ , rollingHashWithSalt
37+ , rollingHashFirstN
38+ -- , rollingHashLastN
39+
40+ -- *** Saturating Reducers
41+ -- | 'product' terminates if it becomes 0. Other folds can theoretically
42+ -- saturate on bounded types, and therefore terminate, however, they will
43+ -- run forever on unbounded types like Integer/Double.
44+ , sum
45+ , product
46+ , maximumBy
47+ , maximum
48+ , minimumBy
49+ , minimum
50+
51+ -- *** Collectors
52+ -- | Avoid using these folds in scalable or performance critical
53+ -- applications, they buffer all the input in GC memory which can be
54+ -- detrimental to performance if the input is large.
55+ , toListRev
56+ -- $toListRev
57+ , toStream
58+ , toStreamRev
59+ , topBy
60+ , top
61+ , bottomBy
62+ , bottom
63+
64+ -- *** Scanners
65+ -- | Stateful transformation of the elements. Useful in combination with
66+ -- the 'scanMaybe' combinator. For scanners the result of the fold is
67+ -- usually a transformation of the current element rather than an
68+ -- aggregation of all elements till now.
69+ , latest
70+ -- , nthLast -- using Ring array
71+ , indexingWith
72+ , indexing
73+ , indexingRev
74+ , rollingMapM
75+
76+ -- *** Filters
77+ -- | Useful in combination with the 'scanMaybe' combinator.
78+ , deleteBy
79+ , uniqBy
80+ , uniq
81+ , repeated
82+ , findIndices
83+ , elemIndices
84+
85+ -- *** Singleton folds
86+ -- | Folds that terminate after consuming exactly one input element. All
87+ -- these can be implemented in terms of the 'maybe' fold.
88+ , one
89+ , null -- XXX not very useful and could be problematic, remove it?
90+ , satisfy
91+ , maybe
92+
93+ -- *** Multi folds
94+ -- | Terminate after consuming one or more elements.
95+ , drainN
96+ -- , lastN
97+ -- , (!!)
98+ , indexGeneric
99+ , index
100+ , findM
101+ , find
102+ , lookup
103+ , findIndex
104+ , elemIndex
105+ , elem
106+ , notElem
107+ , all
108+ , any
109+ , and
110+ , or
111+
112+ -- ** Trimmers
113+ -- | Useful in combination with the 'scanMaybe' combinator.
114+ , takingEndByM
115+ , takingEndBy
116+ , takingEndByM_
117+ , takingEndBy_
118+ , droppingWhileM
119+ , droppingWhile
120+ , prune
121+
122+ -- * Running A Fold
123+ , drive
124+ -- , breakStream
125+
126+ -- * Building Incrementally
127+ , addStream
128+
129+ -- * Combinators
130+ -- ** Utilities
131+ , with
132+
133+ -- ** Mapping on Input
134+ , transform
135+
136+ -- ** Sliding Window
137+ , slide2
138+
139+ -- ** Scanning Input
140+ , scan
141+ , scanMany
142+ , indexed
143+
144+ -- ** Zipping Input
145+ , zipStreamWithM
146+ , zipStream
147+
148+ -- ** Filtering Input
149+ , mapMaybeM
150+ , mapMaybe
151+ , sampleFromthen
152+
153+ {-
154+ -- ** Insertion
155+ -- | Insertion adds more elements to the stream.
156+
157+ , insertBy
158+ , intersperseM
159+
160+ -- ** Reordering
161+ , reverse
162+ -}
163+
164+ -- ** Trimming
165+
166+ -- By elements
167+ , takeEndBySeq
168+ , takeEndBySeq_
169+ {-
170+ , drop
171+ , dropWhile
172+ , dropWhileM
173+ -}
174+
175+ -- ** Serial Append
176+ -- , tail
177+ -- , init
178+ , splitAt -- spanN
179+ -- , splitIn -- sessionN
180+
181+ -- ** Parallel Distribution
182+ , tee
183+ , distribute
184+ -- , distributeFst
185+ -- , distributeMin
186+
187+ -- ** Unzipping
188+ , unzip
189+ -- These two can be expressed using lmap/lmapM and unzip
190+ , unzipWith
191+ , unzipWithM
192+ , unzipWithFstM
193+ , unzipWithMinM
194+
195+ -- ** Partitioning
196+ , partitionByM
197+ , partitionByFstM
198+ , partitionByMinM
199+ , partitionBy
200+ , partition
201+
202+ -- ** Splitting
203+ , chunksBetween
204+ , intersperseWithQuotes
205+
206+ -- ** Nesting
207+ , unfoldMany
208+ , concatSequence
209+
210+ -- * Deprecated
211+ , drainBy
212+ , last
213+ , head
214+ , sequence
215+ , mapM
216+ , variance
217+ , stdDev
218+ )
219+where
220+
221+#include "inline.hs"
222+#include "ArrayMacros.h"
223+
224+import Control.Monad (void)
225+import Control.Monad.IO.Class (MonadIO(..))
226+import Data.Bifunctor (first)
227+import Data.Bits (shiftL, shiftR, (.|.), (.&.))
228+import Data.Either (isLeft, isRight, fromLeft, fromRight)
229+import Data.Int (Int64)
230+import Data.Proxy (Proxy(..))
231+import Data.Word (Word32)
232+import Foreign.Storable (Storable, peek)
233+import Streamly.Internal.Data.MutArray.Type (MutArray(..))
234+import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
235+import Streamly.Internal.Data.Pipe.Type (Pipe (..), PipeState(..))
236+import Streamly.Internal.Data.Unbox (Unbox, sizeOf)
237+import Streamly.Internal.Data.Unfold.Type (Unfold(..))
238+import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
239+import Streamly.Internal.Data.Stream.Type (Stream)
240+
241+import qualified Prelude
242+import qualified Streamly.Internal.Data.MutArray.Type as MA
243+import qualified Streamly.Internal.Data.Array.Type as Array
244+import qualified Streamly.Internal.Data.Fold.Window as Fold
245+import qualified Streamly.Internal.Data.Pipe.Type as Pipe
246+import qualified Streamly.Internal.Data.Ring as Ring
247+import qualified Streamly.Internal.Data.Stream.Type as StreamD
248+
249+import Prelude hiding
250+ ( Foldable(..), filter, drop, dropWhile, take, takeWhile, zipWith
251+ , map, mapM_, sequence, all, any
252+ , notElem, head, last, tail
253+ , reverse, iterate, init, and, or, lookup, (!!)
254+ , scanl, scanl1, replicate, concatMap, mconcat, unzip
255+ , span, splitAt, break, mapM, zip, maybe)
256+import Streamly.Internal.Data.Fold.Type
257+
258+#include "DocTestDataFold.hs"
259+
260+------------------------------------------------------------------------------
261+-- Running
262+------------------------------------------------------------------------------
263+
264+-- | Drive a fold using the supplied 'Stream', reducing the resulting
265+-- expression strictly at each step.
266+--
267+-- Definition:
268+--
269+-- >>> drive = flip Stream.fold
270+--
271+-- Example:
272+--
273+-- >>> Fold.drive (Stream.enumerateFromTo 1 100) Fold.sum
274+-- 5050
275+--
276+{-# INLINE drive #-}
277+drive :: Monad m => Stream m a -> Fold m a b -> m b
278+drive = flip StreamD.fold
279+
280+{-
281+-- | Like 'drive' but also returns the remaining stream. The resulting stream
282+-- would be 'Stream.nil' if the stream finished before the fold.
283+--
284+-- Definition:
285+--
286+-- >>> breakStream = flip Stream.foldBreak
287+--
288+-- /CPS/
289+--
290+{-# INLINE breakStreamK #-}
291+breakStreamK :: Monad m => StreamK m a -> Fold m a b -> m (b, StreamK m a)
292+breakStreamK strm fl = fmap f $ K.foldBreak fl (Stream.toStreamK strm)
293+
294+ where
295+
296+ f (b, str) = (b, Stream.fromStreamK str)
297+-}
298+
299+-- | Append a stream to a fold to build the fold accumulator incrementally. We
300+-- can repeatedly call 'addStream' on the same fold to continue building the
301+-- fold and finally use 'drive' to finish the fold and extract the result. Also
302+-- see the 'Streamly.Data.Fold.addOne' operation which is a singleton version
303+-- of 'addStream'.
304+--
305+-- Definitions:
306+--
307+-- >>> addStream stream = Fold.drive stream . Fold.duplicate
308+--
309+-- Example, build a list incrementally:
310+--
311+-- >>> :{
312+-- pure (Fold.toList :: Fold IO Int [Int])
313+-- >>= Fold.addOne 1
314+-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
315+-- >>= Fold.drive Stream.nil
316+-- >>= print
317+-- :}
318+-- [1,2,3,4]
319+--
320+-- This can be used as an O(n) list append compared to the O(n^2) @++@ when
321+-- used for incrementally building a list.
322+--
323+-- Example, build a stream incrementally:
324+--
325+-- >>> :{
326+-- pure (Fold.toStream :: Fold IO Int (Stream Identity Int))
327+-- >>= Fold.addOne 1
328+-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
329+-- >>= Fold.drive Stream.nil
330+-- >>= print
331+-- :}
332+-- fromList [1,2,3,4]
333+--
334+-- This can be used as an O(n) stream append compared to the O(n^2) @<>@ when
335+-- used for incrementally building a stream.
336+--
337+-- Example, build an array incrementally:
338+--
339+-- >>> :{
340+-- pure (Array.write :: Fold IO Int (Array Int))
341+-- >>= Fold.addOne 1
342+-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
343+-- >>= Fold.drive Stream.nil
344+-- >>= print
345+-- :}
346+-- fromList [1,2,3,4]
347+--
348+-- Example, build an array stream incrementally:
349+--
350+-- >>> :{
351+-- let f :: Fold IO Int (Stream Identity (Array Int))
352+-- f = Fold.groupsOf 2 (Array.writeN 3) Fold.toStream
353+-- in pure f
354+-- >>= Fold.addOne 1
355+-- >>= Fold.addStream (Stream.enumerateFromTo 2 4)
356+-- >>= Fold.drive Stream.nil
357+-- >>= print
358+-- :}
359+-- fromList [fromList [1,2],fromList [3,4]]
360+--
361+addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
362+addStream stream = drive stream . duplicate
363+
364+------------------------------------------------------------------------------
365+-- Transformations on fold inputs
366+------------------------------------------------------------------------------
367+
368+-- | Flatten the monadic output of a fold to pure output.
369+--
370+{-# DEPRECATED sequence "Use \"rmapM id\" instead" #-}
371+{-# INLINE sequence #-}
372+sequence :: Monad m => Fold m a (m b) -> Fold m a b
373+sequence = rmapM id
374+
375+-- | Map a monadic function on the output of a fold.
376+--
377+{-# DEPRECATED mapM "Use rmapM instead" #-}
378+{-# INLINE mapM #-}
379+mapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
380+mapM = rmapM
381+
382+-- |
383+-- >>> mapMaybeM f = Fold.lmapM f . Fold.catMaybes
384+--
385+{-# INLINE mapMaybeM #-}
386+mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Fold m b r -> Fold m a r
387+mapMaybeM f = lmapM f . catMaybes
388+
389+-- | @mapMaybe f fold@ maps a 'Maybe' returning function @f@ on the input of
390+-- the fold, filters out 'Nothing' elements, and return the values extracted
391+-- from 'Just'.
392+--
393+-- >>> mapMaybe f = Fold.lmap f . Fold.catMaybes
394+-- >>> mapMaybe f = Fold.mapMaybeM (return . f)
395+--
396+-- >>> f x = if even x then Just x else Nothing
397+-- >>> fld = Fold.mapMaybe f Fold.toList
398+-- >>> Stream.fold fld (Stream.enumerateFromTo 1 10)
399+-- [2,4,6,8,10]
400+--
401+{-# INLINE mapMaybe #-}
402+mapMaybe :: Monad m => (a -> Maybe b) -> Fold m b r -> Fold m a r
403+mapMaybe f = lmap f . catMaybes
404+
405+------------------------------------------------------------------------------
406+-- Transformations on fold inputs
407+------------------------------------------------------------------------------
408+
409+-- | Apply a monadic function on the input and return the input.
410+--
411+-- >>> Stream.fold (Fold.lmapM (Fold.tracing print) Fold.drain) $ (Stream.enumerateFromTo (1 :: Int) 2)
412+-- 1
413+-- 2
414+--
415+-- /Pre-release/
416+--
417+{-# INLINE tracing #-}
418+tracing :: Monad m => (a -> m b) -> (a -> m a)
419+tracing f x = void (f x) >> return x
420+
421+-- | Apply a monadic function to each element flowing through and discard the
422+-- results.
423+--
424+-- >>> Stream.fold (Fold.trace print Fold.drain) $ (Stream.enumerateFromTo (1 :: Int) 2)
425+-- 1
426+-- 2
427+--
428+-- >>> trace f = Fold.lmapM (Fold.tracing f)
429+--
430+-- /Pre-release/
431+{-# INLINE trace #-}
432+trace :: Monad m => (a -> m b) -> Fold m a r -> Fold m a r
433+trace f = lmapM (tracing f)
434+
435+-- rename to lpipe?
436+--
437+-- | Apply a transformation on a 'Fold' using a 'Pipe'.
438+--
439+-- /Pre-release/
440+{-# INLINE transform #-}
441+transform :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
442+transform (Pipe pstep1 pstep2 pinitial) (Fold fstep finitial fextract ffinal) =
443+ Fold step initial extract final
444+
445+ where
446+
447+ initial = first (Tuple' pinitial) <$> finitial
448+
449+ step (Tuple' ps fs) x = do
450+ r <- pstep1 ps x
451+ go fs r
452+
453+ where
454+
455+ -- XXX use SPEC?
456+ go acc (Pipe.Yield b (Consume ps')) = do
457+ acc' <- fstep acc b
458+ return
459+ $ case acc' of
460+ Partial s -> Partial $ Tuple' ps' s
461+ Done b2 -> Done b2
462+ go acc (Pipe.Yield b (Produce ps')) = do
463+ acc' <- fstep acc b
464+ r <- pstep2 ps'
465+ case acc' of
466+ Partial s -> go s r
467+ Done b2 -> return $ Done b2
468+ go acc (Pipe.Continue (Consume ps')) =
469+ return $ Partial $ Tuple' ps' acc
470+ go acc (Pipe.Continue (Produce ps')) = do
471+ r <- pstep2 ps'
472+ go acc r
473+
474+ extract (Tuple' _ fs) = fextract fs
475+
476+ final (Tuple' _ fs) = ffinal fs
477+
478+{-# INLINE scanWith #-}
479+scanWith :: Monad m => Bool -> Fold m a b -> Fold m b c -> Fold m a c
480+scanWith isMany
481+ (Fold stepL initialL extractL finalL)
482+ (Fold stepR initialR extractR finalR) =
483+ Fold step initial extract final
484+
485+ where
486+
487+ {-# INLINE runStep #-}
488+ runStep actionL sR = do
489+ rL <- actionL
490+ case rL of
491+ Done bL -> do
492+ rR <- stepR sR bL
493+ case rR of
494+ Partial sR1 ->
495+ if isMany
496+ then runStep initialL sR1
497+ else Done <$> finalR sR1
498+ Done bR -> return $ Done bR
499+ Partial sL -> do
500+ !b <- extractL sL
501+ rR <- stepR sR b
502+ case rR of
503+ Partial sR1 -> return $ Partial (sL, sR1)
504+ Done bR -> finalL sL >> return (Done bR)
505+
506+ initial = do
507+ r <- initialR
508+ case r of
509+ Partial sR -> runStep initialL sR
510+ Done b -> return $ Done b
511+
512+ step (sL, sR) x = runStep (stepL sL x) sR
513+
514+ extract = extractR . snd
515+
516+ final (sL, sR) = finalL sL *> finalR sR
517+
518+-- | Scan the input of a 'Fold' to change it in a stateful manner using another
519+-- 'Fold'. The scan stops as soon as the fold terminates.
520+--
521+-- /Pre-release/
522+{-# INLINE scan #-}
523+scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
524+scan = scanWith False
525+
526+-- XXX This does not fuse beacuse of the recursive step. Need to investigate.
527+--
528+-- | Scan the input of a 'Fold' to change it in a stateful manner using another
529+-- 'Fold'. The scan restarts with a fresh state if the fold terminates.
530+--
531+-- /Pre-release/
532+{-# INLINE scanMany #-}
533+scanMany :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
534+scanMany = scanWith True
535+
536+------------------------------------------------------------------------------
537+-- Filters
538+------------------------------------------------------------------------------
539+
540+-- | Returns the latest element omitting the first occurrence that satisfies
541+-- the given equality predicate.
542+--
543+-- Example:
544+--
545+-- >>> input = Stream.fromList [1,3,3,5]
546+-- >>> Stream.fold Fold.toList $ Stream.scanMaybe (Fold.deleteBy (==) 3) input
547+-- [1,3,5]
548+--
549+{-# INLINE_NORMAL deleteBy #-}
550+deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
551+deleteBy eq x0 = fmap extract $ foldl' step (Tuple' False Nothing)
552+
553+ where
554+
555+ step (Tuple' False _) x =
556+ if eq x x0
557+ then Tuple' True Nothing
558+ else Tuple' False (Just x)
559+ step (Tuple' True _) x = Tuple' True (Just x)
560+
561+ extract (Tuple' _ x) = x
562+
563+-- | Provide a sliding window of length 2 elements.
564+--
565+-- See "Streamly.Internal.Data.Fold.Window".
566+--
567+{-# INLINE slide2 #-}
568+slide2 :: Monad m => Fold m (a, Maybe a) b -> Fold m a b
569+slide2 (Fold step1 initial1 extract1 final1) = Fold step initial extract final
570+
571+ where
572+
573+ initial =
574+ first (Tuple' Nothing) <$> initial1
575+
576+ step (Tuple' prev s) cur =
577+ first (Tuple' (Just cur)) <$> step1 s (cur, prev)
578+
579+ extract (Tuple' _ s) = extract1 s
580+
581+ final (Tuple' _ s) = final1 s
582+
583+-- | Return the latest unique element using the supplied comparison function.
584+-- Returns 'Nothing' if the current element is same as the last element
585+-- otherwise returns 'Just'.
586+--
587+-- Example, strip duplicate path separators:
588+--
589+-- >>> input = Stream.fromList "//a//b"
590+-- >>> f x y = x == '/' && y == '/'
591+-- >>> Stream.fold Fold.toList $ Stream.scanMaybe (Fold.uniqBy f) input
592+-- "/a/b"
593+--
594+-- Space: @O(1)@
595+--
596+-- /Pre-release/
597+--
598+{-# INLINE uniqBy #-}
599+uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
600+uniqBy eq = rollingMap f
601+
602+ where
603+
604+ f pre curr =
605+ case pre of
606+ Nothing -> Just curr
607+ Just x -> if x `eq` curr then Nothing else Just curr
608+
609+-- | See 'uniqBy'.
610+--
611+-- Definition:
612+--
613+-- >>> uniq = Fold.uniqBy (==)
614+--
615+{-# INLINE uniq #-}
616+uniq :: (Monad m, Eq a) => Fold m a (Maybe a)
617+uniq = uniqBy (==)
618+
619+-- | Strip all leading and trailing occurrences of an element passing a
620+-- predicate and make all other consecutive occurrences uniq.
621+--
622+-- >> prune p = Stream.dropWhileAround p $ Stream.uniqBy (x y -> p x && p y)
623+--
624+-- @
625+-- > Stream.prune isSpace (Stream.fromList " hello world! ")
626+-- "hello world!"
627+--
628+-- @
629+--
630+-- Space: @O(1)@
631+--
632+-- /Unimplemented/
633+{-# INLINE prune #-}
634+prune ::
635+ -- (Monad m, Eq a) =>
636+ (a -> Bool) -> Fold m a (Maybe a)
637+prune = error "Not implemented yet!"
638+
639+-- | Emit only repeated elements, once.
640+--
641+-- /Unimplemented/
642+repeated :: -- (Monad m, Eq a) =>
643+ Fold m a (Maybe a)
644+repeated = error "Not implemented yet!"
645+
646+------------------------------------------------------------------------------
647+-- Left folds
648+------------------------------------------------------------------------------
649+
650+------------------------------------------------------------------------------
651+-- Run Effects
652+------------------------------------------------------------------------------
653+
654+-- |
655+-- Definitions:
656+--
657+-- >>> drainMapM f = Fold.lmapM f Fold.drain
658+-- >>> drainMapM f = Fold.foldMapM (void . f)
659+--
660+-- Drain all input after passing it through a monadic function. This is the
661+-- dual of mapM_ on stream producers.
662+--
663+{-# INLINE drainMapM #-}
664+drainMapM :: Monad m => (a -> m b) -> Fold m a ()
665+drainMapM f = lmapM f drain
666+
667+{-# DEPRECATED drainBy "Please use 'drainMapM' instead." #-}
668+{-# INLINE drainBy #-}
669+drainBy :: Monad m => (a -> m b) -> Fold m a ()
670+drainBy = drainMapM
671+
672+-- | Returns the latest element of the input stream, if any.
673+--
674+-- >>> latest = Fold.foldl1' (\_ x -> x)
675+-- >>> latest = fmap getLast $ Fold.foldMap (Last . Just)
676+--
677+{-# INLINE latest #-}
678+latest :: Monad m => Fold m a (Maybe a)
679+latest = foldl1' (\_ x -> x)
680+
681+{-# DEPRECATED last "Please use 'latest' instead." #-}
682+{-# INLINE last #-}
683+last :: Monad m => Fold m a (Maybe a)
684+last = latest
685+
686+-- | Terminates with 'Nothing' as soon as it finds an element different than
687+-- the previous one, returns 'the' element if the entire input consists of the
688+-- same element.
689+--
690+{-# INLINE the #-}
691+the :: (Monad m, Eq a) => Fold m a (Maybe a)
692+the = foldt' step initial id
693+
694+ where
695+
696+ initial = Partial Nothing
697+
698+ step Nothing x = Partial (Just x)
699+ step old@(Just x0) x =
700+ if x0 == x
701+ then Partial old
702+ else Done Nothing
703+
704+------------------------------------------------------------------------------
705+-- To Summary
706+------------------------------------------------------------------------------
707+
708+-- | Determine the sum of all elements of a stream of numbers. Returns additive
709+-- identity (@0@) when the stream is empty. Note that this is not numerically
710+-- stable for floating point numbers.
711+--
712+-- >>> sum = Fold.cumulative Fold.windowSum
713+--
714+-- Same as following but numerically stable:
715+--
716+-- >>> sum = Fold.foldl' (+) 0
717+-- >>> sum = fmap Data.Monoid.getSum $ Fold.foldMap Data.Monoid.Sum
718+--
719+{-# INLINE sum #-}
720+sum :: (Monad m, Num a) => Fold m a a
721+sum = Fold.cumulative Fold.windowSum
722+
723+-- | Determine the product of all elements of a stream of numbers. Returns
724+-- multiplicative identity (@1@) when the stream is empty. The fold terminates
725+-- when it encounters (@0@) in its input.
726+--
727+-- Same as the following but terminates on multiplication by @0@:
728+--
729+-- >>> product = fmap Data.Monoid.getProduct $ Fold.foldMap Data.Monoid.Product
730+--
731+{-# INLINE product #-}
732+product :: (Monad m, Num a, Eq a) => Fold m a a
733+product = foldt' step (Partial 1) id
734+
735+ where
736+
737+ step x a =
738+ if a == 0
739+ then Done 0
740+ else Partial $ x * a
741+
742+------------------------------------------------------------------------------
743+-- To Summary (Maybe)
744+------------------------------------------------------------------------------
745+
746+-- | Determine the maximum element in a stream using the supplied comparison
747+-- function.
748+--
749+{-# INLINE maximumBy #-}
750+maximumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
751+maximumBy cmp = foldl1' max'
752+
753+ where
754+
755+ max' x y =
756+ case cmp x y of
757+ GT -> x
758+ _ -> y
759+
760+-- | Determine the maximum element in a stream.
761+--
762+-- Definitions:
763+--
764+-- >>> maximum = Fold.maximumBy compare
765+-- >>> maximum = Fold.foldl1' max
766+--
767+-- Same as the following but without a default maximum. The 'Max' Monoid uses
768+-- the 'minBound' as the default maximum:
769+--
770+-- >>> maximum = fmap Data.Semigroup.getMax $ Fold.foldMap Data.Semigroup.Max
771+--
772+{-# INLINE maximum #-}
773+maximum :: (Monad m, Ord a) => Fold m a (Maybe a)
774+maximum = foldl1' max
775+
776+-- | Computes the minimum element with respect to the given comparison function
777+--
778+{-# INLINE minimumBy #-}
779+minimumBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe a)
780+minimumBy cmp = foldl1' min'
781+
782+ where
783+
784+ min' x y =
785+ case cmp x y of
786+ GT -> y
787+ _ -> x
788+
789+-- | Determine the minimum element in a stream using the supplied comparison
790+-- function.
791+--
792+-- Definitions:
793+--
794+-- >>> minimum = Fold.minimumBy compare
795+-- >>> minimum = Fold.foldl1' min
796+--
797+-- Same as the following but without a default minimum. The 'Min' Monoid uses the
798+-- 'maxBound' as the default maximum:
799+--
800+-- >>> maximum = fmap Data.Semigroup.getMin $ Fold.foldMap Data.Semigroup.Min
801+--
802+{-# INLINE minimum #-}
803+minimum :: (Monad m, Ord a) => Fold m a (Maybe a)
804+minimum = foldl1' min
805+
806+------------------------------------------------------------------------------
807+-- To Summary (Statistical)
808+------------------------------------------------------------------------------
809+
810+-- | Compute a numerically stable arithmetic mean of all elements in the input
811+-- stream.
812+--
813+{-# INLINE mean #-}
814+mean :: (Monad m, Fractional a) => Fold m a a
815+mean = fmap done $ foldl' step begin
816+
817+ where
818+
819+ begin = Tuple' 0 0
820+
821+ step (Tuple' x n) y =
822+ let n1 = n + 1
823+ in Tuple' (x + (y - x) / n1) n1
824+
825+ done (Tuple' x _) = x
826+
827+-- | Compute a numerically stable (population) variance over all elements in
828+-- the input stream.
829+--
830+{-# DEPRECATED variance "Use the streamly-statistics package instead" #-}
831+{-# INLINE variance #-}
832+variance :: (Monad m, Fractional a) => Fold m a a
833+variance = fmap done $ foldl' step begin
834+
835+ where
836+
837+ begin = Tuple3' 0 0 0
838+
839+ step (Tuple3' n mean_ m2) x = Tuple3' n' mean' m2'
840+
841+ where
842+
843+ n' = n + 1
844+ mean' = (n * mean_ + x) / (n + 1)
845+ delta = x - mean_
846+ m2' = m2 + delta * delta * n / (n + 1)
847+
848+ done (Tuple3' n _ m2) = m2 / n
849+
850+-- | Compute a numerically stable (population) standard deviation over all
851+-- elements in the input stream.
852+--
853+{-# DEPRECATED stdDev "Use the streamly-statistics package instead" #-}
854+{-# INLINE stdDev #-}
855+stdDev :: (Monad m, Floating a) => Fold m a a
856+stdDev = sqrt <$> variance
857+
858+-- | Compute an 'Int' sized polynomial rolling hash
859+--
860+-- > H = salt * k ^ n + c1 * k ^ (n - 1) + c2 * k ^ (n - 2) + ... + cn * k ^ 0
861+--
862+-- Where @c1@, @c2@, @cn@ are the elements in the input stream and @k@ is a
863+-- constant.
864+--
865+-- This hash is often used in Rabin-Karp string search algorithm.
866+--
867+-- See https://en.wikipedia.org/wiki/Rolling_hash
868+--
869+{-# INLINE rollingHashWithSalt #-}
870+rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Fold m a Int64
871+rollingHashWithSalt = foldl' step
872+
873+ where
874+
875+ k = 2891336453 :: Int64
876+
877+ step cksum a = cksum * k + fromIntegral (fromEnum a)
878+
879+-- | A default salt used in the implementation of 'rollingHash'.
880+{-# INLINE defaultSalt #-}
881+defaultSalt :: Int64
882+defaultSalt = -2578643520546668380
883+
884+-- | Compute an 'Int' sized polynomial rolling hash of a stream.
885+--
886+-- >>> rollingHash = Fold.rollingHashWithSalt Fold.defaultSalt
887+--
888+{-# INLINE rollingHash #-}
889+rollingHash :: (Monad m, Enum a) => Fold m a Int64
890+rollingHash = rollingHashWithSalt defaultSalt
891+
892+-- | Compute an 'Int' sized polynomial rolling hash of the first n elements of
893+-- a stream.
894+--
895+-- >>> rollingHashFirstN n = Fold.take n Fold.rollingHash
896+--
897+-- /Pre-release/
898+{-# INLINE rollingHashFirstN #-}
899+rollingHashFirstN :: (Monad m, Enum a) => Int -> Fold m a Int64
900+rollingHashFirstN n = take n rollingHash
901+
902+-- XXX Compare this with the implementation in Fold.Window, preferrably use the
903+-- latter if performance is good.
904+
905+-- | Apply a function on every two successive elements of a stream. The first
906+-- argument of the map function is the previous element and the second argument
907+-- is the current element. When processing the very first element in the
908+-- stream, the previous element is 'Nothing'.
909+--
910+-- /Pre-release/
911+--
912+{-# INLINE rollingMapM #-}
913+rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Fold m a b
914+rollingMapM f = Fold step initial extract extract
915+
916+ where
917+
918+ -- XXX We need just a postscan. We do not need an initial result here.
919+ -- Or we can supply a default initial result as an argument to rollingMapM.
920+ initial = return $ Partial (Nothing, error "Empty stream")
921+
922+ step (prev, _) cur = do
923+ x <- f prev cur
924+ return $ Partial (Just cur, x)
925+
926+ extract = return . snd
927+
928+-- |
929+-- >>> rollingMap f = Fold.rollingMapM (\x y -> return $ f x y)
930+--
931+{-# INLINE rollingMap #-}
932+rollingMap :: Monad m => (Maybe a -> a -> b) -> Fold m a b
933+rollingMap f = rollingMapM (\x y -> return $ f x y)
934+
935+------------------------------------------------------------------------------
936+-- Monoidal left folds
937+------------------------------------------------------------------------------
938+
939+-- | Semigroup concat. Append the elements of an input stream to a provided
940+-- starting value.
941+--
942+-- Definition:
943+--
944+-- >>> sconcat = Fold.foldl' (<>)
945+--
946+-- >>> semigroups = fmap Data.Monoid.Sum $ Stream.enumerateFromTo 1 10
947+-- >>> Stream.fold (Fold.sconcat 10) semigroups
948+-- Sum {getSum = 65}
949+--
950+{-# INLINE sconcat #-}
951+sconcat :: (Monad m, Semigroup a) => a -> Fold m a a
952+sconcat = foldl' (<>)
953+
954+-- | Monoid concat. Fold an input stream consisting of monoidal elements using
955+-- 'mappend' and 'mempty'.
956+--
957+-- Definition:
958+--
959+-- >>> mconcat = Fold.sconcat mempty
960+--
961+-- >>> monoids = fmap Data.Monoid.Sum $ Stream.enumerateFromTo 1 10
962+-- >>> Stream.fold Fold.mconcat monoids
963+-- Sum {getSum = 55}
964+--
965+{-# INLINE mconcat #-}
966+mconcat ::
967+ ( Monad m
968+ , Monoid a) => Fold m a a
969+mconcat = sconcat mempty
970+
971+-- |
972+-- Definition:
973+--
974+-- >>> foldMap f = Fold.lmap f Fold.mconcat
975+--
976+-- Make a fold from a pure function that folds the output of the function
977+-- using 'mappend' and 'mempty'.
978+--
979+-- >>> sum = Fold.foldMap Data.Monoid.Sum
980+-- >>> Stream.fold sum $ Stream.enumerateFromTo 1 10
981+-- Sum {getSum = 55}
982+--
983+{-# INLINE foldMap #-}
984+foldMap :: (Monad m, Monoid b) => (a -> b) -> Fold m a b
985+foldMap f = lmap f mconcat
986+
987+-- |
988+-- Definition:
989+--
990+-- >>> foldMapM f = Fold.lmapM f Fold.mconcat
991+--
992+-- Make a fold from a monadic function that folds the output of the function
993+-- using 'mappend' and 'mempty'.
994+--
995+-- >>> sum = Fold.foldMapM (return . Data.Monoid.Sum)
996+-- >>> Stream.fold sum $ Stream.enumerateFromTo 1 10
997+-- Sum {getSum = 55}
998+--
999+{-# INLINE foldMapM #-}
1000+foldMapM :: (Monad m, Monoid b) => (a -> m b) -> Fold m a b
1001+foldMapM act = foldlM' step (pure mempty)
1002+
1003+ where
1004+
1005+ step m a = do
1006+ m' <- act a
1007+ return $! mappend m m'
1008+
1009+------------------------------------------------------------------------------
1010+-- To Containers
1011+------------------------------------------------------------------------------
1012+
1013+-- $toListRev
1014+-- This is more efficient than 'Streamly.Internal.Data.Fold.toList'. toList is
1015+-- exactly the same as reversing the list after 'toListRev'.
1016+
1017+-- | Buffers the input stream to a list in the reverse order of the input.
1018+--
1019+-- Definition:
1020+--
1021+-- >>> toListRev = Fold.foldl' (flip (:)) []
1022+--
1023+-- /Warning!/ working on large lists accumulated as buffers in memory could be
1024+-- very inefficient, consider using "Streamly.Array" instead.
1025+--
1026+
1027+-- xn : ... : x2 : x1 : []
1028+{-# INLINE toListRev #-}
1029+toListRev :: Monad m => Fold m a [a]
1030+toListRev = foldl' (flip (:)) []
1031+
1032+------------------------------------------------------------------------------
1033+-- Partial Folds
1034+------------------------------------------------------------------------------
1035+
1036+-- | A fold that drains the first n elements of its input, running the effects
1037+-- and discarding the results.
1038+--
1039+-- Definition:
1040+--
1041+-- >>> drainN n = Fold.take n Fold.drain
1042+--
1043+-- /Pre-release/
1044+{-# INLINE drainN #-}
1045+drainN :: Monad m => Int -> Fold m a ()
1046+drainN n = take n drain
1047+
1048+------------------------------------------------------------------------------
1049+-- To Elements
1050+------------------------------------------------------------------------------
1051+
1052+-- | Like 'index', except with a more general 'Integral' argument
1053+--
1054+-- /Pre-release/
1055+{-# INLINE indexGeneric #-}
1056+indexGeneric :: (Integral i, Monad m) => i -> Fold m a (Maybe a)
1057+indexGeneric i = foldt' step (Partial 0) (const Nothing)
1058+
1059+ where
1060+
1061+ step j a =
1062+ if i == j
1063+ then Done $ Just a
1064+ else Partial (j + 1)
1065+
1066+-- | Return the element at the given index.
1067+--
1068+-- Definition:
1069+--
1070+-- >>> index = Fold.indexGeneric
1071+--
1072+{-# INLINE index #-}
1073+index :: Monad m => Int -> Fold m a (Maybe a)
1074+index = indexGeneric
1075+
1076+-- | Consume a single input and transform it using the supplied 'Maybe'
1077+-- returning function.
1078+--
1079+-- /Pre-release/
1080+--
1081+{-# INLINE maybe #-}
1082+maybe :: Monad m => (a -> Maybe b) -> Fold m a (Maybe b)
1083+maybe f = foldt' (const (Done . f)) (Partial Nothing) id
1084+
1085+-- | Consume a single element and return it if it passes the predicate else
1086+-- return 'Nothing'.
1087+--
1088+-- Definition:
1089+--
1090+-- >>> satisfy f = Fold.maybe (\a -> if f a then Just a else Nothing)
1091+--
1092+-- /Pre-release/
1093+{-# INLINE satisfy #-}
1094+satisfy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1095+satisfy f = maybe (\a -> if f a then Just a else Nothing)
1096+{-
1097+satisfy f = Fold step (return $ Partial ()) (const (return Nothing))
1098+
1099+ where
1100+
1101+ step () a = return $ Done $ if f a then Just a else Nothing
1102+-}
1103+
1104+-- Naming notes:
1105+--
1106+-- "head" and "next" are two alternative names for the same API. head sounds
1107+-- apt in the context of lists but next sounds more apt in the context of
1108+-- streams where we think in terms of generating and consuming the next element
1109+-- rather than taking the head of some static/persistent structure.
1110+--
1111+-- We also want to keep the nomenclature consistent across folds and parsers,
1112+-- "head" becomes even more unintuitive for parsers because there are two
1113+-- possible variants viz. peek and next.
1114+--
1115+-- Also, the "head" fold creates confusion in situations like
1116+-- https://github.com/composewell/streamly/issues/1404 where intuitive
1117+-- expectation from head is to consume the entire stream and just give us the
1118+-- head. There we want to convey the notion that we consume one element from
1119+-- the stream and stop. The name "one" already being used in parsers for this
1120+-- purpose sounds more apt from this perspective.
1121+--
1122+-- The source of confusion is perhaps due to the fact that some folds consume
1123+-- the entire stream and others terminate early. It may have been clearer if we
1124+-- had separate abstractions for the two use cases.
1125+
1126+-- XXX We can possibly use "head" for the purposes of reducing the entire
1127+-- stream to the head element i.e. take the head and drain the rest.
1128+
1129+-- | Take one element from the stream and stop.
1130+--
1131+-- Definition:
1132+--
1133+-- >>> one = Fold.maybe Just
1134+--
1135+-- This is similar to the stream 'Stream.uncons' operation.
1136+--
1137+{-# INLINE one #-}
1138+one :: Monad m => Fold m a (Maybe a)
1139+one = maybe Just
1140+
1141+-- | Extract the first element of the stream, if any.
1142+--
1143+-- >>> head = Fold.one
1144+--
1145+{-# DEPRECATED head "Please use \"one\" instead" #-}
1146+{-# INLINE head #-}
1147+head :: Monad m => Fold m a (Maybe a)
1148+head = one
1149+
1150+-- | Returns the first element that satisfies the given predicate.
1151+--
1152+-- /Pre-release/
1153+{-# INLINE findM #-}
1154+findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1155+findM predicate =
1156+ Fold step (return $ Partial ()) extract extract
1157+
1158+ where
1159+
1160+ step () a =
1161+ let f r =
1162+ if r
1163+ then Done (Just a)
1164+ else Partial ()
1165+ in f <$> predicate a
1166+
1167+ extract = const $ return Nothing
1168+
1169+-- | Returns the first element that satisfies the given predicate.
1170+--
1171+{-# INLINE find #-}
1172+find :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1173+find p = findM (return . p)
1174+
1175+-- | In a stream of (key-value) pairs @(a, b)@, return the value @b@ of the
1176+-- first pair where the key equals the given value @a@.
1177+--
1178+-- Definition:
1179+--
1180+-- >>> lookup x = fmap snd <$> Fold.find ((== x) . fst)
1181+--
1182+{-# INLINE lookup #-}
1183+lookup :: (Eq a, Monad m) => a -> Fold m (a,b) (Maybe b)
1184+lookup a0 = foldt' step (Partial ()) (const Nothing)
1185+
1186+ where
1187+
1188+ step () (a, b) =
1189+ if a == a0
1190+ then Done $ Just b
1191+ else Partial ()
1192+
1193+-- | Returns the first index that satisfies the given predicate.
1194+--
1195+{-# INLINE findIndex #-}
1196+findIndex :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
1197+findIndex predicate = foldt' step (Partial 0) (const Nothing)
1198+
1199+ where
1200+
1201+ step i a =
1202+ if predicate a
1203+ then Done $ Just i
1204+ else Partial (i + 1)
1205+
1206+-- | Returns the index of the latest element if the element satisfies the given
1207+-- predicate.
1208+--
1209+{-# INLINE findIndices #-}
1210+findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
1211+findIndices predicate =
1212+ -- XXX implement by combining indexing and filtering scans
1213+ fmap (either (const Nothing) Just) $ foldl' step (Left (-1))
1214+
1215+ where
1216+
1217+ step i a =
1218+ if predicate a
1219+ then Right (either id id i + 1)
1220+ else Left (either id id i + 1)
1221+
1222+-- | Returns the index of the latest element if the element matches the given
1223+-- value.
1224+--
1225+-- Definition:
1226+--
1227+-- >>> elemIndices a = Fold.findIndices (== a)
1228+--
1229+{-# INLINE elemIndices #-}
1230+elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
1231+elemIndices a = findIndices (== a)
1232+
1233+-- | Returns the first index where a given value is found in the stream.
1234+--
1235+-- Definition:
1236+--
1237+-- >>> elemIndex a = Fold.findIndex (== a)
1238+--
1239+{-# INLINE elemIndex #-}
1240+elemIndex :: (Eq a, Monad m) => a -> Fold m a (Maybe Int)
1241+elemIndex a = findIndex (== a)
1242+
1243+------------------------------------------------------------------------------
1244+-- To Boolean
1245+------------------------------------------------------------------------------
1246+
1247+-- Similar to 'eof' parser, but the fold consumes and discards an input element
1248+-- when not at eof. XXX Remove or Rename to "eof"?
1249+
1250+-- | Consume one element, return 'True' if successful else return 'False'. In
1251+-- other words, test if the input is empty or not.
1252+--
1253+-- WARNING! It consumes one element if the stream is not empty. If that is not
1254+-- what you want please use the eof parser instead.
1255+--
1256+-- Definition:
1257+--
1258+-- >>> null = fmap isJust Fold.one
1259+--
1260+{-# INLINE null #-}
1261+null :: Monad m => Fold m a Bool
1262+null = foldt' (\() _ -> Done False) (Partial ()) (const True)
1263+
1264+-- | Returns 'True' if any element of the input satisfies the predicate.
1265+--
1266+-- Definition:
1267+--
1268+-- >>> any p = Fold.lmap p Fold.or
1269+--
1270+-- Example:
1271+--
1272+-- >>> Stream.fold (Fold.any (== 0)) $ Stream.fromList [1,0,1]
1273+-- True
1274+--
1275+{-# INLINE any #-}
1276+any :: Monad m => (a -> Bool) -> Fold m a Bool
1277+any predicate = foldt' step initial id
1278+
1279+ where
1280+
1281+ initial = Partial False
1282+
1283+ step _ a =
1284+ if predicate a
1285+ then Done True
1286+ else Partial False
1287+
1288+-- | Return 'True' if the given element is present in the stream.
1289+--
1290+-- Definition:
1291+--
1292+-- >>> elem a = Fold.any (== a)
1293+--
1294+{-# INLINE elem #-}
1295+elem :: (Eq a, Monad m) => a -> Fold m a Bool
1296+elem a = any (== a)
1297+
1298+-- | Returns 'True' if all elements of the input satisfy the predicate.
1299+--
1300+-- Definition:
1301+--
1302+-- >>> all p = Fold.lmap p Fold.and
1303+--
1304+-- Example:
1305+--
1306+-- >>> Stream.fold (Fold.all (== 0)) $ Stream.fromList [1,0,1]
1307+-- False
1308+--
1309+{-# INLINE all #-}
1310+all :: Monad m => (a -> Bool) -> Fold m a Bool
1311+all predicate = foldt' step initial id
1312+
1313+ where
1314+
1315+ initial = Partial True
1316+
1317+ step _ a =
1318+ if predicate a
1319+ then Partial True
1320+ else Done False
1321+
1322+-- | Returns 'True' if the given element is not present in the stream.
1323+--
1324+-- Definition:
1325+--
1326+-- >>> notElem a = Fold.all (/= a)
1327+--
1328+{-# INLINE notElem #-}
1329+notElem :: (Eq a, Monad m) => a -> Fold m a Bool
1330+notElem a = all (/= a)
1331+
1332+-- | Returns 'True' if all elements are 'True', 'False' otherwise
1333+--
1334+-- Definition:
1335+--
1336+-- >>> and = Fold.all (== True)
1337+--
1338+{-# INLINE and #-}
1339+and :: Monad m => Fold m Bool Bool
1340+and = all (== True)
1341+
1342+-- | Returns 'True' if any element is 'True', 'False' otherwise
1343+--
1344+-- Definition:
1345+--
1346+-- >>> or = Fold.any (== True)
1347+--
1348+{-# INLINE or #-}
1349+or :: Monad m => Fold m Bool Bool
1350+or = any (== True)
1351+
1352+------------------------------------------------------------------------------
1353+-- Grouping/Splitting
1354+------------------------------------------------------------------------------
1355+
1356+------------------------------------------------------------------------------
1357+-- Grouping without looking at elements
1358+------------------------------------------------------------------------------
1359+
1360+------------------------------------------------------------------------------
1361+-- Binary APIs
1362+------------------------------------------------------------------------------
1363+
1364+-- | @splitAt n f1 f2@ composes folds @f1@ and @f2@ such that first @n@
1365+-- elements of its input are consumed by fold @f1@ and the rest of the stream
1366+-- is consumed by fold @f2@.
1367+--
1368+-- >>> let splitAt_ n xs = Stream.fold (Fold.splitAt n Fold.toList Fold.toList) $ Stream.fromList xs
1369+--
1370+-- >>> splitAt_ 6 "Hello World!"
1371+-- ("Hello ","World!")
1372+--
1373+-- >>> splitAt_ (-1) [1,2,3]
1374+-- ([],[1,2,3])
1375+--
1376+-- >>> splitAt_ 0 [1,2,3]
1377+-- ([],[1,2,3])
1378+--
1379+-- >>> splitAt_ 1 [1,2,3]
1380+-- ([1],[2,3])
1381+--
1382+-- >>> splitAt_ 3 [1,2,3]
1383+-- ([1,2,3],[])
1384+--
1385+-- >>> splitAt_ 4 [1,2,3]
1386+-- ([1,2,3],[])
1387+--
1388+-- > splitAt n f1 f2 = Fold.splitWith (,) (Fold.take n f1) f2
1389+--
1390+-- /Internal/
1391+
1392+{-# INLINE splitAt #-}
1393+splitAt
1394+ :: Monad m
1395+ => Int
1396+ -> Fold m a b
1397+ -> Fold m a c
1398+ -> Fold m a (b, c)
1399+splitAt n fld = splitWith (,) (take n fld)
1400+
1401+------------------------------------------------------------------------------
1402+-- Element Aware APIs
1403+------------------------------------------------------------------------------
1404+--
1405+------------------------------------------------------------------------------
1406+-- Binary APIs
1407+------------------------------------------------------------------------------
1408+
1409+{-# INLINE takingEndByM #-}
1410+takingEndByM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1411+takingEndByM p = Fold step initial extract extract
1412+
1413+ where
1414+
1415+ initial = return $ Partial Nothing'
1416+
1417+ step _ a = do
1418+ r <- p a
1419+ return
1420+ $ if r
1421+ then Done $ Just a
1422+ else Partial $ Just' a
1423+
1424+ extract = return . toMaybe
1425+
1426+-- |
1427+--
1428+-- >>> takingEndBy p = Fold.takingEndByM (return . p)
1429+--
1430+{-# INLINE takingEndBy #-}
1431+takingEndBy :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1432+takingEndBy p = takingEndByM (return . p)
1433+
1434+{-# INLINE takingEndByM_ #-}
1435+takingEndByM_ :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1436+takingEndByM_ p = Fold step initial extract extract
1437+
1438+ where
1439+
1440+ initial = return $ Partial Nothing'
1441+
1442+ step _ a = do
1443+ r <- p a
1444+ return
1445+ $ if r
1446+ then Done Nothing
1447+ else Partial $ Just' a
1448+
1449+ extract = return . toMaybe
1450+
1451+-- |
1452+--
1453+-- >>> takingEndBy_ p = Fold.takingEndByM_ (return . p)
1454+--
1455+{-# INLINE takingEndBy_ #-}
1456+takingEndBy_ :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1457+takingEndBy_ p = takingEndByM_ (return . p)
1458+
1459+{-# INLINE droppingWhileM #-}
1460+droppingWhileM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
1461+droppingWhileM p = Fold step initial extract extract
1462+
1463+ where
1464+
1465+ initial = return $ Partial Nothing'
1466+
1467+ step Nothing' a = do
1468+ r <- p a
1469+ return
1470+ $ Partial
1471+ $ if r
1472+ then Nothing'
1473+ else Just' a
1474+ step _ a = return $ Partial $ Just' a
1475+
1476+ extract = return . toMaybe
1477+
1478+-- |
1479+-- >>> droppingWhile p = Fold.droppingWhileM (return . p)
1480+--
1481+{-# INLINE droppingWhile #-}
1482+droppingWhile :: Monad m => (a -> Bool) -> Fold m a (Maybe a)
1483+droppingWhile p = droppingWhileM (return . p)
1484+
1485+------------------------------------------------------------------------------
1486+-- Binary splitting on a separator
1487+------------------------------------------------------------------------------
1488+
1489+data SplitOnSeqState acc a rb rh w ck =
1490+ SplitOnSeqEmpty !acc
1491+ | SplitOnSeqSingle !acc !a
1492+ | SplitOnSeqWord !acc !Int !w
1493+ | SplitOnSeqWordLoop !acc !w
1494+ | SplitOnSeqKR !acc !Int !rb !rh
1495+ | SplitOnSeqKRLoop !acc !ck !rb !rh
1496+
1497+-- XXX Need to add tests for takeEndBySeq, we have tests for takeEndBySeq_ .
1498+
1499+-- | Continue taking the input until the input sequence matches the supplied
1500+-- sequence, taking the supplied sequence as well. If the pattern is empty this
1501+-- acts as an identity fold.
1502+--
1503+-- >>> s = Stream.fromList "hello there. How are you?"
1504+-- >>> f = Fold.takeEndBySeq (Array.fromList "re") Fold.toList
1505+-- >>> Stream.fold f s
1506+-- "hello there"
1507+--
1508+-- >>> Stream.fold Fold.toList $ Stream.foldMany f s
1509+-- ["hello there",". How are"," you?"]
1510+--
1511+-- /Pre-release/
1512+{-# INLINE takeEndBySeq #-}
1513+takeEndBySeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) =>
1514+ Array.Array a
1515+ -> Fold m a b
1516+ -> Fold m a b
1517+takeEndBySeq patArr (Fold fstep finitial fextract ffinal) =
1518+ Fold step initial extract final
1519+
1520+ where
1521+
1522+ patLen = Array.length patArr
1523+
1524+ initial = do
1525+ res <- finitial
1526+ case res of
1527+ Partial acc
1528+ | patLen == 0 ->
1529+ -- XXX Should we match nothing or everything on empty
1530+ -- pattern?
1531+ -- Done <$> ffinal acc
1532+ return $ Partial $ SplitOnSeqEmpty acc
1533+ | patLen == 1 -> do
1534+ pat <- liftIO $ Array.unsafeIndexIO 0 patArr
1535+ return $ Partial $ SplitOnSeqSingle acc pat
1536+ | SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
1537+ return $ Partial $ SplitOnSeqWord acc 0 0
1538+ | otherwise -> do
1539+ (rb, rhead) <- liftIO $ Ring.new patLen
1540+ return $ Partial $ SplitOnSeqKR acc 0 rb rhead
1541+ Done b -> return $ Done b
1542+
1543+ -- Word pattern related
1544+ maxIndex = patLen - 1
1545+
1546+ elemBits = SIZE_OF(a) * 8
1547+
1548+ wordMask :: Word
1549+ wordMask = (1 `shiftL` (elemBits * patLen)) - 1
1550+
1551+ wordPat :: Word
1552+ wordPat = wordMask .&. Array.foldl' addToWord 0 patArr
1553+
1554+ addToWord wd a = (wd `shiftL` elemBits) .|. fromIntegral (fromEnum a)
1555+
1556+ -- For Rabin-Karp search
1557+ k = 2891336453 :: Word32
1558+ coeff = k ^ patLen
1559+
1560+ addCksum cksum a = cksum * k + fromIntegral (fromEnum a)
1561+
1562+ deltaCksum cksum old new =
1563+ addCksum cksum new - coeff * fromIntegral (fromEnum old)
1564+
1565+ -- XXX shall we use a random starting hash or 1 instead of 0?
1566+ -- XXX Need to keep this cached across fold calls in foldmany
1567+ -- XXX We may need refold to inject the cached state instead of
1568+ -- initializing the state every time.
1569+ -- XXX Allocation of ring buffer should also be done once
1570+ patHash = Array.foldl' addCksum 0 patArr
1571+
1572+ step (SplitOnSeqEmpty s) x = do
1573+ res <- fstep s x
1574+ case res of
1575+ Partial s1 -> return $ Partial $ SplitOnSeqEmpty s1
1576+ Done b -> return $ Done b
1577+ step (SplitOnSeqSingle s pat) x = do
1578+ res <- fstep s x
1579+ case res of
1580+ Partial s1
1581+ | pat /= x -> return $ Partial $ SplitOnSeqSingle s1 pat
1582+ | otherwise -> Done <$> ffinal s1
1583+ Done b -> return $ Done b
1584+ step (SplitOnSeqWord s idx wrd) x = do
1585+ res <- fstep s x
1586+ let wrd1 = addToWord wrd x
1587+ case res of
1588+ Partial s1
1589+ | idx == maxIndex -> do
1590+ if wrd1 .&. wordMask == wordPat
1591+ then Done <$> ffinal s1
1592+ else return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1593+ | otherwise ->
1594+ return $ Partial $ SplitOnSeqWord s1 (idx + 1) wrd1
1595+ Done b -> return $ Done b
1596+ step (SplitOnSeqWordLoop s wrd) x = do
1597+ res <- fstep s x
1598+ let wrd1 = addToWord wrd x
1599+ case res of
1600+ Partial s1
1601+ | wrd1 .&. wordMask == wordPat ->
1602+ Done <$> ffinal s1
1603+ | otherwise ->
1604+ return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1605+ Done b -> return $ Done b
1606+ step (SplitOnSeqKR s idx rb rh) x = do
1607+ res <- fstep s x
1608+ case res of
1609+ Partial s1 -> do
1610+ rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1611+ if idx == maxIndex
1612+ then do
1613+ let fld = Ring.unsafeFoldRing (Ring.ringBound rb)
1614+ let !ringHash = fld addCksum 0 rb
1615+ if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1616+ then Done <$> ffinal s1
1617+ else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1618+ else
1619+ return $ Partial $ SplitOnSeqKR s1 (idx + 1) rb rh1
1620+ Done b -> return $ Done b
1621+ step (SplitOnSeqKRLoop s cksum rb rh) x = do
1622+ res <- fstep s x
1623+ case res of
1624+ Partial s1 -> do
1625+ old <- liftIO $ peek rh
1626+ rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1627+ let ringHash = deltaCksum cksum old x
1628+ if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1629+ then Done <$> ffinal s1
1630+ else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1631+ Done b -> return $ Done b
1632+
1633+ extractFunc fex state =
1634+ let st =
1635+ case state of
1636+ SplitOnSeqEmpty s -> s
1637+ SplitOnSeqSingle s _ -> s
1638+ SplitOnSeqWord s _ _ -> s
1639+ SplitOnSeqWordLoop s _ -> s
1640+ SplitOnSeqKR s _ _ _ -> s
1641+ SplitOnSeqKRLoop s _ _ _ -> s
1642+ in fex st
1643+
1644+ extract state = extractFunc fextract state
1645+
1646+ final state = extractFunc ffinal state
1647+
1648+-- | Like 'takeEndBySeq' but discards the matched sequence.
1649+--
1650+-- /Pre-release/
1651+--
1652+{-# INLINE takeEndBySeq_ #-}
1653+takeEndBySeq_ :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) =>
1654+ Array.Array a
1655+ -> Fold m a b
1656+ -> Fold m a b
1657+takeEndBySeq_ patArr (Fold fstep finitial fextract ffinal) =
1658+ Fold step initial extract final
1659+
1660+ where
1661+
1662+ patLen = Array.length patArr
1663+
1664+ initial = do
1665+ res <- finitial
1666+ case res of
1667+ Partial acc
1668+ | patLen == 0 ->
1669+ -- XXX Should we match nothing or everything on empty
1670+ -- pattern?
1671+ -- Done <$> ffinal acc
1672+ return $ Partial $ SplitOnSeqEmpty acc
1673+ | patLen == 1 -> do
1674+ pat <- liftIO $ Array.unsafeIndexIO 0 patArr
1675+ return $ Partial $ SplitOnSeqSingle acc pat
1676+ -- XXX Need to add tests for this case
1677+ | SIZE_OF(a) * patLen <= sizeOf (Proxy :: Proxy Word) ->
1678+ return $ Partial $ SplitOnSeqWord acc 0 0
1679+ | otherwise -> do
1680+ (rb, rhead) <- liftIO $ Ring.new patLen
1681+ return $ Partial $ SplitOnSeqKR acc 0 rb rhead
1682+ Done b -> return $ Done b
1683+
1684+ -- Word pattern related
1685+ maxIndex = patLen - 1
1686+
1687+ elemBits = SIZE_OF(a) * 8
1688+
1689+ wordMask :: Word
1690+ wordMask = (1 `shiftL` (elemBits * patLen)) - 1
1691+
1692+ elemMask :: Word
1693+ elemMask = (1 `shiftL` elemBits) - 1
1694+
1695+ wordPat :: Word
1696+ wordPat = wordMask .&. Array.foldl' addToWord 0 patArr
1697+
1698+ addToWord wd a = (wd `shiftL` elemBits) .|. fromIntegral (fromEnum a)
1699+
1700+ -- For Rabin-Karp search
1701+ k = 2891336453 :: Word32
1702+ coeff = k ^ patLen
1703+
1704+ addCksum cksum a = cksum * k + fromIntegral (fromEnum a)
1705+
1706+ deltaCksum cksum old new =
1707+ addCksum cksum new - coeff * fromIntegral (fromEnum old)
1708+
1709+ -- XXX shall we use a random starting hash or 1 instead of 0?
1710+ -- XXX Need to keep this cached across fold calls in foldMany
1711+ -- XXX We may need refold to inject the cached state instead of
1712+ -- initializing the state every time.
1713+ -- XXX Allocation of ring buffer should also be done once
1714+ patHash = Array.foldl' addCksum 0 patArr
1715+
1716+ step (SplitOnSeqEmpty s) x = do
1717+ res <- fstep s x
1718+ case res of
1719+ Partial s1 -> return $ Partial $ SplitOnSeqEmpty s1
1720+ Done b -> return $ Done b
1721+ step (SplitOnSeqSingle s pat) x = do
1722+ if pat /= x
1723+ then do
1724+ res <- fstep s x
1725+ case res of
1726+ Partial s1 -> return $ Partial $ SplitOnSeqSingle s1 pat
1727+ Done b -> return $ Done b
1728+ else Done <$> ffinal s
1729+ step (SplitOnSeqWord s idx wrd) x = do
1730+ let wrd1 = addToWord wrd x
1731+ if idx == maxIndex
1732+ then do
1733+ if wrd1 .&. wordMask == wordPat
1734+ then Done <$> ffinal s
1735+ else return $ Partial $ SplitOnSeqWordLoop s wrd1
1736+ else return $ Partial $ SplitOnSeqWord s (idx + 1) wrd1
1737+ step (SplitOnSeqWordLoop s wrd) x = do
1738+ let wrd1 = addToWord wrd x
1739+ old = (wordMask .&. wrd)
1740+ `shiftR` (elemBits * (patLen - 1))
1741+ res <- fstep s (toEnum $ fromIntegral old)
1742+ case res of
1743+ Partial s1
1744+ | wrd1 .&. wordMask == wordPat ->
1745+ Done <$> ffinal s1
1746+ | otherwise ->
1747+ return $ Partial $ SplitOnSeqWordLoop s1 wrd1
1748+ Done b -> return $ Done b
1749+ step (SplitOnSeqKR s idx rb rh) x = do
1750+ rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1751+ if idx == maxIndex
1752+ then do
1753+ let fld = Ring.unsafeFoldRing (Ring.ringBound rb)
1754+ let !ringHash = fld addCksum 0 rb
1755+ if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1756+ then Done <$> ffinal s
1757+ else return $ Partial $ SplitOnSeqKRLoop s ringHash rb rh1
1758+ else return $ Partial $ SplitOnSeqKR s (idx + 1) rb rh1
1759+ step (SplitOnSeqKRLoop s cksum rb rh) x = do
1760+ old <- liftIO $ peek rh
1761+ res <- fstep s old
1762+ case res of
1763+ Partial s1 -> do
1764+ rh1 <- liftIO $ Ring.unsafeInsert rb rh x
1765+ let ringHash = deltaCksum cksum old x
1766+ if ringHash == patHash && Ring.unsafeEqArray rb rh1 patArr
1767+ then Done <$> ffinal s1
1768+ else return $ Partial $ SplitOnSeqKRLoop s1 ringHash rb rh1
1769+ Done b -> return $ Done b
1770+
1771+ -- XXX extract should return backtrack count as well. If the fold
1772+ -- terminates early inside extract, we may still have buffered data
1773+ -- remaining which will be lost if we do not communicate that to the
1774+ -- driver.
1775+ extractFunc fex state = do
1776+ let consumeWord s n wrd = do
1777+ if n == 0
1778+ then fex s
1779+ else do
1780+ let old = elemMask .&. (wrd `shiftR` (elemBits * (n - 1)))
1781+ r <- fstep s (toEnum $ fromIntegral old)
1782+ case r of
1783+ Partial s1 -> consumeWord s1 (n - 1) wrd
1784+ Done b -> return b
1785+
1786+ let consumeRing s n rb rh =
1787+ if n == 0
1788+ then fex s
1789+ else do
1790+ old <- liftIO $ peek rh
1791+ let rh1 = Ring.advance rb rh
1792+ r <- fstep s old
1793+ case r of
1794+ Partial s1 -> consumeRing s1 (n - 1) rb rh1
1795+ Done b -> return b
1796+
1797+ case state of
1798+ SplitOnSeqEmpty s -> fex s
1799+ SplitOnSeqSingle s _ -> fex s
1800+ SplitOnSeqWord s idx wrd -> consumeWord s idx wrd
1801+ SplitOnSeqWordLoop s wrd -> consumeWord s patLen wrd
1802+ SplitOnSeqKR s idx rb _ -> consumeRing s idx rb (Ring.startOf rb)
1803+ SplitOnSeqKRLoop s _ rb rh -> consumeRing s patLen rb rh
1804+
1805+ extract state = extractFunc fextract state
1806+
1807+ final state = extractFunc ffinal state
1808+
1809+------------------------------------------------------------------------------
1810+-- Distributing
1811+------------------------------------------------------------------------------
1812+--
1813+-- | Distribute one copy of the stream to each fold and zip the results.
1814+--
1815+-- @
1816+-- |-------Fold m a b--------|
1817+-- ---stream m a---| |---m (b,c)
1818+-- |-------Fold m a c--------|
1819+-- @
1820+--
1821+-- Definition:
1822+--
1823+-- >>> tee = Fold.teeWith (,)
1824+--
1825+-- Example:
1826+--
1827+-- >>> t = Fold.tee Fold.sum Fold.length
1828+-- >>> Stream.fold t (Stream.enumerateFromTo 1.0 100.0)
1829+-- (5050.0,100)
1830+--
1831+{-# INLINE tee #-}
1832+tee :: Monad m => Fold m a b -> Fold m a c -> Fold m a (b,c)
1833+tee = teeWith (,)
1834+
1835+-- XXX use "List" instead of "[]"?, use Array for output to scale it to a large
1836+-- number of consumers? For polymorphic case a vector could be helpful. For
1837+-- Storables we can use arrays. Will need separate APIs for those.
1838+--
1839+-- | Distribute one copy of the stream to each fold and collect the results in
1840+-- a container.
1841+--
1842+-- @
1843+--
1844+-- |-------Fold m a b--------|
1845+-- ---stream m a---| |---m [b]
1846+-- |-------Fold m a b--------|
1847+-- | |
1848+-- ...
1849+-- @
1850+--
1851+-- >>> Stream.fold (Fold.distribute [Fold.sum, Fold.length]) (Stream.enumerateFromTo 1 5)
1852+-- [15,5]
1853+--
1854+-- >>> distribute = Prelude.foldr (Fold.teeWith (:)) (Fold.fromPure [])
1855+--
1856+-- This is the consumer side dual of the producer side 'sequence' operation.
1857+--
1858+-- Stops when all the folds stop.
1859+--
1860+{-# INLINE distribute #-}
1861+distribute :: Monad m => [Fold m a b] -> Fold m a [b]
1862+distribute = Prelude.foldr (teeWith (:)) (fromPure [])
1863+
1864+------------------------------------------------------------------------------
1865+-- Partitioning
1866+------------------------------------------------------------------------------
1867+
1868+{-# INLINE partitionByMUsing #-}
1869+partitionByMUsing :: Monad m =>
1870+ ( (x -> y -> (x, y))
1871+ -> Fold m (Either b c) x
1872+ -> Fold m (Either b c) y
1873+ -> Fold m (Either b c) (x, y)
1874+ )
1875+ -> (a -> m (Either b c))
1876+ -> Fold m b x
1877+ -> Fold m c y
1878+ -> Fold m a (x, y)
1879+partitionByMUsing t f fld1 fld2 =
1880+ let l = lmap (fromLeft undefined) fld1 -- :: Fold m (Either b c) x
1881+ r = lmap (fromRight undefined) fld2 -- :: Fold m (Either b c) y
1882+ in lmapM f (t (,) (filter isLeft l) (filter isRight r))
1883+
1884+-- | Partition the input over two folds using an 'Either' partitioning
1885+-- predicate.
1886+--
1887+-- @
1888+--
1889+-- |-------Fold b x--------|
1890+-- -----stream m a --> (Either b c)----| |----(x,y)
1891+-- |-------Fold c y--------|
1892+-- @
1893+--
1894+-- Example, send input to either fold randomly:
1895+--
1896+-- >>> :set -package random
1897+-- >>> import System.Random (randomIO)
1898+-- >>> randomly a = randomIO >>= \x -> return $ if x then Left a else Right a
1899+-- >>> f = Fold.partitionByM randomly Fold.length Fold.length
1900+-- >>> Stream.fold f (Stream.enumerateFromTo 1 100)
1901+-- ...
1902+--
1903+-- Example, send input to the two folds in a proportion of 2:1:
1904+--
1905+-- >>> :{
1906+-- proportionately m n = do
1907+-- ref <- newIORef $ cycle $ concat [replicate m Left, replicate n Right]
1908+-- return $ \a -> do
1909+-- r <- readIORef ref
1910+-- writeIORef ref $ tail r
1911+-- return $ Prelude.head r a
1912+-- :}
1913+--
1914+-- >>> :{
1915+-- main = do
1916+-- g <- proportionately 2 1
1917+-- let f = Fold.partitionByM g Fold.length Fold.length
1918+-- r <- Stream.fold f (Stream.enumerateFromTo (1 :: Int) 100)
1919+-- print r
1920+-- :}
1921+--
1922+-- >>> main
1923+-- (67,33)
1924+--
1925+--
1926+-- This is the consumer side dual of the producer side 'mergeBy' operation.
1927+--
1928+-- When one fold is done, any input meant for it is ignored until the other
1929+-- fold is also done.
1930+--
1931+-- Stops when both the folds stop.
1932+--
1933+-- /See also: 'partitionByFstM' and 'partitionByMinM'./
1934+--
1935+-- /Pre-release/
1936+{-# INLINE partitionByM #-}
1937+partitionByM :: Monad m
1938+ => (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
1939+partitionByM = partitionByMUsing teeWith
1940+
1941+-- | Similar to 'partitionByM' but terminates when the first fold terminates.
1942+--
1943+{-# INLINE partitionByFstM #-}
1944+partitionByFstM :: Monad m
1945+ => (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
1946+partitionByFstM = partitionByMUsing teeWithFst
1947+
1948+-- | Similar to 'partitionByM' but terminates when any fold terminates.
1949+--
1950+{-# INLINE partitionByMinM #-}
1951+partitionByMinM :: Monad m =>
1952+ (a -> m (Either b c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
1953+partitionByMinM = partitionByMUsing teeWithMin
1954+
1955+-- Note: we could use (a -> Bool) instead of (a -> Either b c), but the latter
1956+-- makes the signature clearer as to which case belongs to which fold.
1957+-- XXX need to check the performance in both cases.
1958+
1959+-- | Same as 'partitionByM' but with a pure partition function.
1960+--
1961+-- Example, count even and odd numbers in a stream:
1962+--
1963+-- >>> :{
1964+-- let f = Fold.partitionBy (\n -> if even n then Left n else Right n)
1965+-- (fmap (("Even " ++) . show) Fold.length)
1966+-- (fmap (("Odd " ++) . show) Fold.length)
1967+-- in Stream.fold f (Stream.enumerateFromTo 1 100)
1968+-- :}
1969+-- ("Even 50","Odd 50")
1970+--
1971+-- /Pre-release/
1972+{-# INLINE partitionBy #-}
1973+partitionBy :: Monad m
1974+ => (a -> Either b c) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
1975+partitionBy f = partitionByM (return . f)
1976+
1977+-- | Compose two folds such that the combined fold accepts a stream of 'Either'
1978+-- and routes the 'Left' values to the first fold and 'Right' values to the
1979+-- second fold.
1980+--
1981+-- Definition:
1982+--
1983+-- >>> partition = Fold.partitionBy id
1984+--
1985+{-# INLINE partition #-}
1986+partition :: Monad m
1987+ => Fold m b x -> Fold m c y -> Fold m (Either b c) (x, y)
1988+partition = partitionBy id
1989+
1990+{-
1991+-- | Send one item to each fold in a round-robin fashion. This is the consumer
1992+-- side dual of producer side 'mergeN' operation.
1993+--
1994+-- partitionN :: Monad m => [Fold m a b] -> Fold m a [b]
1995+-- partitionN fs = Fold step begin done
1996+-}
1997+
1998+------------------------------------------------------------------------------
1999+-- Unzipping
2000+------------------------------------------------------------------------------
2001+
2002+{-# INLINE unzipWithMUsing #-}
2003+unzipWithMUsing :: Monad m =>
2004+ ( (x -> y -> (x, y))
2005+ -> Fold m (b, c) x
2006+ -> Fold m (b, c) y
2007+ -> Fold m (b, c) (x, y)
2008+ )
2009+ -> (a -> m (b, c))
2010+ -> Fold m b x
2011+ -> Fold m c y
2012+ -> Fold m a (x, y)
2013+unzipWithMUsing t f fld1 fld2 =
2014+ let f1 = lmap fst fld1 -- :: Fold m (b, c) b
2015+ f2 = lmap snd fld2 -- :: Fold m (b, c) c
2016+ in lmapM f (t (,) f1 f2)
2017+
2018+-- | Like 'unzipWith' but with a monadic splitter function.
2019+--
2020+-- Definition:
2021+--
2022+-- >>> unzipWithM k f1 f2 = Fold.lmapM k (Fold.unzip f1 f2)
2023+--
2024+-- /Pre-release/
2025+{-# INLINE unzipWithM #-}
2026+unzipWithM :: Monad m
2027+ => (a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2028+unzipWithM = unzipWithMUsing teeWith
2029+
2030+-- | Similar to 'unzipWithM' but terminates when the first fold terminates.
2031+--
2032+{-# INLINE unzipWithFstM #-}
2033+unzipWithFstM :: Monad m =>
2034+ (a -> m (b, c)) -> Fold m b x -> Fold m c y -> Fold m a (x, y)
2035+unzipWithFstM = unzipWithMUsing teeWithFst
2036+
2037+-- | Similar to 'unzipWithM' but terminates when any fold terminates.
2038+--
2039+{-# INLINE unzipWithMinM #-}
2040+unzipWithMinM :: Monad m =>
2041+ (a -> m (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2042+unzipWithMinM = unzipWithMUsing teeWithMin
2043+
2044+-- | Split elements in the input stream into two parts using a pure splitter
2045+-- function, direct each part to a different fold and zip the results.
2046+--
2047+-- Definitions:
2048+--
2049+-- >>> unzipWith f = Fold.unzipWithM (return . f)
2050+-- >>> unzipWith f fld1 fld2 = Fold.lmap f (Fold.unzip fld1 fld2)
2051+--
2052+-- This fold terminates when both the input folds terminate.
2053+--
2054+-- /Pre-release/
2055+{-# INLINE unzipWith #-}
2056+unzipWith :: Monad m
2057+ => (a -> (b,c)) -> Fold m b x -> Fold m c y -> Fold m a (x,y)
2058+unzipWith f = unzipWithM (return . f)
2059+
2060+-- | Send the elements of tuples in a stream of tuples through two different
2061+-- folds.
2062+--
2063+-- @
2064+--
2065+-- |-------Fold m a x--------|
2066+-- ---------stream of (a,b)--| |----m (x,y)
2067+-- |-------Fold m b y--------|
2068+--
2069+-- @
2070+--
2071+-- Definition:
2072+--
2073+-- >>> unzip = Fold.unzipWith id
2074+--
2075+-- This is the consumer side dual of the producer side 'zip' operation.
2076+--
2077+{-# INLINE unzip #-}
2078+unzip :: Monad m => Fold m a x -> Fold m b y -> Fold m (a,b) (x,y)
2079+unzip = unzipWith id
2080+
2081+------------------------------------------------------------------------------
2082+-- Combining streams and folds - Zipping
2083+------------------------------------------------------------------------------
2084+
2085+-- XXX These can be implemented using the fold scan, using the stream as a
2086+-- state.
2087+-- XXX Stream Skip state cannot be efficiently handled in folds but can be
2088+-- handled in parsers using the Continue facility. See zipWithM in the Parser
2089+-- module.
2090+--
2091+-- cmpBy, eqBy, isPrefixOf, isSubsequenceOf etc can be implemented using
2092+-- zipStream.
2093+
2094+-- | Zip a stream with the input of a fold using the supplied function.
2095+--
2096+-- /Unimplemented/
2097+--
2098+{-# INLINE zipStreamWithM #-}
2099+zipStreamWithM :: -- Monad m =>
2100+ (a -> b -> m c) -> Stream m a -> Fold m c x -> Fold m b x
2101+zipStreamWithM = undefined
2102+
2103+-- | Zip a stream with the input of a fold.
2104+--
2105+-- >>> zip = Fold.zipStreamWithM (curry return)
2106+--
2107+-- /Unimplemented/
2108+--
2109+{-# INLINE zipStream #-}
2110+zipStream :: Monad m => Stream m a -> Fold m (a, b) x -> Fold m b x
2111+zipStream = zipStreamWithM (curry return)
2112+
2113+-- | Pair each element of a fold input with its index, starting from index 0.
2114+--
2115+{-# INLINE indexingWith #-}
2116+indexingWith :: Monad m => Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
2117+indexingWith i f = fmap toMaybe $ foldl' step initial
2118+
2119+ where
2120+
2121+ initial = Nothing'
2122+
2123+ step Nothing' a = Just' (i, a)
2124+ step (Just' (n, _)) a = Just' (f n, a)
2125+
2126+-- |
2127+-- >>> indexing = Fold.indexingWith 0 (+ 1)
2128+--
2129+{-# INLINE indexing #-}
2130+indexing :: Monad m => Fold m a (Maybe (Int, a))
2131+indexing = indexingWith 0 (+ 1)
2132+
2133+-- |
2134+-- >>> indexingRev n = Fold.indexingWith n (subtract 1)
2135+--
2136+{-# INLINE indexingRev #-}
2137+indexingRev :: Monad m => Int -> Fold m a (Maybe (Int, a))
2138+indexingRev n = indexingWith n (subtract 1)
2139+
2140+-- | Pair each element of a fold input with its index, starting from index 0.
2141+--
2142+-- >>> indexed = Fold.scanMaybe Fold.indexing
2143+--
2144+{-# INLINE indexed #-}
2145+indexed :: Monad m => Fold m (Int, a) b -> Fold m a b
2146+indexed = scanMaybe indexing
2147+
2148+-- | Change the predicate function of a Fold from @a -> b@ to accept an
2149+-- additional state input @(s, a) -> b@. Convenient to filter with an
2150+-- addiitonal index or time input.
2151+--
2152+-- >>> filterWithIndex = Fold.with Fold.indexed Fold.filter
2153+--
2154+-- @
2155+-- filterWithAbsTime = with timestamped filter
2156+-- filterWithRelTime = with timeIndexed filter
2157+-- @
2158+--
2159+-- /Pre-release/
2160+{-# INLINE with #-}
2161+with ::
2162+ (Fold m (s, a) b -> Fold m a b)
2163+ -> (((s, a) -> c) -> Fold m (s, a) b -> Fold m (s, a) b)
2164+ -> (((s, a) -> c) -> Fold m a b -> Fold m a b)
2165+with f comb g = f . comb g . lmap snd
2166+
2167+-- XXX Implement as a filter
2168+-- sampleFromthen :: Monad m => Int -> Int -> Fold m a (Maybe a)
2169+
2170+-- | @sampleFromthen offset stride@ samples the element at @offset@ index and
2171+-- then every element at strides of @stride@.
2172+--
2173+{-# INLINE sampleFromthen #-}
2174+sampleFromthen :: Monad m => Int -> Int -> Fold m a b -> Fold m a b
2175+sampleFromthen offset size =
2176+ with indexed filter (\(i, _) -> (i + offset) `mod` size == 0)
2177+
2178+------------------------------------------------------------------------------
2179+-- Nesting
2180+------------------------------------------------------------------------------
2181+
2182+-- | @concatSequence f t@ applies folds from stream @t@ sequentially and
2183+-- collects the results using the fold @f@.
2184+--
2185+-- /Unimplemented/
2186+--
2187+{-# INLINE concatSequence #-}
2188+concatSequence ::
2189+ -- IsStream t =>
2190+ Fold m b c -> t (Fold m a b) -> Fold m a c
2191+concatSequence _f _p = undefined
2192+
2193+-- | Group the input stream into groups of elements between @low@ and @high@.
2194+-- Collection starts in chunks of @low@ and then keeps doubling until we reach
2195+-- @high@. Each chunk is folded using the provided fold function.
2196+--
2197+-- This could be useful, for example, when we are folding a stream of unknown
2198+-- size to a stream of arrays and we want to minimize the number of
2199+-- allocations.
2200+--
2201+-- NOTE: this would be an application of "many" using a terminating fold.
2202+--
2203+-- /Unimplemented/
2204+--
2205+{-# INLINE chunksBetween #-}
2206+chunksBetween :: -- Monad m =>
2207+ Int -> Int -> Fold m a b -> Fold m b c -> Fold m a c
2208+chunksBetween _low _high _f1 _f2 = undefined
2209+
2210+-- | A fold that buffers its input to a pure stream.
2211+--
2212+-- /Warning!/ working on large streams accumulated as buffers in memory could
2213+-- be very inefficient, consider using "Streamly.Data.Array" instead.
2214+--
2215+-- >>> toStream = fmap Stream.fromList Fold.toList
2216+--
2217+-- /Pre-release/
2218+{-# INLINE toStream #-}
2219+toStream :: (Monad m, Monad n) => Fold m a (Stream n a)
2220+toStream = fmap StreamD.fromList toList
2221+
2222+-- This is more efficient than 'toStream'. toStream is exactly the same as
2223+-- reversing the stream after toStreamRev.
2224+--
2225+-- | Buffers the input stream to a pure stream in the reverse order of the
2226+-- input.
2227+--
2228+-- >>> toStreamRev = fmap Stream.fromList Fold.toListRev
2229+--
2230+-- /Warning!/ working on large streams accumulated as buffers in memory could
2231+-- be very inefficient, consider using "Streamly.Data.Array" instead.
2232+--
2233+-- /Pre-release/
2234+
2235+-- xn : ... : x2 : x1 : []
2236+{-# INLINE toStreamRev #-}
2237+toStreamRev :: (Monad m, Monad n) => Fold m a (Stream n a)
2238+toStreamRev = fmap StreamD.fromList toListRev
2239+
2240+-- XXX This does not fuse. It contains a recursive step function. We will need
2241+-- a Skip input constructor in the fold type to make it fuse.
2242+--
2243+-- | Unfold and flatten the input stream of a fold.
2244+--
2245+-- @
2246+-- Stream.fold (unfoldMany u f) = Stream.fold f . Stream.unfoldMany u
2247+-- @
2248+--
2249+-- /Pre-release/
2250+{-# INLINE unfoldMany #-}
2251+unfoldMany :: Monad m => Unfold m a b -> Fold m b c -> Fold m a c
2252+unfoldMany (Unfold ustep inject) (Fold fstep initial extract final) =
2253+ Fold consume initial extract final
2254+
2255+ where
2256+
2257+ {-# INLINE produce #-}
2258+ produce fs us = do
2259+ ures <- ustep us
2260+ case ures of
2261+ StreamD.Yield b us1 -> do
2262+ fres <- fstep fs b
2263+ case fres of
2264+ Partial fs1 -> produce fs1 us1
2265+ -- XXX What to do with the remaining stream?
2266+ Done c -> return $ Done c
2267+ StreamD.Skip us1 -> produce fs us1
2268+ StreamD.Stop -> return $ Partial fs
2269+
2270+ {-# INLINE_LATE consume #-}
2271+ consume s a = inject a >>= produce s
2272+
2273+-- | Get the bottom most @n@ elements using the supplied comparison function.
2274+--
2275+{-# INLINE bottomBy #-}
2276+bottomBy :: (MonadIO m, Unbox a) =>
2277+ (a -> a -> Ordering)
2278+ -> Int
2279+ -> Fold m a (MutArray a)
2280+bottomBy cmp n = Fold step initial extract extract
2281+
2282+ where
2283+
2284+ initial = do
2285+ arr <- MA.pinnedNew n
2286+ if n <= 0
2287+ then return $ Done arr
2288+ else return $ Partial (arr, 0)
2289+
2290+ step (arr, i) x =
2291+ if i < n
2292+ then do
2293+ arr' <- MA.snoc arr x
2294+ MA.bubble cmp arr'
2295+ return $ Partial (arr', i + 1)
2296+ else do
2297+ x1 <- MA.getIndexUnsafe (i - 1) arr
2298+ case x `cmp` x1 of
2299+ LT -> do
2300+ MA.putIndexUnsafe (i - 1) arr x
2301+ MA.bubble cmp arr
2302+ return $ Partial (arr, i)
2303+ _ -> return $ Partial (arr, i)
2304+
2305+ extract = return . fst
2306+
2307+-- | Get the top @n@ elements using the supplied comparison function.
2308+--
2309+-- To get bottom n elements instead:
2310+--
2311+-- >>> bottomBy cmp = Fold.topBy (flip cmp)
2312+--
2313+-- Example:
2314+--
2315+-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2316+-- >>> Stream.fold (Fold.topBy compare 3) stream >>= MutArray.toList
2317+-- [17,11,9]
2318+--
2319+-- /Pre-release/
2320+--
2321+{-# INLINE topBy #-}
2322+topBy :: (MonadIO m, Unbox a) =>
2323+ (a -> a -> Ordering)
2324+ -> Int
2325+ -> Fold m a (MutArray a)
2326+topBy cmp = bottomBy (flip cmp)
2327+
2328+-- | Fold the input stream to top n elements.
2329+--
2330+-- Definition:
2331+--
2332+-- >>> top = Fold.topBy compare
2333+--
2334+-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2335+-- >>> Stream.fold (Fold.top 3) stream >>= MutArray.toList
2336+-- [17,11,9]
2337+--
2338+-- /Pre-release/
2339+{-# INLINE top #-}
2340+top :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
2341+top = bottomBy $ flip compare
2342+
2343+-- | Fold the input stream to bottom n elements.
2344+--
2345+-- Definition:
2346+--
2347+-- >>> bottom = Fold.bottomBy compare
2348+--
2349+-- >>> stream = Stream.fromList [2::Int,7,9,3,1,5,6,11,17]
2350+-- >>> Stream.fold (Fold.bottom 3) stream >>= MutArray.toList
2351+-- [1,2,3]
2352+--
2353+-- /Pre-release/
2354+{-# INLINE bottom #-}
2355+bottom :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (MutArray a)
2356+bottom = bottomBy compare
2357+
2358+------------------------------------------------------------------------------
2359+-- Interspersed parsing
2360+------------------------------------------------------------------------------
2361+
2362+data IntersperseQState fs ps =
2363+ IntersperseQUnquoted !fs !ps
2364+ | IntersperseQQuoted !fs !ps
2365+ | IntersperseQQuotedEsc !fs !ps
2366+
2367+-- Useful for parsing CSV with quoting and escaping
2368+{-# INLINE intersperseWithQuotes #-}
2369+intersperseWithQuotes :: (Monad m, Eq a) =>
2370+ a -> a -> a -> Fold m a b -> Fold m b c -> Fold m a c
2371+intersperseWithQuotes
2372+ quote
2373+ esc
2374+ separator
2375+ (Fold stepL initialL _ finalL)
2376+ (Fold stepR initialR extractR finalR) = Fold step initial extract final
2377+
2378+ where
2379+
2380+ errMsg p status =
2381+ error $ "intersperseWithQuotes: " ++ p ++ " parsing fold cannot "
2382+ ++ status ++ " without input"
2383+
2384+ {-# INLINE initL #-}
2385+ initL mkState = do
2386+ resL <- initialL
2387+ case resL of
2388+ Partial sL ->
2389+ return $ Partial $ mkState sL
2390+ Done _ ->
2391+ errMsg "content" "succeed"
2392+
2393+ initial = do
2394+ res <- initialR
2395+ case res of
2396+ Partial sR -> initL (IntersperseQUnquoted sR)
2397+ Done b -> return $ Done b
2398+
2399+ {-# INLINE collect #-}
2400+ collect nextS sR b = do
2401+ res <- stepR sR b
2402+ case res of
2403+ Partial s ->
2404+ initL (nextS s)
2405+ Done c -> return (Done c)
2406+
2407+ {-# INLINE process #-}
2408+ process a sL sR nextState = do
2409+ r <- stepL sL a
2410+ case r of
2411+ Partial s -> return $ Partial (nextState sR s)
2412+ Done b -> collect nextState sR b
2413+
2414+ {-# INLINE processQuoted #-}
2415+ processQuoted a sL sR nextState = do
2416+ r <- stepL sL a
2417+ case r of
2418+ Partial s -> return $ Partial (nextState sR s)
2419+ Done _ -> do
2420+ _ <- finalR sR
2421+ error "Collecting fold finished inside quote"
2422+
2423+ step (IntersperseQUnquoted sR sL) a
2424+ | a == separator = do
2425+ b <- finalL sL
2426+ collect IntersperseQUnquoted sR b
2427+ | a == quote = processQuoted a sL sR IntersperseQQuoted
2428+ | otherwise = process a sL sR IntersperseQUnquoted
2429+
2430+ step (IntersperseQQuoted sR sL) a
2431+ | a == esc = processQuoted a sL sR IntersperseQQuotedEsc
2432+ | a == quote = process a sL sR IntersperseQUnquoted
2433+ | otherwise = processQuoted a sL sR IntersperseQQuoted
2434+
2435+ step (IntersperseQQuotedEsc sR sL) a =
2436+ processQuoted a sL sR IntersperseQQuoted
2437+
2438+ extract (IntersperseQUnquoted sR _) = extractR sR
2439+ extract (IntersperseQQuoted _ _) =
2440+ error "intersperseWithQuotes: finished inside quote"
2441+ extract (IntersperseQQuotedEsc _ _) =
2442+ error "intersperseWithQuotes: finished inside quote, at escape char"
2443+
2444+ final (IntersperseQUnquoted sR sL) = finalL sL *> finalR sR
2445+ final (IntersperseQQuoted sR sL) = do
2446+ _ <- finalR sR
2447+ _ <- finalL sL
2448+ error "intersperseWithQuotes: finished inside quote"
2449+ final (IntersperseQQuotedEsc sR sL) = do
2450+ _ <- finalR sR
2451+ _ <- finalL sL
2452+ error "intersperseWithQuotes: finished inside quote, at escape char"
core/src/Streamly/Internal/Data/Fold/Container.hs+119−40
@@ -9,9 +9,6 @@
99
1010module Streamly.Internal.Data.Fold.Container
1111 (
12− -- * Imports
13− -- $setup
14−
1512 -- * Set operations
1613 toSet
1714 , toIntSet
@@ -27,14 +24,27 @@ module Streamly.Internal.Data.Fold.Container
2724 -- | Direct values in the input stream to different folds using an n-ary
2825 -- fold selector. 'demux' is a generalization of 'classify' (and
2926 -- 'partition') where each key of the classifier can use a different fold.
30− , demuxKvToContainer
31− , demuxKvToMap
27+ --
28+ -- You need to see only 'demux' if you are looking to find the capabilities
29+ -- of these combinators, all others are variants of that.
3230
31+ -- *** Output is a container
32+ -- | The fold state snapshot returns the key-value container of in-progress
33+ -- folds.
3334 , demuxToContainer
3435 , demuxToContainerIO
3536 , demuxToMap
3637 , demuxToMapIO
3738
39+ -- *** Input is explicit key-value tuple
40+ -- | Like above but inputs are in explicit key-value pair form.
41+ , demuxKvToContainer
42+ , demuxKvToMap
43+
44+ -- *** Scan of finished fold results
45+ -- | Like above, but the resulting fold state snapshot contains the key
46+ -- value container as well as the finished key result if a fold in the
47+ -- container finished.
3848 , demuxGeneric
3949 , demux
4050 , demuxGenericIO
@@ -89,8 +99,9 @@ import qualified Data.IntSet as IntSet
8999import qualified Data.Set as Set
90100import qualified Streamly.Internal.Data.IsMap as IsMap
91101
92−import Prelude hiding (length)
93−import Streamly.Internal.Data.Fold
102+import Prelude hiding (Foldable(..))
103+import Streamly.Internal.Data.Fold.Type
104+import Streamly.Internal.Data.Fold.Combinators
94105
95106-- $setup
96107-- >>> :m
@@ -251,19 +262,23 @@ countDistinctInt = fmap (\(Tuple' _ n) -> n) $ foldl' step initial
251262-- because key is to be determined on each input whereas fold is to be
252263-- determined only once for a key.
253264
265+-- | This is the most general of all demux, classify operations.
266+--
267+-- See 'demux' for documentation.
254268{-# INLINE demuxGeneric #-}
255269demuxGeneric :: (Monad m, IsMap f, Traversable f) =>
256270 (a -> Key f)
257271 -> (a -> m (Fold m a b))
258272 -> Fold m a (m (f b), Maybe (Key f, b))
259−demuxGeneric getKey getFold = fmap extract $ foldlM' step initial
273+demuxGeneric getKey getFold =
274+ Fold (\s a -> Partial <$> step s a) (Partial <$> initial) extract final
260275
261276 where
262277
263278 initial = return $ Tuple' IsMap.mapEmpty Nothing
264279
265280 {-# INLINE runFold #-}
266− runFold kv (Fold step1 initial1 extract1) (k, a) = do
281+ runFold kv (Fold step1 initial1 extract1 final1) (k, a) = do
267282 res <- initial1
268283 case res of
269284 Partial s -> do
@@ -271,7 +286,7 @@ demuxGeneric getKey getFold = fmap extract $ foldlM' step initial
271286 return
272287 $ case res1 of
273288 Partial _ ->
274− let fld = Fold step1 (return res1) extract1
289+ let fld = Fold step1 (return res1) extract1 final1
275290 in Tuple' (IsMap.mapInsert k fld kv) Nothing
276291 Done b -> Tuple' (IsMap.mapDelete k kv) (Just (k, b))
277292 Done b -> return $ Tuple' kv (Just (k, b))
@@ -284,25 +299,50 @@ demuxGeneric getKey getFold = fmap extract $ foldlM' step initial
284299 runFold kv fld (k, a)
285300 Just f -> runFold kv f (k, a)
286301
287− extract (Tuple' kv x) = (Prelude.mapM f kv, x)
302+ extract (Tuple' kv x) = return (Prelude.mapM f kv, x)
288303
289304 where
290305
291− f (Fold _ i e) = do
306+ f (Fold _ i e _) = do
292307 r <- i
293308 case r of
294309 Partial s -> e s
295− Done b -> return b
310+ _ -> error "demuxGeneric: unreachable code"
311+
312+ final (Tuple' kv x) = return (Prelude.mapM f kv, x)
313+
314+ where
315+
316+ f (Fold _ i _ fin) = do
317+ r <- i
318+ case r of
319+ Partial s -> fin s
320+ _ -> error "demuxGeneric: unreachable code"
296321
297−-- | In a key value stream, fold values corresponding to each key with a key
298−-- specific fold. The fold returns the fold result as the second component of
299−-- the output tuple whenever a fold terminates. The first component of the
300−-- tuple is a Map of in-progress folds. If a fold terminates, another
301−-- instance of the fold is started upon receiving an input with that key.
322+-- | @demux getKey getFold@: In a key value stream, fold values corresponding
323+-- to each key using a key specific fold. @getFold@ is invoked to generate a
324+-- key specific fold when a key is encountered for the first time in the
325+-- stream.
326+--
327+-- The first component of the output tuple is a key-value Map of in-progress
328+-- folds. The fold returns the fold result as the second component of the
329+-- output tuple whenever a fold terminates.
330+--
331+-- If a fold terminates, another instance of the fold is started upon receiving
332+-- an input with that key, @getFold@ is invoked again whenever the key is
333+-- encountered again.
302334--
303335-- This can be used to scan a stream and collect the results from the scan
304336-- output.
305337--
338+-- Since the fold generator function is monadic we can add folds dynamically.
339+-- For example, we can maintain a Map of keys to folds in an IORef and lookup
340+-- the fold from that corresponding to a key. This Map can be changed
341+-- dynamically, folds for new keys can be added or folds for old keys can be
342+-- deleted or modified.
343+--
344+-- Compare with 'classify', the fold in 'classify' is a static fold.
345+--
306346-- /Pre-release/
307347--
308348{-# INLINE demux #-}
@@ -312,40 +352,43 @@ demux :: (Monad m, Ord k) =>
312352 -> Fold m a (m (Map k b), Maybe (k, b))
313353demux = demuxGeneric
314354
355+-- | This is specialized version of 'demuxGeneric' that uses mutable IO cells
356+-- as fold accumulators for better performance.
315357{-# INLINE demuxGenericIO #-}
316358demuxGenericIO :: (MonadIO m, IsMap f, Traversable f) =>
317359 (a -> Key f)
318360 -> (a -> m (Fold m a b))
319361 -> Fold m a (m (f b), Maybe (Key f, b))
320−demuxGenericIO getKey getFold = fmap extract $ foldlM' step initial
362+demuxGenericIO getKey getFold =
363+ Fold (\s a -> Partial <$> step s a) (Partial <$> initial) extract final
321364
322365 where
323366
324367 initial = return $ Tuple' IsMap.mapEmpty Nothing
325368
326369 {-# INLINE initFold #-}
327− initFold kv (Fold step1 initial1 extract1) (k, a) = do
370+ initFold kv (Fold step1 initial1 extract1 final1) (k, a) = do
328371 res <- initial1
329372 case res of
330373 Partial s -> do
331374 res1 <- step1 s a
332375 case res1 of
333376 Partial _ -> do
334− let fld = Fold step1 (return res1) extract1
377+ let fld = Fold step1 (return res1) extract1 final1
335378 ref <- liftIO $ newIORef fld
336379 return $ Tuple' (IsMap.mapInsert k ref kv) Nothing
337380 Done b -> return $ Tuple' kv (Just (k, b))
338381 Done b -> return $ Tuple' kv (Just (k, b))
339382
340383 {-# INLINE runFold #-}
341− runFold kv ref (Fold step1 initial1 extract1) (k, a) = do
384+ runFold kv ref (Fold step1 initial1 extract1 final1) (k, a) = do
342385 res <- initial1
343386 case res of
344387 Partial s -> do
345388 res1 <- step1 s a
346389 case res1 of
347390 Partial _ -> do
348− let fld = Fold step1 (return res1) extract1
391+ let fld = Fold step1 (return res1) extract1 final1
349392 liftIO $ writeIORef ref fld
350393 return $ Tuple' kv Nothing
351394 Done b ->
@@ -363,20 +406,34 @@ demuxGenericIO getKey getFold = fmap extract $ foldlM' step initial
363406 f <- liftIO $ readIORef ref
364407 runFold kv ref f (k, a)
365408
366− extract (Tuple' kv x) = (Prelude.mapM f kv, x)
409+ extract (Tuple' kv x) = return (Prelude.mapM f kv, x)
367410
368411 where
369412
370413 f ref = do
371− (Fold _ i e) <- liftIO $ readIORef ref
414+ Fold _ i e _ <- liftIO $ readIORef ref
372415 r <- i
373416 case r of
374417 Partial s -> e s
375− Done b -> return b
418+ _ -> error "demuxGenericIO: unreachable code"
419+
420+ final (Tuple' kv x) = return (Prelude.mapM f kv, x)
421+
422+ where
423+
424+ f ref = do
425+ Fold _ i _ fin <- liftIO $ readIORef ref
426+ r <- i
427+ case r of
428+ Partial s -> fin s
429+ _ -> error "demuxGenericIO: unreachable code"
376430
377431-- | This is specialized version of 'demux' that uses mutable IO cells as
378432-- fold accumulators for better performance.
379433--
434+-- Keep in mind that the values in the returned Map may be changed by the
435+-- ongoing fold if you are using those concurrently in another thread.
436+--
380437{-# INLINE demuxIO #-}
381438demuxIO :: (MonadIO m, Ord k) =>
382439 (a -> k)
@@ -384,6 +441,13 @@ demuxIO :: (MonadIO m, Ord k) =>
384441 -> Fold m a (m (Map k b), Maybe (k, b))
385442demuxIO = demuxGenericIO
386443
444+-- | Fold a key value stream to a key-value Map. If the same key appears
445+-- multiple times, only the last value is retained.
446+{-# INLINE kvToMapOverwriteGeneric #-}
447+kvToMapOverwriteGeneric :: (Monad m, IsMap f) => Fold m (Key f, a) (f a)
448+kvToMapOverwriteGeneric =
449+ foldl' (\kv (k, v) -> IsMap.mapInsert k v kv) IsMap.mapEmpty
450+
387451{-# INLINE demuxToContainer #-}
388452demuxToContainer :: (Monad m, IsMap f, Traversable f) =>
389453 (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b)
@@ -471,8 +535,8 @@ classifyGeneric :: (Monad m, IsMap f, Traversable f, Ord (Key f)) =>
471535 -- for that use case. We return an action because we want it to be lazy so
472536 -- that the downstream consumers can choose to process or discard it.
473537 (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
474−classifyGeneric f (Fold step1 initial1 extract1) =
475− fmap extract $ foldlM' step initial
538+classifyGeneric f (Fold step1 initial1 extract1 final1) =
539+ Fold (\s a -> Partial <$> step s a) (Partial <$> initial) extract final
476540
477541 where
478542
@@ -509,7 +573,16 @@ classifyGeneric f (Fold step1 initial1 extract1) =
509573 let kv1 = IsMap.mapDelete k kv
510574 in Tuple3' kv1 (Set.insert k set) (Just (k, b))
511575
512− extract (Tuple3' kv _ x) = (Prelude.mapM extract1 kv, x)
576+ extract (Tuple3' kv _ x) = return (Prelude.mapM extract1 kv, x)
577+
578+ final (Tuple3' kv set x) = return (IsMap.mapTraverseWithKey f1 kv, x)
579+
580+ where
581+
582+ f1 k s = do
583+ if Set.member k set
584+ then extract1 s
585+ else final1 s
513586
514587-- | Folds the values for each key using the supplied fold. When scanning, as
515588-- soon as the fold is complete, its result is available in the second
@@ -534,8 +607,8 @@ classify = classifyGeneric
534607{-# INLINE classifyGenericIO #-}
535608classifyGenericIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) =>
536609 (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
537−classifyGenericIO f (Fold step1 initial1 extract1) =
538− fmap extract $ foldlM' step initial
610+classifyGenericIO f (Fold step1 initial1 extract1 final1) =
611+ Fold (\s a -> Partial <$> step s a) (Partial <$> initial) extract final
539612
540613 where
541614
@@ -574,8 +647,21 @@ classifyGenericIO f (Fold step1 initial1 extract1) =
574647 in return
575648 $ Tuple3' kv1 (Set.insert k set) (Just (k, b))
576649
577− extract (Tuple3' kv _ x) =
578− (Prelude.mapM (\ref -> liftIO (readIORef ref) >>= extract1) kv, x)
650+ extract (Tuple3' kv _ x) = return (Prelude.mapM g kv, x)
651+
652+ where
653+
654+ g ref = liftIO (readIORef ref) >>= extract1
655+
656+ final (Tuple3' kv set x) = return (IsMap.mapTraverseWithKey g kv, x)
657+
658+ where
659+
660+ g k ref = do
661+ s <- liftIO $ readIORef ref
662+ if Set.member k set
663+ then extract1 s
664+ else final1 s
579665
580666-- | Same as classify except that it uses mutable IORef cells in the
581667-- Map providing better performance. Be aware that if this is used as a scan,
@@ -590,13 +676,6 @@ classifyIO :: (MonadIO m, Ord k) =>
590676 (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
591677classifyIO = classifyGenericIO
592678
593−-- | Fold a key value stream to a key-value Map. If the same key appears
594−-- multiple times, only the last value is retained.
595−{-# INLINE kvToMapOverwriteGeneric #-}
596−kvToMapOverwriteGeneric :: (Monad m, IsMap f) => Fold m (Key f, a) (f a)
597−kvToMapOverwriteGeneric =
598− foldl' (\kv (k, v) -> IsMap.mapInsert k v kv) IsMap.mapEmpty
599−
600679{-# INLINE toContainer #-}
601680toContainer :: (Monad m, IsMap f, Traversable f, Ord (Key f)) =>
602681 (a -> Key f) -> Fold m a b -> Fold m a (f b)
core/src/Streamly/Internal/Data/Fold/Step.hs+2−2
@@ -8,7 +8,7 @@
88--
99module Streamly.Internal.Data.Fold.Step
1010 (
11− -- * Types
11+ -- * Step Type
1212 Step (..)
1313
1414 , mapMStep
@@ -40,7 +40,7 @@ data Step s b
4040 = Partial !s
4141 | Done !b
4242
43−-- | 'first' maps over 'Partial' and 'second' maps over 'Done'.
43+-- | 'first' maps over the fold state and 'second' maps over the fold result.
4444--
4545instance Bifunctor Step where
4646 {-# INLINE bimap #-}
core/src/Streamly/Internal/Data/Fold/Tee.hs+8−7
@@ -1,3 +1,4 @@
1+{-# LANGUAGE CPP #-}
12-- |
23-- Module : Streamly.Internal.Data.Fold.Tee
34-- Copyright : (c) 2020 Composewell Technologies
@@ -15,25 +16,25 @@ module Streamly.Internal.Data.Fold.Tee
1516 )
1617where
1718
19+#if !MIN_VERSION_base(4,18,0)
1820import Control.Applicative (liftA2)
21+#endif
1922import Streamly.Internal.Data.Fold.Type (Fold)
2023
2124import qualified Streamly.Internal.Data.Fold.Type as Fold
2225
26+#include "DocTestDataFold.hs"
27+
2328-- | @Tee@ is a newtype wrapper over the 'Fold' type providing distributing
2429-- 'Applicative', 'Semigroup', 'Monoid', 'Num', 'Floating' and 'Fractional'
2530-- instances.
2631--
27−-- The input received by the
28−-- composed 'Tee' is replicated and distributed to both the constituent Tees.
32+-- The input received by the composed 'Tee' is replicated and distributed to
33+-- the constituent folds of the 'Tee'.
2934--
3035-- For example, to compute the average of numbers in a stream without going
3136-- through the stream twice:
3237--
33−-- >>> import Streamly.Internal.Data.Fold.Tee (Tee(..))
34−-- >>> import qualified Streamly.Data.Stream as Stream
35−-- >>> import qualified Streamly.Data.Fold as Fold
36−--
3738-- >>> avg = (/) <$> (Tee Fold.sum) <*> (Tee $ fmap fromIntegral Fold.length)
3839-- >>> Stream.fold (unTee avg) $ Stream.fromList [1.0..100.0]
3940-- 50.5
@@ -78,7 +79,7 @@ instance (Semigroup b, Monad m) => Semigroup (Tee m a b) where
7879-- | '<>' distributes the input to both the argument 'Tee's and combines their
7980-- outputs using the 'Monoid' instance of the output type.
8081--
81−instance (Semigroup b, Monoid b, Monad m) => Monoid (Tee m a b) where
82+instance (Monoid b, Monad m) => Monoid (Tee m a b) where
8283 {-# INLINE mempty #-}
8384 mempty = pure mempty
8485
core/src/Streamly/Internal/Data/Fold/Type.hs+373−151

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Window.hs+59−53

This diff is too big to show here.

core/src/Streamly/Internal/Data/IOFinalizer.hs+12−2

This diff is too big to show here.

core/src/Streamly/Internal/Data/IORef/Unboxed.hs+23−22

This diff is too big to show here.

core/src/Streamly/Internal/Data/IsMap.hs+8

This diff is too big to show here.

core/src/Streamly/Internal/Data/List.hs+81−16

This diff is too big to show here.

core/src/Streamly/Internal/Data/MutArray.hsnew file+207

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/Generic/Mut/Type.hs → core/src/Streamly/Internal/Data/MutArray/Generic.hsrenamed+414−75

This diff is too big to show here.

core/src/Streamly/Internal/Data/MutArray/Stream.hsnew file+145

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/Mut/Type.hs → core/src/Streamly/Internal/Data/MutArray/Type.hsrenamed+1503−536

This diff is too big to show here.

core/src/Streamly/Internal/Data/MutByteArray.hsnew file+251

This diff is too big to show here.

core/src/Streamly/Internal/Data/MutByteArray/Type.hsnew file+321

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser.hs+3611−4

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser/ParserD.hsdeleted−3672

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser/ParserDK.hsdeleted−1544

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser/ParserD/Tee.hs → core/src/Streamly/Internal/Data/Parser/Tee.hsrenamed+1−1

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser/ParserD/Type.hs → core/src/Streamly/Internal/Data/Parser/Type.hsrenamed+110−83

This diff is too big to show here.

core/src/Streamly/Internal/Data/ParserK.hsnew file+16

This diff is too big to show here.

core/src/Streamly/Internal/Data/Parser/ParserK/Type.hs → core/src/Streamly/Internal/Data/ParserK/Type.hsrenamed+301−89

This diff is too big to show here.

core/src/Streamly/Internal/Data/Pipe.hs+7−10

This diff is too big to show here.

core/src/Streamly/Internal/Data/Producer.hs+6−13

This diff is too big to show here.

core/src/Streamly/Internal/Data/Producer/Source.hs+22−9

This diff is too big to show here.

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

This diff is too big to show here.

core/src/Streamly/Internal/Data/Refold/Type.hs+2−2

This diff is too big to show here.

core/src/Streamly/Internal/Data/Ring.hs+603−31

This diff is too big to show here.

core/src/Streamly/Internal/Data/Ring/Generic.hsnew file+185

This diff is too big to show here.

core/src/Streamly/Internal/Data/Ring/Unboxed.hsdeleted−615

This diff is too big to show here.

core/src/Streamly/Internal/Data/Serialize/TH.hsnew file+530

This diff is too big to show here.

core/src/Streamly/Internal/Data/Serialize/TH/Bottom.hsnew file+475

This diff is too big to show here.

core/src/Streamly/Internal/Data/Serialize/TH/Common.hsnew file+70

This diff is too big to show here.

core/src/Streamly/Internal/Data/Serialize/TH/RecHeader.hsnew file+411

This diff is too big to show here.

core/src/Streamly/Internal/Data/Serialize/Type.hsnew file+317

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream.hs+31−3

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Bottom.hsdeleted−670

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Container.hs → core/src/Streamly/Internal/Data/Stream/Container.hsrenamed+70−63

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Cross.hsdeleted−143

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Eliminate.hs+701−229

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Enumerate.hsdeleted−560

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Exception.hs+369−90

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Expand.hsdeleted−893

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Generate.hs+948−217

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Lift.hs+70−36

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Nesting.hs → core/src/Streamly/Internal/Data/Stream/Nesting.hsrenamed+152−250

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Reduce.hsdeleted−444

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Step.hs → core/src/Streamly/Internal/Data/Stream/Step.hsrenamed+2−2

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD.hs+3−29

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hsdeleted−838

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Exception.hsdeleted−480

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Generate.hsdeleted−1211

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Lift.hsdeleted−131

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Top.hsdeleted−356

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Transform.hsdeleted−1962

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Transformer.hsdeleted−185

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD/Type.hsdeleted−2081

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamDK.hsdeleted−52

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Top.hsnew file+480

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Transform.hs+1197−282

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Transformer.hs+91−43

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Type.hs+1958−229

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Zip.hsdeleted−91

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamK.hs → core/src/Streamly/Internal/Data/StreamK.hsrenamed+508−191

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamK/Alt.hs → core/src/Streamly/Internal/Data/StreamK/Alt.hsrenamed+1−1

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamK/Transformer.hs → core/src/Streamly/Internal/Data/StreamK/Transformer.hsrenamed+3−3

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamK/Type.hs → core/src/Streamly/Internal/Data/StreamK/Type.hsrenamed+137−58

This diff is too big to show here.

core/src/Streamly/Internal/Data/Time/Clock.hs+3−3

This diff is too big to show here.

core/src/Streamly/Internal/Data/Time/Units.hs+1−4

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unboxed.hs → core/src/Streamly/Internal/Data/Unbox.hsrenamed+316−263

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unbox/TH.hsnew file+498

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unfold.hs+31−193

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unfold/Enumeration.hs+14−45

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unfold/Type.hs+127−20

This diff is too big to show here.

core/src/Streamly/Internal/FileSystem/Dir.hs+69−22

This diff is too big to show here.

core/src/Streamly/Internal/FileSystem/File.hs+30−31

This diff is too big to show here.

core/src/Streamly/Internal/FileSystem/Handle.hs+40−49

This diff is too big to show here.

core/src/Streamly/Internal/FileSystem/Path.hsnew file+515

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Array.hs+6

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Parser.hs+354−25

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Stream.hs+58−30

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/String.hs+17−12

This diff is too big to show here.

core/src/Streamly/Unicode/Parser.hs+12−2

This diff is too big to show here.

core/src/Streamly/Unicode/Stream.hs+13−10

This diff is too big to show here.

core/src/Streamly/Unicode/String.hs+15−1

This diff is too big to show here.

core/streamly-core.cabal+191−108

This diff is too big to show here.

docs/Developer/Benchmarks.md+8

This diff is too big to show here.

docs/Developer/MAINTAINING.md+6−9

This diff is too big to show here.

docs/Developer/module-organization.md+1−1

This diff is too big to show here.

docs/Developer/optimization-guidelines.md+13−1

This diff is too big to show here.

docs/Developer/paths.rst+25−2

This diff is too big to show here.

docs/Documentation.mdnew file+5

This diff is too big to show here.

docs/User/HowTo/Compiling.md+27−14

This diff is too big to show here.

docs/User/HowTo/streamly-vs-async.md+2

This diff is too big to show here.

docs/User/HowTo/streamly-vs-lists.md+2

This diff is too big to show here.

docs/User/Project/ApiChangelogs/0.8.3-0.9.0.txtnew file+175

This diff is too big to show here.

docs/User/ProjectRelated/API-changelog.txt → docs/User/Project/ApiChangelogs/0.8.3.txtrenamed

The content is the same.

docs/User/Project/ApiChangelogs/0.9.0-0.10.0.txtnew file+424

This diff is too big to show here.

docs/User/ProjectRelated/CONTRIBUTORS.md → docs/User/Project/CONTRIBUTORS.mdrenamed+9−1

This diff is too big to show here.

docs/User/ProjectRelated/Changelog.md → docs/User/Project/Changelog.mdrenamed+49−9

This diff is too big to show here.

docs/User/ProjectRelated/Credits.md → docs/User/Project/Credits.mdrenamed

The content is the same.

docs/User/ProjectRelated/Github.link → docs/User/Project/Github.linkrenamed

The content is the same.

docs/User/ProjectRelated/README.md → docs/User/Project/README.mdrenamed+9−2

This diff is too big to show here.

docs/User/ProjectRelated/Roadmap.link → docs/User/Project/Roadmap.linkrenamed

The content is the same.

docs/User/ProjectRelated/Upgrading.md → docs/User/Project/Upgrading-0.8-to-0.9.mdrenamed+132−23

This diff is too big to show here.

docs/User/Tutorials/ConcurrentStreams.hs+2

This diff is too big to show here.

docs/User/Tutorials/ReactiveProgramming.hs+2

This diff is too big to show here.

docs/User/Tutorials/Tutorial.hs+2

This diff is too big to show here.

docs/User/Tutorials/before-you-begin.md+22−3

This diff is too big to show here.

docs/User/Tutorials/setup-and-usage.md → docs/User/Tutorials/getting-started.mdrenamed+24−25

This diff is too big to show here.

docs/User/Tutorials/quick-overview.md+12−14

This diff is too big to show here.

docs/streamly-docs.cabal+8−6

This diff is too big to show here.

hie.yaml+14−10

This diff is too big to show here.

src/Streamly.hsdeleted−624

This diff is too big to show here.

src/Streamly/Data/Fold/Prelude.hsnew file+65

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Data/Stream/Concurrent.hsdeleted−191

This diff is too big to show here.

src/Streamly/Data/Stream/Exception.hsdeleted−24

This diff is too big to show here.

src/Streamly/Data/Stream/MkType.hs+41−10

This diff is too big to show here.

src/Streamly/Data/Stream/Prelude.hs+217−15

This diff is too big to show here.

src/Streamly/Data/Stream/Time.hsdeleted−37

This diff is too big to show here.

src/Streamly/Data/Unicode/Stream.hsdeleted−99

This diff is too big to show here.

src/Streamly/Internal/Control/ForkLifted.hs+17−4

This diff is too big to show here.

src/Streamly/Internal/Data/Array/ArrayMacros.hdeleted−40

This diff is too big to show here.

src/Streamly/Internal/Data/Channel.hsnew file+19

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Channel/Dispatcher.hs → src/Streamly/Internal/Data/Channel/Dispatcher.hsrenamed+3−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Channel/Types.hs → src/Streamly/Internal/Data/Channel/Types.hsrenamed+22−32

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Channel/Worker.hs → src/Streamly/Internal/Data/Channel/Worker.hsrenamed+3−3

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Async.hs+6−3

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent.hs+37−49

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent/Channel.hs+31−10

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent/Channel/Type.hs+8−7

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Prelude.hsnew file+19

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/SVar.hs+8−7

This diff is too big to show here.

src/Streamly/Internal/Data/IsMap/HashMap.hs+10

This diff is too big to show here.

src/Streamly/Internal/Data/SVar.hs+1

This diff is too big to show here.

src/Streamly/Internal/Data/SmallArray.hs+4−4

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Ahead.hs+15−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Async.hs+22−3

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Common.hs → src/Streamly/Internal/Data/Stream/Common.hsrenamed+4−4

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent.hs+205−76

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel.hs+19−16

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Append.hs+11−11

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Consumer.hs+2−2

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Dispatcher.hs+3−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Interleave.hs+11−9

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Operations.hs+5−5

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Type.hs+4−4

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Instances.hs+6−9

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Expand.hs+8−4

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Top.hs+4−5

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Transform.hs+5−5

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Type.hs+6−5

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Exception/Lifted.hs → src/Streamly/Internal/Data/Stream/Lifted.hsrenamed+16−12

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/MkType.hs+33−34

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Parallel.hs+15−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Prelude.hsnew file+19

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar.hsnew file+18

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar/Eliminate.hs+3−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar/Generate.hs+4−2

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Serial.hs+18−5

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Time.hs+10−10

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Zip.hs+42−3

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Zip/Concurrent.hsdeleted−50

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/ZipAsync.hs+5−4

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold/Exception.hs+1−3

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold/Prelude.hsnew file+17

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold/SVar.hs+3−2

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event.hs+5−2

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Darwin.hs+5−5

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Linux.hs+15−9

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Windows.hs+11−8

This diff is too big to show here.

src/Streamly/Internal/FileSystem/FD.hs+15−14

This diff is too big to show here.

src/Streamly/Internal/Network/Inet/TCP.hs+84−48

This diff is too big to show here.

src/Streamly/Internal/Network/Socket.hs+34−31

This diff is too big to show here.

src/Streamly/Internal/System/IOVec.hs+7−7

This diff is too big to show here.

src/Streamly/Internal/Unicode/Char.hs+10−8

This diff is too big to show here.

src/Streamly/Memory/Array.hsdeleted−74

This diff is too big to show here.

src/Streamly/Network/Inet/TCP.hs+41−30

This diff is too big to show here.

src/Streamly/Network/Socket.hs+16−30

This diff is too big to show here.

src/Streamly/Prelude.hs+4−4

This diff is too big to show here.

streamly.cabal+112−85

This diff is too big to show here.

targets/Targets.hs+11−5

This diff is too big to show here.

test/Streamly/Test/Data/Array.hs+9−10

This diff is too big to show here.

test/Streamly/Test/Data/Array/Stream.hs+1−1

This diff is too big to show here.

test/Streamly/Test/Data/Fold.hs+8−8

This diff is too big to show here.

test/Streamly/Test/Data/Fold/Window.hs+8−9

This diff is too big to show here.

test/Streamly/Test/Data/Array/Mut.hs → test/Streamly/Test/Data/MutArray.hsrenamed+5−5

This diff is too big to show here.

test/Streamly/Test/Data/Parser.hs+264−115

This diff is too big to show here.

test/Streamly/Test/Data/Parser/ParserD.hs → test/Streamly/Test/Data/ParserK.hsrenamed+17−13

This diff is too big to show here.

test/Streamly/Test/Data/Ring/Unboxed.hs+2−2

This diff is too big to show here.

test/Streamly/Test/Data/Serialize.hsnew file+306

This diff is too big to show here.

test/Streamly/Test/Data/Serialize/CompatV0.hsnew file+46

This diff is too big to show here.

test/Streamly/Test/Data/Serialize/CompatV1.hsnew file+48

This diff is too big to show here.

test/Streamly/Test/Data/Serialize/TH.hsnew file+82

This diff is too big to show here.

test/Streamly/Test/Data/Stream.hsnew file+33

This diff is too big to show here.

test/Streamly/Test/Data/Stream/Concurrent.hs+122−78

This diff is too big to show here.

test/Streamly/Test/Data/Unbox.hs+166−38

This diff is too big to show here.

test/Streamly/Test/Data/Unbox/TH.hsnew file+146

This diff is too big to show here.

test/Streamly/Test/Data/Unfold.hs+2−2

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Common.hs+1−1

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Linux.hs+16−3

This diff is too big to show here.

test/Streamly/Test/FileSystem/Handle.hs+2−2

This diff is too big to show here.

test/Streamly/Test/Prelude/Serial.hs+8−4

This diff is too big to show here.

test/Streamly/Test/Prelude/Top.hs+1−1

This diff is too big to show here.

test/Streamly/Test/Serialize/Serializable.hs+2−2

This diff is too big to show here.

test/Streamly/Test/Unicode/Char.hs+1−1

This diff is too big to show here.

test/Streamly/Test/Unicode/Parser.hsnew file+231

This diff is too big to show here.

test/Streamly/Test/Unicode/Stream.hs+2−2

This diff is too big to show here.

test/lib/Streamly/Test/Common.hs+4

This diff is too big to show here.

test/lib/Streamly/Test/Prelude/Common.hs+9−2

This diff is too big to show here.

test/streamly-tests.cabal+94−32

This diff is too big to show here.