102d2fb...master · streamly

git.iko.soy/streamly

536 files changed+121886−46708

since splitsnapshots

unifiedsplit

.circleci/config.yml+80−263

@@ -1,7 +1,7 @@

11version: 2.1

33#-----------------------------------------------------------------------------

4−# packcheck-0.4.2

4+# packcheck-0.7.0

55# Packcheck global environment variables

66#-----------------------------------------------------------------------------

@@ -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"

43− CABAL_BUILD_OPTIONS: "--flag limit-build-mem"

42+ 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 ).

@@ -58,16 +56,16 @@ env: &env

5856 PACKCHECK: "./packcheck.sh"

5957 # If you have not committed packcheck.sh in your repo at PACKCHECK

6058 # then it is automatically pulled from this URL.

61− PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/harendra-kumar/packcheck"

62− PACKCHECK_GITHUB_COMMIT: "563702bd02c41343dcd3dfcfef0845ca428a9240"

59+ PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/composewell/packcheck"

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,42 +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

106106

107−project-preinstall: &project-preinstall

108− run: |

109− # If a custom stack-yaml is specified, replace the default with that

110− if test -e "$STACK_YAML"; then rm -f stack.yaml && ln -sv $STACK_YAML stack.yaml; else true; fi

111− unset STACK_YAML

107+ # Required for and by packcheck

108+ apt-get install -y curl

112109

113110 # Get packcheck if needed

114− CURL=$(which curl)

115− PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh

116− if test ! -e "$PACKCHECK"; then $CURL -sL -o "$PACKCHECK" $PACKCHECK_URL; fi;

117− 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

118124

119125restore: &restore

120126 # Needs to happen after installing ca-certificates

@@ -130,272 +136,83 @@ save: &save

130136 save_cache:

131137 key: v1-{{ .Environment.CIRCLE_JOB }}-{{ .Branch }}

132138 paths:

133− - ~/.cabal

134− - ~/.ghc

135139 - ~/.local

140+ - ~/.cabal

136141 - ~/.stack

142+ - ~/.ghcup

137143

138144#-----------------------------------------------------------------------------

139145# Build matrix

140146#-----------------------------------------------------------------------------

141147

142148jobs:

143− stack-ghc-8_8:

144− <<: *env

145− executor: amd64-executor

146− steps:

147− - *preinstall

148− - checkout

149− - *project-preinstall

150− - *restore

151− - run:

152− name: GHC 8.8 + stack lts-16.12

153− environment:

154− BUILD: "stack"

155− RESOLVER: "lts-16.12"

156− SDIST_OPTIONS: "--ignore-check"

157− STACK_BUILD_OPTIONS: "--flag streamly-benchmarks:-opt"

158− command: |

159− apt-get build-dep -y ghc-8.8.4

160− apt-get install -y cabal-install-3.2

161− bash -c "$PACKCHECK $BUILD"

162− - *save

163149 cabal-ghc-8_6_5:

164150 <<: *env

165151 executor: amd64-executor

166152 steps:

167− - *preinstall

168153 - checkout

169− - *project-preinstall

170154 - *restore

171− - run: |

172− apt-get install -y ghc-8.6.3

173− apt-get install -y cabal-install-2.4

174− bash -c "$PACKCHECK cabal-v2"

175− - *save

176− cabal-ghc-8_4_4:

177− <<: *env

178− executor: x86-executor

179− steps:

180155 - *preinstall

181− - checkout

182− - *project-preinstall

183− - *restore

184− - run:

185− name: GHC 8.4.4 + x86 + debug

186− environment:

187− BUILD: "cabal-v2"

188− GHCVER: "8.4.4"

189− CABAL_BUILD_OPTIONS: "--flag debug --flag limit-build-mem"

190− command: |

191− apt-get install -y ghc-8.4.4

192− apt-get install -y cabal-install-3.2

193− bash -c "$PACKCHECK $BUILD"

194− - *save

195− cabal-ghc-8_2_2:

196− <<: *env

197− executor: amd64-executor

198− steps:

199− - *preinstall

200− - checkout

201− - *project-preinstall

202− - *restore

203156 - run:

204157 environment:

205− BUILD: "cabal-v2"

206− DISABLE_TEST: "yes"

207− DISABLE_BENCH: "yes"

208− DISABLE_DOCS: "yes"

158+ GHCVER: "8.6.5"

159+ CABAL_VERSION: "3.6.2.0"

160+ CABAL_PROJECT: "cabal.project"

209161 DISABLE_SDIST_BUILD: "yes"

210− DISABLE_DIST_CHECKS: "yes"

162+ CABAL_BUILD_OPTIONS: "--flag debug --flag -opt"

211163 command: |

212− apt-get install -y ghc-8.2.2

213− apt-get install -y cabal-install-3.2

214− apt-get install libtinfo-dev

215− bash -c "$PACKCHECK $BUILD"

164+ bash -c "$PACKCHECK cabal"

216165 - *save

217− cabal-ghc-8_0_2:

166+ cabal-ghc-9_8_1-docspec:

218167 <<: *env

219168 executor: amd64-executor

220169 steps:

221− - *preinstall

222170 - checkout

223− - *project-preinstall

224171 - *restore

225− - run:

226− environment:

227− BUILD: "cabal-v2"

228− DISABLE_TEST: "yes"

229− DISABLE_BENCH: "yes"

230− DISABLE_DOCS: "yes"

231− DISABLE_SDIST_BUILD: "yes"

232− DISABLE_DIST_CHECKS: "yes"

233− command: |

234− apt-get install -y ghc-8.0.2

235− apt-get install -y cabal-install-3.2

236− bash -c "$PACKCHECK $BUILD"

237− - *save

238− cabal-ghc-7_10_3:

239− <<: *env

240− executor: amd64-executor

241− steps:

242172 - *preinstall

243− - checkout

244− - *project-preinstall

245− - *restore

246− - run: |

247− apt-get install -y ghc-7.10.3

248− apt-get install -y cabal-install-2.4

249− bash -c "$PACKCHECK cabal-v2"

250− - *save

251− stack-ghc-8_4:

252− <<: *env

253− executor: amd64-executor

254− steps:

255− - *preinstall

256− - checkout

257− - *project-preinstall

258− - *restore

259− - run: |

260− bash -c "$PACKCHECK stack RESOLVER=lts-12"

261− - *save

262− stack-ghc-8_2:

263− <<: *env

264− executor: amd64-executor

265− steps:

266− - *preinstall

267− - checkout

268− - *project-preinstall

269− - *restore

270− - run: |

271− bash -c "$PACKCHECK stack RESOLVER=lts-11"

272− - *save

273− cabal-ghcjs-8_4:

274− <<: *env

275− executor: amd64-executor

276− steps:

277− - *preinstall

278− - checkout

279− - *project-preinstall

280− - *restore

281− - run:

282− name: GHCJS 8.4+no-test+no-docs

283− environment:

284− BUILD: cabal-v2

285− ENABLE_GHCJS: "yes"

286− DISABLE_TEST: "yes"

287− ENABLE_INSTALL: ""

288− DISABLE_DOCS: "yes"

289− DISABLE_SDIST_BUILD: "yes"

290− command: |

291− add-apt-repository -y ppa:hvr/ghcjs

292− add-apt-repository -y 'deb https://deb.nodesource.com/node_11.x xenial main'

293− curl -sSL https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add -

294− apt-get update

295− apt-get install -y cabal-install-3.2

296− apt-get install -y nodejs

297− apt-get install -y ghcjs-8.4

298− bash -c "$PACKCHECK $BUILD"

299− - *save

300− coveralls-ghc-8_2_2:

301− <<: *env

302− executor: amd64-executor

303− steps:

304− - *preinstall

305− - checkout

306− - *project-preinstall

307− - *restore

308173 - run:

309174 environment:

310− BUILD: cabal

311− COVERALLS_OPTIONS: "--repo-token=\"$REPO_TOKEN\" --coverage-mode=StrictlyFullLines --exclude-dir=test test"

312− GHC_OPTIONS: "-DCOVERAGE_BUILD"

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"

313185 command: |

314− apt-get install -y ghc-8.2.2

315− apt-get install -y cabal-install-2.4

316− bash -c "$PACKCHECK cabal-v1"

186+ bash -c "$PACKCHECK cabal"

317187 - *save

318− coveralls-ghc-8_8_3:

188+ hlint-trailing-spaces:

319189 <<: *env

320190 executor: amd64-executor

321191 steps:

322− - *preinstall

323192 - checkout

324− - *project-preinstall

325193 - *restore

326− - run:

327− environment:

328− BUILD: cabal-v2

329− COVERALLS_OPTIONS: "--repo-token=\"$REPO_TOKEN\" --coverage-mode=StrictlyFullLines --exclude-dir=test"

330− CABAL_PROJECT: "cabal.project.coverage"

331− CABAL_BUILD_TARGETS: ""

332− command: |

333− apt-get install -y ghc-8.8.3

334− apt-get install -y cabal-install-3.0

335− bash -c "$PACKCHECK cabal-v2"

336− no_output_timeout: 25m

337− - *save

338− coveralls-ghc-8_10_2:

339− <<: *env

340− executor: amd64-executor

341− steps:

342194 - *preinstall

343− - checkout

344− - *project-preinstall

345− - *restore

346− - run:

347− name: Build and test with inspection, coverage, Werror

348− command: |

349− apt-get install -y ghc-8.10.2

350− apt-get install -y cabal-install-3.2

351− # Run tests with coverage

352− cabal update

353− cabal user-config update -a "jobs: 2"

354− bin/test.sh --coverage --raw

355− # Upload results to coveralls.io

356− PATH=$HOME/.cabal/bin:$PATH

357− export PATH

358− which hpc-coveralls 2>/dev/null || cabal install --project-file cabal.project.hpc-coveralls hpc-coveralls

359− hpc-coveralls --repo-token="$REPO_TOKEN" --coverage-mode=StrictlyFullLines

360− no_output_timeout: 25m

361− - *save

362− hlint-src:

363− <<: *env

364− executor: amd64-executor

365− steps:

366− - *preinstall

367− - checkout

368− - *project-preinstall

369− - *restore

370195 - run:

371− name: Hlint src

196+ name: hlint and trailing spaces

372197 environment:

373− BUILD: cabal-v2

374− HLINT_OPTIONS: lint --cpp-include=src --cpp-include=test

375− HLINT_TARGETS: src test benchmark

198+ DISABLE_SDIST_BUILD: "yes"

199+ HLINT_VERSION: 3.6.1

200+ HLINT_OPTIONS: lint

201+ HLINT_TARGETS: core/src src test benchmark

376202 command: |

377− bash -c "$PACKCHECK $BUILD"

203+ bash -c "$PACKCHECK hlint" || exit 1

204+ echo "Checking trailing spaces..."

205+ count=$(find . -name "*.hs" -exec grep -H '\ $' {} \; | tee /dev/tty | wc -l)

206+ exit $count

378207 - *save

379208

380209workflows:

381210 version: 2

382211 build:

383212 jobs:

384− #- cabal-ghc-8.6.5

385− #- cabal-ghc-8_4_4:

386− # name: GHC 8.4.4 + x86 + debug

387− - cabal-ghc-8_2_2:

388− name: GHC 8.2.2 + no-test + no-bench + no-docs

389− - cabal-ghc-8_0_2:

390− name: GHC 8.0.2 + no-test + no-bench + no-docs

391− #- cabal-ghc-7.10.3

392− - cabal-ghcjs-8_4:

393− name: GHCJS 8.4 + no-test + no-docs

394− #- stack-ghc-8.4

395− #- stack-ghc-8.2

396− #- coveralls-ghc-8.2.2

397− #- coveralls-ghc-8.8.3

398− - coveralls-ghc-8_10_2:

399− name: GHC 8.10.2 + inspection + coverage + Werror

400− - hlint-src:

401− name: Hlint src

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+211−83

@@ -8,123 +8,251 @@ on:

99jobs:

1010 build:

11− name: GHC ${{ matrix.name }}

11+ name: GHC ${{matrix.name}}

1212 env:

13− CABAL_REINIT_CONFIG: y

13+ # packcheck environment variables

1414 LC_ALL: C.UTF-8

15−

16− ENABLE_INSTALL: "n"

17−

18− STACK_UPGRADE: "y"

19−

20− CABAL_CHECK_RELAX: y

21− CABAL_NO_SANDBOX: y

22− CABAL_HACKAGE_MIRROR: hackage.haskell.org:http://hackage.fpcomplete.com

23−

24− PACKCHECK_LOCAL_PATH: "./packcheck.sh"

25− PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/harendra-kumar/packcheck"

26− PACKCHECK_GITHUB_COMMIT: "563702bd02c41343dcd3dfcfef0845ca428a9240"

27−

2815 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 }}

2921 GHCVER: ${{ matrix.ghc_version }}

30− RESOLVER: ${{ matrix.resolver }}

22+ CABALVER: ${{ matrix.cabal_version }}

23+ DISABLE_DOCS: ${{ matrix.disable_docs }}

24+ ENABLE_DOCSPEC: ${{ matrix.enable_docspec }}

25+ DISABLE_TEST: ${{ matrix.disable_test }}

26+ DISABLE_BENCH: ${{ matrix.disable_bench }}

27+ DISABLE_DIST_CHECKS: ${{ matrix.disable_dist_checks }}

28+ SDIST_OPTIONS: ${{ matrix.sdist_options }}

29+ DISABLE_SDIST_BUILD: ${{ matrix.disable_sdist_build }}

30+

31+ # Cabal options

32+ CABAL_REINIT_CONFIG: y

33+ # Github has machines with 2 CPUS and 6GB memory so the cabal jobs

34+ # default (ncpus) is good, this can be checked from the packcheck

35+ # output in case it changes.

3136 CABAL_BUILD_OPTIONS: ${{ matrix.cabal_build_options }} --flag limit-build-mem

3237 CABAL_BUILD_TARGETS: ${{ matrix.cabal_build_targets }}

3338 CABAL_PROJECT: ${{ matrix.cabal_project }}

39+ CABAL_CHECK_RELAX: y

40+

41+ # Stack options

42+ STACK_UPGRADE: "y"

43+ RESOLVER: ${{ matrix.resolver }}

44+ STACK_YAML: ${{ matrix.stack_yaml }}

3445 STACK_BUILD_OPTIONS: ${{ matrix.stack_build_options }}

35− DISABLE_DOCS: ${{ matrix.disable_docs }}

36− SDIST_OPTIONS: ${{ matrix.sdist_options }}

37− DISABLE_SDIST_BUILD: ${{ matrix.disable_sdist_build }}

38− DISABLE_DIST_CHECKS: ${{ matrix.disable_dist_checks }}

46+

47+ # packcheck location and revision

48+ PACKCHECK: "./packcheck.sh"

49+ PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/composewell/packcheck"

50+ PACKCHECK_GITHUB_COMMIT: "v0.7.0"

51+

52+ # Pull token from "secrets" setting of the github repo

53+ COVERALLS_TOKEN: ${{ secrets.COVERALLS_TOKEN }}

54+ COVERAGE: ${{ matrix.coverage }}

55+

56+ # hlint

57+ HLINT_VERSION: 3.6.1

58+ HLINT_OPTIONS: "lint"

59+ HLINT_TARGETS: "core/src src test benchmark"

60+

61+ # Subdir

62+ SUBDIR: ${{ matrix.subdir }}

3963

4064 runs-on: ${{ matrix.runner }}

65+ continue-on-error: ${{ matrix.ignore_error }}

4166 strategy:

42− fail-fast: false

67+ fail-fast: true

4368 matrix:

44− name: [8.10.4+stack+lts-17.8, 8.10.2+macOS, 8.8.3+inspection+fusion-plugin+Werror, 8.8.4+stack+lts-16.31, 8.6.5+fusion-plugin, 8.6.5+streamk, 8.4.4+debug, doctests]

45− cabal_version: ["3.2"]

69+ # The order is important to optimize fail-fast.

70+ name:

71+ - 9.8.1-Werror

72+ # - 9.8.1-docspec

73+ # - 8.10.7-coverage

74+

75+ # Note: if cabal.project is not specified benchmarks and tests won't

76+ # run. But we need at least one test where we test without

77+ # cabal.project because that is how hackage would build it.

4678 include:

47− #- name: 9.0.1+no-bench

48− # ghc_version: 9.0.1

49− # build: cabal-v2

50− # cabal_build_options: "--allow-newer=hsc2hs"

51− # cabal_build_targets: "streamly streamly-tests"

52− # disable_sdist_build: "y"

79+ - name: head

80+ 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"

91+ runner: ubuntu-latest

92+ build: cabal

93+ cabal_version: 3.10.2.0

94+ cabal_project: cabal.project.ghc-head

95+ disable_sdist_build: "y"

96+ ignore_error: true

97+ # Note: use linux for warning build for convenient dev testing

98+ - name: 9.8.1-Werror

99+ ghc_version: 9.8.1

100+ runner: ubuntu-latest

101+ build: cabal

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

53108 # runner: ubuntu-latest

54− - name: 8.10.4+stack+lts-17.8

55− build: stack

56− resolver: lts-17.8

57− sdist_options: "--ignore-check"

58− stack_build_options: "--flag streamly-benchmarks:-opt"

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

59120 runner: ubuntu-latest

60− - name: 8.10.2+macOS

61− ghc_version: 8.10.2

62− build: cabal-v2

121+ build: cabal

122+ cabal_version: 3.10.1.0

63123 disable_sdist_build: "y"

64− runner: macos-latest

65− - name: 8.8.3+inspection+fusion-plugin+Werror

66− ghc_version: 8.8.3

67− build: cabal-v2

68− cabal_project: cabal.project.ci

124+ cabal_project: cabal.project

69125 cabal_build_options: "--flag fusion-plugin --flag inspection"

126+ ignore_error: false

127+ - name: 9.6.3-macos

128+ ghc_version: 9.6.3

129+ runner: macos-latest

130+ build: cabal

131+ cabal_version: 3.10.1.0

132+ disable_sdist_build: "y"

133+ cabal_project: cabal.project

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

140+ disable_sdist_build: "y"

141+ cabal_project: cabal.project

142+ ignore_error: false

143+ - name: 9.2.8

144+ ghc_version: 9.2.8

145+ runner: ubuntu-latest

146+ build: cabal

147+ cabal_project: cabal.project

148+ cabal_version: 3.6.2.0

149+ disable_sdist_build: "y"

150+ ignore_error: false

151+ - name: 9.0.2-streamly-sdist

152+ ghc_version: 9.0.2

153+ runner: ubuntu-latest

154+ build: cabal

155+ cabal_version: 3.6.2.0

156+ cabal_project: cabal.project.streamly

157+ ignore_error: true

158+ - name: 9.0.2-streamly-core-sdist

159+ ghc_version: 9.0.2

160+ runner: ubuntu-latest

161+ build: cabal

162+ cabal_version: 3.6.2.0

163+ subdir: core

164+ ignore_error: false

165+ - name: 8.10.7-streamly-sdist-stack

70166 runner: ubuntu-latest

71− - name: 8.8.4+stack+lts-16.31

72167 build: stack

73− resolver: lts-16.31

168+ resolver: lts-20.13

169+ stack_yaml: stack.yaml

74170 sdist_options: "--ignore-check"

75171 stack_build_options: "--flag streamly-benchmarks:-opt"

172+ cabal_version: 3.6.2.0

173+ ignore_error: false

174+ # - name: 8.10.7-coverage

175+ # ghc_version: 8.10.7

176+ # runner: ubuntu-latest

177+ # coverage: "y"

178+ # cabal_version: 3.6.2.0

179+ # ignore_error: false

180+ - name: 8.8.4

181+ ghc_version: 8.8.4

76182 runner: ubuntu-latest

77− - name: 8.6.5+streamk

78− ghc_version: 8.6.5

79− build: cabal-v2

80− cabal_build_options: "--flag streamk --flag -opt"

81− runner: ubuntu-latest

82− - name: 8.6.5+fusion-plugin

183+ build: cabal

184+ cabal_version: 3.6.2.0

185+ cabal_project: cabal.project

186+ disable_sdist_build: "y"

187+ ignore_error: false

188+ - name: 8.6.5-debug-unoptimized

83189 ghc_version: 8.6.5

84− build: cabal-v2

85− cabal_build_options: "--flag fusion-plugin"

86− # haddock generation does not work with 8.6.5+fusion-plugin

87− disable_docs: "y"

88190 runner: ubuntu-latest

89− - name: 8.4.4+debug

90− ghc_version: 8.4.4

91− build: cabal-v2

191+ build: cabal

192+ cabal_version: 3.6.2.0

193+ cabal_project: cabal.project

92194 cabal_build_options: "--flag debug --flag -opt"

195+ disable_sdist_build: "y"

196+ ignore_error: false

197+ - name: hlint

198+ build: hlint

93199 runner: ubuntu-latest

94− - name: doctests

95− ghc_version: 8.8.3

96− build: cabal-v2

97− cabal_build_options: "--flag doctests"

98− disable_dist_checks: "y"

99− cabal_build_targets: doctests

100− runner: ubuntu-latest

200+ ignore_error: true

101201

102202 steps:

103203 - uses: actions/checkout@v2

104204

105− - uses: haskell/actions/setup@v1

106− with:

107− ghc-version: ${{ matrix.ghc_version }}

108− cabal-version: ${{ matrix.cabal_version }}

109−

110205 - uses: actions/cache@v1

111− name: Cache ~/.cabal

206+ name: Cache common directories

112207 with:

113− path: ~/.cabal

114− key: ${{ runner.os }}-${{ matrix.ghc_version }}-cabal

208+ path: |

209+ ~/.local

210+ ~/.cabal

211+ ~/.stack

212+ ~/.ghcup

213+ # Bump the key version to clear the cache

214+ key: ${{ runner.os }}-${{ matrix.ghc_version }}-cabal-v2

115215

116216 - name: Download packcheck

117217 run: |

118− # If a custom stack-yaml is specified, replace the default with that

119− if test -e "$STACK_YAML"; then rm -f stack.yaml && ln -sv $STACK_YAML stack.yaml; else true; fi

120− unset STACK_YAML

121−

122− # Get packcheck if needed

123− CURL=$(which curl)

124− PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh

125− if test ! -e "$PACKCHECK_LOCAL_PATH"; then $CURL -sL -o "$PACKCHECK_LOCAL_PATH" $PACKCHECK_URL; fi;

126− chmod +x $PACKCHECK_LOCAL_PATH

218+ if test ! -e "$PACKCHECK"

219+ then

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

230+ fi

127231

128− - name: Run packcheck

232+ - name: Run tests

129233 run: |

130− bash -c "$PACKCHECK_LOCAL_PATH $BUILD"

234+ if test -n "$COVERAGE"

235+ then

236+ # Run tests with coverage

237+ cabal update

238+ # Build hpc-coveralls if needed

239+ sudo apt-get install -y libcurl4-gnutls-dev

240+ export PATH=$HOME/.cabal/bin:$PATH

241+ which hpc-coveralls 2>/dev/null || cabal install --project-file cabal.project.hpc-coveralls hpc-coveralls

242+ # Run tests and upload results to coveralls.io

243+ bin/test.sh --coverage --raw

244+ # XXX Uncomment this and fix it properly later

245+ # hpc-coveralls --repo-token="$COVERALLS_TOKEN" --coverage-mode=StrictlyFullLines

246+ else

247+ # /usr/local/opt/curl/bin for macOS

248+ export PATH=$HOME/.local/bin:$HOME/.ghcup/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/opt/curl/bin

249+ if test -n "$SUBDIR"

250+ then

251+ mv "$PACKCHECK" "$SUBDIR/packcheck.sh"

252+ # This is required as dist-newstyle will be created on the top level

253+ # directory as it is considered the working dir.

254+ rm cabal.project

255+ cd "$SUBDIR"

256+ fi

257+ bash -c "$PACKCHECK $BUILD"

258+ fi

.github/workflows/packdiff.ymlnew file+39

@@ -0,0 +1,39 @@

1+name: Packdiff

3+on: pull_request

5+jobs:

6+ packdiff:

8+ runs-on: ubuntu-latest

10+ steps:

11+

12+ - name: Download ghc

13+ run: |

14+ GHCUP_VER=0.1.18.0

15+ curl -sL -o ./ghcup https://downloads.haskell.org/~ghcup/$GHCUP_VER/x86_64-linux-ghcup-$GHCUP_VER

16+ chmod +x ./ghcup

17+ GHCVER=8.10.7

18+ ./ghcup install ghc $GHCVER

19+ ./ghcup set ghc $GHCVER

20+ cabal update

21+

22+ - uses: actions/cache@v2

23+ name: Cache ~/.cabal

24+ with:

25+ path: |

26+ ~/.cabal

27+ # Bump the key version to clear the cache

28+ key: cache-v2

29+

30+ - name: Checkout the current branch

31+ uses: actions/checkout@v2

32+ with:

33+ fetch-depth: 0

34+

35+ - name: Run packdiff on streamly-core

36+ run: cabal run packdiff --project-file=cabal.project.packdiff -- streamly-core $(git rev-parse origin/master) $(git rev-parse HEAD)

37+

38+ - name: Run packdiff on streamly

39+ run: cabal run packdiff --project-file=cabal.project.packdiff -- streamly $(git rev-parse origin/master) $(git rev-parse HEAD)

.github/workflows/regression-check.ymlnew file+165

@@ -0,0 +1,165 @@

1+name: Regression checking

3+on:

4+ workflow_dispatch:

5+ pull_request:

7+# References:

8+# https://docs.github.com/en/actions/managing-workflow-runs/manually-running-a-workflow

9+# https://docs.github.com/en/actions/using-workflows/reusing-workflows#reusable-workflows-and-starter-workflows

10+# https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#onworkflow_call

11+# https://docs.github.com/en/actions/learn-github-actions/contexts#about-contexts-and-expressions

12+

13+# You can override the default DIFF_CUTOFF_PERCENT by specifying a cutoff along

14+# with the benchmark target.

15+# Eg, "Data.Async:12" where "Data.Async" is the benchmark target, ":" is the

16+# seperator, and "12" is the new cutoff percent

17+jobs:

18+ check-regressions:

19+ env:

20+ CI_BENCHMARKS_WITH_CUTOFF: >-

21+ Data.Array

22+ Data.MutArray

23+ Data.Array.Generic

24+ Data.Ring.Unboxed

25+ Data.Fold

26+ Data.Fold.Window

27+ Data.Parser

28+ Data.ParserK

29+ Data.StreamD

30+ Data.StreamK:6

31+ Data.Unfold

32+ Data.Stream

33+ Data.Stream.Concurrent

34+ Data.Stream.ConcurrentEager

35+ Data.Stream.ConcurrentInterleaved

36+ Data.Stream.ConcurrentOrdered

37+ FileSystem.Handle

38+ Unicode.Char

39+ Unicode.Stream

40+ Unicode.Utf8

41+ CI_FIELDS: allocated

42+ CI_DIFF_CUTOFF_PERCENT: 3

43+

44+ runs-on: ubuntu-latest

45+

46+ steps:

47+

48+ - name: Update environment

49+ run: |

50+ CI_BENCHMARKS=""

51+ for i in $CI_BENCHMARKS_WITH_CUTOFF

52+ do

53+ bname=$(echo "$i" | cut -d: -f1)

54+ CI_BENCHMARKS="$CI_BENCHMARKS $bname"

55+ done

56+ echo "CI_BENCHMARKS=$CI_BENCHMARKS" >> $GITHUB_ENV

57+

58+ - name: Download ghc

59+ run: |

60+ GHCUP_VER=0.1.18.0

61+ curl -sL -o ./ghcup https://downloads.haskell.org/~ghcup/$GHCUP_VER/x86_64-linux-ghcup-$GHCUP_VER

62+ chmod +x ./ghcup

63+ GHCVER=9.2.7

64+ ./ghcup install ghc $GHCVER

65+ ./ghcup set ghc $GHCVER

66+ cabal update

67+

68+ - uses: actions/cache@v2

69+ name: Cache ~/.cabal

70+ with:

71+ path: |

72+ ~/.cabal

73+ # Bump the key version to clear the cache

74+ key: cache-v2

75+

76+ - name: Cache bench-runner from pr

77+ id: cache-bench-runner-pr

78+ uses: actions/cache@v2

79+ with:

80+ path: bench-runner

81+ # Bump the key version to clear the cache

82+ key: bench-runner-v1

83+

84+ # -----------------------------------------------------------------

85+ # -- Install bench-report in the current directory

86+ # -----------------------------------------------------------------

87+

88+ - name: Checkout the current branch

89+ uses: actions/checkout@v2

90+ with:

91+ clean: false

92+

93+ - name: Install bench-runner

94+ run: |

95+ cabal install bench-runner --project-file=cabal.project.report --installdir=./

96+

97+ # -----------------------------------------------------------------

98+ # -- Generate reports for the base branch and upload

99+ # -----------------------------------------------------------------

100+

101+ - name: Checkout the base branch

102+ uses: actions/checkout@v2

103+ with:

104+ ref: master

105+ clean: false

106+

107+ - name: Run benchmarks

108+ run: |

109+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw

110+

111+ - name: Move charts to charts-master

112+ run: mv charts charts-master

113+

114+ # -----------------------------------------------------------------

115+ # -- Download, generate reports for the current branch and append

116+ # -----------------------------------------------------------------

117+

118+ - name: Checkout the current branch

119+ uses: actions/checkout@v2

120+ with:

121+ clean: false

122+

123+ - name: Copy charts-master to charts

124+ run: cp -r charts-master charts

125+

126+ - name: Run benchmarks and append

127+ run: |

128+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --raw --append

129+

130+ # -----------------------------------------------------------------

131+ # -- Compare

132+ # -----------------------------------------------------------------

133+

134+ - name: List all benchmarks

135+ run: |

136+ ./bench-runner --package-name streamly-benchmarks --package-version 0.0.0 --targets "$CI_BENCHMARKS" --no-measure

137+

138+ - name: Compare benchmarks

139+ run: |

140+

141+ EXIT_STATUS=0

142+

143+ for i in $CI_BENCHMARKS_WITH_CUTOFF

144+ do

145+ arrI=(${i//:/ })

146+

147+ bname=${arrI[0]}

148+ cutoff=${arrI[1]}

149+

150+ test -z "$cutoff" && cutoff=$CI_DIFF_CUTOFF_PERCENT

151+

152+ echo

153+ echo "Checking $bname for regressions greater than $cutoff percent"

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 \

161+ | grep -v "^$"

162+ test $? -eq 1 && EXIT_STATUS=1

163+ done

164+

165+ exit $EXIT_STATUS

.gitignore+7−3

@@ -1,7 +1,11 @@

11# Build files/directories

2−/.stack-work/

3−/dist/

4−/dist-newstyle*/

2+.stack-work/

3+dist/

4+dist-newstyle*/

5+.cabal.nix

6+autom4te.cache/

7+benchmark/bench-report/bin/bench-report

8+charts/

610# Local GHC and Cabal related files

711.ghc.environment*

.hlint.ignore+12−39

@@ -1,67 +1,40 @@

1−src/Streamly/Internal/Data/Stream/SVar.hs

1+core/src/Streamly/Internal/Data/Stream/StreamK/Type.hs

2+core/src/Streamly/Internal/Data/Pipe/Type.hs

3+core/src/Streamly/Internal/Unicode/Stream.hs

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

5+src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs

26src/Streamly/Internal/Data/Stream/Serial.hs

37src/Streamly/Internal/Data/Stream/Zip.hs

4−src/Streamly/Internal/Data/Stream/Parallel.hs

5−src/Streamly/Internal/Data/Stream/Async.hs

6−src/Streamly/Internal/Data/Stream/StreamDK.hs

7−src/Streamly/Internal/Data/Stream/StreamK.hs

8−src/Streamly/Internal/Data/Stream/StreamK/Type.hs

9−src/Streamly/Internal/Data/Stream/Ahead.hs

10−src/Streamly/Internal/Data/Stream/StreamD/Type.hs

11−src/Streamly/Internal/Data/Stream/StreamDK/Type.hs

12−src/Streamly/Internal/Data/Stream/StreamD.hs

13−src/Streamly/Internal/Data/Stream/StreamD/Generate.hs

14−src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs

15−src/Streamly/Internal/Data/Stream/StreamD/Transform.hs

16−src/Streamly/Internal/Data/Stream/StreamD/Exception.hs

17−src/Streamly/Internal/Data/Stream/StreamD/Lift.hs

18−src/Streamly/Internal/Data/Stream/StreamD/Nesting.hs

19−src/Streamly/Internal/Data/Pipe/Type.hs

20−src/Streamly/Internal/Data/SmallArray/Type.hs

21−src/Streamly/Internal/Unicode/Stream.hs

22−src/Streamly/Internal/Data/IORef/Prim.hs

23−src/Streamly/Internal/Data/Array/Prim/Type.hs

24−src/Streamly/Internal/Data/Array/Prim/Mut/Type.hs

25−src/Streamly/Internal/Data/Array/Prim/MutTypesInclude.hs

26−src/Streamly/Internal/Data/Array/Prim/Pinned/Mut/Type.hs

27−src/Streamly/Internal/Data/Array/Prim/Pinned/Type.hs

28−src/Streamly/Internal/Data/Array/Prim/TypesInclude.hs

29−test/Streamly/Test/Common/Array.hs

308test/Streamly/Test/Data/Array.hs

31−test/Streamly/Test/Data/Array/Prim.hs

32−test/Streamly/Test/Data/Array/Prim/Pinned.hs

33−test/Streamly/Test/Data/Array/Foreign.hs

349test/Streamly/Test/Data/Parser.hs

35−test/Streamly/Test/Data/Parser/ParserD.hs

10+test/Streamly/Test/Data/ParserK.hs

3611test/Streamly/Test/Data/SmallArray.hs

3712test/Streamly/Test/Data/Unfold.hs

3813test/Streamly/Test/FileSystem/Event.hs

3914test/Streamly/Test/Prelude/Concurrent.hs

15+test/Streamly/Test/Data/Stream/Concurrent.hs

16+test/lib/Streamly/Test/Prelude/Common.hs

4017test/Streamly/Test/Prelude/Fold.hs

4118test/Streamly/Test/Prelude/Rate.hs

4219test/Streamly/Test/Prelude/Serial.hs

4320test/Streamly/Test/Unicode/Stream.hs

21+test/Streamly/Test/Data/Unbox.hs

4422benchmark/lib/Streamly/Benchmark/Common.hs

4523benchmark/lib/Streamly/Benchmark/Common/Handle.hs

4624benchmark/lib/Streamly/Benchmark/Prelude.hs

4725benchmark/NanoBenchmarks.hs

4826benchmark/Streamly/Benchmark/Data/Array.hs

49−benchmark/Streamly/Benchmark/Data/ArrayOps.hs

50−benchmark/Streamly/Benchmark/Data/NestedUnfoldOps.hs

5127benchmark/Streamly/Benchmark/Data/Parser.hs

52−benchmark/Streamly/Benchmark/Data/Parser/ParserD.hs

28+benchmark/Streamly/Benchmark/Data/ParserK.hs

5329benchmark/Streamly/Benchmark/Data/Stream/StreamDK.hs

5430benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs

5531benchmark/Streamly/Benchmark/Data/Unfold.hs

5632benchmark/Streamly/Benchmark/FileSystem/Handle.hs

5733benchmark/Streamly/Benchmark/Prelude/Async.hs

34+benchmark/Streamly/Benchmark/Prelude/Concurrent.hs

35+benchmark/Streamly/Benchmark/Prelude/Merge.hs

5836benchmark/Streamly/Benchmark/Prelude/Parallel.hs

5937benchmark/Streamly/Benchmark/Prelude/Rate.hs

60−benchmark/Streamly/Benchmark/Prelude/Serial/Exceptions.hs

61−benchmark/Streamly/Benchmark/Prelude/Serial/Nested.hs

62−benchmark/Streamly/Benchmark/Prelude/Serial/Split.hs

63−benchmark/Streamly/Benchmark/Prelude/Serial/Transformation1.hs

6438benchmark/Streamly/Benchmark/Prelude/WAsync.hs

6539benchmark/Streamly/Benchmark/Prelude/ZipAsync.hs

6640benchmark/Streamly/Benchmark/Prelude/ZipSerial.hs

67−benchmark/Streamly/Benchmark/Unicode/Stream.hs

.hlint.yaml+17−2

@@ -10,6 +10,8 @@

1010- suggest: {name: "Unused LANGUAGE pragma"}

1111- suggest: {name: "Eta reduce"}

1212- suggest: {name: "Reduce duplication"}

13+

14+# Warnings currently ignored

1315- ignore: {name: "Use list literal pattern"}

1416- ignore: {name: "Use tuple-section"} # requires GHC extension

1517- ignore: {name: "Use fromMaybe"} # may want to use this suggestion, but it didn't match the common idiom of the library

@@ -22,11 +24,24 @@

2224- ignore: {name: "Use uncurry"}

2325- ignore: {name: "Redundant $!"}

2426- ignore: {name: "Use fmap"}

27+- ignore: {name: "Use ++"}

2528

29+# Warnings ignored in specific places

30+- ignore: {name: "Use mapM", within: Stream.Transform}

31+- ignore: {name: "Use traverse", within: Stream.Transform}

32+- ignore: {name: "Redundant <*", within: Stream.Expand}

33+- ignore: {name: "Redundant bracket", within: Stream.Split}

34+- ignore: {name: "Use isDigit", within: Streamly.Internal.Unicode.Parser}

2635

2736# Specify additional command line arguments

2837#

29−# - arguments: [--color, --cpp-simple, -XQuasiQuotes]

38+- arguments:

39+ [ --cpp-include=src

40+ , --cpp-include=src/Streamly/Internal/Data/Stream

41+ , --cpp-include=src/Streamly/Internal/Data/Array

42+ , --cpp-include=test

43+ , --cpp-define=CABAL_OS_LINUX

44+ ]

3045

3146

3247# Control which extensions/flags/modules/functions can be used

@@ -56,7 +71,7 @@

5671# Turn on hints that are off by default

5772#

5873# Ban "module X(module X) where", to require a real export list

59−# - warn: {name: Use explicit module export list}

74+- warn: {name: Use explicit module export list}

6075#

6176# Replace a $ b $ c with a . b $ c

6277# - group: {name: dollar, enabled: true}

.packcheck.ignore+32

@@ -1,4 +1,36 @@

1+.circleci/config.yml

2+.ghci

3+.github/workflows/haskell.yml

4+.github/workflows/regression-check.yml

5+.github/workflows/packdiff.yml

6+.gitignore

7+.hlint.ignore

8+.hlint.yaml

19.packcheck.ignore

10+appveyor.yml

11+benchmark/bench-runner/default.nix

12+benchmark/bench-runner/cabal.project

13+bin/ghc.sh

14+bin/repl

15+bin/run-ci.sh

16+bin/run-repl-quick.sh

17+cabal.project

218cabal.project.coverage

19+cabal.project.doctest

20+cabal.project.ghc-head

321cabal.project.hpc-coveralls

22+cabal.project.O0

23+cabal.project.report

24+cabal.project.packdiff

25+cabal.project.streamly

26+cabal.project.Werror

27+cabal.project.Werror-nocode

28+core/

29+default.nix

30+examples/README.md

431hie.yaml

32+stack.yaml

33+targets/default.nix

34+targets/cabal.project

35+test/test-runner/default.nix

36+test/test-runner/cabal.project

.travis.ymldeleted−242

@@ -1,242 +0,0 @@

1−# packcheck-0.4.2

2−# You can use any of the options supported by packcheck as environment

3−# variables here. See https://github.com/harendra-kumar/packcheck for all

4−# options and their explanation.

5−

6−if: branch = master

7−

8−# dist: trusty

9−dist: xenial

10−env:

11− # ------------------------------------------------------------------------

12− # Global options, you can use these per build as well

13− # ------------------------------------------------------------------------

14− global:

15− # ------------------------------------------------------------------------

16− # Common options

17− # ------------------------------------------------------------------------

18− - GHC_OPTIONS="-Werror"

19− - CABAL_REINIT_CONFIG=y

20− - LC_ALL=C.UTF-8

21−

22− # ------------------------------------------------------------------------

23− # What to build

24− # ------------------------------------------------------------------------

25− # - DISABLE_TEST=y

26− # - DISABLE_BENCH=y

27− # - DISABLE_DOCS=y

28− # - DISABLE_SDIST_BUILD=y

29− # - DISABLE_DIST_CHECKS=y

30− - ENABLE_INSTALL=y

31−

32− # ------------------------------------------------------------------------

33− # stack options

34− # ------------------------------------------------------------------------

35− # Note requiring a specific version of stack using STACKVER may fail due to

36− # github API limit while checking and upgrading/downgrading to the specific

37− # version.

38− #- STACKVER="1.6.5"

39− - STACK_UPGRADE="y"

40−

41− # ------------------------------------------------------------------------

42− # cabal options

43− # ------------------------------------------------------------------------

44− - CABAL_CHECK_RELAX=y

45− - CABAL_NO_SANDBOX=y

46− - CABAL_HACKAGE_MIRROR=hackage.haskell.org:http://hackage.fpcomplete.com

47−

48− # ------------------------------------------------------------------------

49− # Where to find the required tools

50− # ------------------------------------------------------------------------

51− - PATH=/bin:/usr/bin

52− - TOOLS_DIR=/opt

53−

54− # ------------------------------------------------------------------------

55− # Location of packcheck.sh (the shell script invoked to perform CI tests ).

56− # ------------------------------------------------------------------------

57− # You can either commit the packcheck.sh script at this path in your repo or

58− # you can use it by specifying the PACKCHECK_REPO_URL option below in which

59− # case it will be automatically copied from the packcheck repo to this path

60− # during CI tests. In any case it is finally invoked from this path.

61− - PACKCHECK_LOCAL_PATH="./packcheck.sh"

62− # If you have not committed packcheck.sh in your repo at PACKCHECK_LOCAL_PATH

63− # then it is automatically pulled from this URL.

64− - PACKCHECK_GITHUB_URL="https://raw.githubusercontent.com/harendra-kumar/packcheck"

65− - PACKCHECK_GITHUB_COMMIT="563702bd02c41343dcd3dfcfef0845ca428a9240"

66−

67−notifications:

68− email:

69− on_success: change

70− on_failure: always

71−

72−# This matrix has total of 6 builds enabled, we try to cover last three major

73−# GHC versions, stack, cabal, Linux and OSX with minimum number of builds

74−# possible. You can uncomment other disabled builds or comment out existing

75−# ones to your taste.

76−#

77−# We pre-install the cabal-install package to not incur the penalty of building

78−# it the first time in cached builds or every time in uncached builds.

79−matrix:

80− include:

81−

82− # --------------------------------------------------------------------------

83− # (Linux) cabal builds (BUILD=cabal-v1, BUILD=cabal-v2). Common envvars are:

84− # CABAL_CONFIGURE_OPTIONS (cabal-v1), CABAL_BUILD_OPTIONS (cabal-v2)

85− # --------------------------------------------------------------------------

86−

87− #- env: BUILD=cabal-v2 GHCVER=head

88− # addons: {apt: {packages: [cabal-install-head,ghc-head], sources: [hvr-ghc]}}

89−

90− # With coverage

91− - name: "GHC 8.10.1+inspection+Werror+coverage"

92− env: BUILD=cabal-v2 COVERALLS_OPTIONS=" --repo-token=9ezA743hCAcmzX3Ic273LhNlIXVdl7D1l --coverage-mode=StrictlyFullLines --exclude-dir=test" CABAL_PROJECT="cabal.project.coverage" GHC_OPTIONS=""

93− addons: {apt: {packages: [cabal-install-3.2,ghc-8.10.1], sources: [hvr-ghc]}}

94−

95− # Built on github ci/on travis-stack-linux/on travis-stack-macOS

96− #- env: BUILD=cabal-v2 GHCVER=8.8.4 GHC_OPTIONS="" CABAL_BUILD_OPTIONS=""

97− # addons: {apt: {packages: [cabal-install-3.2,ghc-8.8.4], sources: [hvr-ghc]}}

98− # os: linux

99− # arch: amd64

100−

101− # Built on github ci

102− #- env: BUILD=cabal-v2 GHCVER=8.6.5 GHC_OPTIONS="" CABAL_BUILD_OPTIONS=""

103− # addons: {apt: {packages: [cabal-install-3.2,ghc-8.6.5], sources: [hvr-ghc]}}

104− # os: linux

105− # arch: amd64

106−

107− - name: "GHC 8.4.4+x86+debug"

108− env: BUILD=cabal-v2 GHCVER=8.4.4 GHC_OPTIONS="" CABAL_BUILD_OPTIONS="--flag debug"

109− addons: {apt: {packages: [cabal-install-3.2,ghc-8.4.4], sources: [hvr-ghc]}}

110− os: linux

111− arch: x86

112−

113− # Built on circleci

114− # GHC-8.2.2 hogs memory leading to out-of-memory when compiling benchmarks

115− #- env: BUILD=cabal-v2 GHCVER=8.2.2 GHC_OPTIONS="" DISABLE_BENCH=y

116− # addons: {apt: {packages: [cabal-install-2.4,ghc-8.2.2], sources: [hvr-ghc]}}

117−

118− - name: "GHC 8.0.2"

119− env: BUILD=cabal-v2 GHCVER=8.0.2 GHC_OPTIONS=""

120− addons: {apt: {packages: [cabal-install-3.2,ghc-8.0.2], sources: [hvr-ghc]}}

121− os: linux

122− arch: amd64

123−

124− # You can specify build flags like this:

125− #- env: BUILD=cabal-v2 CABAL_BUILD_OPTIONS="--flags=dev"

126− # addons: {apt: {packages: [cabal-install-head,ghc-head], sources: [hvr-ghc]}}

127−

128− # --------------------------------------------------------------------------

129− # GHCJS cabal builds

130− # --------------------------------------------------------------------------

131−

132− # Use CABAL_BUILD_OPTIONS to pass any options to cabal e.g. project-file

133− # DISABLE_SDIST_BUILD is set because of a cabal issue. 'cabal info'

134− # unnecessarily requires "ghc".

135− - name: "GHCJS 8.4+no-test+no-docs"

136− env: BUILD=cabal-v2 ENABLE_GHCJS=y DISABLE_TEST=y ENABLE_INSTALL= DISABLE_DOCS=y DISABLE_SDIST_BUILD=y

137− addons:

138− apt:

139− sources:

140− - hvr-ghc

141− - sourceline: 'ppa:hvr/ghcjs'

142− - sourceline: 'deb https://deb.nodesource.com/node_11.x xenial main'

143− key_url: 'https://deb.nodesource.com/gpgkey/nodesource.gpg.key'

144− packages: [cabal-install-3.2,ghcjs-8.4]

145−

146− # --------------------------------------------------------------------------

147− # (Linux) stack builds (BUILD=stack). Some common envvars for stack builds

148− # are: STACK_YAML, STACK_OPTIONS, STACK_BUILD_OPTIONS

149− # --------------------------------------------------------------------------

150− #

151− # NOTE: cabal-install is required for some of the packcheck options to work.

152− # We just install it so that packcheck does not build it from source

153− # otherwise.

154−

155− #- env: BUILD=stack RESOLVER=nightly

156− # addons: {apt: {packages: [cabal-install-1.24], sources: [hvr-ghc]}}

157−

158− - name: "GHC 8.8+stack lts-16.12"

159− env: BUILD=stack RESOLVER=lts-16.12 GHCVER=8.8 SDIST_OPTIONS="--ignore-check"

160− addons: {apt: {packages: [cabal-install-3.2], sources: [hvr-ghc]}}

161− os: linux

162− arch: amd64

163−

164− #- env: BUILD=stack RESOLVER=lts-12 GHCVER=8.4

165− # addons: {apt: {packages: [cabal-install-2.4], sources: [hvr-ghc]}}

166−

167− # GHC-8.2.2 hogs memory leading to out-of-memory when compiling benchmarks

168− # So disable the benchmarks for this build.

169− #- env: BUILD=stack GHCVER=8.2.2 RESOLVER=lts-11 GHC_OPTIONS="" DISABLE_SDIST_BUILD=y DISABLE_DIST_CHECKS=y DISABLE_BENCH=y

170− # addons: {apt: {packages: [cabal-install-2.4], sources: [hvr-ghc]}}

171−

172− #- env: BUILD=stack RESOLVER=lts-9 GHCVER=8.0

173− # addons: {apt: {packages: [cabal-install-2.4], sources: [hvr-ghc]}}

174−

175− #- env: BUILD=stack RESOLVER=lts-6 GHCVER=7.10

176− # addons: {apt: {packages: [cabal-install-2.4], sources: [hvr-ghc]}}

177−

178− # You can keep a STACK_YAML file at any path location

179− #- env: BUILD=stack STACK_YAML=.ci/stack-8.0.yaml

180−

181− # You can specify build flags like this:

182− #- env: BUILD=stack RESOLVER=lts-12 STACK_BUILD_OPTIONS="--flag packcheck:dev"

183−

184− # --------------------------------------------------------------------------

185− # OS X builds

186− # --------------------------------------------------------------------------

187−

188− # On OSX autoreconf is not installed therefore disable sdist build

189− - name: "GHC 8.8"

190− env: BUILD=stack RESOLVER=lts-16.12 GHCVER=8.8 GHC_OPTIONS="" DISABLE_SDIST_BUILD=y SDIST_OPTIONS="--ignore-check"

191− os: osx

192−

193− # --------------------------------------------------------------------------

194− # Lint e.g. HLINT_COMMANDS="hlint lint src; hlint lint test"

195− # --------------------------------------------------------------------------

196−

197− - name: "hlint src"

198− env: BUILD=cabal-v2 HLINT_OPTIONS="lint" HLINT_TARGETS="src"

199−

200− - name: "hlint test benchmarks"

201− env: BUILD=cabal-v2 HLINT_OPTIONS="lint" HLINT_TARGETS="test benchmarks"

202−

203− # --------------------------------------------------------------------------

204− # Builds that are allowed to fail

205− # --------------------------------------------------------------------------

206−

207− allow_failures:

208− - env: BUILD=cabal-v2 GHCVER=head GHC_OPTIONS=""

209− - env: BUILD=stack RESOLVER=nightly DISABLE_SDIST_BUILD=y DISABLE_DIST_CHECKS=y

210− - env: BUILD=cabal-v2 HLINT_OPTIONS="lint" HLINT_TARGETS="test benchmarks"

211−

212−# ------------------------------------------------------------------------

213−# Settings beyond this point are advanced and normally not tweaked

214−# ------------------------------------------------------------------------

215−

216−language: generic

217−sudo: false

218−cache:

219− directories:

220− - $HOME/.cabal

221− - $HOME/.ghc

222− - $HOME/.ghcjs

223− - $HOME/.local

224− - $HOME/.stack

225−install: true

226−

227−script:

228− - |

229− # If a custom stack-yaml is specified, replace the default with that

230− if test -e "$STACK_YAML"; then rm -f stack.yaml && ln -sv $STACK_YAML stack.yaml; else true; fi

231− unset STACK_YAML

232−

233− # Get packcheck if needed

234− CURL=$(which curl)

235− PACKCHECK_URL=${PACKCHECK_GITHUB_URL}/${PACKCHECK_GITHUB_COMMIT}/packcheck.sh

236− if test ! -e "$PACKCHECK_LOCAL_PATH"; then $CURL -sL -o "$PACKCHECK_LOCAL_PATH" $PACKCHECK_URL; fi;

237− chmod +x $PACKCHECK_LOCAL_PATH

238−

239− # This script is governed by various PACKCHECK envvars that are set above.

240− # In addition, hpc-coveralls needs TRAVIS, TRAVIS_JOB_ID variables set by

241− # the travis CI environment.

242− - bash -c "$PACKCHECK_LOCAL_PATH $BUILD PATH=/bin:/usr/bin"

CHANGELOG.mdnew file+1

@@ -0,0 +1 @@

1+docs/User/Project/Changelog.md

CONTRIBUTING.mdmode 100644 → 120000+1−251

@@ -1,251 +0,0 @@

1−# Contributors' Guide

2−

3−## Bug Reports

4−

5−Please feel free to [open an

6−issue](https://github.com/composewell/streamly/issues) for any questions,

7−suggestions, issues or bugs in the library. In case you are reporting a bug

8−we will appreciate if you provide as much detail as possible to reproduce or

9−understand the problem, but nevertheless you are encouraged to open an issue

10−for any problem that you may encounter.

11−

12−## Picking Issues to Work on

13−

14−Beginners are encouraged to pick up issues that are marked `help wanted`. It is

15−a good idea to update the issue expressing your intent so that others do not

16−duplicate the effort and people with a background on the issue can help.

17−

18−## Contributing A Change

19−

20−If the feature makes significant changes to design, we encourage you to open an

21−issue as early as possible so that you do not have to redo much work because of

22−changes in design decisions. However, if you are confident, you can still go

23−ahead and take that risk as the maintainers are supposed to be reasonable

24−people.

25−

26−### Pull Requests (PR)

27−

28−Please feel free to [send a pull

29−request (PR)](https://github.com/composewell/streamly/pulls) whether it is a

30−single letter typo fix or a complex change. We will accept any PR that makes a

31−net positive change to the package. We encourage you to provide a complete,

32−consistent change with test, documentation and benchmarks. You can contact the

33−[maintainers](https://gitter.im/composewell/streamly) for any help or

34−collaboration needed in that regard. However, if due to lack of time you are

35−not able to complete the PR, you are still welcome to submit it, maintainers

36−will try their best to actively contribute and pick up your change as long as

37−the change is approved.

38−

39−### Pull Request (PR) Checklist

40−

41−Here is a quick checklist for a PR, for details please see the next section:

42−

43−* PR contains one logical changeset

44−* Each commit in the PR consists of a logical change

45−* Commits are rebased/squashed/fixup/reordered as needed

46−* Stylistic changes to irrelevant parts of the code are separated in

47− independent commits.

48−* Code is formatted as per the style of the file or that of other files

49−* Compiler warnings are fixed

50−* Reasonable hlint suggestions are accepted

51−* Tests are added to cover the changed parts

52−* All [tests](test) pass

53−* [Performance benchmarks](benchmark) are added, where applicable

54−* No significant regressions are reported by [performance benchmarks](benchmark/README.md)

55−* Haddock documentation is added to user visible APIs and data types

56−* Tutorial module, [README](README.md), and [guides](docs) are updated if

57− necessary.

58−* [Changelog](Changelog.md) is updated if needed

59−* The code conforms to the license, it is not stolen, credit is given,

60− copyright notices are retained, original license is included if needed.

61−

62−### Structuring Pull Requests

63−

64−__Lean PR:__ Please keep the reviewer in mind when sending pull

65−requests. Use one PR for each logical changeset. A lean and thin

66−PR with one independent logical change is more likely to be reviewed and

67−merged quickly than a big monolithic PR with several unrelated changes.

68−

69−__PR Dependencies:__ If your change depends on an earlier PR you can

70−create a branch from the old PR's branch, and raise a new PR targeting

71−to merge into the old PR branch. Do not push the commits to the same PR

72−just because the commit depends on that PR.

73−

74−__Commits:__ You are encouraged to group a logically related set of

75−changes into a single commit. When the overall changeset is largish you

76−can divide it into multiple smaller commits, with each commit having

77−a logically grouped changeset and the title summarizing the logical

78−grouping. Always keep in mind a logical division helps reviewers

79−understand and review your code quickly, easier history tracking and

80−when required clean reversal changes.

81−

82−__Functional Changes:__ Keep the reviewer in mind when making

83−changes. Please resist the temptation to make style related changes to

84−surrounding code unless you are changing that code anyway . Whenever

85−possible, try to separate unrelated refactoring changes which do not

86−affect functionality in separate commits so that it is easier for the

87−reviewer to verify functional changes.

88−

89−__Style Changes:__ Make sure that your IDE/Editor is not automatically

90−making sweeping style changes to all the files you are editing. That

91−makes separating the signal from the noise very difficult and makes

92−everything harder. If you would like to make style related changes

93−then please send a separate PR with just those changes and no other

94−functionality changes.

95−

96−__Rebasing:__ If your commits reflect how you fixed intermediate

97−problems during testing or made random changes at different times you

98−may have to squash your changes (`git rebase -i`) into a single commit

99−or logically related set of commits.

100−

101−### Resolving Conflicts

102−

103−If during the course of development or before you send the PR you find that

104−your changes are conflicting with the master branch then use `git rebase

105−master` to rebase your changes on top of master. DO NOT MERGE MASTER INTO YOUR

106−BRANCH.

107−

108−### Testing

109−

110−It is a good idea to include tests for the changes where applicable. See the

111−existing tests [here](test).

112−

113−### Documentation

114−

115−For user visible APIs, it is a good idea to provide haddock documentation that

116−is easily understood by the end programmer and does not sound highfalutin,

117−and preferably with examples. If your change affects the tutorial or needs to

118−be mentioned in the tutorial then please update the tutorial. Check if the

119−additional [guides](docs) are affected or need to updated.

120−

121−### Performance Benchmarks

122−

123−It is a good idea to run performance benchmarks to see if your change affects

124−any of the existing performance benchmarks. If you introduced something new

125−then you may want to add benchmarks to check if it performs as well as expected

126−by the programmers to deem it usable.

127−

128−See the [README](benchmark/README) file in the `benchmark` directory for more

129−details on how to run the benchmarks.

130−

131−The first level of check is the regression in "allocations", this is

132−the most stable measure of regression. "bytesCopied" is another stable

133−measure, it gives an idea of the amount of long lived data being copied

134−across generations of GC.

135−

136−The next measure to look at is "cpuTime" this may have some variance

137−from run to run because of factors like cpu frequency scaling, load on

138−the system or the number of context switches etc. However, the variance

139−would usually be within 5-10%, anything more than that is likely to be a

140−red flag.

141−

142−Quite often an increase in "cpuTime" would correspond to an increase

143−in "allocations". Increase in "allocations" indicates an inefficiency

144−in computing due to too much GC activity e.g. due to lack of

145−fusion. However, it is also possible for the cpu time to go up without

146−the allocations going up, this indicates an inefficiency in processing

147−in general or more CPU being used for the same task. It could be because

148−of inefficient code generation, branch mis-predictions or lack of cache

149−locality etc.

150−

151−For concurrent benchmarks we can compare "cpuTime" and "time" to check

152−the degree of concurrency and total efficiency.

153−

154−### Changelog

155−

156−Any new changes that affect the user of the library in some way must be

157−documented under `Unreleased` section at the top of the `Changelog`. The

158−changes in the changelog must be organized in the following categories, in that

159−order:

160−

161−* Breaking Changes

162−* Enhancements

163−* Bug Fixes

164−* Deprecations

165−

166−If there are very few changes then you can just prefix a bullet with these

167−annotations. If there are many changes make sections to group them. A section

168−can be absent if there is nothing to add in it.

169−

170−If you make changes that are incompatible with the released versions

171−of the library please indicate that in the `Changelog` as `Breaking Changes`

172−and also write short notes regarding what the programmers need to do to adapt

173−their existing code to the new change.

174−

175−### Licensing

176−

177−If you have copied code from elsewhere you need to conform to the

178−licensing terms of the original code. Usually you would need to add a

179−copyright notice in the source header, and include the license of the

180−original code as per the terms of the license. If the code you are

181−copying does not have an associated license please do not use it.

182−

183−## Developer documentation

184−

185−To build haddock documentation for all modules, including the ones not exposed

186−to users of the library, use the following commands:

187−

188−```

189−$ cabal haddock

190−$ stack haddock --no-haddock-deps

191−```

192−

193−For design documentation see the `design` directory.

194−

195−## Coding Guidelines

196−

197−### Coding Style

198−

199−Please see [the Haskell coding style guide](https://github.com/composewell/haskell-dev/blob/master/coding-style.rst).

200−

201−### StreamD coding style

202−

203−Some conventions that we follow in the StreamD code are illustrated by the

204−following example:

205−

206−```

207−mapM f (Stream step1 state1) = Stream step state

208− where

209−

210− step gst st = do

211− r <- step1 (adaptState gst) st

212− case r of

213− Yield x s -> f x >>= \a -> return $ Yield a s

214− Skip s -> return $ Skip s

215− Stop -> return Stop

216−```

217−

218−* For the input streams use numbering for `step` and `state` e.g.

219− step1/state1. For the output stream use `step` and `state`.

220−* For state argument of `step`, use `st`.

221−* For result of executing a `step` use `r` or `res`

222−* For the yielded element use `x`

223−* For the yielded state use `s`

224−

225−In general, the rule is - the shorter the scope of a variable the shorter its

226−name can be. For example, `s` has the shortest scope in the above code, `st`

227−has a bigger scope and `state` has the biggest scope.

228−

229−## Design guides

230−

231−See [the design directory](design) for design guidelines and documents.

232−

233−### Tricky Parts

234−

235−The state-passing through each API is currently fragile. Every time we run a

236−stream we need to be careful about the state we are passing to it. In case of

237−folds where there is no incoming state, we start with the initial state

238−`defState`. When we have an incoming state passed to us there are two cases:

239−

240−1. When we are building a concurrent stream that needs to share the same `SVar`

241− we pass the incoming state as is.

242−2. In all other cases we must not share the SVar and every time we pass on the

243− state to run a stream we must use `adaptState` to reset the `SVar` in the

244− state.

245−

246−When in doubt just use `adaptState` on the state before passing it on, we will at

247−most lose concurrency but the behavior will be correct.

248−

249−There is no type level enforcement about this as of now, and therefore we need

250−to be careful when coding. There are specific tests to detect and report any

251−problems due to this, all transform operations must be added to those tests.

@@ -0,0 +1 @@

1+docs/Developer/Contributing.md

INSTALL.mddeleted−298

@@ -1,298 +0,0 @@

1−<!--

3−SPDX-License-Identifer: BSD-3-Clause

4−-->

5−

6−# Getting started with the `streamly` package

7−

8−This guide will show you how to write a simple program that uses

9−`streamly`, using the [`cabal`](https://www.haskell.org/cabal/) build

10−manager for Haskell.

11−

12−<!-- TODO: Add instructions for `stack` and `nix`.

13−

14−If you are using `stack` or `nix` please make sure to add the latest

15−version from Hackage to your tool configuration. -->

16−

17−No prior knowledge of either Haskell or of `cabal` is needed. We do

18−however assume that you are using a command-line shell on a POSIX

19−operating system. If you are running Windows™ then you may need

20−to run a command-line shell under `msys` and some of the commands

21−below may also need to be changed in small ways to make them work.

22−

23−**Note**: If you are new to Haskell you may find the [Haskell Getting

24−Started

25−Guide](https://github.com/composewell/haskell-dev/blob/master/getting-started.rst)

26−to be useful.

27−

28−If you know your way around Haskell, and have an up to date toolchain

29−already installed, then you can jump straight to the section titled

30−"[_Prepare Your Build Directory_](#user-content-prepare-your-build-directory)".

31−

32−## Getting started with `streamly` using `cabal`

33−

34−To get started, you will need a recent `cabal` binary to be installed

35−on your system.

36−

37−### Installing `cabal`

38−

39−A pre-packaged `cabal` binary may already be available for your

40−operating system.

41−

42−For example, on Debian GNU/Linux, you could install `cabal` using::

43−

44−```

45−$ sudo apt install cabal-install

46−```

47−

48−### Installing `ghc`

49−

50−You would also need to install the Glasgow Haskell Compiler `ghc`. In

51−most operating systems, using the system's package manager to install

52−`cabal` would also bring in a version of `ghc` as a dependency.

53−

54−Please verify that `ghc` is present:

55−

56−```

57−$ ghc --version

58−The Glorious Glasgow Haskell Compilation System, version 8.0.2

59−```

60−

61−If `ghc` isn't present, please install it using your operating

62−system's package manager. For example, on Debian GNU/Linux, use:

63−

64−```

65−$ sudo apt install ghc

66−```

67−

68−### Update `cabal` if necessary

69−

70−Many operating systems ship an old version of `cabal`; in order to use

71−`streamly` you should use `cabal` version 3.0 (or later).

72−

73−You can check the installed version of `cabal` by using its

74−`--version` flag:

75−

76−```

77−$ which cabal

78−/usr/bin/cabal

79−$ /usr/bin/cabal --version

80−cabal-install version 1.24.0.2

81−compiled using version 1.24.2.0 of the Cabal library

82−```

83−

84−In this example, the installed `cabal` binary is too old for our

85−needs. It would need to be upgraded.

86−

87−You can ask `cabal` to upgrade itself (please see

88−<https://www.haskell.org/cabal/>):

89−

90−```

91−$ cabal install Cabal cabal-install

92−Resolving dependencies...

93−Downloading base16-bytestring-0.1.1.7...

94−... lots of build output ...

95−Building cabal-install-3.0.0.0...

96−Installed cabal-install-3.0.0.0

97−```

98−

99−`cabal` will usually place its compiled binaries inside the directory

100−`$HOME/.cabal/bin`.

101−

102−You can verify the version of your newly installed binary by using the

103−`--version` flag again:

104−

105−```

106−$ $HOME/.cabal/bin/cabal --version

107−cabal-install version 3.0.0.0

108−compiled using version 3.0.2.0 of the Cabal library

109−```

110−

111−If you have upgraded `cabal`, do be sure to specify `$HOME/.cabal/bin`

112−early in your `PATH` shell variable, so that the new binary gets used

113−instead of the older version on your system.

114−

115−```

116−$ PATH=$HOME/.cabal/bin:$PATH

117−```

118−

119−Once you have `cabal` version 3.0 (or later) successfully installed,

120−please refresh its package list by using `cabal update`.

121−

122−```

123−$ cabal update

124−Downloading the latest package list from hackage.haskell.org

125−```

126−

127−### Prepare Your Build Directory

128−

129−Next, create a build directory, so that you can use `cabal`'s isolated

130−builds feature.

131−

132−```

133−$ mkdir streamly-play

134−$ cd streamly-play

135−```

136−

137−Run `cabal init` to create an initial set of project files:

138−

139−```

140−$ cabal init --minimal --dependency base --dependency streamly

141−

142−Generating LICENSE...

143−... other messages ...

144−Generating Main.hs...

145−Generating streamly-play.cabal...

146−

147−Warning: no synopsis given. You should edit the .cabal file and add one.

148−You may want to edit the .cabal file and add a Description field.

149−```

150−

151−This invocation will set up a build with two build dependencies,

152−namely `base` and `streamly`. You can add additional dependencies

153−later, by editing the `build-depends` section of the generated cabal

154−file `streamly-play.cabal`. Please see the [Cabal User

155−Guide](https://www.haskell.org/cabal/users-guide/) for more

156−information on how to configure `cabal`.

157−

158−This invocation also creates a skeletal `Main.hs` program which we

159−will use later.

160−

161−### Try `streamly` in the GHCi REPL

162−

163−You can now try out `streamly` using the `GHCi` interpreter's

164−read-eval-print-loop (REPL) facility.

165−

166−To start up the GHCi REPL using the released `streamly` version on

167−Hackage, please use:

168−

169−```

170−$ cabal repl --build-depends streamly

171−... plenty of build messaages, the first time around ...

172−GHCi, version 8.8.3: https://www.haskell.org/ghc/ :? for help

173−[1 of 1] Compiling Main ( Main.hs, interpreted )

174−Ok, one module loaded.

175−*Main>

176−```

177−

178−Once at the `*Main>` prompt, you can import `streamly` and use it

179−directly:

180−

181−```

182−*Main> import qualified Streamly.Prelude as S

183−

184−*Main S> S.drain $ S.mapM print $ S.fromList [1..3]

185−1

186−2

187−3

188−*Main S>

189−```

190−

191−For the curious, here is a high level overview of what these lines

192−do:

193−

194−1. `import qualified Streamly.Prelude as S` imports the Streamly

195− prelude into GHCi, and makes it available as module `S`.

196−2. `[1..3]` generates the Haskell list `[1, 2, 3]`.

197−3. `S.fromList` transforms that list into a stream of integers.

198−4. `S.mapM print` transforms the stream of integers into a stream of

199− actions that would print those integers when executed.

200−5. `S.drain` transforms that stream of actions into an IO action that

201− `main` or GHCi's REPL can execute.

202−

203−These concepts are explained in greater detail in the [Streamly

204−Tutorial][tutorial].

205−

206−#### Using a specific version of `streamly` in the REPL

207−

208−You can also ask `cabal` to use a specific version of `streamly` by

209−adding a version number constraint to the `--build-depends` flag:

210−

211−```

212−$ cabal repl --build-depends streamly==0.7.2

213−[1 of 1] Compiling Main ( Main.hs, interpreted )

214−Ok, modules loaded: Main.

215−*Main>

216−```

217−

218−#### (Advanced) Using the development version of `streamly` in the REPL

219−

220−To use the development version of `streamly`, we need to configure

221−`cabal` to fetch it from Github.

222−

223−Create a `cabal.project` file in the current directory with the

224−following content:

225−

226−```

227−packages: .

228−source-repository-package

229− type: git

230− location: https://github.com/composewell/streamly

231− tag: master

232−```

233−

234−With this file present, `cabal` will fetch and build the current

235−version of `streamly` from Github every time it is run. For example:

236−

237−```

238−$ cabal repl

239−... fetches the 'master' branch of streamly from Github ...

240−... build messages ...

241−[1 of 1] Compiling Main v ( Main.hs, interpreted )

242−Ok, modules loaded: Main.

243−*Main>

244−```

245−

246−### Using `streamly` in a standalone program

247−

248−Let us now turn the single-line stanza above into a standalone program

249−that uses `streamly`.

250−

251−Edit `Main.hs` to contain the following:

252−

253−```haskell

254−module Main where

255−

256−import qualified Streamly.Prelude as S

257−

258−main :: IO ()

259−main = S.drain $ S.mapM print $ S.fromList [1..3]

260−```

261−

262−Build and run this program using `cabal run`:

263−

264−```

265−$ cabal run

266−... build messages ...

267−1

268−2

269−3

270−```

271−

272−## Which version of `streamly` should you use?

273−

274−If you are new to Streamly, we recommend using latest [stable release

275−of streamly][streamly-hackage] on Hackage.

276−

277−If you need access to cutting edge features (and do not mind the

278−occasional breakage), please use the [development version of

279−streamly][streamly-github] on Github.

280−

281−

282−## Next Steps

283−

284−If you got this far successfully, congratulations!

285−

286−* For an overview of the `streamly` package, please read the

287− [Streamly Tutorial][tutorial].

288−* Please browse the code examples in the

289− [`examples`](./examples/README.md) directory.

290−* If you would like to start on a real world project, please take a

291− look at the [recommended compilation options](./docs/Build.md).

292−

293−

294−

295−

296− [tutorial]: https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html

297− [streamly-hackage]: https://hackage.haskell.org/package/streamly

298− [streamly-github]: https://github.com/composewell/streamly

LICENSE+68

@@ -25,3 +25,71 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

2525CAUSED 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.

28+

29+-------------------------------------------------------------------------------

30+fsnotify-0.3.0.1 (http://hackage.haskell.org/package/fsnotify-0.3.0.1/)

31+-------------------------------------------------------------------------------

33+

35+

36+Redistribution and use in source and binary forms, with or without

37+modification, are permitted provided that the following conditions are met:

38+

39+ * Redistributions of source code must retain the above copyright

40+ notice, this list of conditions and the following disclaimer.

41+

42+ * Redistributions in binary form must reproduce the above

43+ copyright notice, this list of conditions and the following

44+ disclaimer in the documentation and/or other materials provided

45+ with the distribution.

46+

47+ * Neither the name of Mark Dittmer nor the names of other

48+ contributors may be used to endorse or promote products derived

49+ from this software without specific prior written permission.

50+

51+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

52+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

53+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

54+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

55+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

56+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

57+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

58+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

59+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

60+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

61+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

62+

63+-------------------------------------------------------------------------------

64+hfsevents-0.1.6 (http://hackage.haskell.org/package/hfsevents-0.1.6)

65+-------------------------------------------------------------------------------

67+

69+

70+Redistribution and use in source and binary forms, with or without

71+modification, are permitted provided that the following conditions are met:

72+

73+ * Redistributions of source code must retain the above copyright

74+ notice, this list of conditions and the following disclaimer.

75+

76+ * Redistributions in binary form must reproduce the above

77+ copyright notice, this list of conditions and the following

78+ disclaimer in the documentation and/or other materials provided

79+ with the distribution.

80+

81+ * Neither the name of Luite Stegeman nor the names of other

82+ contributors may be used to endorse or promote products derived

83+ from this software without specific prior written permission.

84+

85+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

86+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

87+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

88+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

89+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

90+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

91+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

92+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

93+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

94+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

95+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

MAINTAINING.mddeleted−256

@@ -1,256 +0,0 @@

1−# Maintainers' Guide

2−

3−## PR Merge Checklist

4−

5−* All the CI tests pass

6−* New tests are added where applicable

7−* Benchmarks are added where applicable

8−* Run benchmarks locally if you suspect any regressions

9−* Documentation is added for any new combinators

10− * New combinators have time and space complexity annotations

11− * New combinators have `since` annotation

12−* Changelog entry is added for exposed combinators.

13−* Identify breaking changes, or changes that may require depndency

14− version bound changes. See https://pvp.haskell.org/. Also see the

15− "Breaking changes section below".

16−* Optionally, look at hlint output if anything in that is worth fixing.

17−* Merge the PR by rebasing. Note that github always creates new commits when

18− merged with rebase, it records the committer as well as the author in the

19− commit. This makes the local branch diverge from master. You can rebase and

20− merge the commit manually in your local git tree and push the resulting

21− master branch to avoid new commits and divergence from the original tree.

22−

23−## Release Checklist

24−

25−* Check if any critical pending bugs or issues are to be included

26−* If this is a major release check if any previously deprecated features are to

27− be removed in this release.

28−* _Documentation_:

29−

30− * README is updated

31− * Haddock docs are consistent with the changes in the release

32− * Tutorial has been updated for new changes

33− * Documents in the `docs` directory are consistent with new changes

34− * All combinators have time and space complexity annotations

35− * All combinators have `since` annotation

36−

37−* _Benchmarks_:

38−

39− * Check regressions from previous release

40− * Run benchmarks with large stream size (`bench.sh -- long`) to

41− check for space leaks and to ensure constant memory usage for streaming

42− operations.

43− * Run benchmarks with `dev` flag on. Some `fileio` benchmarks are disabled

44− in regular runs.

45− * Check comparative benchmarks using streaming-benchmarks

46−

47−* _Tests_:

48−

49− * Run tests with `dev` flag on. Many tests are disabled in regular runs.

50−

51−* _Examples_:

52−

53− * Update

54− [streamly-examples](https://github.com/composewell/streamly-examples)

55− to make sure it runs with the latest release.

56−

57−* _Update Package Metadata:_

58−

59− * Update `stack.yaml` to latest stable resolver, cleanup extra-deps

60− * Make sure the description in cabal file is in sync with README and other docs

61− * Make sure CI configs include last three major releases of GHC in CI testing.

62− * Update `tested-with` field

63− * Make sure all dependency bounds can use latest versions

64− * Make sure any additional files are added to `extra-source-files` in cabal

65− file

66−

67−* Copyrights and Contibutors

68−

69− * Make sure contributors to the release are listed in

70− `credits/CONTRIBUTORS.md`.

71− * Bump the release version in `credits/CONTRIBUTORS.md`.

72− * Make sure any third party code included in the release has been listed in

73− `credits/COPYRIGHTS.md` and the license is added to the repo.

74− * Change the `Unreleased` section, if exists, at the top of

75− `credits/COPYRIGHTS.md` to the new release version number.

76−

77−* _Update changelog & Version_:

78−

79− * Make sure all the bug fixes being included in this release are marked

80− with a target release on github. So that users can search by release if

81− they want.

82− * Change the `Unreleased` section at the top of changelog file to the new

83− release version number.

84− * Bump the package version in cabal file or package.yaml

85− * Bump the package version in configure.ac and run autoreconf

86−

87−* _Upload_:

88−

89− * Wait for final CI tests to pass:

90−

91− * Create a git tag corresponding to the release where X.Y.Z is the new

92− package version (`git tag vX.Y.Z && git push -f origin vX.Y.Z`).

93− * Mask out the build status lines from the README

94− * Upload to hackage

95− * Use a clean workspace to create source distribution

96− by freshly cloning the git repository. The reason for

97− doing this is that we use wild-cards in cabal file for

98− `extra-source-files`, these wild-cards may match additional

99− files lying around in the workspace and unintentionally ship

100− them as well.

101− * `cabal v2-sdist`; `cabal upload --publish <tarpath>`

102− * `stack upload .`

103− * Add to stackage (`build-constraints.yaml` in Stackage repo) if needed

104− * Optionally upload `package-X.Y.Z-sdist.tar.gz` to github release page

105− * Update release contributors on github release page

106− (`git shortlog -s prev_tag..new_tag | sed $'s/^[0-9 \t]*/* /' | sort -f`)

107− * Update and if needed release streaming-benchmarks package

108− * Check https://matrix.hackage.haskell.org/package/streamly

109− * Check haddocks on Hackage, upload if not built

110− * Announce to haskell-cafe@haskell.org

111−

112−## Breaking Changes

113−

114−This section lists what constitutes breaking changes. See

115−https://pvp.haskell.org/ breaking changes that can be determined by the

116−API alone. We specify some additional recommendations here:

117−

118−Behavior changes, this kind of changes are nasty and should be avoided. If such

119−changes are made they should be emphasized adequately in the changelog:

120−

121−* Silent changes in the behavior of an API without any changes to the

122− signature.

123−* Even fixing a bug could break things as users may have employed workarounds

124− for the bug.

125−* Changes in the behavior of a dependency may also cause a change in behavior.

126−

127−Be cautious about the following:

128−

129−* Change in version bounds of dependencies may cause compilation failure for

130− some programs because they may not be able to find a build plan.

131−* Ideally, new warnings should not be considered breaking, dependencies

132− should never be compiled with -Werror. But packages may not be following

133− it perfectly.

134−* Deprecating an API may issue new warnings, however the code can still be

135− compiled if warnings are not treated as errors.

136−

137−Internal APIs:

138−

139−* Internal APIs can change without having to change the major version. However,

140− we should try to align the Internal API changes with a major release as long

141− as possible.

142−

143−## Managing Issues

144−

145−We label the issues in different dimensions based on the lifecyle and different

146−management aspects of the issue. The folowing sections discuss the labels used

147−to manage the issues. If a new label is required, it should be discussed before

148−creating it.

149−

150−### Disposition

151−

152−The level-1 triaging of the issue determines the current disposition

153−of the issue. If no change is required the issue must have one of the

154−following labels:

155−

156−* invalid

157−* question

158−* discussion

159−* duplicate

160−* wontfix

161−

162−If a change is required we need to do level-2 triage of the issue, see the

163−sections below.

164−

165−### Change type

166−

167−When a change is required we need to put one of the __change type__

168−labels as part of level-2 triaging:

169−

170−* performance: User visible impact on performance.

171−* usability: It is not convenient to use the library.

172−* documentation: documentation is not correct or sufficient.

173−* bug: A functionality issue, not working as expected.

174−* enhancement: A new feature or enhancement of the product.

175−* maintenance: A refactor or any other change with no user visible impact.

176−

177−### Aspect

178−

179−In addition we can put a __product aspect__ label describing a feature name or

180−any other product specific classification bucket.

181−

182−* aspect:<aspect name>

183−

184−### Severity

185−

186−Optionally we can add a severity label to indicate how severe is the

187−impact of the bug/issue, which may determine how important it is to fix it. By

188−default the severity is normal, if it is high we put a label:

189−

190−* severity:high

191−

192−### Change impact

193−

194−For a user visible issue whether it has a release/changelog impact:

195−

196−* enhancement: includes a new feature or enhancement

197−* breaking: has a breaking impact on existing deployments

198−* deprecating: deprecates an existing functionality

199−

200−__RULE__: Any commit that may affect the end user in some way MUST have

201−either a changelog entry OR MUST have an issue marked with one of the

202−above labels OR both.

203−

204−### Priority

205−

206−By default the issues are normal priority. We use a label for high priority

207−issues:

208−

209−* priority:high

210−

211−### Scheduling

212−

213−If the issue is assigned to someone then it is considered scheduled. Otherwise

214−it is unscheduled. Unassigned issues may have the following labels:

215−

216−* deferred: blocked on any other fix or a decision to be made, or deliberately

217− deferred for some reason.

218−* help-wanted: anyone can take the issue and contribute

219−

220−## Correlating Changes, Issues and Releases

221−

222−For planning purposes, open issues may be marked with milestones or target

223−releases. However, it may not always be known which release a fix will finally

224−land in. For example, we may decide to make a minor release instead of a major

225−one if there are no breaking changes yet, so we may not always know what would

226−be the next release version.

227−

228−Trackability means that we should be able to find which issues got fixed in

229−which release. Or what all issues got fixed in a particular release. We track

230−significant changes using the changelog. However, there may be more changes

231−that can only be tracked via issues, PRs or commits. When we make a release we

232−can mark all the issues fixed in that release with a correct release target for

233−future trackability.

234−

235−For better trackability of which issue got fixed in which release we need the

236−following:

237−

238−* Before you close an issue make sure a commit or a PR fixing the issue is

239− attached with it. In the commit message you can reference an issue like

240− "fixes #50", you can do the same in a PR as well.

241−* Before we make a new release EVERY issue with a commit included in that

242− release that affects the end user, especially bugs and breaking changes MUST

243− have the target release correctly set.

244−

245−## Changelog Management

246−

247−Keep the unreleased changes in the `Unreleased` section at the top of changelog

248−file. Using `Unreleased` instead of the next release number for unreleased

249−changes is important. First, we do not know the next release number in advance,

250−it could be a major or minor release. Second, if we use the next release

251−number instead, then when adding a new change to the changelog, at one look we

252−cannot know whether the release number on top is unreleased or released.

253−

254−## TODO

255−

256−* GPG signed releases and tags

README.mdmode 100644 → 120000+1−606

@@ -1,606 +0,0 @@

1−# Streamly

2−

3−[![Hackage](https://img.shields.io/hackage/v/streamly.svg?style=flat)](https://hackage.haskell.org/package/streamly)

4−[![Gitter chat](https://badges.gitter.im/composewell/gitter.svg)](https://gitter.im/composewell/streamly)

5−[![Travis](https://travis-ci.com/composewell/streamly.svg?branch=master)](https://travis-ci.com/composewell/streamly)

6−[![Appveyor](https://ci.appveyor.com/api/projects/status/ajxg0c79raou9ned?svg=true)](https://ci.appveyor.com/project/harendra-kumar/streamly)

7−[![CircleCI](https://circleci.com/gh/composewell/streamly/tree/master.svg?style=svg)](https://circleci.com/gh/composewell/streamly/tree/master)

8−[![Coverage Status](https://coveralls.io/repos/composewell/streamly/badge.svg?branch=master&service=github)](https://coveralls.io/github/composewell/streamly?branch=master)

9−

10−## Learning Materials

11−

12−* Documentation: [Quick](#streaming-concurrently) | [Tutorial](https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html) | [Reference (Hackage)](https://hackage.haskell.org/package/streamly) | [Reference (Latest)](https://composewell.github.io/streamly) | [Guides](docs)

13−* Installing: [Installing](./INSTALL.md) | [Building for optimal performance](docs/Build.md)

14−* Examples: [streamly](examples) | [streamly-examples](https://github.com/composewell/streamly-examples)

15−* Benchmarks: [Streaming](https://github.com/composewell/streaming-benchmarks) | [Concurrency](https://github.com/composewell/concurrency-benchmarks)

16−* Talks: [Functional Conf 2019 Video](https://www.youtube.com/watch?v=uzsqgdMMgtk) | [Functional Conf 2019 Slides](https://www.slideshare.net/HarendraKumar10/streamly-concurrent-data-flow-programming)

17−

18−## Streaming Concurrently

19−

20−Haskell lists express pure computations using composable stream operations like

21−`:`, `unfold`, `map`, `filter`, `zip` and `fold`. Streamly is exactly like

22−lists except that it can express sequences of pure as well as monadic

23−computations aka streams. More importantly, it can express monadic sequences

24−with concurrent execution semantics without introducing any additional APIs.

25−

26−Streamly expresses concurrency using standard, well known abstractions.

27−Concurrency semantics are defined for list operations, semigroup, applicative

28−and monadic compositions. Programmer does not need to know any low level

29−notions of concurrency like threads, locking or synchronization. Concurrent

30−and non-concurrent programs are fundamentally the same. A chosen segment of

31−the program can be made concurrent by annotating it with an appropriate

32−combinator. We can choose a combinator for lookahead style or asynchronous

33−concurrency. Concurrency is automatically scaled up or down based on the

34−demand from the consumer application, we can finally say goodbye to managing

35−thread pools and associated sizing issues. The result is truly fearless

36−and declarative monadic concurrency.

37−

38−## Where to use streamly?

39−

40−Streamly is a general purpose programming framework. It can be used equally

41−efficiently from a simple `Hello World!` program to a massively concurrent

42−application. The answer to the question, "where to use streamly?" - would be

43−similar to the answer to - "Where to use Haskell lists or the IO monad?".

44−

45−Streamly simplifies streaming and makes it as intuitive as plain lists. Unlike

46−other streaming libraries, no fancy types are required. Streamly is simply a

47−generalization of Haskell lists to monadic streaming optionally with concurrent

48−composition. The basic stream type in streamly `SerialT m a` can be considered

49−as a list type `[a]` parameterized by the monad `m`. For example, `SerialT IO

50−a` is a moral equivalent of `[a]` in the IO monad. `SerialT Identity a`, is

51−equivalent to pure lists. Streams are constructed very much like lists, except

52−that they use `nil` and `cons` instead of `[]` and `:`. Unlike lists, streams

53−can be constructed from monadic effects, not just pure elements. Streams are

54−processed just like lists, with list like combinators, except that they are

55−monadic and work in a streaming fashion. In other words streamly just completes

56−what lists lack, you do not need to learn anything new. Please see [streamly vs

57−lists](docs/streamly-vs-lists.md) for a detailed comparison.

58−

59−Not surprisingly, the monad instance of streamly is a list transformer, with

60−concurrency capability.

61−

62−## Why data flow programming?

63−

64−If you need some convincing for using streaming or data flow programming

65−paradigm itself then try to answer this question - why do we use lists in

66−Haskell? It boils down to why we use functional programming in the first place.

67−Haskell is successful in enforcing the functional data flow paradigm for pure

68−computations using lists, but not for monadic computations. In the absence of a

69−standard and easy to use data flow programming paradigm for monadic

70−computations, and the IO monad providing an escape hatch to an imperative

71−model, we just love to fall into the imperative trap, and start asking the same

72−fundamental question again - why do we have to use the streaming data model?

73−

74−## Comparative Performance

75−

76−High performance and simplicity are the two primary goals of streamly.

77−`Streamly` employs two different stream representations (CPS and direct style)

78−and interconverts between the two to get the best of both worlds on different

79−operations. It uses both foldr/build (for CPS style) and stream fusion (for

80−direct style) techniques to fuse operations. In terms of performance,

81−Streamly's goal is to compete with equivalent C programs. Streamly redefines

82−"blazing fast" for streaming libraries, it competes with lists and `vector`.

83−Other streaming libraries like "streaming", "pipes" and "conduit" are orders of

84−magnitude slower on most microbenchmarks. See [streaming

85−benchmarks](https://github.com/composewell/streaming-benchmarks) for detailed

86−comparison.

87−

88−The following chart shows a comparison of those streamly and list operations

89−where performance of the two differs by more than 10%. Positive y-axis displays

90−how many times worse is a list operation compared to the same streamly

91−operation, negative y-axis shows where streamly is worse compared to lists.

92−

93−![Streamly vs Lists (time) comparison](charts-0/streamly-vs-list-time.svg)

94−

95−Streamly uses lock-free synchronization for concurrent operations. It employs

96−auto-scaling of the degree of concurrency based on demand. For CPU bound tasks

97−it tries to keep the threads close to the number of CPUs available whereas for

98−IO bound tasks more threads can be utilized. Parallelism can be utilized with

99−little overhead even if the task size is very small. See [concurrency

100−benchmarks](https://github.com/composewell/concurrency-benchmarks) for detailed

101−performance results and a comparison with the `async` package.

102−

103−## Installing and using

104−

105−Please see [INSTALL.md](./INSTALL.md) for instructions on how to use streamly

106−with your Haskell build tool or package manager. You may want to go through it

107−before jumping to run the examples below.

108−

109−The module `Streamly.Prelude` provides the core stream types and combinators

110−for type casting, controlling concurrency, stream construction, transformation,

111−folding, merging, and zipping.

112−

113−## Streaming Pipelines

114−

115−The following snippet provides a simple stream composition example that reads

116−numbers from stdin, prints the squares of even numbers and exits if an even

117−number more than 9 is entered.

118−

119−``` haskell

120−import qualified Streamly.Prelude as S

121−import Data.Function ((&))

122−

123−main = S.drain $

124− S.repeatM getLine

125− & fmap read

126− & S.filter even

127− & S.takeWhile (<= 9)

128− & fmap (\x -> x * x)

129− & S.mapM print

130−```

131−

132−Unlike `pipes` or `conduit` and like `vector` and `streaming`, `streamly`

133−composes stream data instead of stream processors (functions). A stream is

134−just like a list and is explicitly passed around to functions that process the

135−stream. Therefore, no special operator is needed to join stages in a streaming

136−pipeline, just the standard function application (`$`) or reverse function

137−application (`&`) operator is enough.

138−

139−## Concurrent Stream Generation

140−

141−`consM` or its operator form `|:` can be used to construct a stream from

142−monadic actions. A stream constructed with `consM` can run the monadic actions

143−in the stream concurrently when used with appropriate stream type combinator

144−(e.g. `fromAsync`, `fromAhead` or `fromParallel`).

145−

146−The following code finishes in 3 seconds (6 seconds when serial), note the

147−order of elements in the resulting output, the outputs are consumed as soon as

148−each action is finished (asyncly):

149−

150−``` haskell

151−> let p n = threadDelay (n * 1000000) >> return n

152−> S.toList $ S.fromAsync $ p 3 |: p 2 |: p 1 |: S.nil

153−[1,2,3]

154−```

155−

156−Use `fromAhead` if you want speculative concurrency i.e. execute the actions in

157−the stream concurrently but consume the results in the specified order:

158−

159−``` haskell

160−> S.toList $ S.fromAhead $ p 3 |: p 2 |: p 1 |: S.nil

161−[3,2,1]

162−```

163−

164−Monadic stream generation functions e.g. `unfoldrM`, `replicateM`, `repeatM`,

165−`iterateM` and `fromFoldableM` etc. can work concurrently.

166−

167−The following finishes in 10 seconds (100 seconds when serial):

168−

169−``` haskell

170−S.drain $ S.fromAsync $ S.replicateM 10 $ p 10

171−```

172−

173−## Concurrency Auto Scaling

174−

175−Concurrency is auto-scaled i.e. more actions are executed concurrently if the

176−consumer is consuming the stream at a higher speed. How many tasks are executed

177−concurrently can be controlled by `maxThreads` and how many results are

178−buffered ahead of consumption can be controlled by `maxBuffer`. See the

179−documentation in the `Streamly.Prelude` module.

180−

181−## Concurrent Streaming Pipelines

182−

183−Use `|&` or `|$` to apply stream processing functions concurrently. The

184−following example prints a "hello" every second; if you use `&` instead of

185−`|&` you will see that the delay doubles to 2 seconds instead because of serial

186−application.

187−

188−``` haskell

189−main = S.drain $

190− S.repeatM (threadDelay 1000000 >> return "hello")

191− |& S.mapM (\x -> threadDelay 1000000 >> putStrLn x)

192−```

193−

194−## Mapping Concurrently

195−

196−We can use `mapM` or `sequence` functions concurrently on a stream.

197−

198−``` haskell

199−> let p n = threadDelay (n * 1000000) >> return n

200−> S.drain $ S.fromAhead $ S.mapM (\x -> p 1 >> print x) (S.fromSerial $ S.repeatM (p 1))

201−```

202−

203−## Serial and Concurrent Merging

204−

205−Semigroup and Monoid instances can be used to fold streams serially or

206−concurrently. In the following example we compose ten actions in the

207−stream, each with a delay of 1 to 10 seconds, respectively. Since all the

208−actions are concurrent we see one output printed every second:

209−

210−``` haskell

211−import qualified Streamly.Prelude as S

212−import Control.Concurrent (threadDelay)

213−

214−main = S.toList $ S.fromParallel $ foldMap delay [1..10]

215− where delay n = S.yieldM $ threadDelay (n * 1000000) >> print n

216−```

217−

218−Streams can be combined together in many ways. We provide some examples

219−below, see the tutorial for more ways. We use the following `delay`

220−function in the examples to demonstrate the concurrency aspects:

221−

222−``` haskell

223−import qualified Streamly.Prelude as S

224−import Control.Concurrent

225−

226−delay n = S.yieldM $ do

227− threadDelay (n * 1000000)

228− tid <- myThreadId

229− putStrLn (show tid ++ ": Delay " ++ show n)

230−```

231−### Serial

232−

233−``` haskell

234−main = S.drain $ delay 3 <> delay 2 <> delay 1

235−```

236−```

237−ThreadId 36: Delay 3

238−ThreadId 36: Delay 2

239−ThreadId 36: Delay 1

240−```

241−

242−### Parallel

243−

244−``` haskell

245−main = S.drain . S.fromParallel $ delay 3 <> delay 2 <> delay 1

246−```

247−```

248−ThreadId 42: Delay 1

249−ThreadId 41: Delay 2

250−ThreadId 40: Delay 3

251−```

252−

253−## Nested Loops (aka List Transformer)

254−

255−The monad instance composes like a list monad.

256−

257−``` haskell

258−import qualified Streamly.Prelude as S

259−

260−loops = do

261− x <- S.fromFoldable [1,2]

262− y <- S.fromFoldable [3,4]

263− S.yieldM $ putStrLn $ show (x, y)

264−

265−main = S.drain loops

266−```

267−```

268−(1,3)

269−(1,4)

270−(2,3)

271−(2,4)

272−```

273−

274−## Concurrent Nested Loops

275−

276−To run the above code with speculative concurrency i.e. each iteration in the

277−loop can run concurrently but the results are presented to the consumer of the

278−output in the same order as serial execution:

279−

280−``` haskell

281−main = S.drain $ S.fromAhead $ loops

282−```

283−

284−Different stream types execute the loop iterations in different ways. For

285−example, `fromWSerial` interleaves the loop iterations. There are several

286−concurrent stream styles to execute the loop iterations concurrently in

287−different ways, see the `Streamly.Tutorial` module for a detailed treatment.

288−

289−## Magical Concurrency

290−

291−Streams can perform semigroup (<>) and monadic bind (>>=) operations

292−concurrently using combinators like `fromAsync`, `parallelly`. For example,

293−to concurrently generate squares of a stream of numbers and then concurrently

294−sum the square roots of all combinations of two streams:

295−

296−``` haskell

297−import qualified Streamly.Prelude as S

298−

299−main = do

300− s <- S.sum $ S.fromAsync $ do

301− -- Each square is performed concurrently, (<>) is concurrent

302− x2 <- foldMap (\x -> return $ x * x) [1..100]

303− y2 <- foldMap (\y -> return $ y * y) [1..100]

304− -- Each addition is performed concurrently, monadic bind is concurrent

305− return $ sqrt (x2 + y2)

306− print s

307−```

308−

309−The concurrency facilities provided by streamly can be compared with

310−[OpenMP](https://en.wikipedia.org/wiki/OpenMP) and

311−[Cilk](https://en.wikipedia.org/wiki/Cilk) but with a more declarative

312−expression.

313−

314−## Example: Listing Directories Recursively/Concurrently

315−

316−The following code snippet lists a directory tree recursively, reading multiple

317−directories concurrently:

318−

319−```haskell

320−import Control.Monad.IO.Class (liftIO)

321−import Path.IO (listDir, getCurrentDir) -- from path-io package

322−import Streamly.Prelude (AsyncT, adapt)

323−import qualified Streamly.Prelude as S

324−

325−listDirRecursive :: AsyncT IO ()

326−listDirRecursive = getCurrentDir >>= readdir >>= liftIO . mapM_ putStrLn

327− where

328− readdir dir = do

329− (dirs, files) <- listDir dir

330− S.yield (map show dirs ++ map show files) <> foldMap readdir dirs

331−

332−main :: IO ()

333−main = S.drain $ adapt $ listDirRecursive

334−```

335−

336−`AsyncT` is a stream monad transformer. If you are familiar with a list

337−transformer, it is nothing but `ListT` with concurrency semantics. For example,

338−the semigroup operation `<>` is concurrent. This makes `foldMap` concurrent

339−too. You can replace `AsyncT` with `SerialT` and the above code will become

340−serial, exactly equivalent to a `ListT`.

341−

342−## Rate Limiting

343−

344−For bounded concurrent streams, stream yield rate can be specified. For

345−example, to print hello once every second you can simply write this:

346−

347−``` haskell

348−import Streamly.Prelude as S

349−

350−main = S.drain $ S.fromAsync $ S.avgRate 1 $ S.repeatM $ putStrLn "hello"

351−```

352−

353−For some practical uses of rate control, see

354−[AcidRain.hs](https://github.com/composewell/streamly/tree/master/examples/AcidRain.hs)

355−and

356−[CirclingSquare.hs](https://github.com/composewell/streamly/tree/master/examples/CirclingSquare.hs)

357−.

358−Concurrency of the stream is automatically controlled to match the specified

359−rate. Rate control works precisely even at throughputs as high as millions of

360−yields per second. For more sophisticated rate control see the haddock

361−documentation.

362−

363−## Arrays

364−

365−The `Streamly.Data.Array.Foreign` module provides immutable arrays. Arrays are the

366−computing duals of streams. Streams are good at sequential access and immutable

367−transformations of in-transit data whereas arrays are good at random access and

368−in-place transformations of buffered data. Unlike streams which are potentially

369−infinite, arrays are necessarily finite. Arrays can be used as an efficient

370−interface between streams and external storage systems like memory, files and

371−network. Streams and arrays complete each other to provide a general purpose

372−computing system. The design of streamly as a general purpose computing

373−framework is centered around these two fundamental aspects of computing and

374−storage.

375−

376−`Streamly.Data.Array.Foreign` uses pinned memory outside GC and therefore avoid any

377−GC overhead for the storage in arrays. Streamly allows efficient

378−transformations over arrays using streams. It uses arrays to transfer data to

379−and from the operating system and to store data in memory.

380−

381−## Folds

382−

383−Folds are consumers of streams. `Streamly.Data.Fold` module provides a `Fold`

384−type that represents a `foldl'`. Such folds can be efficiently composed

385−allowing the compiler to perform stream fusion and therefore implement high

386−performance combinators for consuming streams. A stream can be distributed to

387−multiple folds, or it can be partitioned across multiple folds, or

388−demultiplexed over multiple folds, or unzipped to two folds. We can also use

389−folds to fold segments of stream generating a stream of the folded results.

390−

391−If you are familiar with the `foldl` library, these are the same composable

392−left folds but simpler and better integrated with streamly, and with many more

393−powerful ways of composing and applying them.

394−

395−## Unfolds

396−

397−Unfolds are duals of folds. Folds help us compose consumers of streams

398−efficiently and unfolds help us compose producers of streams efficiently.

399−`Streamly.Data.Unfold` provides an `Unfold` type that represents an `unfoldr`

400−or a stream generator. Such generators can be combined together efficiently

401−allowing the compiler to perform stream fusion and implement high performance

402−stream merging combinators.

403−

404−## File IO

405−

406−The following code snippets implement some common Unix command line utilities

407−using streamly. You can compile these with `ghc -O2 -fspec-constr-recursive=16

408−-fmax-worker-args=16` and compare the performance with regular GNU coreutils

409−available on your system. Though many of these are not most optimal solutions

410−to keep them short and elegant. Source file

411−[HandleIO.hs](https://github.com/composewell/streamly/tree/master/examples/HandleIO.hs)

412−in the examples directory includes these examples.

413−

414−``` haskell

415−module Main where

416−

417−import qualified Streamly.Prelude as S

418−import qualified Streamly.Data.Fold as FL

419−import qualified Streamly.Data.Array.Foreign as A

420−import qualified Streamly.FileSystem.Handle as FH

421−import qualified System.IO as FH

422−

423−import Data.Char (ord)

424−import System.Environment (getArgs)

425−import System.IO (openFile, IOMode(..), stdout)

426−

427−withArg f = do

428− (name : _) <- getArgs

429− src <- openFile name ReadMode

430− f src

431−

432−withArg2 f = do

433− (sname : dname : _) <- getArgs

434− src <- openFile sname ReadMode

435− dst <- openFile dname WriteMode

436− f src dst

437−```

438−

439−### cat

440−

441−``` haskell

442−cat = S.fold (FH.writeChunks stdout) . S.unfold FH.readChunks

443−main = withArg cat

444−```

445−

446−### cp

447−

448−``` haskell

449−cp src dst = S.fold (FH.writeChunks dst) $ S.unfold FH.readChunks src

450−main = withArg2 cp

451−```

452−

453−### wc -l

454−

455−``` haskell

456−wcl = S.length . S.splitOn (== 10) FL.drain . S.unfold FH.read

457−main = withArg wcl >>= print

458−```

459−

460−### Average Line Length

461−

462−``` haskell

463−avgll =

464− S.fold avg

465− . S.splitOn (== 10) FL.length

466− . S.unfold FH.read

467−

468− where avg = (/) <$> toDouble FL.sum <*> toDouble FL.length

469− toDouble = fmap (fromIntegral :: Int -> Double)

470−

471−main = withArg avgll >>= print

472−```

473−

474−### Line Length Histogram

475−

476−`classify` is not released yet, and is available in

477−`Streamly.Internal.Data.Fold`

478−

479−``` haskell

480−llhisto =

481− S.fold (FL.classify FL.length)

482− . S.map bucket

483− . S.splitOn (== 10) FL.length

484− . S.unfold FH.read

485−

486− where

487− bucket n = let i = n `mod` 10 in if i > 9 then (9,n) else (i,n)

488−

489−main = withArg llhisto >>= print

490−```

491−

492−## Socket IO

493−

494−Its easy to build concurrent client and server programs using streamly.

495−`Streamly.Network.*` modules provide easy combinators to build network servers

496−and client programs using streamly. See

497−[FromFileClient.hs](https://github.com/composewell/streamly/tree/master/examples/FromFileClient.hs),

498−[EchoServer.hs](https://github.com/composewell/streamly/tree/master/examples/EchoServer.hs),

499−[FileSinkServer.hs](https://github.com/composewell/streamly/tree/master/examples/FileSinkServer.hs)

500−in the examples directory.

501−

502−## Exceptions

503−

504−Exceptions can be thrown at any point using the `MonadThrow` instance. Standard

505−exception handling combinators like `bracket`, `finally`, `handle`,

506−`onException` are provided in `Streamly.Prelude` module.

507−

508−In presence of concurrency, synchronous exceptions work just the way they are

509−supposed to work in non-concurrent code. When concurrent streams

510−are combined together, exceptions from the constituent streams are propagated

511−to the consumer stream. When an exception occurs in any of the constituent

512−streams other concurrent streams are promptly terminated.

513−

514−There is no notion of explicit threads in streamly, therefore, no

515−asynchronous exceptions to deal with. You can just ignore the zillions of

516−blogs, talks, caveats about async exceptions. Async exceptions just don't

517−exist. Please don't use things like `myThreadId` and `throwTo` just for fun!

518−

519−## Reactive Programming (FRP)

520−

521−Streamly is a foundation for first class reactive programming as well by virtue

522−of integrating concurrency and streaming. See

523−[AcidRain.hs](https://github.com/composewell/streamly/tree/master/examples/AcidRain.hs)

524−for a console based FRP game example and

525−[CirclingSquare.hs](https://github.com/composewell/streamly/tree/master/examples/CirclingSquare.hs)

526−for an SDL based animation example.

527−

528−## Conclusion

529−

530−Streamly, short for streaming concurrently, provides monadic streams, with a

531−simple API, almost identical to standard lists, and an in-built

532−support for concurrency. By using stream-style combinators on stream

533−composition, streams can be generated, merged, chained, mapped, zipped, and

534−consumed concurrently – providing a generalized high level programming

535−framework unifying streaming and concurrency. Controlled concurrency allows

536−even infinite streams to be evaluated concurrently. Concurrency is auto scaled

537−based on feedback from the stream consumer. The programmer does not have to be

538−aware of threads, locking or synchronization to write scalable concurrent

539−programs.

540−

541−Streamly is a programmer first library, designed to be useful and friendly to

542−programmers for solving practical problems in a simple and concise manner. Some

543−key points in favor of streamly are:

544−

545− * _Simplicity_: Simple list like streaming API, if you know how to use lists

546− then you know how to use streamly. This library is built with simplicity

547− and ease of use as a design goal.

548− * _Concurrency_: Simple, powerful, and scalable concurrency. Concurrency is

549− built-in, and not intrusive, concurrent programs are written exactly the

550− same way as non-concurrent ones.

551− * _Generality_: Unifies functionality provided by several disparate packages

552− (streaming, concurrency, list transformer, logic programming, reactive

553− programming) in a concise API.

554− * _Performance_: Streamly is designed for high performance. It employs stream

555− fusion optimizations for best possible performance. Serial peformance is

556− equivalent to the venerable `vector` library in most cases and even better

557− in some cases. Concurrent performance is unbeatable. See

558− [streaming-benchmarks](https://github.com/composewell/streaming-benchmarks)

559− for a comparison of popular streaming libraries on micro-benchmarks.

560−

561−The basic streaming functionality of streamly is equivalent to that provided by

562−streaming libraries like

563−[vector](https://hackage.haskell.org/package/vector),

564−[streaming](https://hackage.haskell.org/package/streaming),

565−[pipes](https://hackage.haskell.org/package/pipes), and

566−[conduit](https://hackage.haskell.org/package/conduit).

567−In addition to providing streaming functionality, streamly subsumes

568−the functionality of list transformer libraries like `pipes` or

569−[list-t](https://hackage.haskell.org/package/list-t), and also the logic

570−programming library [logict](https://hackage.haskell.org/package/logict). On

571−the concurrency side, it subsumes the functionality of the

572−[async](https://hackage.haskell.org/package/async) package, and provides even

573−higher level concurrent composition. Because it supports

574−streaming with concurrency we can write FRP applications similar in concept to

575−[Yampa](https://hackage.haskell.org/package/Yampa) or

576−[reflex](https://hackage.haskell.org/package/reflex).

577−

578−See the `Comparison with existing packages` section at the end of the

579−[tutorial](https://hackage.haskell.org/package/streamly/docs/Streamly-Tutorial.html).

580−

581−## Support

582−

583−Please feel free to ask questions on the

584−[streamly gitter channel](https://gitter.im/composewell/streamly).

585−If you require professional support, consulting, training or timely

586−enhancements to the library please contact

587−[support@composewell.com](mailto:support@composewell.com).

588−

589−## Credits

590−

591−The following authors/libraries have influenced or inspired this library in a

592−significant way:

593−

594− * Roman Leshchinskiy ([vector](http://hackage.haskell.org/package/vector))

595− * Gabriel Gonzalez ([foldl](https://hackage.haskell.org/package/foldl))

596− * Alberto G. Corona ([transient](https://hackage.haskell.org/package/transient))

597−

598−See the `credits` directory for full list of contributors, credits and licenses.

599−

600−## Contributing

601−

602−The code is available under BSD-3 license

603−[on github](https://github.com/composewell/streamly). Join the [gitter

604−chat](https://gitter.im/composewell/streamly) channel for discussions. Please

605−ask any questions on the gitter channel or [contact the maintainer

606−directly](mailto:streamly@composewell.com). All contributions are welcome!

@@ -0,0 +1 @@

1+docs/User/Project/README.md

Setup.hs+2−2

@@ -1,6 +1,6 @@

11module Main (main) where

3−import Distribution.Extra.Doctest (defaultMainAutoconfWithDoctests)

3+import Distribution.Simple

55main :: IO ()

6−main = defaultMainAutoconfWithDoctests "doctests"

6+main = defaultMainWithHooks autoconfUserHooks

appveyor.yml+7−6

@@ -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"

@@ -34,18 +36,17 @@ environment:

3436 # Note requiring a specific version of stack using STACKVER may fail due to

3537 # github API limit while checking and upgrading/downgrading to the specific

3638 # version.

37− #STACKVER: "1.6.5"

39+ # STACKVER: "1.6.5"

3840 STACK_UPGRADE: "y"

39− RESOLVER: "lts-16.12"

41+ # RESOLVER: "lts-18.27"

4042 STACK_ROOT: "c:\\sr"

4143 STACK_BUILD_OPTIONS: "--flag streamly-benchmarks:-opt"

44+ STACK_YAML: "stack.yaml"

4245

4346 # ------------------------------------------------------------------------

4447 # cabal options

4548 # ------------------------------------------------------------------------

4649 CABAL_CHECK_RELAX: "y"

47− CABAL_NO_SANDBOX: "y"

48− CABAL_HACKAGE_MIRROR: "hackage.haskell.org:http://hackage.fpcomplete.com"

4950

5051 # ------------------------------------------------------------------------

5152 # Where to find the required tools

@@ -63,8 +64,8 @@ environment:

6364 PACKCHECK_LOCAL_PATH: "./packcheck.sh"

6465 # If you have not committed packcheck.sh in your repo at PACKCHECK_LOCAL_PATH

6566 # then it is automatically pulled from this URL.

66− PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/harendra-kumar/packcheck"

67− PACKCHECK_GITHUB_COMMIT: "563702bd02c41343dcd3dfcfef0845ca428a9240"

67+ PACKCHECK_GITHUB_URL: "https://raw.githubusercontent.com/composewell/packcheck"

68+ PACKCHECK_GITHUB_COMMIT: "35efa99b2082d13722b8a0183ac6455df98e91b9"

6869

6970 # Override the temp directory to avoid sed escaping issues

7071 # See https://github.com/haskell/cabal/issues/5386

benchmark/Chart.hsdeleted−194

@@ -1,194 +0,0 @@

1−{-# LANGUAGE RecordWildCards #-}

2−{-# LANGUAGE ScopedTypeVariables #-}

3−

4−module Main where

5−

6−import Control.Exception (catch, ErrorCall(..))

7−import Control.Monad.Trans.State

8−import Control.Monad.Trans.Maybe

9−import Data.Char (toLower)

10−import Data.List

11−import System.Environment (getArgs)

12−import Control.Monad.IO.Class (liftIO)

13−import Control.Monad (mzero)

14−

15−import BenchShow

16−

17−------------------------------------------------------------------------------

18−-- Command line parsing

19−------------------------------------------------------------------------------

20−

21−data BenchType

22− = Compare String

23− | Standard String

24− deriving Show

25−

26−data Options = Options

27− { genGraphs :: Bool

28− , benchType :: Maybe BenchType

29− , fields :: [String]

30− } deriving Show

31−

32−defaultOptions :: Options

33−defaultOptions = Options False Nothing ["time"]

34−

35−setGenGraphs :: Monad m => Bool -> StateT (a, Options) m ()

36−setGenGraphs val = do

37− (args, opts) <- get

38− put (args, opts { genGraphs = val })

39−

40−setBenchType :: Monad m => BenchType -> StateT (a, Options) m ()

41−setBenchType val = do

42− (args, opts) <- get

43− put (args, opts { benchType = Just val })

44−

45−setFields :: Monad m => [String] -> StateT (a, Options) m ()

46−setFields val = do

47− (args, opts) <- get

48− put (args, opts { fields = val })

49−

50−-- Like the shell "shift" to shift the command line arguments

51−shift :: StateT ([String], Options) (MaybeT IO) (Maybe String)

52−shift = do

53− s <- get

54− case s of

55− ([], _) -> return Nothing

56− (x : xs, opts) -> put (xs, opts) >> return (Just x)

57−

58−parseBench :: StateT ([String], Options) (MaybeT IO) ()

59−parseBench = do

60− x <- shift

61− case x of

62− Just str | "_cmp" `isSuffixOf` str -> setBenchType (Compare str)

63− Just str -> setBenchType (Standard str)

64− Nothing -> do

65− liftIO $ putStrLn "please provide a benchmark type "

66− mzero

67−

68−parseFields :: StateT ([String], Options) (MaybeT IO) ()

69−parseFields = do

70− x <- shift

71− case x of

72− Just str -> setFields (words str)

73− Nothing -> do

74− liftIO $ putStrLn

75− "please provide a list of fields after --fields"

76− mzero

77−

78−-- totally imperative style option parsing

79−parseOptions :: IO (Maybe Options)

80−parseOptions = do

81− args <- getArgs

82− runMaybeT $ flip evalStateT (args, defaultOptions) $ do

83− parseLoop

84− fmap snd get

85−

86− where

87−

88− parseOpt opt =

89− case opt of

90− "--graphs" -> setGenGraphs True

91− "--benchmark" -> parseBench

92− "--fields" -> parseFields

93− str -> do

94− liftIO $ putStrLn $ "Unrecognized option " <> str

95− mzero

96−

97− parseLoop = do

98− next <- shift

99− case next of

100− Just opt -> parseOpt opt >> parseLoop

101− Nothing -> return ()

102−

103−ignoringErr :: IO () -> IO ()

104−ignoringErr a = catch a (\(ErrorCall err :: ErrorCall) ->

105− putStrLn $ "Failed with error:\n" <> err <> "\nSkipping.")

106−

107−------------------------------------------------------------------------------

108−-- Generic

109−------------------------------------------------------------------------------

110−

111−makeGraphs :: String -> Config -> String -> IO ()

112−makeGraphs name cfg@Config{..} inputFile =

113− ignoringErr $ graph inputFile name cfg

114−

115−------------------------------------------------------------------------------

116−-- Arrays

117−------------------------------------------------------------------------------

118−

119−showComparisons :: Options -> Config -> FilePath -> FilePath -> IO ()

120−showComparisons Options{..} cfg inp out =

121− let cfg1 = cfg { classifyBenchmark = classifyComparison }

122− in if genGraphs

123− then ignoringErr $ graph inp "comparison"

124− cfg1 { outputDir = Just out

125− , presentation = Groups Absolute

126− }

127− else ignoringErr $ report inp Nothing cfg1

128−

129− where

130−

131− dropComponent = dropWhile (== '/') . dropWhile (/= '/')

132−

133− classifyComparison b = Just

134− ( takeWhile (/= '/') b

135− , dropComponent b

136− )

137−

138−------------------------------------------------------------------------------

139−-- text reports

140−------------------------------------------------------------------------------

141−

142−selectBench

143− :: (SortColumn -> Maybe GroupStyle -> Either String [(String, Double)])

144− -> [String]

145−selectBench f =

146− reverse

147− $ fmap fst

148− $ either

149− (const $ either error (sortOn snd) $ f (ColumnIndex 0) (Just PercentDiff))

150− (sortOn snd)

151− $ f (ColumnIndex 1) (Just PercentDiff)

152−

153−benchShow ::

154− Options

155− -> Config

156− -> (Config -> String -> IO ())

157− -> String

158− -> FilePath

159− -> IO ()

160−benchShow Options{..} cfg func inp out =

161− if genGraphs

162− then func cfg {outputDir = Just out} inp

163− else ignoringErr $ report inp Nothing cfg

164−

165−main :: IO ()

166−main = do

167− res <- parseOptions

168− case res of

169− Nothing -> do

170− putStrLn "cannot parse options"

171− return ()

172− Just opts@Options{fields = fs, benchType = btype} ->

173− let cfg = defaultConfig

174− { presentation = Groups PercentDiff

175− , selectBenchmarks = selectBench

176− , selectFields = filter

177− ( flip elem fs

178− . fmap toLower

179− )

180− }

181− in case btype of

182− Just (Compare str) ->

183− showComparisons opts cfg

184− { title = Just str }

185− ("charts/" ++ str ++ "/results.csv")

186− ("charts/" ++ str)

187− Just (Standard str) ->

188− benchShow opts cfg

189− { title = Just str }

190− (makeGraphs str)

191− ("charts/" ++ str ++ "/results.csv")

192− ("charts/" ++ str)

193− Nothing ->

194− error "Please specify a benchmark using --benchmark."

benchmark/NanoBenchmarks.hs+27−22

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-------------------------------------------------------------------------------

24-- Investigate specific benchmarks more closely in isolation, possibly looking

35-- at GHC generated code for optimizing specific problematic cases.

@@ -6,30 +8,27 @@

68{-# LANGUAGE FlexibleContexts #-}

79{-# LANGUAGE ScopedTypeVariables #-}

810

9−import Streamly.Prelude (SerialT)

10−import Streamly.Internal.Data.SVar (MonadAsync)

11+import Data.Char (ord)

12+import Streamly.Internal.Data.Stream (Stream)

13+import System.IO (hSeek, SeekMode(..), openFile, IOMode(..))

1114

12−import qualified Streamly.Data.Array.Foreign as A

13−import qualified Streamly.FileSystem.Handle as FH

15+import qualified Streamly.Data.Array as A

1416import qualified Streamly.Internal.FileSystem.Handle as IFH

1517import qualified Streamly.Data.Fold as FL

18+import qualified Streamly.Internal.Data.Stream as S

1619import qualified Streamly.Internal.Data.Stream.IsStream as Internal

17−import qualified Streamly.Prelude as S

18−import qualified Streamly.Internal.Data.Stream.StreamK as K

1920

20−import Data.Char (ord)

21−import Gauge

22−import System.IO (hSeek, SeekMode(..), openFile, IOMode(..))

21+import Test.Tasty.Bench

2322import System.Random

2423

2524maxValue :: Int

2625maxValue = 100000

2726

28−-- type Stream = K.Stream

29−type Stream = SerialT

27+drain :: Monad m => S.Stream m a -> m ()

28+drain = S.fold FL.drain

3029

3130{-# INLINE sourceUnfoldrM #-}

32−sourceUnfoldrM :: MonadAsync m => Stream m Int

31+sourceUnfoldrM :: Monad m => Stream m Int

3332sourceUnfoldrM = S.unfoldrM step 0

3433 where

3534 step cnt =

@@ -38,7 +37,7 @@ sourceUnfoldrM = S.unfoldrM step 0

3837 else return (Just (cnt, cnt + 1))

3938

4039{-# INLINE sourceUnfoldrMN #-}

41−sourceUnfoldrMN :: MonadAsync m => Int -> Stream m Int

40+sourceUnfoldrMN :: Monad m => Int -> Stream m Int

4241sourceUnfoldrMN n = S.unfoldrM step n

4342 where

4443 step cnt =

@@ -67,7 +66,7 @@ takeAllDropOne = S.drop 1 . S.take maxValue

6766

6867{-# INLINE takeDrop #-}

6968takeDrop :: Monad m => Stream m Int -> m ()

70−takeDrop = S.drain .

69+takeDrop = drain .

7170 takeAllDropOne . takeAllDropOne . takeAllDropOne . takeAllDropOne

7271

7372-------------------------------------------------------------------------------

@@ -82,7 +81,7 @@ dropWhileFalse = S.dropWhile (> maxValue)

8281

8382{-# INLINE dropWhileFalseX4 #-}

8483dropWhileFalseX4 :: Monad m => Stream m Int -> m ()

85−dropWhileFalseX4 = S.drain

84+dropWhileFalseX4 = drain

8685 . dropWhileFalse . dropWhileFalse . dropWhileFalse . dropWhileFalse

8786

8887-------------------------------------------------------------------------------

@@ -91,7 +90,7 @@ dropWhileFalseX4 = S.drain

9190

9291{-# INLINE iterateSource #-}

9392iterateSource

94− :: MonadAsync m

93+ :: Monad m

9594 => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int

9695iterateSource g i n = f i (sourceUnfoldrMN n)

9796 where

@@ -103,20 +102,26 @@ iterateSource g i n = f i (sourceUnfoldrMN n)

103102main :: IO ()

104103main = do

105104 defaultMain [bench "unfoldr" $ nfIO $

106− randomRIO (1,1) >>= \n -> S.drain (sourceUnfoldr n)]

105+ randomRIO (1,1) >>= \n -> drain (sourceUnfoldr n)]

107106 defaultMain [bench "take-drop" $ nfIO $ takeDrop sourceUnfoldrM]

108107 defaultMain [bench "dropWhileFalseX4" $

109108 nfIO $ dropWhileFalseX4 sourceUnfoldrM]

110109 defaultMain [bench "iterate-mapM" $

111− nfIO $ S.drain $ iterateSource (S.mapM return) 100000 10]

110+ nfIO $ drain $ iterateSource (S.mapM return) 100000 10]

112111

113112 inText <- openFile "benchmark/text-processing/gutenberg-500.txt" ReadMode

114113 defaultMain [mkBenchText "splitOn abc...xyz" inText $ do

115− (S.length $ Internal.splitOnSeq (A.fromList $ map (fromIntegral . ord)

116− "abcdefghijklmnopqrstuvwxyz") FL.drain

117− $ IFH.toBytes inText) >>= print

114+ S.fold FL.length

115+ (Internal.splitOnSeq

116+ (A.fromList

117+ $ map (fromIntegral . ord) "abcdefghijklmnopqrstuvwxyz"

118+ )

119+ FL.drain

120+ $ IFH.read inText

121+ )

122+ >>= print

118123 ]

119124 where

120125

121126 mkBenchText name h action =

122− bench name $ perRunEnv (hSeek h AbsoluteSeek 0) (\_ -> action)

127+ env (hSeek h AbsoluteSeek 0) (\_ -> bench name $ nfIO action)

benchmark/README.mdmode 100644 → 120000+1−243

@@ -1,243 +0,0 @@

1−## Building a single benchmark suite

2−

3−```

4−$ cabal build streamly-benchmarks:Prelude.Serial

5−```

6−

7−or:

8−

9−```

10−$ cabal build --enable-benchmarks bench:Prelude.Serial

11−```

12−

13−## Building all benchmarks suites

14−

15−```

16−$ cabal build --enable-benchmarks streamly-benchmarks

17−```

18−

19−or:

20−

21−```

22−$ cabal build --enable-benchmarks all

23−```

24−

25−Disable optimization, quick build:

26−

27−```

28−$ cabal build --flag "-opt" ...

29−```

30−

31−## Build and run single benchmarks:

32−

33−For quick results you may have to use `--quick` and possibly some other

34−`gauge` options, or better use `bench.sh --quick` as described in the

35−following sections.

36−

37−```

38−$ cabal run bench:Prelude.Serial -- --quick

39−```

40−

41−`cabal bench` can be used but you cannot pass arguments (like --quick):

42−

43−```

44−$ cabal bench Prelude.Serial

45−```

46−

47−## Build and run all benchmarks

48−

49−Don't try this, it will take too long, use the `bench.sh` method instead.

50−

51−```

52−$ cabal bench all

53−```

54−

55−or:

56−

57−```

58−$ cd benchmark; cabal bench

59−```

60−

61−or this, note this command does not work from "benchmark" dir:

62−

63−```

64−$ cabal bench streamly-benchmarks

65−```

66−

67−## Building and Running Benchmarks with bench.sh

68−

69−`<streamly repo>/bin/bench.sh` script is the top level driver for

70−running benchmarks. It runs the requested benchmarks and then creates a

71−report from the results using the `bench-show` package. Try `bench.sh

72−--help` for available options to run it.

73−

74−## bench.sh: Quick start

75−

76−Run the default benchmark suites:

77−

78−```

79−$ bench.sh --quick

80−```

81−

82−You can remove the `--quick` option to run benchmark with lower speed but

83−better accuracy, or use `--slow` to even further lower the speed and increase

84−the accuracy a bit.

85−

86−Show available benchmark suites:

87−

88−```

89−$ bench.sh --benchmarks help

90−```

91−

92−Run all benchmark suites in the `serial_grp` group:

93−

94−```

95−$ bench.sh --benchmarks serial_grp

96−```

97−

98−Run `Prelude.Serial` and `Data.Parser` benchmark suites:

99−

100−```

101−$ bench.sh --benchmarks "Prelude.Serial Data.Parser"

102−```

103−

104−Run all O(1) space complexity benchmarks in `Prelude.Serial` suite:

105−

106−```

107−$ bench.sh --benchmarks Prelude.Serial -- Prelude.Serial/o-1-space

108−```

109−

110−Anything after a `--` is passed to the benchmark executable,

111−it basically selects all benchmarks starting with

112−`Prelude.Serial/o-1-space` prefix.

113−

114−Run a specific benchmark in `Prelude.Serial` suite:

115−

116−```

117−$ bench.sh --benchmarks Prelude.Serial -- Prelude.Serial/o-1-space/generation/unfoldr

118−```

119−

120−Run a benchmark directly instead of running it through `bench.sh`:

121−

122−```

123−$ cabal run bench:Prelude.Serial -- --quick Prelude.Serial/o-1-space/generation/unfoldr

124−```

125−

126−The options after `--` are the benchmark executable options.

127−

128−## Comparing results of arbitrary runs

129−

130−Note: use `--quick` and benchmark selection if you do not intend to wait for a

131−while.

132−

133−To compare two sets of results, first run the benchmarks at the baseline

134−commit:

135−

136−```

137−$ bench.sh

138−```

139−

140−And then run with the `--append` option at the commit that you want to compare

141−with the baseline. It will show the comparison with the baseline:

142−

143−```

144−$ bench.sh --append

145−```

146−

147−Append just adds the next set of results in the same results file. You can keep

148−appending more results and all of them will be compared with the baseline.

149−

150−## Comparing results of two commits

151−

152−Note: use `--quick` and benchmark selection if you do not intend to wait for a

153−while.

154−

155−You can use `--compare` to compare the previous commit with the head commit:

156−

157−```

158−$ bench.sh --compare

159−```

160−

161−To compare the head commit with some other base commit:

162−

163−```

164−$ bench.sh --compare --base d918833

165−```

166−

167−To compare two arbitrary commits:

168−

169−```

170−$ bench.sh --compare --base d918833 --candidate 38aa5f2

171−```

172−

173−Note that the above may not always work because the script and the benchmarks

174−themselves might have changed across the commits. The `--append` method is more

175−reliable to compare.

176−

177−## Comparing benchmark suites

178−

179−First see the available benchmark suites:

180−

181−```

182−$ bench.sh --benchmarks help

183−```

184−

185−You will see some benchmark suites end with `_cmp`, these are comparison

186−groups. If you run a comparison group benchmark, comparison of all the

187−benchmark suites in that group will be shown in the end. For example to compare

188−all array benchmark suites:

189−

190−```

191−$ bench.sh --benchmarks array_cmp

192−```

193−

194−## Reporting without measuring

195−

196−You can use the `--no-measure` option to report the already measured results in

197−the benchmarks results file. A results file may collect an arbitrary number of

198−results by running with `--append` multiple times. Each benchmark has its own

199−results file, for example the `Prelude.Serial` benchmark has the results file at

200−`charts/Prelude.Serial/results.csv`.

201−

202−You can also manually edit the file to remove a set of results if you like or

203−to append results from previously saved results or from some other results

204−file. After editing you can run `bench.sh` with the `--no-measure` option to

205−see the reports corresponding to the results.

206−

207−## Additional benchmark configuration

208−

209−### Stream size

210−

211−You can specify the stream size (default is 100000) to be used for

212−benchmarking:

213−

214−```

215−$ cabal run bench:Prelude.Serial -- --quick --stream-size 1000000

216−```

217−

218−### Unicode input

219−

220−In the `FileSystem.Handle` benchmark you can specify the input file as an

221−environment variable:

222−

223−```

224−$ export Benchmark_FileSystem_Handle_InputFile=./gutenberg-500.txt

225−$ cabal run FileSystem.Handle -- --quick FileSystem.Handle/o-1-space/reduce/read/S.splitOnSeq

226−```

227−

228−The automatic tests do not test unicode input, this option is useful to specify

229−a unicode text file manually.

230−

231−## Benchmarking notes

232−

233−We use gauge instead of criterion for benchmarking. We have fixed

234−several issues in gauge inherited from criterion. We have added several

235−features as well e.g. rusage stats, running benchmarks in an isolated

236−process etc which are crucial to our benchmarking analysis process.

237−

238−### Gotchas

239−

240−Gauge forces a GC before and after the measurement. However, we have observed

241−that sometimes the GC stats may not be accurate when the number of iterations

242−in the measurement is small (e.g. 1 iteration). In such cases usually the

243−number of GCs and GC times would also be 0.

@@ -0,0 +1 @@

1+../docs/Developer/Benchmarks.md

benchmark/Streamly/Benchmark/Data/Array.hs+79−140

@@ -1,132 +1,112 @@

1−-- |

2−-- Module : Main

4−--

5−-- License : BSD-3-Clause

6−-- Maintainer : streamly@composewell.com

1+{-# OPTIONS_GHC -Wno-deprecations #-}

2+{-# OPTIONS_GHC -Wno-orphans #-}

84{-# LANGUAGE CPP #-}

9−{-# LANGUAGE FlexibleContexts #-}

105

11−import Control.DeepSeq (NFData(..))

12−import System.Random (randomRIO)

6+#include "Streamly/Benchmark/Data/Array/CommonImports.hs"

137

14−import qualified Streamly.Benchmark.Data.ArrayOps as Ops

15−import qualified Streamly.Data.Array.Foreign as A

16−import qualified Streamly.Internal.Data.Array.Foreign as IA

17−import qualified Streamly.Prelude as S

18−

19−import Gauge

20−import Streamly.Benchmark.Common hiding (benchPureSrc)

21−import qualified Streamly.Benchmark.Prelude as P

8+import Control.DeepSeq (deepseq)

229

23−#ifdef MEMORY_ARRAY

10+import qualified Streamly.Internal.Data.Array as IA

2411import qualified GHC.Exts as GHC

25−import Foreign.Storable (Storable(..))

26−#endif

2712

28−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

29−import Control.DeepSeq (deepseq)

30−#endif

13+-- import qualified Streamly.Data.Array as A

14+import qualified Streamly.Internal.Data.Array as A

15+

16+type Stream = A.Array

17+

18+#include "Streamly/Benchmark/Data/Array/Common.hs"

19+

20+instance NFData (A.Array a) where

21+ {-# INLINE rnf #-}

22+ rnf _ = ()

3123

3224-------------------------------------------------------------------------------

33−--

25+-- Benchmark helpers

3426-------------------------------------------------------------------------------

3527

36−#ifdef MEMORY_ARRAY

3728-- Drain a source that generates a pure array

3829{-# INLINE benchPureSrc #-}

39−benchPureSrc ::

40− (NFData a, Storable a) => String -> (Int -> Ops.Stream a) -> Benchmark

30+benchPureSrc :: String -> (Int -> Stream a) -> Benchmark

4131benchPureSrc name src = benchPure name src id

42−#endif

43−

44−{-# INLINE benchIO #-}

45−benchIO :: NFData b => String -> (Int -> IO a) -> (a -> b) -> Benchmark

46−benchIO name src f = bench name $ nfIO $

47− randomRIO (1,1) >>= src >>= return . f

4832

4933-- Drain a source that generates an array in the IO monad

5034{-# INLINE benchIOSrc #-}

51−benchIOSrc ::

52−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

53− NFData a =>

54−#endif

55−#ifdef MEMORY_ARRAY

56− Storable a =>

57−#endif

58− String -> (Int -> IO (Ops.Stream a)) -> Benchmark

35+benchIOSrc :: String -> (Int -> IO (Stream a)) -> Benchmark

5936benchIOSrc name src = benchIO name src id

6037

61−{-# INLINE benchPureSink #-}

62−benchPureSink :: NFData b => Int -> String -> (Ops.Stream Int -> b) -> Benchmark

63−benchPureSink value name f = benchIO name (Ops.sourceIntFromTo value) f

38+-------------------------------------------------------------------------------

39+-- Bench Ops

40+-------------------------------------------------------------------------------

41+

42+{-# INLINE sourceIntFromToFromList #-}

43+sourceIntFromToFromList :: MonadIO m => Int -> Int -> m (Stream Int)

44+sourceIntFromToFromList value n = P.return $ A.fromListN value [n..n + value]

45+

46+{-# INLINE readInstance #-}

47+readInstance :: P.String -> Stream Int

48+readInstance str =

49+ let r = P.reads str

50+ in case r of

51+ [(x,"")] -> x

52+ _ -> P.error "readInstance: no parse"

53+

54+#ifdef DEVBUILD

55+{-

56+{-# INLINE foldableFoldl' #-}

57+foldableFoldl' :: Stream Int -> Int

58+foldableFoldl' = F.foldl' (+) 0

59+

60+{-# INLINE foldableSum #-}

61+foldableSum :: Stream Int -> Int

62+foldableSum = P.sum

63+-}

64+#endif

65+

66+{-# INLINE sourceIsList #-}

67+sourceIsList :: Int -> Int -> Stream Int

68+sourceIsList value n = GHC.fromList [n..n+value]

6469

65−{-# INLINE benchIO' #-}

66−benchIO' :: NFData b => String -> (Int -> IO a) -> (a -> IO b) -> Benchmark

67−benchIO' name src f = bench name $ nfIO $

68− randomRIO (1,1) >>= src >>= f

70+{-# INLINE sourceIsString #-}

71+sourceIsString :: Int -> Int -> Stream P.Char

72+sourceIsString value n = GHC.fromString (P.replicate (n + value) 'a')

6973

70−{-# INLINE benchIOSink #-}

71−benchIOSink :: NFData b => Int -> String -> (Ops.Stream Int -> IO b) -> Benchmark

72−benchIOSink value name f = benchIO' name (Ops.sourceIntFromTo value) f

74+{-# INLINE sourceIntFromToFromStream #-}

75+sourceIntFromToFromStream :: MonadIO m => Int -> Int -> m (Stream Int)

76+sourceIntFromToFromStream value n = S.fold A.write $ S.enumerateFromTo n (n + value)

77+

78+-------------------------------------------------------------------------------

79+-- Bench groups

80+-------------------------------------------------------------------------------

7381

7482o_1_space_generation :: Int -> [Benchmark]

7583o_1_space_generation value =

7684 [ bgroup

7785 "generation"

78− [ benchIOSrc "writeN . intFromTo" (Ops.sourceIntFromTo value)

79−#ifndef DATA_SMALLARRAY

80− , benchIOSrc "write . intFromTo" (Ops.sourceIntFromToFromStream value)

81−#endif

82− , benchIOSrc

83− "fromList . intFromTo"

84− (Ops.sourceIntFromToFromList value)

85− , benchIOSrc "writeN . unfoldr" (Ops.sourceUnfoldr value)

86− , benchIOSrc "writeN . fromList" (Ops.sourceFromList value)

87−#ifdef MEMORY_ARRAY

88− , benchPureSrc "writeN . IsList.fromList" (Ops.sourceIsList value)

86+ [ benchIOSrc "write . intFromTo" (sourceIntFromToFromStream value)

87+ , let testStr = "fromList " ++ mkListString value

88+ in testStr `deepseq` bench "read" (nf readInstance testStr)

89+ , benchPureSrc "writeN . IsList.fromList" (sourceIsList value)

8990 , benchPureSrc

9091 "writeN . IsString.fromString"

91− (Ops.sourceIsString value)

92−#endif

93−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

94−#ifdef DATA_SMALLARRAY

95− , let testStr =

96− "fromListN " ++

97− show (value + 1) ++

98− "[1" ++ concat (replicate value ",1") ++ "]"

99−#else

100− , let testStr = mkListString value

101−#endif

102− in testStr `deepseq` (bench "read" $ nf Ops.readInstance testStr)

103−#endif

104− , benchPureSink value "show" Ops.showInstance

92+ (sourceIsString value)

93+

10594 ]

10695 ]

10796

10897o_1_space_elimination :: Int -> [Benchmark]

10998o_1_space_elimination value =

11099 [ bgroup "elimination"

111− [ benchPureSink value "id" id

112− , benchPureSink value "==" Ops.eqInstance

113− , benchPureSink value "/=" Ops.eqInstanceNotEq

114− , benchPureSink value "<" Ops.ordInstance

115− , benchPureSink value "min" Ops.ordInstanceMin

116−#ifdef MEMORY_ARRAY

117− -- length is used to check for foldr/build fusion

118− , benchPureSink value "length . IsList.toList" (length . GHC.toList)

119−#endif

120− , benchIOSink value "foldl'" Ops.pureFoldl'

121− , benchIOSink value "read" Ops.unfoldReadDrain

122− , benchIOSink value "toStreamRev" Ops.toStreamRevDrain

123− , benchFold "lastN.1" (S.fold (IA.lastN 1)) (P.sourceUnfoldrM value)

124− , benchFold "lastN.10" (S.fold (IA.lastN 10)) (P.sourceUnfoldrM value)

125−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

100+ [ benchPureSink value "length . IsList.toList" (length . GHC.toList)

101+ , benchFold "writeLastN.1"

102+ (S.fold (IA.writeLastN 1)) (P.sourceUnfoldrM value)

103+ , benchFold "writeLastN.10"

104+ (S.fold (IA.writeLastN 10)) (P.sourceUnfoldrM value)

126105#ifdef DEVBUILD

127− , benchPureSink value "foldable/foldl'" Ops.foldableFoldl'

128− , benchPureSink value "foldable/sum" Ops.foldableSum

129−#endif

106+{-

107+ benchPureSink value "foldable/foldl'" foldableFoldl'

108+ , benchPureSink value "foldable/sum" foldableSum

109+-}

130110#endif

131111 ]

132112 ]

@@ -136,66 +116,25 @@ o_n_heap_serial value =

136116 [ bgroup "elimination"

137117 [

138118 -- Converting the stream to an array

139− benchFold "lastN.Max" (S.fold (IA.lastN (value + 1)))

140− (P.sourceUnfoldrM value)

141− , benchFold "writeN" (S.fold (A.writeN value))

119+ benchFold "writeLastN.Max" (S.fold (IA.writeLastN (value + 1)))

142120 (P.sourceUnfoldrM value)

143121 ]

144122 ]

145123

146−o_1_space_transformation :: Int -> [Benchmark]

147−o_1_space_transformation value =

148− [ bgroup "transformation"

149− [ benchIOSink value "scanl'" (Ops.scanl' value 1)

150− , benchIOSink value "scanl1'" (Ops.scanl1' value 1)

151− , benchIOSink value "map" (Ops.map value 1)

152− ]

153− ]

154−

155−o_1_space_transformationX4 :: Int -> [Benchmark]

156−o_1_space_transformationX4 value =

157− [ bgroup "transformationX4"

158− [ benchIOSink value "scanl'" (Ops.scanl' value 4)

159− , benchIOSink value "scanl1'" (Ops.scanl1' value 4)

160− , benchIOSink value "map" (Ops.map value 4)

161− ]

162− ]

163−

164124moduleName :: String

165−#ifdef DATA_SMALLARRAY

166−moduleName = "Data.SmallArray"

167−#elif defined(MEMORY_ARRAY)

168−moduleName = "Memory.Array"

169−#elif defined(DATA_ARRAY_PRIM)

170−moduleName = "Data.Array.Prim"

171−#elif defined(DATA_ARRAY_PRIM_PINNED)

172−moduleName = "Data.Array.Prim.Pinnned"

173−#else

174125moduleName = "Data.Array"

175−#endif

176126

177−#ifdef DATA_SMALLARRAY

178−defStreamSize :: Int

179−defStreamSize = 128

180−#else

181127defStreamSize :: Int

182128defStreamSize = defaultStreamSize

183−#endif

184129

185130main :: IO ()

186−main = do

187− (value, cfg, benches) <- parseCLIOpts defStreamSize

188− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

131+main = runWithCLIOpts defStreamSize allBenchmarks

189132

190133 where

191134

192135 allBenchmarks size =

193− [ bgroup (o_1_space_prefix moduleName) $ concat

194− [ o_1_space_generation size

195− , o_1_space_elimination size

196− , o_1_space_transformation size

197− , o_1_space_transformationX4 size

198− ]

136+ [ bgroup (o_1_space_prefix moduleName) $

137+ o_1_space_generation size ++ o_1_space_elimination size

199138 , bgroup (o_n_space_prefix moduleName) $

200139 o_n_heap_serial size

201− ]

140+ ] ++ commonBenchmarks size

benchmark/Streamly/Benchmark/Data/Array/Common.hsnew file+185

@@ -0,0 +1,185 @@

1+-------------------------------------------------------------------------------

2+-- Benchmark helpers

3+-------------------------------------------------------------------------------

5+{-# INLINE benchIO #-}

6+benchIO :: NFData b => String -> (Int -> IO a) -> (a -> b) -> Benchmark

7+benchIO name src f = bench name $ nfIO $

8+ (randomRIO (1,1) >>= src) <&> f

10+{-# INLINE benchPureSink #-}

11+benchPureSink :: NFData b => Int -> String -> (Stream Int -> b) -> Benchmark

12+benchPureSink value name = benchIO name (sourceIntFromTo value)

13+

14+{-# INLINE benchIO' #-}

15+benchIO' :: NFData b => String -> (Int -> IO a) -> (a -> IO b) -> Benchmark

16+benchIO' name src f = bench name $ nfIO $

17+ randomRIO (1,1) >>= src >>= f

18+

19+{-# INLINE benchIOSink #-}

20+benchIOSink :: NFData b => Int -> String -> (Stream Int -> IO b) -> Benchmark

21+benchIOSink value name = benchIO' name (sourceIntFromTo value)

22+

23+-------------------------------------------------------------------------------

24+-- Bench Ops

25+-------------------------------------------------------------------------------

26+

27+{-# INLINE sourceUnfoldr #-}

28+sourceUnfoldr :: MonadIO m => Int -> Int -> m (Stream Int)

29+sourceUnfoldr value n = S.fold (A.writeN value) $ S.unfoldr step n

30+ where

31+ step cnt =

32+ if cnt > n + value

33+ then Nothing

34+ else Just (cnt, cnt + 1)

35+

36+{-# INLINE sourceIntFromTo #-}

37+sourceIntFromTo :: MonadIO m => Int -> Int -> m (Stream Int)

38+sourceIntFromTo value n = S.fold (A.writeN value) $ S.enumerateFromTo n (n + value)

39+

40+{-# INLINE sourceFromList #-}

41+sourceFromList :: MonadIO m => Int -> Int -> m (Stream Int)

42+sourceFromList value n = S.fold (A.writeN value) $ S.fromList [n..n+value]

43+

44+-------------------------------------------------------------------------------

45+-- Transformation

46+-------------------------------------------------------------------------------

47+

48+{-# INLINE composeN #-}

49+composeN :: P.Monad m

50+ => Int -> (Stream Int -> m (Stream Int)) -> Stream Int -> m (Stream Int)

51+composeN n f x =

52+ case n of

53+ 1 -> f x

54+ 2 -> f x P.>>= f

55+ 3 -> f x P.>>= f P.>>= f

56+ 4 -> f x P.>>= f P.>>= f P.>>= f

57+ _ -> undefined

58+

59+{-# INLINE scanl' #-}

60+{-# INLINE scanl1' #-}

61+{-# INLINE map #-}

62+

63+scanl' , scanl1', map

64+ :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

65+

66+

67+{-# INLINE onArray #-}

68+onArray

69+ :: MonadIO m => Int -> (Stream.Stream m Int -> Stream.Stream m Int)

70+ -> Stream Int

71+ -> m (Stream Int)

72+onArray value f arr = S.fold (A.writeN value) $ f $ S.unfold A.reader arr

73+

74+scanl' value n = composeN n $ onArray value $ S.scan (Fold.foldl' (+) 0)

75+scanl1' value n = composeN n $ onArray value $ Stream.scanl1' (+)

76+map value n = composeN n $ onArray value $ fmap (+1)

77+-- map n = composeN n $ A.map (+1)

78+

79+{-# INLINE eqInstance #-}

80+eqInstance :: Stream Int -> Bool

81+eqInstance src = src == src

82+

83+{-# INLINE eqInstanceNotEq #-}

84+eqInstanceNotEq :: Stream Int -> Bool

85+eqInstanceNotEq src = src P./= src

86+

87+{-# INLINE ordInstance #-}

88+ordInstance :: Stream Int -> Bool

89+ordInstance src = src P.< src

90+

91+{-# INLINE ordInstanceMin #-}

92+ordInstanceMin :: Stream Int -> Stream Int

93+ordInstanceMin src = P.min src src

94+

95+{-# INLINE showInstance #-}

96+showInstance :: Stream Int -> P.String

97+showInstance = P.show

98+

99+{-# INLINE pureFoldl' #-}

100+pureFoldl' :: MonadIO m => Stream Int -> m Int

101+pureFoldl' = S.fold (Fold.foldl' (+) 0) . S.unfold A.reader

102+

103+-------------------------------------------------------------------------------

104+-- Elimination

105+-------------------------------------------------------------------------------

106+

107+{-# INLINE unfoldReadDrain #-}

108+unfoldReadDrain :: MonadIO m => Stream Int -> m ()

109+unfoldReadDrain = S.fold Fold.drain . S.unfold A.reader

110+

111+{-# INLINE toStreamRevDrain #-}

112+toStreamRevDrain :: MonadIO m => Stream Int -> m ()

113+toStreamRevDrain = S.fold Fold.drain . A.readRev

114+

115+-------------------------------------------------------------------------------

116+-- Bench groups

117+-------------------------------------------------------------------------------

118+

119+common_o_1_space_generation :: Int -> [Benchmark]

120+common_o_1_space_generation value =

121+ [ bgroup

122+ "generation"

123+ [ benchIOSrc "writeN . intFromTo" (sourceIntFromTo value)

124+ , benchIOSrc

125+ "fromList . intFromTo"

126+ (sourceIntFromToFromList value)

127+ , benchIOSrc "writeN . unfoldr" (sourceUnfoldr value)

128+ , benchIOSrc "writeN . fromList" (sourceFromList value)

129+ , benchPureSink value "show" showInstance

130+ ]

131+ ]

132+

133+common_o_1_space_elimination :: Int -> [Benchmark]

134+common_o_1_space_elimination value =

135+ [ bgroup "elimination"

136+ [ benchPureSink value "id" id

137+ , benchPureSink value "==" eqInstance

138+ , benchPureSink value "/=" eqInstanceNotEq

139+ , benchPureSink value "<" ordInstance

140+ , benchPureSink value "min" ordInstanceMin

141+ , benchIOSink value "foldl'" pureFoldl'

142+ , benchIOSink value "read" unfoldReadDrain

143+ , benchIOSink value "toStreamRev" toStreamRevDrain

144+ ]

145+ ]

146+

147+common_o_n_heap_serial :: Int -> [Benchmark]

148+common_o_n_heap_serial value =

149+ [ bgroup "elimination"

150+ [

151+ -- Converting the stream to an array

152+ benchFold "writeN" (S.fold (A.writeN value))

153+ (P.sourceUnfoldrM value)

154+ ]

155+ ]

156+

157+common_o_1_space_transformation :: Int -> [Benchmark]

158+common_o_1_space_transformation value =

159+ [ bgroup "transformation"

160+ [ benchIOSink value "scanl'" (scanl' value 1)

161+ , benchIOSink value "scanl1'" (scanl1' value 1)

162+ , benchIOSink value "map" (map value 1)

163+ ]

164+ ]

165+

166+common_o_1_space_transformationX4 :: Int -> [Benchmark]

167+common_o_1_space_transformationX4 value =

168+ [ bgroup "transformationX4"

169+ [ benchIOSink value "scanl'" (scanl' value 4)

170+ , benchIOSink value "scanl1'" (scanl1' value 4)

171+ , benchIOSink value "map" (map value 4)

172+ ]

173+ ]

174+

175+commonBenchmarks :: Int -> [Benchmark]

176+commonBenchmarks size =

177+ [ bgroup (o_1_space_prefix moduleName) $ concat

178+ [ common_o_1_space_generation size

179+ , common_o_1_space_elimination size

180+ , common_o_1_space_transformation size

181+ , common_o_1_space_transformationX4 size

182+ ]

183+ , bgroup (o_n_space_prefix moduleName) $

184+ common_o_n_heap_serial size

185+ ]

benchmark/Streamly/Benchmark/Data/Array/CommonImports.hsnew file+16

@@ -0,0 +1,16 @@

1+{-# LANGUAGE FlexibleContexts #-}

3+import Control.DeepSeq (NFData(..))

4+import Control.Monad.IO.Class (MonadIO)

5+import Data.Functor ((<&>))

6+import System.Random (randomRIO)

8+import qualified Streamly.Data.Fold as Fold

9+import qualified Streamly.Data.Stream as S

10+import qualified Streamly.Internal.Data.Stream as Stream

11+

12+import Test.Tasty.Bench

13+import Streamly.Benchmark.Common hiding (benchPureSrc)

14+import qualified Stream.Common as P

15+

16+import Prelude as P hiding (map)

benchmark/Streamly/Benchmark/Data/Array/Generic.hsnew file+119

@@ -0,0 +1,119 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

2+{-# OPTIONS_GHC -Wno-orphans #-}

4+{-# LANGUAGE CPP #-}

6+#include "Streamly/Benchmark/Data/Array/CommonImports.hs"

8+import Control.DeepSeq (deepseq)

10+import qualified Streamly.Internal.Data.Array.Generic as IA

11+import qualified Streamly.Internal.Data.Array.Generic as A

12+

13+type Stream = A.Array

14+

15+#include "Streamly/Benchmark/Data/Array/Common.hs"

16+

17+instance NFData a => NFData (A.Array a) where

18+ {-# INLINE rnf #-}

19+ rnf = A.foldl' (\_ x -> rnf x) ()

20+

21+-------------------------------------------------------------------------------

22+-- Benchmark helpers

23+-------------------------------------------------------------------------------

24+

25+-- Drain a source that generates an array in the IO monad

26+{-# INLINE benchIOSrc #-}

27+benchIOSrc :: NFData a => String -> (Int -> IO (Stream a)) -> Benchmark

28+benchIOSrc name src = benchIO name src id

29+

30+-------------------------------------------------------------------------------

31+-- Bench Ops

32+-------------------------------------------------------------------------------

33+

34+{-# INLINE sourceIntFromToFromList #-}

35+sourceIntFromToFromList :: MonadIO m => Int -> Int -> m (Stream Int)

36+sourceIntFromToFromList value n = P.return $ A.fromListN value [n..n + value]

37+

38+{-# INLINE readInstance #-}

39+readInstance :: P.String -> Stream Int

40+readInstance str =

41+ let r = P.reads str

42+ in case r of

43+ [(x,"")] -> x

44+ _ -> P.error "readInstance: no parse"

45+

46+#ifdef DEVBUILD

47+{-

48+{-# INLINE foldableFoldl' #-}

49+foldableFoldl' :: Stream Int -> Int

50+foldableFoldl' = F.foldl' (+) 0

51+

52+{-# INLINE foldableSum #-}

53+foldableSum :: Stream Int -> Int

54+foldableSum = P.sum

55+-}

56+#endif

57+

58+{-# INLINE sourceIntFromToFromStream #-}

59+sourceIntFromToFromStream :: MonadIO m => Int -> Int -> m (Stream Int)

60+sourceIntFromToFromStream value n =

61+ S.fold A.write $ S.enumerateFromTo n (n + value)

62+

63+-------------------------------------------------------------------------------

64+-- Bench groups

65+-------------------------------------------------------------------------------

66+

67+o_1_space_generation :: Int -> [Benchmark]

68+o_1_space_generation value =

69+ [ bgroup

70+ "generation"

71+ [ benchIOSrc "write . intFromTo" (sourceIntFromToFromStream value)

72+ , let testStr = "fromList " ++ mkListString value

73+ in testStr `deepseq` bench "read" (nf readInstance testStr)

74+ ]

75+ ]

76+

77+o_1_space_elimination :: Int -> [Benchmark]

78+o_1_space_elimination value =

79+ [ bgroup "elimination"

80+ [ benchFold "writeLastN.1"

81+ (S.fold (IA.writeLastN 1)) (P.sourceUnfoldrM value)

82+ , benchFold "writeLastN.10"

83+ (S.fold (IA.writeLastN 10)) (P.sourceUnfoldrM value)

84+#ifdef DEVBUILD

85+{-

86+ benchPureSink value "foldable/foldl'" foldableFoldl'

87+ , benchPureSink value "foldable/sum" foldableSum

88+-}

89+#endif

90+ ]

91+ ]

92+

93+o_n_heap_serial :: Int -> [Benchmark]

94+o_n_heap_serial value =

95+ [ bgroup "elimination"

96+ [

97+ -- Converting the stream to an array

98+ benchFold "writeLastN.Max" (S.fold (IA.writeLastN (value + 1)))

99+ (P.sourceUnfoldrM value)

100+ ]

101+ ]

102+

103+moduleName :: String

104+moduleName = "Data.Array.Generic"

105+

106+defStreamSize :: Int

107+defStreamSize = defaultStreamSize

108+

109+main :: IO ()

110+main = runWithCLIOpts defStreamSize allBenchmarks

111+

112+ where

113+

114+ allBenchmarks size =

115+ [ bgroup (o_1_space_prefix moduleName) $

116+ o_1_space_generation size ++ o_1_space_elimination size

117+ , bgroup (o_n_space_prefix moduleName) $

118+ o_n_heap_serial size

119+ ] ++ commonBenchmarks size

benchmark/Streamly/Benchmark/Data/Array/SmallArray.hsnew file+95

@@ -0,0 +1,95 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

3+{-# LANGUAGE CPP #-}

5+#include "Streamly/Benchmark/Data/Array/CommonImports.hs"

7+import Control.DeepSeq (deepseq)

9+import qualified Streamly.Internal.Data.SmallArray as A

10+type Stream = A.SmallArray

11+

12+#include "Streamly/Benchmark/Data/Array/Common.hs"

13+

14+-------------------------------------------------------------------------------

15+-- Benchmark helpers

16+-------------------------------------------------------------------------------

17+

18+-- Drain a source that generates an array in the IO monad

19+{-# INLINE benchIOSrc #-}

20+benchIOSrc :: NFData a => String -> (Int -> IO (Stream a)) -> Benchmark

21+benchIOSrc name src = benchIO name src id

22+

23+-------------------------------------------------------------------------------

24+-- Bench Ops

25+-------------------------------------------------------------------------------

26+

27+{-# INLINE sourceIntFromToFromList #-}

28+sourceIntFromToFromList :: MonadIO m => Int -> Int -> m (Stream Int)

29+sourceIntFromToFromList value n = P.return $ A.fromListN value [n..n + value]

30+

31+{-# INLINE readInstance #-}

32+readInstance :: P.String -> Stream Int

33+readInstance str =

34+ let r = P.reads str

35+ in case r of

36+ [(x,"")] -> x

37+ _ -> P.error "readInstance: no parse"

38+

39+#ifdef DEVBUILD

40+{-

41+{-# INLINE foldableFoldl' #-}

42+foldableFoldl' :: Stream Int -> Int

43+foldableFoldl' = F.foldl' (+) 0

44+

45+{-# INLINE foldableSum #-}

46+foldableSum :: Stream Int -> Int

47+foldableSum = P.sum

48+-}

49+#endif

50+

51+-------------------------------------------------------------------------------

52+-- Bench groups

53+-------------------------------------------------------------------------------

54+

55+o_1_space_generation :: Int -> [Benchmark]

56+o_1_space_generation value =

57+ [ bgroup

58+ "generation"

59+ [ let testStr =

60+ "fromListN " ++

61+ show (value + 1) ++

62+ "[1" ++ concat (replicate value ",1") ++ "]"

63+ in testStr `deepseq` bench "read" (nf readInstance testStr)

64+ ]

65+ ]

66+

67+{-

68+o_1_space_elimination :: Int -> [Benchmark]

69+o_1_space_elimination value =

70+ [ bgroup "elimination"

71+ [

72+#ifdef DEVBUILD

73+{-

74+ benchPureSink value "foldable/foldl'" foldableFoldl'

75+ , benchPureSink value "foldable/sum" foldableSum

76+-}

77+#endif

78+ ]

79+ ]

80+-}

81+

82+moduleName :: String

83+moduleName = "Data.SmallArray"

84+

85+defStreamSize :: Int

86+defStreamSize = 128

87+

88+main :: IO ()

89+main = runWithCLIOpts defStreamSize allBenchmarks

90+

91+ where

92+

93+ allBenchmarks size =

94+ bgroup (o_1_space_prefix moduleName) (o_1_space_generation size)

95+ : commonBenchmarks size

benchmark/Streamly/Benchmark/Data/Array/Stream/Foreign.hs → benchmark/Streamly/Benchmark/Data/Array/Stream.hsrenamed+134−32

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Streamly.Benchmark.Data.ParserD

@@ -23,27 +25,61 @@ module Main

2325 main

2426 ) where

2527

28+import Control.DeepSeq (NFData(..))

29+import Control.Monad (void, when)

30+import Control.Monad.Catch (MonadCatch)

2631import Data.Functor.Identity (runIdentity)

32+import Data.Maybe (isJust)

2733import Data.Word (Word8)

34+import Streamly.Internal.Data.Stream (Stream)

35+import Streamly.Internal.Data.StreamK (StreamK)

2836import System.IO (Handle)

37+import System.Random (randomRIO)

2938import Prelude hiding ()

3039

31−import qualified Streamly.Prelude as Stream

32−import qualified Streamly.Internal.Data.Array.Foreign as Array

33−import qualified Streamly.Internal.Data.Array.Stream.Foreign as ArrayStream

40+import qualified Streamly.Data.Stream as Stream

41+import qualified Streamly.Internal.Data.Array as Array

42+import qualified Streamly.Internal.Data.Array.Stream as ArrayStream

43+import qualified Streamly.Internal.Data.Fold as Fold

44+import qualified Streamly.Internal.Data.Parser as Parser

45+import qualified Streamly.Internal.Data.Stream as Stream

46+import qualified Streamly.Internal.Data.StreamK as StreamK

3447import qualified Streamly.Internal.FileSystem.Handle as Handle

3548import qualified Streamly.Internal.Unicode.Stream as Unicode

3649

37−import Gauge hiding (env)

50+import Test.Tasty.Bench hiding (env)

3851import Streamly.Benchmark.Common

3952import Streamly.Benchmark.Common.Handle

53+import Control.Monad.IO.Class (MonadIO)

4054

4155#ifdef INSPECTION

42−import Foreign.Storable (Storable)

43−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))

56+import Streamly.Internal.Data.MutByteArray (Unbox)

57+import Streamly.Internal.Data.Stream (Step(..))

4458import Test.Inspection

4559#endif

4660

61+-------------------------------------------------------------------------------

62+-- Utilities

63+-------------------------------------------------------------------------------

64+

65+-- XXX these can be moved to the common module

66+

67+{-# INLINE sourceUnfoldrM #-}

68+sourceUnfoldrM :: MonadIO m => Int -> Int -> Stream.Stream m Int

69+sourceUnfoldrM value n = Stream.unfoldrM step n

70+ where

71+ step cnt =

72+ if cnt > n + value

73+ then return Nothing

74+ else return (Just (cnt, cnt + 1))

75+

76+{-# INLINE benchIO #-}

77+benchIO

78+ :: NFData b

79+ => String -> (Int -> Stream IO a) -> (Stream IO a -> IO b) -> Benchmark

80+benchIO name src sink =

81+ bench name $ nfIO $ randomRIO (1,1) >>= sink . src

82+

4783-------------------------------------------------------------------------------

4884-- read chunked using toChunks

4985-------------------------------------------------------------------------------

@@ -51,11 +87,11 @@ import Test.Inspection

5187-- | Get the last byte from a file bytestream.

5288toChunksLast :: Handle -> IO (Maybe Word8)

5389toChunksLast inh = do

54− let s = Handle.toChunks inh

90+ let s = Handle.readChunks inh

5591 larr <- Stream.last s

5692 return $ case larr of

5793 Nothing -> Nothing

58− Just arr -> Array.readIndex arr (Array.length arr - 1)

94+ Just arr -> Array.getIndex (Array.length arr - 1) arr

5995

6096#ifdef INSPECTION

6197inspect $ hasNoTypeClasses 'toChunksLast

@@ -65,8 +101,8 @@ inspect $ 'toChunksLast `hasNoType` ''Step

65101-- | Count the number of bytes in a file.

66102toChunksSumLengths :: Handle -> IO Int

67103toChunksSumLengths inh =

68− let s = Handle.toChunks inh

69− in Stream.sum (Stream.map Array.length s)

104+ let s = Handle.readChunks inh

105+ in Stream.fold Fold.sum (Stream.map Array.length s)

70106

71107#ifdef INSPECTION

72108inspect $ hasNoTypeClasses 'toChunksSumLengths

@@ -76,8 +112,8 @@ inspect $ 'toChunksSumLengths `hasNoType` ''Step

76112-- | Sum the bytes in a file.

77113toChunksCountBytes :: Handle -> IO Word8

78114toChunksCountBytes inh = do

79− let foldlArr' f z = runIdentity . Stream.foldl' f z . Array.toStream

80− let s = Handle.toChunks inh

115+ let foldlArr' f z = runIdentity . Stream.foldl' f z . Array.read

116+ let s = Handle.readChunks inh

81117 Stream.foldl' (\acc arr -> acc + foldlArr' (+) 0 arr) 0 s

82118

83119#ifdef INSPECTION

@@ -87,7 +123,7 @@ inspect $ 'toChunksCountBytes `hasNoType` ''Step

87123

88124toChunksDecodeUtf8Arrays :: Handle -> IO ()

89125toChunksDecodeUtf8Arrays =

90− Stream.drain . Unicode.decodeUtf8Arrays . Handle.toChunks

126+ Stream.drain . Unicode.decodeUtf8Chunks . Handle.readChunks

91127

92128#ifdef INSPECTION

93129inspect $ hasNoTypeClasses 'toChunksDecodeUtf8Arrays

@@ -101,7 +137,9 @@ inspect $ hasNoTypeClasses 'toChunksDecodeUtf8Arrays

101137-- | Count the number of lines in a file.

102138toChunksSplitOnSuffix :: Handle -> IO Int

103139toChunksSplitOnSuffix =

104− Stream.length . ArrayStream.splitOnSuffix 10 . Handle.toChunks

140+ Stream.fold Fold.length

141+ . ArrayStream.splitOnSuffix 10

142+ . Handle.readChunks

105143

106144#ifdef INSPECTION

107145inspect $ hasNoTypeClasses 'toChunksSplitOnSuffix

@@ -111,7 +149,10 @@ inspect $ 'toChunksSplitOnSuffix `hasNoType` ''Step

111149-- XXX use a word splitting combinator instead of splitOn and test it.

112150-- | Count the number of words in a file.

113151toChunksSplitOn :: Handle -> IO Int

114−toChunksSplitOn = Stream.length . ArrayStream.splitOn 32 . Handle.toChunks

152+toChunksSplitOn =

153+ Stream.fold Fold.length

154+ . ArrayStream.splitOn 32

155+ . Handle.readChunks

115156

116157#ifdef INSPECTION

117158inspect $ hasNoTypeClasses 'toChunksSplitOn

@@ -149,12 +190,11 @@ o_1_space_read_chunked env =

149190copyChunksSplitInterposeSuffix :: Handle -> Handle -> IO ()

150191copyChunksSplitInterposeSuffix inh outh =

151192 Stream.fold (Handle.write outh)

152− $ ArrayStream.interposeSuffix 10

153− $ ArrayStream.splitOnSuffix 10

154− $ Handle.toChunks inh

193+ $ ArrayStream.interposeSuffix 10 . ArrayStream.splitOnSuffix 10

194+ $ Handle.readChunks inh

155195

156196#ifdef INSPECTION

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

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

158198inspect $ 'copyChunksSplitInterposeSuffix `hasNoType` ''Step

159199#endif

160200

@@ -163,13 +203,12 @@ inspect $ 'copyChunksSplitInterposeSuffix `hasNoType` ''Step

163203copyChunksSplitInterpose :: Handle -> Handle -> IO ()

164204copyChunksSplitInterpose inh outh =

165205 Stream.fold (Handle.write outh)

166− $ ArrayStream.interpose 32

167206 -- XXX this is not correct word splitting combinator

168− $ ArrayStream.splitOn 32

169− $ Handle.toChunks inh

207+ $ ArrayStream.interpose 32 . ArrayStream.splitOn 32

208+ $ Handle.readChunks inh

170209

171210#ifdef INSPECTION

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

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

173212inspect $ 'copyChunksSplitInterpose `hasNoType` ''Step

174213#endif

175214

@@ -183,25 +222,88 @@ o_1_space_copy_toChunks_group_ungroup env =

183222 ]

184223 ]

185224

225+-------------------------------------------------------------------------------

226+-- Parsers

227+-------------------------------------------------------------------------------

228+

229+{-# INLINE drainWhile #-}

230+drainWhile :: MonadCatch m => (a -> Bool) -> Parser.Parser a m ()

231+drainWhile p = Parser.takeWhile p Fold.drain

232+

233+-------------------------------------------------------------------------------

234+-- Folds and parsers

235+-------------------------------------------------------------------------------

236+

237+{-# INLINE fold #-}

238+fold :: Stream IO (Array.Array Int) -> IO ()

239+fold s = void $ ArrayStream.foldBreak Fold.drain $ StreamK.fromStream s

240+

241+{-# INLINE parse #-}

242+parse :: Int -> Stream IO (Array.Array Int) -> IO ()

243+parse value s =

244+ void $ ArrayStream.parseBreak (drainWhile (< value)) $ StreamK.fromStream s

245+

246+{-# INLINE foldBreak #-}

247+foldBreak :: StreamK IO (Array.Array Int) -> IO ()

248+foldBreak s = do

249+ (r, s1) <- ArrayStream.foldBreak Fold.one s

250+ when (isJust r) $ foldBreak s1

251+

252+{-# INLINE parseBreak #-}

253+parseBreak :: StreamK IO (Array.Array Int) -> IO ()

254+parseBreak s = do

255+ r <- ArrayStream.parseBreak Parser.one s

256+ case r of

257+ (Left _, _) -> return ()

258+ (Right _, s1) -> parseBreak s1

259+

260+o_1_space_serial_array ::

261+ Int -> [Array.Array Int] -> [Array.Array Int] -> [Benchmark]

262+o_1_space_serial_array bound arraysSmall arraysBig =

263+ [ benchIO "fold (of 100)" (\_ -> Stream.fromList arraysSmall) fold

264+ , benchIO "fold (single)" (\_ -> Stream.fromList arraysBig) fold

265+ , benchIO

266+ "foldBreak (recursive, small arrays)"

267+ (\_ -> Stream.fromList arraysSmall)

268+ (foldBreak . StreamK.fromStream)

269+ , benchIO "parse (of 100)" (\_ -> Stream.fromList arraysSmall)

270+ $ parse bound

271+ , benchIO "parse (single)" (\_ -> Stream.fromList arraysBig)

272+ $ parse bound

273+ , benchIO

274+ "parseBreak (recursive, small arrays)"

275+ (\_ -> Stream.fromList arraysSmall)

276+ (parseBreak . StreamK.fromStream)

277+ ]

278+

186279-------------------------------------------------------------------------------

187280-- Driver

188281-------------------------------------------------------------------------------

189282

190283moduleName :: String

191−moduleName = "Data.Array.Stream.Foreign"

284+moduleName = "Data.Array.Stream"

192285

193286main :: IO ()

194287main = do

195− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

196288 env <- mkHandleBenchEnv

197− value `seq` runMode (mode cfg) cfg benches

198− (allBenchmarks env)

289+ runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)

199290

200291 where

201292

202− allBenchmarks env =

203− [ bgroup (o_1_space_prefix moduleName)

204− ( o_1_space_read_chunked env

205− ++ o_1_space_copy_toChunks_group_ungroup env

206− )

293+ alloc value =

294+ if value <= 0

295+ then return (undefined, undefined)

296+ else

297+ do

298+ small <- Stream.toList $ Stream.chunksOf 100 $ sourceUnfoldrM value 0

299+ big <- Stream.toList $ Stream.chunksOf value $ sourceUnfoldrM value 0

300+ return (small, big)

301+

302+ allBenchmarks env arrays value =

303+ let (arraysSmall, arraysBig) = arrays

304+ in [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat

305+ [ o_1_space_read_chunked env

306+ , o_1_space_serial_array value arraysSmall arraysBig

307+ , o_1_space_copy_toChunks_group_ungroup env

308+ ]

207309 ]

benchmark/Streamly/Benchmark/Data/ArrayOps.hsdeleted−242

@@ -1,242 +0,0 @@

1−-- |

2−-- Module : Streamly.Benchmark.Data.ArrayOps

4−--

5−-- License : BSD-3-Clause

6−-- Maintainer : streamly@composewell.com

7−

8−{-# LANGUAGE CPP #-}

9−{-# LANGUAGE FlexibleContexts #-}

10−{-# LANGUAGE ScopedTypeVariables #-}

11−

12−-- CPP:

13−-- MEMORY_ARRAY

14−-- DATA_ARRAY

15−-- DATA_ARRAY_PRIM

16−-- DATA_ARRAY_PRIM_PINNED

17−-- DATA_SMALLARRAY

18−

19−module Streamly.Benchmark.Data.ArrayOps where

20−

21−import Control.Monad.IO.Class (MonadIO)

22−import Prelude (Bool, Int, Maybe(..), ($), (+), (.), (==), (>), undefined)

23−

24−import qualified Prelude as P

25−import qualified Streamly.Prelude as S

26−

27−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

28−#ifdef DEVBUILD

29−import qualified Data.Foldable as F

30−#endif

31−#endif

32−

33−#ifdef DATA_SMALLARRAY

34−import qualified Streamly.Internal.Data.SmallArray as A

35−type Stream = A.SmallArray

36−#elif defined(MEMORY_ARRAY)

37−import qualified GHC.Exts as GHC

38−import qualified Streamly.Data.Array.Foreign as A

39−import qualified Streamly.Internal.Data.Array.Foreign as A

40−type Stream = A.Array

41−#elif defined(DATA_ARRAY_PRIM)

42−import qualified Streamly.Internal.Data.Array.Prim as A

43−type Stream = A.Array

44−#elif defined(DATA_ARRAY_PRIM_PINNED)

45−import qualified Streamly.Internal.Data.Array.Prim.Pinned as A

46−type Stream = A.Array

47−#elif defined(DATA_ARRAY)

48−import qualified Streamly.Internal.Data.Array as A

49−type Stream = A.Array

50−#endif

51−

52−-------------------------------------------------------------------------------

53−-- Benchmark ops

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

55−

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

57−-- Stream generation and elimination

58−-------------------------------------------------------------------------------

59−

60−-------------------------------------------------------------------------------

61−-- CPP Common to:

62−-- MEMORY_ARRAY

63−-- DATA_ARRAY

64−-- DATA_ARRAY_PRIM

65−-- DATA_ARRAY_PRIM_PINNED

66−-- DATA_SMALLARRAY

67−-------------------------------------------------------------------------------

68−

69−{-# INLINE sourceUnfoldr #-}

70−sourceUnfoldr :: MonadIO m => Int -> Int -> m (Stream Int)

71−sourceUnfoldr value n = S.fold (A.writeN value) $ S.unfoldr step n

72− where

73− step cnt =

74− if cnt > n + value

75− then Nothing

76− else (Just (cnt, cnt + 1))

77−

78−{-# INLINE sourceIntFromTo #-}

79−sourceIntFromTo :: MonadIO m => Int -> Int -> m (Stream Int)

80−sourceIntFromTo value n = S.fold (A.writeN value) $ S.enumerateFromTo n (n + value)

81−

82−{-# INLINE sourceFromList #-}

83−sourceFromList :: MonadIO m => Int -> Int -> m (Stream Int)

84−sourceFromList value n = S.fold (A.writeN value) $ S.fromList [n..n+value]

85−

86−-- Different defination of sourceIntFromToFromList for DATA_SMALLARRAY

87−-- CPP:

88−{-# INLINE sourceIntFromToFromList #-}

89−sourceIntFromToFromList :: MonadIO m => Int -> Int -> m (Stream Int)

90−#ifndef DATA_SMALLARRAY

91−sourceIntFromToFromList value n = P.return $ A.fromList $ [n..n + value]

92−#else

93−sourceIntFromToFromList value n = P.return $ A.fromListN value $ [n..n + value]

94−#endif

95−

96−-------------------------------------------------------------------------------

97−-- CPP Common to:

98−-- MEMORY_ARRAY

99−-- DATA_ARRAY

100−-- DATA_ARRAY_PRIM

101−-- DATA_ARRAY_PRIM_PINNED

102−-------------------------------------------------------------------------------

103−

104−-- CPP:

105−#ifndef DATA_SMALLARRAY

106−{-# INLINE sourceIntFromToFromStream #-}

107−sourceIntFromToFromStream :: MonadIO m => Int -> Int -> m (Stream Int)

108−sourceIntFromToFromStream value n = S.fold A.write $ S.enumerateFromTo n (n + value)

109−#endif

110−

111−-------------------------------------------------------------------------------

112−-- CPP Common to:

113−-- MEMORY_ARRAY

114−-------------------------------------------------------------------------------

115−

116−-- CPP:

117−#ifdef MEMORY_ARRAY

118−{-# INLINE sourceIsList #-}

119−sourceIsList :: Int -> Int -> Stream Int

120−sourceIsList value n = GHC.fromList [n..n+value]

121−

122−{-# INLINE sourceIsString #-}

123−sourceIsString :: Int -> Int -> Stream P.Char

124−sourceIsString value n = GHC.fromString (P.replicate (n + value) 'a')

125−#endif

126−

127−-------------------------------------------------------------------------------

128−-- Transformation

129−-------------------------------------------------------------------------------

130−

131−-------------------------------------------------------------------------------

132−-- CPP Common to:

133−-- MEMORY_ARRAY

134−-- DATA_ARRAY

135−-- DATA_ARRAY_PRIM

136−-- DATA_ARRAY_PRIM_PINNED

137−-- DATA_SMALLARRAY

138−-------------------------------------------------------------------------------

139−

140−{-# INLINE composeN #-}

141−composeN :: P.Monad m

142− => Int -> (Stream Int -> m (Stream Int)) -> Stream Int -> m (Stream Int)

143−composeN n f x =

144− case n of

145− 1 -> f x

146− 2 -> f x P.>>= f

147− 3 -> f x P.>>= f P.>>= f

148− 4 -> f x P.>>= f P.>>= f P.>>= f

149− _ -> undefined

150−

151−{-# INLINE scanl' #-}

152−{-# INLINE scanl1' #-}

153−{-# INLINE map #-}

154−

155−scanl' , scanl1', map

156− :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

157−

158−

159−{-# INLINE onArray #-}

160−onArray

161− :: MonadIO m => Int -> (S.SerialT m Int -> S.SerialT m Int)

162− -> Stream Int

163− -> m (Stream Int)

164−onArray value f arr = S.fold (A.writeN value) $ f $ (S.unfold A.read arr)

165−

166−scanl' value n = composeN n $ onArray value $ S.scanl' (+) 0

167−scanl1' value n = composeN n $ onArray value $ S.scanl1' (+)

168−map value n = composeN n $ onArray value $ S.map (+1)

169−-- map n = composeN n $ A.map (+1)

170−

171−{-# INLINE eqInstance #-}

172−eqInstance :: Stream Int -> Bool

173−eqInstance src = src == src

174−

175−{-# INLINE eqInstanceNotEq #-}

176−eqInstanceNotEq :: Stream Int -> Bool

177−eqInstanceNotEq src = src P./= src

178−

179−{-# INLINE ordInstance #-}

180−ordInstance :: Stream Int -> Bool

181−ordInstance src = src P.< src

182−

183−{-# INLINE ordInstanceMin #-}

184−ordInstanceMin :: Stream Int -> Stream Int

185−ordInstanceMin src = P.min src src

186−

187−{-# INLINE showInstance #-}

188−showInstance :: Stream Int -> P.String

189−showInstance src = P.show src

190−

191−{-# INLINE pureFoldl' #-}

192−pureFoldl' :: MonadIO m => Stream Int -> m Int

193−pureFoldl' = S.foldl' (+) 0 . S.unfold A.read

194−

195−-------------------------------------------------------------------------------

196−-- CPP Common to:

197−-- MEMORY_ARRAY

198−-- DATA_ARRAY

199−-- DATA_SMALLARRAY

200−-------------------------------------------------------------------------------

201−

202−-- CPP:

203−#if !defined(DATA_ARRAY_PRIM) && !defined(DATA_ARRAY_PRIM_PINNED)

204−{-# INLINE readInstance #-}

205−readInstance :: P.String -> Stream Int

206−readInstance str =

207− let r = P.reads str

208− in case r of

209− [(x,"")] -> x

210− _ -> P.error "readInstance: no parse"

211−

212−#ifdef DEVBUILD

213−{-# INLINE foldableFoldl' #-}

214−foldableFoldl' :: Stream Int -> Int

215−foldableFoldl' = F.foldl' (+) 0

216−

217−{-# INLINE foldableSum #-}

218−foldableSum :: Stream Int -> Int

219−foldableSum = P.sum

220−#endif

221−#endif

222−

223−-------------------------------------------------------------------------------

224−-- Elimination

225−-------------------------------------------------------------------------------

226−

227−-------------------------------------------------------------------------------

228−-- CPP Common to:

229−-- MEMORY_ARRAY

230−-- DATA_ARRAY

231−-- DATA_ARRAY_PRIM

232−-- DATA_ARRAY_PRIM_PINNED

233−-- DATA_SMALLARRAY

234−-------------------------------------------------------------------------------

235−

236−{-# INLINE unfoldReadDrain #-}

237−unfoldReadDrain :: MonadIO m => Stream Int -> m ()

238−unfoldReadDrain = S.drain . S.unfold A.read

239−

240−{-# INLINE toStreamRevDrain #-}

241−toStreamRevDrain :: MonadIO m => Stream Int -> m ()

242−toStreamRevDrain = S.drain . A.toStreamRev

benchmark/Streamly/Benchmark/Data/Fold.hs+328−123

@@ -6,34 +6,51 @@

66-- Maintainer : streamly@composewell.com

88{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE FlexibleInstances #-}

10+{-# LANGUAGE RankNTypes #-}

11+{-# LANGUAGE ScopedTypeVariables #-}

12+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}

13+{-# OPTIONS_GHC -Wno-orphans #-}

14+

15+#undef FUSION_CHECK

16+#ifdef FUSION_CHECK

17+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}

18+#endif

919

1020module Main (main) where

1121

1222import Control.DeepSeq (NFData(..))

23+import Control.Monad (when)

24+import Control.Monad.IO.Class (MonadIO(..))

25+import Data.Functor.Identity (Identity(..))

1326import Data.Map.Strict (Map)

27+import Data.Hashable (Hashable)

28+import Data.HashMap.Strict (HashMap)

29+import Data.IntMap.Strict (IntMap)

1430import Data.Monoid (Last(..), Sum(..))

1531import System.Random (randomRIO)

1632

17−import Streamly.Prelude (SerialT)

33+import Streamly.Internal.Data.Stream (Stream)

1834import Streamly.Internal.Data.Fold (Fold(..))

35+import Streamly.Internal.Data.IsMap.HashMap ()

36+import Streamly.Internal.Data.MutArray (MutArray)

1937

20−import qualified Data.Map.Strict as Map

2138import qualified Streamly.Internal.Data.Fold as FL

39+import qualified Streamly.Data.Fold.Prelude as Fold

40+import qualified Streamly.Internal.Data.Unfold as Unfold

2241import qualified Streamly.Internal.Data.Pipe as Pipe

23−import qualified Streamly.Internal.Data.Sink as Sink

24−import qualified Streamly.Internal.Data.Stream.IsStream as IP

25−import qualified Streamly.Prelude as S

42+import qualified Streamly.Internal.Data.Stream as Stream

2643

27−import Gauge

44+import Test.Tasty.Bench

2845import Streamly.Benchmark.Common

29−import Prelude hiding (all, any, take, unzip, sequence_)

46+import Prelude hiding (all, any, take, unzip, sequence_, filter)

3047

3148-- We need a monadic bind here to make sure that the function f does not get

3249-- completely optimized out by the compiler in some cases.

3350

3451{-# INLINE sourceUnfoldrM #-}

35−sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

36−sourceUnfoldrM value n = S.unfoldrM step n

52+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

53+sourceUnfoldrM value n = Stream.unfoldrM step n

3754 where

3855 step cnt =

3956 if cnt > n + value

@@ -41,14 +58,14 @@ sourceUnfoldrM value n = S.unfoldrM step n

4158 else return (Just (cnt, cnt + 1))

4259

4360{-# INLINE source #-}

44−source :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

61+source :: Monad m => Int -> Int -> Stream m Int

4562source = sourceUnfoldrM

4663

4764-- | Takes a fold method, and uses it with a default source.

4865{-# INLINE benchIOSink #-}

4966benchIOSink

50− :: (S.IsStream t, NFData b)

51− => Int -> String -> (t IO Int -> IO b) -> Benchmark

67+ :: NFData b

68+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

5269benchIOSink value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . source value

5370

5471-------------------------------------------------------------------------------

@@ -56,124 +73,221 @@ benchIOSink value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . source va

5673-------------------------------------------------------------------------------

5774

5875{-# INLINE any #-}

59−any :: (Monad m, Ord a) => a -> SerialT m a -> m Bool

60−any value = IP.fold (FL.any (> value))

76+any :: (Monad m, Ord a) => a -> Stream m a -> m Bool

77+any value = Stream.fold (FL.any (> value))

6178

6279{-# INLINE all #-}

63−all :: (Monad m, Ord a) => a -> SerialT m a -> m Bool

64−all value = IP.fold (FL.all (<= value))

80+all :: (Monad m, Ord a) => a -> Stream m a -> m Bool

81+all value = Stream.fold (FL.all (<= value))

6582

6683{-# INLINE take #-}

67−take :: Monad m => Int -> SerialT m a -> m ()

68−take value = IP.fold (FL.take value FL.drain)

84+take :: Monad m => Int -> Stream m a -> m ()

85+take value = Stream.fold (FL.take value FL.drain)

6986

7087{-# INLINE sequence_ #-}

7188sequence_ :: Monad m => Int -> Fold m a ()

7289sequence_ value =

73− foldr f (FL.yield ()) (Prelude.replicate value (FL.take 1 FL.drain))

90+ foldr f (FL.fromPure ()) (Prelude.replicate value (FL.take 1 FL.drain))

7491

7592 where

7693

7794 {-# INLINE f #-}

7895 f m k = FL.concatMap (const k) m

7996

97+-------------------------------------------------------------------------------

98+-- Filter

99+-------------------------------------------------------------------------------

100+

101+{-# INLINE filter #-}

102+filter :: Monad m => Int -> Stream m Int -> m ()

103+filter _ = Stream.fold (FL.filter even FL.drain)

104+

105+{-# INLINE scanMaybe #-}

106+scanMaybe :: Monad m => Int -> Stream m Int -> m ()

107+scanMaybe _ = Stream.fold (FL.scanMaybe (FL.filtering even) FL.drain)

108+

109+{-# INLINE scanMaybe2 #-}

110+scanMaybe2 :: Monad m => Int -> Stream m Int -> m ()

111+scanMaybe2 _ =

112+ Stream.fold

113+ $ FL.scanMaybe (FL.filtering even)

114+ $ FL.scanMaybe (FL.filtering odd) FL.drain

115+

80116-------------------------------------------------------------------------------

81117-- Splitting by serial application

82118-------------------------------------------------------------------------------

83119

84120{-# INLINE takeEndBy_ #-}

85−takeEndBy_ :: Monad m => Int -> SerialT m Int -> m ()

86−takeEndBy_ value = IP.fold (FL.takeEndBy_ (>= value) FL.drain)

121+takeEndBy_ :: Monad m => Int -> Stream m Int -> m ()

122+takeEndBy_ value = Stream.fold (FL.takeEndBy_ (>= value) FL.drain)

87123

88124{-# INLINE many #-}

89−many :: Monad m => SerialT m Int -> m ()

90−many = IP.fold (FL.many (FL.take 1 FL.drain) FL.drain)

125+many :: Monad m => Stream m Int -> m ()

126+many = Stream.fold (FL.many (FL.take 1 FL.drain) FL.drain)

91127

92128{-# INLINE splitAllAny #-}

93−splitAllAny :: Monad m => Int -> SerialT m Int -> m (Bool, Bool)

129+splitAllAny :: Monad m => Int -> Stream m Int -> m (Bool, Bool)

94130splitAllAny value =

95− IP.fold

96− (FL.serialWith (,)

131+ Stream.fold

132+ (FL.splitWith (,)

97133 (FL.all (<= (value `div` 2)))

98134 (FL.any (> value))

99135 )

100136

101−{-

102137{-# INLINE split_ #-}

103−split_ :: Monad m

104− => Int -> SerialT m Int -> m ()

138+split_ :: Monad m => Int -> Stream m Int -> m Bool

105139split_ value =

106− IP.fold

140+ Stream.fold

107141 (FL.split_

108142 (FL.all (<= (value `div` 2)))

109143 (FL.any (> value))

110144 )

111−-}

145+

146+{-# INLINE shortest #-}

147+shortest :: Monad m => Stream m Int -> m (Either Int Int)

148+shortest = Stream.fold (FL.shortest FL.sum FL.length)

149+

150+{-# INLINE longest #-}

151+longest :: Monad m => Stream m Int -> m (Either Int Int)

152+longest = Stream.fold (FL.longest FL.sum FL.length)

153+

154+{-# INLINE foldBreak #-}

155+foldBreak :: Monad m => Stream m Int -> m ()

156+foldBreak s = do

157+ (r, s1) <- Stream.foldBreak (FL.take 1 FL.length) s

158+ when (r /= 0) $ foldBreak s1

112159

113160-------------------------------------------------------------------------------

114161-- Distributing by parallel application

115162-------------------------------------------------------------------------------

116163

117164{-# INLINE teeSumLength #-}

118−teeSumLength :: Monad m => SerialT m Int -> m (Int, Int)

119−teeSumLength = IP.fold (FL.teeWith (,) FL.sum FL.length)

165+teeSumLength :: Monad m => Stream m Int -> m (Int, Int)

166+teeSumLength = Stream.fold (FL.teeWith (,) FL.sum FL.length)

120167

121168{-# INLINE teeAllAny #-}

122−teeAllAny :: (Monad m, Ord a) => a -> SerialT m a -> m (Bool, Bool)

123−teeAllAny value = IP.fold (FL.teeWith (,) all_ any_)

169+teeAllAny :: (Monad m, Ord a) => a -> Stream m a -> m (Bool, Bool)

170+teeAllAny value = Stream.fold (FL.teeWith (,) all_ any_)

124171

125172 where

126173

127174 all_ = FL.all (<= value)

128175 any_ = FL.any (> value)

129176

177+{-# INLINE teeWithFst #-}

178+teeWithFst :: Monad m => Stream m Int -> m (Int, Int)

179+teeWithFst = Stream.fold (FL.teeWithFst (,) FL.sum FL.length)

180+

181+{-# INLINE teeWithMin #-}

182+teeWithMin :: Monad m => Stream m Int -> m (Int, Int)

183+teeWithMin = Stream.fold (FL.teeWithMin (,) FL.sum FL.length)

184+

130185{-# INLINE distribute #-}

131−distribute :: Monad m => SerialT m Int -> m [Int]

132−distribute = IP.fold (FL.distribute [FL.sum, FL.length])

186+distribute :: Monad m => Stream m Int -> m [Int]

187+distribute = Stream.fold (FL.distribute [FL.sum, FL.length])

133188

134189-------------------------------------------------------------------------------

135190-- Partitioning

136191-------------------------------------------------------------------------------

137192

193+{-# INLINE oddEven #-}

194+oddEven :: Int -> Either Int Int

195+oddEven x = if odd x then Left x else Right x

196+

138197{-# INLINE partition #-}

139−partition :: Monad m => SerialT m Int -> m (Int, Int)

140−partition =

141− let f a =

142− if odd a

143− then Left a

144− else Right a

145− in IP.fold $ FL.map f (FL.partition FL.sum FL.length)

146−

147−{-# INLINE demuxWith #-}

148−demuxWith ::

149− (Monad m, Ord k)

150− => (a -> (k, a'))

151− -> Map k (Fold m a' b)

152− -> SerialT m a

153− -> m (Map k b)

154−demuxWith f mp = S.fold (FL.demuxWith f mp)

155−

156−{-# INLINE demuxDefaultWith #-}

157−demuxDefaultWith ::

158− (Monad m, Ord k, Num b)

159− => (a -> (k, b))

160− -> Map k (Fold m b b)

161− -> SerialT m a

162− -> m (Map k b, b)

163−demuxDefaultWith f mp = S.fold (FL.demuxDefaultWith f mp (FL.map snd FL.sum))

164−

165−{-# INLINE classifyWith #-}

166−classifyWith ::

167− (Monad m, Ord k, Num a) => (a -> k) -> SerialT m a -> m (Map k a)

168−classifyWith f = S.fold (FL.classifyWith f FL.sum)

198+partition :: Monad m => Stream m Int -> m (Int, Int)

199+partition = Stream.fold $ FL.lmap oddEven (FL.partition FL.sum FL.length)

200+

201+{-# INLINE partitionByFstM #-}

202+partitionByFstM :: Monad m => Stream m Int -> m (Int, Int)

203+partitionByFstM =

204+ Stream.fold (FL.partitionByFstM (return . oddEven) FL.sum FL.length)

205+

206+{-# INLINE partitionByMinM #-}

207+partitionByMinM :: Monad m => Stream m Int -> m (Int, Int)

208+partitionByMinM =

209+ Stream.fold (FL.partitionByMinM (return . oddEven) FL.sum FL.length)

210+

211+{-# INLINE demuxToMap #-}

212+demuxToMap :: (Monad m, Ord k) =>

213+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (Map k b)

214+demuxToMap f g = Stream.fold (FL.demuxToContainer f g)

215+

216+{-# INLINE demuxToIntMap #-}

217+demuxToIntMap :: Monad m =>

218+ (a -> Int) -> (a -> m (Fold m a b)) -> Stream m a -> m (IntMap b)

219+demuxToIntMap f g = Stream.fold (FL.demuxToContainer f g)

220+

221+{-# INLINE demuxToHashMap #-}

222+demuxToHashMap :: (Monad m, Hashable k) =>

223+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)

224+demuxToHashMap f g = Stream.fold (FL.demuxToContainer f g)

225+

226+{-# INLINE demuxToMapIO #-}

227+demuxToMapIO :: (MonadIO m, Ord k) =>

228+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (Map k b)

229+demuxToMapIO f g = Stream.fold (FL.demuxToContainerIO f g)

230+

231+{-# INLINE demuxToHashMapIO #-}

232+demuxToHashMapIO :: (MonadIO m, Hashable k) =>

233+ (a -> k) -> (a -> m (Fold m a b)) -> Stream m a -> m (HashMap k b)

234+demuxToHashMapIO f g = Stream.fold (FL.demuxToContainerIO f g)

235+

236+{-# INLINE toMap #-}

237+toMap ::

238+ (Monad m, Ord k, Num a) => (a -> k) -> Stream m a -> m (Map k a)

239+toMap f = Stream.fold (FL.toContainer f FL.sum)

240+

241+{-# INLINE toIntMap #-}

242+toIntMap ::

243+ (Monad m, Num a) => (a -> Int) -> Stream m a -> m (IntMap a)

244+toIntMap f = Stream.fold (FL.toContainer f FL.sum)

245+

246+{-# INLINE toMapIO #-}

247+toMapIO ::

248+ (MonadIO m, Ord k, Num a) => (a -> k) -> Stream m a -> m (Map k a)

249+toMapIO f = Stream.fold (FL.toContainerIO f FL.sum)

250+

251+{-# INLINE toIntMapIO #-}

252+toIntMapIO ::

253+ (MonadIO m, Num a) => (a -> Int) -> Stream m a -> m (IntMap a)

254+toIntMapIO f = Stream.fold (FL.toContainerIO f FL.sum)

255+

256+{-# INLINE toHashMapIO #-}

257+toHashMapIO :: (MonadIO m, Ord k, Num a, Hashable k) =>

258+ (a -> k) -> Stream m a -> m (HashMap k a)

259+toHashMapIO f = Stream.fold (Fold.toHashMapIO f FL.sum)

169260

170261-------------------------------------------------------------------------------

171262-- unzip

172263-------------------------------------------------------------------------------

173264

174265{-# INLINE unzip #-}

175−unzip :: Monad m => SerialT m Int -> m (Int, Int)

176−unzip = IP.fold $ FL.map (\a -> (a, a)) (FL.unzip FL.sum FL.length)

266+unzip :: Monad m => Stream m Int -> m (Int, Int)

267+unzip = Stream.fold $ FL.lmap (\a -> (a, a)) (FL.unzip FL.sum FL.length)

268+

269+{-# INLINE unzipWithFstM #-}

270+unzipWithFstM :: Monad m => Stream m Int -> m (Int, Int)

271+unzipWithFstM = do

272+ let f a = return (a + 1, a)

273+ Stream.fold (FL.unzipWithFstM f FL.sum FL.length)

274+

275+{-# INLINE unzipWithMinM #-}

276+unzipWithMinM :: Monad m => Stream m Int -> m (Int, Int)

277+unzipWithMinM = do

278+ let f a = return (a + 1, a)

279+ Stream.fold (FL.unzipWithMinM f FL.sum FL.length)

280+

281+-------------------------------------------------------------------------------

282+-- Nested

283+-------------------------------------------------------------------------------

284+

285+{-# INLINE unfoldMany #-}

286+unfoldMany :: Int -> Benchmarkable

287+unfoldMany val =

288+ nfIO

289+ $ Stream.fold (FL.unfoldMany Unfold.replicateM FL.drain)

290+ $ Stream.fromPure (val, randomRIO (1, 1 :: Int))

177291

178292-------------------------------------------------------------------------------

179293-- Benchmarks

@@ -182,92 +296,113 @@ unzip = IP.fold $ FL.map (\a -> (a, a)) (FL.unzip FL.sum FL.length)

182296moduleName :: String

183297moduleName = "Data.Fold"

184298

299+instance NFData (MutArray a) where

300+ {-# INLINE rnf #-}

301+ rnf _ = ()

302+

303+instance NFData a => NFData (Stream Identity a) where

304+ {-# INLINE rnf #-}

305+ rnf xs = runIdentity $ Stream.fold (FL.foldl' (\_ x -> rnf x) ()) xs

306+

185307o_1_space_serial_elimination :: Int -> [Benchmark]

186308o_1_space_serial_elimination value =

187309 [ bgroup "elimination"

188− [ benchIOSink value "drain" (S.fold FL.drain)

189− , benchIOSink value "drainBy" (S.fold (FL.drainBy return))

190− , benchIOSink value "drainN" (S.fold (FL.drainN value))

191− , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)

192− , benchIOSink value "last" (S.fold FL.last)

193− , benchIOSink value "length" (S.fold FL.length)

194− , benchIOSink value "sum" (S.fold FL.sum)

195− , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))

196− , benchIOSink value "product" (S.fold FL.product)

197− , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))

198− , benchIOSink value "maximum" (S.fold FL.maximum)

199− , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))

200− , benchIOSink value "minimum" (S.fold FL.minimum)

310+ [ benchIOSink value "drain" (Stream.fold FL.drain)

311+ , benchIOSink value "drainBy" (Stream.fold (FL.drainBy return))

312+ , benchIOSink value "drainN" (Stream.fold (FL.drainN value))

313+ , benchIOSink value "last" (Stream.fold FL.last)

314+ , benchIOSink value "length" (Stream.fold FL.length)

315+ , benchIOSink value "top" (Stream.fold $ FL.top 10)

316+ , benchIOSink value "bottom" (Stream.fold $ FL.bottom 10)

317+ , benchIOSink value "sum" (Stream.fold FL.sum)

318+ , benchIOSink value "sum (foldMap)" (Stream.fold (FL.foldMap Sum))

319+ , benchIOSink value "product" (Stream.fold FL.product)

320+ , benchIOSink value "maximumBy" (Stream.fold (FL.maximumBy compare))

321+ , benchIOSink value "maximum" (Stream.fold FL.maximum)

322+ , benchIOSink value "minimumBy" (Stream.fold (FL.minimumBy compare))

323+ , benchIOSink value "minimum" (Stream.fold FL.minimum)

201324 , benchIOSink

202325 value

203326 "mean"

204− (S.fold FL.mean . S.map (fromIntegral :: Int -> Double))

327+ (Stream.fold FL.mean . fmap (fromIntegral :: Int -> Double))

205328 , benchIOSink

206329 value

207330 "variance"

208− (S.fold FL.variance . S.map (fromIntegral :: Int -> Double))

331+ (Stream.fold FL.variance . fmap (fromIntegral :: Int -> Double))

209332 , benchIOSink

210333 value

211334 "stdDev"

212− (S.fold FL.stdDev . S.map (fromIntegral :: Int -> Double))

335+ (Stream.fold FL.stdDev . fmap (fromIntegral :: Int -> Double))

213336 , benchIOSink

214337 value

215338 "mconcat"

216− (S.fold FL.mconcat . S.map (Last . Just))

339+ (Stream.fold FL.mconcat . fmap (Last . Just))

217340 , benchIOSink

218341 value

219342 "foldMap"

220− (S.fold (FL.foldMap (Last . Just)))

343+ (Stream.fold (FL.foldMap (Last . Just)))

221344 , benchIOSink

222345 value

223346 "foldMapM"

224− (S.fold (FL.foldMapM (return . Last . Just)))

225− , benchIOSink value "index" (S.fold (FL.index (value + 1)))

226− , benchIOSink value "head" (S.fold FL.head)

227− , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))

347+ (Stream.fold (FL.foldMapM (return . Last . Just)))

348+ , benchIOSink value "index" (Stream.fold (FL.index (value + 1)))

349+ , benchIOSink value "head" (Stream.fold FL.head)

350+ , benchIOSink value "find" (Stream.fold (FL.find (== (value + 1))))

228351 , benchIOSink

229352 value

230353 "lookup"

231− (S.fold (FL.map (\a -> (a, a)) (FL.lookup (value + 1))))

354+ (Stream.fold (FL.lmap (\a -> (a, a)) (FL.lookup (value + 1))))

232355 , benchIOSink

233356 value

234357 "findIndex"

235− (S.fold (FL.findIndex (== (value + 1))))

358+ (Stream.fold (FL.findIndex (== (value + 1))))

236359 , benchIOSink

237360 value

238361 "elemIndex"

239− (S.fold (FL.elemIndex (value + 1)))

240− , benchIOSink value "null" (S.fold FL.null)

241− , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))

242− , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))

362+ (Stream.fold (FL.elemIndex (value + 1)))

363+ , benchIOSink value "null" (Stream.fold FL.null)

364+ , benchIOSink value "elem" (Stream.fold (FL.elem (value + 1)))

365+ , benchIOSink value "notElem" (Stream.fold (FL.notElem (value + 1)))

243366 , benchIOSink value "all" $ all value

244367 , benchIOSink value "any" $ any value

245368 , benchIOSink value "take" $ take value

246369 , benchIOSink value "takeEndBy_" $ takeEndBy_ value

247− , benchIOSink value "and" (S.fold FL.and . S.map (<= (value + 1)))

248− , benchIOSink value "or" (S.fold FL.or . S.map (> (value + 1)))

370+ , benchIOSink value "and" (Stream.fold FL.and . fmap (<= (value + 1)))

371+ , benchIOSink value "or" (Stream.fold FL.or . fmap (> (value + 1)))

249372 ]

250373 ]

251374

252375o_1_space_serial_transformation :: Int -> [Benchmark]

253376o_1_space_serial_transformation value =

254377 [ bgroup "transformation"

255− [ benchIOSink value "map" (S.fold (FL.map (+ 1) FL.drain))

378+ [ benchIOSink value "map" (Stream.fold (FL.lmap (+ 1) FL.drain))

256379 , let f x = if even x then Just x else Nothing

257380 fld = FL.mapMaybe f FL.drain

258− in benchIOSink value "mapMaybe" (S.fold fld)

381+ in benchIOSink value "mapMaybe" (Stream.fold fld)

259382 , benchIOSink

260383 value

261384 "rsequence"

262− (S.fold (FL.rmapM id (return <$> FL.drain)))

263− , benchIOSink value "rmapM" (S.fold (FL.rmapM return FL.drain))

385+ (Stream.fold (FL.rmapM id (return <$> FL.drain)))

386+ , benchIOSink value "rmapM" (Stream.fold (FL.rmapM return FL.drain))

264387 , benchIOSink

265388 value

266389 "pipe-mapM"

267− (S.fold

390+ (Stream.fold

268391 (FL.transform

269392 (Pipe.mapM (\x -> return $ x + 1))

270393 FL.drain))

394+ , benchIOSink

395+ value

396+ "fold-scan"

397+ (Stream.fold $ FL.scan FL.sum FL.drain)

398+ , benchIOSink

399+ value

400+ "fold-scanMany"

401+ (Stream.fold $ FL.scanMany (FL.take 2 FL.drain) FL.drain)

402+ , benchIOSink

403+ value

404+ "fold-postscan"

405+ (Stream.fold $ FL.postscan FL.sum FL.drain)

271406 ]

272407 ]

273408

@@ -275,30 +410,33 @@ o_1_space_serial_composition :: Int -> [Benchmark]

275410o_1_space_serial_composition value =

276411 [ bgroup

277412 "composition"

278− [ benchIOSink value "serialWith (all, any)" $ splitAllAny value

413+ [ benchIOSink value "filter even" $ filter value

414+ , benchIOSink value "scanMaybe even" $ scanMaybe value

415+ , benchIOSink value "scanMaybe even, odd" $ scanMaybe2 value

416+ , benchIOSink value "foldBreak (recursive)" foldBreak

417+ , benchIOSink value "splitWith (all, any)" $ splitAllAny value

418+ , benchIOSink value "split_ (all, any)" $ split_ value

279419 , benchIOSink value "tee (all, any)" $ teeAllAny value

280420 , benchIOSink value "many drain (take 1)" many

421+ , bench "unfoldMany" $ unfoldMany value

422+ , benchIOSink value "shortest (sum, length)" shortest

423+ , benchIOSink value "longest (sum, length)" longest

281424 , benchIOSink value "tee (sum, length)" teeSumLength

425+ , benchIOSink value "teeWithFst (sum, length)" teeWithFst

426+ , benchIOSink value "teeWithMin (sum, length)" teeWithMin

282427 , benchIOSink value "distribute [sum, length]" distribute

283428 , benchIOSink value "partition (sum, length)" partition

429+ , benchIOSink value "partitionByFstM (sum, length)" partitionByFstM

430+ , benchIOSink value "partitionByMinM (sum, length)" partitionByMinM

284431 , benchIOSink value "unzip (sum, length)" unzip

285− , benchIOSink value "demuxDefaultWith [sum, length] sum"

286− $ demuxDefaultWith fn mp

287− , benchIOSink value "demuxWith [sum, length]" $ demuxWith fn mp

288− , benchIOSink value "classifyWith sum" $ classifyWith (fst . fn)

432+ , benchIOSink value "unzipWithFstM (sum, length)" unzipWithFstM

433+ , benchIOSink value "unzipWithMinM (sum, length)" unzipWithMinM

289434 ]

290435 ]

291436

292− where

293−

294− -- We use three keys 0, 1, and 2. 0 and 1 are mapped and 3 is unmapped.

295− fn x = (x `mod` 3, x)

296−

297− mp = Map.fromList [(0, FL.sum), (1, FL.length)]

298−

299437o_n_space_serial :: Int -> [Benchmark]

300438o_n_space_serial value =

301− [ benchIOSink value "sequence_/100" $ S.fold (sequence_ (value `div` 100))

439+ [ benchIOSink value "sequence_/100" $ Stream.fold (sequence_ (value `div` 100))

302440 ]

303441

304442o_n_heap_serial :: Int -> [Benchmark]

@@ -307,21 +445,71 @@ o_n_heap_serial value =

307445 -- Left folds for building a structure are inherently non-streaming

308446 -- as the structure cannot be lazily consumed until fully built.

309447 [

310− benchIOSink value "toList" (S.fold FL.toList)

311− , benchIOSink value "toListRev" (S.fold FL.toListRev)

312− , benchIOSink value "toStream" (S.fold FL.toStream)

313− , benchIOSink value "toStreamRev" (S.fold FL.toStreamRev)

448+ benchIOSink value "toList" (Stream.fold FL.toList)

449+ , benchIOSink value "toListRev" (Stream.fold FL.toListRev)

450+ , benchIOSink value "toStream"

451+ (Stream.fold FL.toStream

452+ :: Stream IO a -> IO (Stream Identity a))

453+ , benchIOSink value "toStreamRev"

454+ (Stream.fold FL.toStreamRev

455+ :: Stream IO a -> IO (Stream Identity a))

456+ , benchIOSink value "nub" (Stream.fold FL.nub)

457+ ]

458+ , bgroup "key-value"

459+ [

460+ benchIOSink value "demuxToMap (64 buckets) [sum, length]"

461+ $ demuxToMap (getKey 64) (getFold . getKey 64)

462+ , benchIOSink value "demuxToIntMap (64 buckets) [sum, length]"

463+ $ demuxToIntMap (getKey 64) (getFold . getKey 64)

464+ , benchIOSink value "demuxToHashMap (64 buckets) [sum, length]"

465+ $ demuxToHashMap (getKey 64) (getFold . getKey 64)

466+ , benchIOSink value "demuxToMapIO (64 buckets) [sum, length]"

467+ $ demuxToMapIO (getKey 64) (getFold . getKey 64)

468+ , benchIOSink value "demuxToHashMapIO (64 buckets) [sum, length]"

469+ $ demuxToHashMapIO (getKey 64) (getFold . getKey 64)

470+

471+ -- classify: immutable

472+ , benchIOSink value "toMap (64 buckets) sum"

473+ $ toMap (getKey 64)

474+ , benchIOSink value "toIntMap (64 buckets) sum"

475+ $ toIntMap (getKey 64)

476+

477+ -- classify: mutable cells

478+ , benchIOSink value "toMapIO (single bucket) sum"

479+ $ toMapIO (getKey 1)

480+ , benchIOSink value "toMapIO (64 buckets) sum"

481+ $ toMapIO (getKey 64)

482+ , benchIOSink value "toMapIO (max buckets) sum"

483+ $ toMapIO (getKey value)

484+ , benchIOSink value "toIntMapIO (64 buckets) sum"

485+ $ toIntMapIO (getKey 64)

486+ , benchIOSink value "toHashMapIO (single bucket) sum"

487+ $ toHashMapIO (getKey 1)

488+ , benchIOSink value "toHashMapIO (64 buckets) sum"

489+ $ toHashMapIO (getKey 64)

490+ , benchIOSink value "toHashMapIO (max buckets) sum"

491+ $ toHashMapIO (getKey value)

314492 ]

315493 ]

316494

495+ where

496+

497+ getKey buckets = (`mod` buckets)

498+

499+ getFold k =

500+ return $ case k of

501+ 0 -> FL.sum

502+ 1 -> FL.length

503+ _ -> FL.length

504+

317505-------------------------------------------------------------------------------

318506-- Driver

319507-------------------------------------------------------------------------------

320508

321509main :: IO ()

322510main = do

323− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

324− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

511+#ifndef FUSION_CHECK

512+ runWithCLIOpts defaultStreamSize allBenchmarks

325513

326514 where

327515

@@ -334,3 +522,20 @@ main = do

334522 , bgroup (o_n_space_prefix moduleName) (o_n_space_serial value)

335523 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

336524 ]

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.hsnew file+191

@@ -0,0 +1,191 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

3+module Main (main) where

5+import Control.DeepSeq (NFData)

6+import Streamly.Data.Fold (Fold)

7+import Streamly.Internal.Data.Stream (Stream)

8+import System.Random (randomRIO)

10+import qualified Streamly.Data.Fold as Fold

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

14+

15+import Streamly.Benchmark.Common

16+import Test.Tasty.Bench

17+

18+{-# INLINE source #-}

19+source :: (Monad m, Num a, Stream.Enumerable a) =>

20+ Int -> a -> Stream m a

21+source len from =

22+ Stream.enumerateFromThenTo from (from + 1) (from + fromIntegral len)

23+

24+{-# INLINE sourceDescending #-}

25+sourceDescending :: (Monad m, Num a, Stream.Enumerable a) =>

26+ Int -> a -> Stream m a

27+sourceDescending len from =

28+ Stream.enumerateFromThenTo

29+ (from + fromIntegral len)

30+ (from + fromIntegral (len - 1))

31+ from

32+

33+{-# INLINE sourceDescendingInt #-}

34+sourceDescendingInt :: Monad m => Int -> Int -> Stream m Int

35+sourceDescendingInt = sourceDescending

36+

37+{-# INLINE benchWith #-}

38+benchWith :: (Num a, NFData b) =>

39+ (Int -> a -> Stream IO a) -> Int -> String -> Fold IO a b -> Benchmark

40+benchWith src len name f =

41+ bench name

42+ $ nfIO

43+ $ randomRIO (1, 1 :: Int) >>= Stream.fold f . src len . fromIntegral

44+

45+{-# INLINE benchWithFold #-}

46+benchWithFold :: NFData a => Int -> String -> Fold IO Double a -> Benchmark

47+benchWithFold = benchWith source

48+

49+{-# INLINE benchWithFoldInt #-}

50+benchWithFoldInt :: Int -> String -> Fold IO Int Int -> Benchmark

51+benchWithFoldInt = benchWith source

52+

53+{-# INLINE benchScanWith #-}

54+benchScanWith :: Num a =>

55+ (Int -> a -> Stream IO a) -> Int -> String -> Fold IO a b -> Benchmark

56+benchScanWith src len name f =

57+ bench name

58+ $ nfIO

59+ $ randomRIO (1, 1 :: Int)

60+ >>= Stream.fold Fold.drain

61+ . Stream.postscan f

62+ . src len

63+ . fromIntegral

64+

65+{-# INLINE benchWithPostscan #-}

66+benchWithPostscan :: Int -> String -> Fold IO Double a -> Benchmark

67+benchWithPostscan = benchScanWith source

68+

69+o_1_space_folds :: Int -> [Benchmark]

70+o_1_space_folds numElements =

71+ [ bgroup "fold"

72+ [ benchWithFold numElements "minimum (window size 100)"

73+ (Window.windowMinimum 100)

74+ , benchWithFold numElements "minimum (window size 1000)"

75+ (Window.windowMinimum 1000)

76+ , benchWith sourceDescendingInt numElements

77+ "minimum descending (window size 1000)"

78+ (Window.windowMinimum 1000)

79+

80+ , benchWithFold numElements "maximum (window size 100)"

81+ (Window.windowMaximum 100)

82+ , benchWithFold numElements "maximum (window size 1000)"

83+ (Window.windowMaximum 1000)

84+ , benchWith sourceDescendingInt numElements

85+ "maximum descending (window size 1000)"

86+ (Window.windowMaximum 1000)

87+

88+ , benchWithFold numElements "range (window size 100)"

89+ (Window.windowRange 100)

90+ , benchWithFold numElements "range (window size 1000)"

91+ (Window.windowRange 1000)

92+ , benchWith sourceDescendingInt numElements

93+ "range descending (window size 1000)"

94+ (Window.windowRange 1000)

95+

96+ , benchWithFoldInt numElements "sumInt (window size 100)"

97+ (Ring.slidingWindow 100 Window.windowSumInt)

98+ , benchWithFoldInt numElements "sum for Int (window size 100)"

99+ (Ring.slidingWindow 100 Window.windowSum)

100+ , benchWithFold numElements "sum (window size 100)"

101+ (Ring.slidingWindow 100 Window.windowSum)

102+ , benchWithFold numElements "sum (window size 1000)"

103+ (Ring.slidingWindow 1000 Window.windowSum)

104+ , benchWithFold numElements "sum (entire stream)"

105+ (Window.cumulative Window.windowSum)

106+ , benchWithFold numElements "sum (Data.Fold)"

107+ Fold.sum

108+

109+ , benchWithFold numElements "mean (window size 100)"

110+ (Ring.slidingWindow 100 Window.windowMean)

111+ , benchWithFold numElements "mean (window size 1000)"

112+ (Ring.slidingWindow 1000 Window.windowMean)

113+ , benchWithFold numElements "mean (entire stream)"

114+ (Window.cumulative Window.windowMean)

115+ , benchWithFold numElements "mean (Data.Fold)"

116+ Fold.mean

117+

118+ , benchWithFold numElements "powerSum 2 (window size 100)"

119+ (Ring.slidingWindow 100 (Window.windowPowerSum 2))

120+ , benchWithFold numElements "powerSum 2 (entire stream)"

121+ (Window.cumulative (Window.windowPowerSum 2))

122+

123+ ]

124+ ]

125+

126+o_1_space_scans :: Int -> [Benchmark]

127+o_1_space_scans numElements =

128+ [ bgroup "scan"

129+ [ benchWithPostscan numElements "minimum (window size 10)"

130+ (Window.windowMinimum 10)

131+ -- Below window size 30 the linear search based impl performs better

132+ -- than the dequeue based implementation.

133+ , benchWithPostscan numElements "minimum (window size 30)"

134+ (Window.windowMinimum 30)

135+ , benchWithPostscan numElements "minimum (window size 1000)"

136+ (Window.windowMinimum 1000)

137+ , benchScanWith sourceDescendingInt numElements

138+ "minimum descending (window size 1000)"

139+ (Window.windowMinimum 1000)

140+

141+ , benchWithPostscan numElements "maximum (window size 10)"

142+ (Window.windowMaximum 10)

143+ , benchWithPostscan numElements "maximum (window size 30)"

144+ (Window.windowMaximum 30)

145+ , benchWithPostscan numElements "maximum (window size 1000)"

146+ (Window.windowMaximum 1000)

147+ , benchScanWith sourceDescendingInt numElements

148+ "maximum descending (window size 1000)"

149+ (Window.windowMaximum 1000)

150+

151+ , benchWithPostscan numElements "range (window size 10)"

152+ (Window.windowRange 10)

153+ , benchWithPostscan numElements "range (window size 30)"

154+ (Window.windowRange 30)

155+ , benchWithPostscan numElements "range (window size 1000)"

156+ (Window.windowRange 1000)

157+ , benchScanWith sourceDescendingInt numElements

158+ "range descending (window size 1000)"

159+ (Window.windowRange 1000)

160+

161+ , benchWithPostscan numElements "sum (window size 100)"

162+ (Ring.slidingWindow 100 Window.windowSum)

163+ , benchWithPostscan numElements "sum (window size 1000)"

164+ (Ring.slidingWindow 1000 Window.windowSum)

165+

166+ , benchWithPostscan numElements "mean (window size 100)"

167+ (Ring.slidingWindow 100 Window.windowMean)

168+ , benchWithPostscan numElements "mean (window size 1000)"

169+ (Ring.slidingWindow 1000 Window.windowMean)

170+

171+ , benchWithPostscan numElements "powerSum 2 (window size 100)"

172+ (Ring.slidingWindow 100 (Window.windowPowerSum 2))

173+ , benchWithPostscan numElements "powerSum 2 (window size 1000)"

174+ (Ring.slidingWindow 1000 (Window.windowPowerSum 2))

175+ ]

176+ ]

177+

178+moduleName :: String

179+moduleName = "Data.Fold.Window"

180+

181+main :: IO ()

182+main = runWithCLIOpts defaultStreamSize allBenchmarks

183+

184+ where

185+

186+ allBenchmarks value =

187+ [ bgroup (o_1_space_prefix moduleName) $ concat

188+ [ o_1_space_folds value

189+ , o_1_space_scans value

190+ ]

191+ ]

benchmark/Streamly/Benchmark/Data/MutArray.hsnew file+300

@@ -0,0 +1,300 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

2+{-# OPTIONS_GHC -Wno-orphans #-}

4+-- |

5+-- Module : Streamly.Benchmark.Data.Array.Unboxed.Mut

7+-- License : BSD-3-Clause

8+-- Maintainer : streamly@composewell.com

10+{-# LANGUAGE CPP #-}

11+{-# LANGUAGE FlexibleContexts #-}

12+{-# LANGUAGE ScopedTypeVariables #-}

13+

14+#ifdef __HADDOCK_VERSION__

15+#undef INSPECTION

16+#endif

17+

18+#ifdef INSPECTION

19+{-# LANGUAGE TemplateHaskell #-}

20+{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

21+#endif

22+

23+import Control.DeepSeq (NFData(..))

24+import Control.Monad.IO.Class (MonadIO)

25+import Data.Functor ((<&>))

26+import System.Random (randomRIO)

27+import Prelude

28+ ( IO

29+ , Int

30+ , Integral(..)

31+ , Maybe(..)

32+ , Monad(..)

33+ , Num(..)

34+ , Ord(..)

35+ , String

36+ , ($)

37+ , (.)

38+ , (||)

39+ , concat

40+ , const

41+ , fmap

42+ , id

43+ , undefined

44+ )

45+import Streamly.Internal.Data.MutArray (MutArray)

46+

47+import qualified Streamly.Internal.Data.Array as Array

48+import qualified Streamly.Internal.Data.MutArray as MArray

49+import qualified Streamly.Internal.Data.Fold as Fold

50+import qualified Streamly.Internal.Data.Stream as Stream

51+

52+import Test.Tasty.Bench

53+import Streamly.Benchmark.Common hiding (benchPureSrc)

54+

55+type Stream = MutArray

56+

57+instance NFData (MutArray a) where

58+ {-# INLINE rnf #-}

59+ rnf _ = ()

60+

61+-------------------------------------------------------------------------------

62+-- Benchmark helpers

63+-------------------------------------------------------------------------------

64+

65+{-# INLINE benchIO #-}

66+benchIO :: NFData b => String -> (Int -> IO a) -> (a -> b) -> Benchmark

67+benchIO name src f = bench name $ nfIO $

68+ (randomRIO (1,1) >>= src) <&> f

69+

70+{-# INLINE benchPureSink #-}

71+benchPureSink :: NFData b => Int -> String -> (Stream Int -> b) -> Benchmark

72+benchPureSink value name = benchIO name (sourceIntFromTo value)

73+

74+{-# INLINE benchIO' #-}

75+benchIO' :: NFData b => String -> (Int -> IO a) -> (a -> IO b) -> Benchmark

76+benchIO' name src f = bench name $ nfIO $

77+ randomRIO (1,1) >>= src >>= f

78+

79+{-# INLINE benchIOSink #-}

80+benchIOSink :: NFData b => Int -> String -> (Stream Int -> IO b) -> Benchmark

81+benchIOSink value name = benchIO' name (sourceIntFromTo value)

82+

83+-- Drain a source that generates an array in the IO monad

84+{-# INLINE benchIOSrc #-}

85+benchIOSrc :: String -> (Int -> IO (Stream a)) -> Benchmark

86+benchIOSrc name src = benchIO name src id

87+

88+drain :: Monad m => Stream.Stream m a -> m ()

89+drain = Stream.fold Fold.drain

90+

91+-------------------------------------------------------------------------------

92+-- Bench Ops

93+-------------------------------------------------------------------------------

94+

95+{-# INLINE sourceUnfoldr #-}

96+sourceUnfoldr :: MonadIO m => Int -> Int -> m (Stream Int)

97+sourceUnfoldr value n =

98+ Stream.fold (MArray.writeN value) $ Stream.unfoldr step n

99+

100+ where

101+

102+ step cnt =

103+ if cnt > n + value

104+ then Nothing

105+ else Just (cnt, cnt + 1)

106+

107+{-# INLINE sourceIntFromTo #-}

108+sourceIntFromTo :: MonadIO m => Int -> Int -> m (Stream Int)

109+sourceIntFromTo value n =

110+ Stream.fold (MArray.writeN value) $ Stream.enumerateFromTo n (n + value)

111+

112+{-# INLINE sourceFromList #-}

113+sourceFromList :: MonadIO m => Int -> Int -> m (Stream Int)

114+sourceFromList value n =

115+ Stream.fold (MArray.writeN value) $ Stream.fromList [n .. n + value]

116+

117+{-# INLINE sourceIntFromToFromList #-}

118+sourceIntFromToFromList :: MonadIO m => Int -> Int -> m (Stream Int)

119+sourceIntFromToFromList value n = MArray.fromListN value [n..n + value]

120+

121+{-# INLINE sourceIntFromToFromStream #-}

122+sourceIntFromToFromStream :: MonadIO m => Int -> Int -> m (Stream Int)

123+sourceIntFromToFromStream value n =

124+ Stream.fold MArray.write $ Stream.enumerateFromTo n (n + value)

125+

126+{-# INLINE sourceUnfoldrM #-}

127+sourceUnfoldrM :: Monad m => Int -> Int -> Stream.Stream m Int

128+sourceUnfoldrM value n = Stream.unfoldrM step n

129+ where

130+ step cnt =

131+ if cnt > n + value

132+ then return Nothing

133+ else return (Just (cnt, cnt + 1))

134+

135+-------------------------------------------------------------------------------

136+-- Transformation

137+-------------------------------------------------------------------------------

138+

139+{-# INLINE composeN #-}

140+composeN :: Monad m

141+ => Int -> (Stream Int -> m (Stream Int)) -> Stream Int -> m (Stream Int)

142+composeN n f x =

143+ case n of

144+ 1 -> f x

145+ 2 -> f x >>= f

146+ 3 -> f x >>= f >>= f

147+ 4 -> f x >>= f >>= f >>= f

148+ _ -> undefined

149+

150+{-# INLINE scanl' #-}

151+scanl' :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

152+scanl' value n = composeN n $ onArray value $ Stream.scan (Fold.foldl' (+) 0)

153+

154+{-# INLINE scanl1' #-}

155+scanl1' :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

156+scanl1' value n = composeN n $ onArray value $ Stream.scanl1' (+)

157+

158+{-# INLINE map #-}

159+map :: MonadIO m => Int -> Int -> Stream Int -> m (Stream Int)

160+map value n = composeN n $ onArray value $ fmap (+ 1)

161+

162+{-# INLINE onArray #-}

163+onArray

164+ :: MonadIO m => Int -> (Stream.Stream m Int -> Stream.Stream m Int)

165+ -> Stream Int

166+ -> m (Stream Int)

167+onArray value f arr =

168+ Stream.fold (MArray.writeN value) $ f $ Stream.unfold MArray.reader arr

169+

170+-------------------------------------------------------------------------------

171+-- Elimination

172+-------------------------------------------------------------------------------

173+

174+{-# INLINE unfoldReadDrain #-}

175+unfoldReadDrain :: MonadIO m => Stream Int -> m ()

176+unfoldReadDrain = drain . Stream.unfold MArray.reader

177+

178+{-# INLINE unfoldReadRevDrain #-}

179+unfoldReadRevDrain :: MonadIO m => Stream Int -> m ()

180+unfoldReadRevDrain = drain . Stream.unfold MArray.readerRev

181+

182+{-# INLINE toStreamDRevDrain #-}

183+toStreamDRevDrain :: MonadIO m => Stream Int -> m ()

184+toStreamDRevDrain = drain . MArray.readRev

185+

186+{-# INLINE toStreamDDrain #-}

187+toStreamDDrain :: MonadIO m => Stream Int -> m ()

188+toStreamDDrain = drain . MArray.read

189+

190+{-# INLINE unfoldFold #-}

191+unfoldFold :: MonadIO m => Stream Int -> m Int

192+unfoldFold = Stream.fold (Fold.foldl' (+) 0) . Stream.unfold MArray.reader

193+

194+-------------------------------------------------------------------------------

195+-- Bench groups

196+-------------------------------------------------------------------------------

197+

198+o_1_space_generation :: Int -> [Benchmark]

199+o_1_space_generation value =

200+ [ bgroup

201+ "generation"

202+ [ benchIOSrc "writeN . intFromTo" (sourceIntFromTo value)

203+ , benchIOSrc

204+ "fromList . intFromTo"

205+ (sourceIntFromToFromList value)

206+ , benchIOSrc "writeN . unfoldr" (sourceUnfoldr value)

207+ , benchIOSrc "writeN . fromList" (sourceFromList value)

208+ , benchIOSrc "write . intFromTo" (sourceIntFromToFromStream value)

209+ ]

210+ ]

211+

212+o_1_space_elimination :: Int -> [Benchmark]

213+o_1_space_elimination value =

214+ [ bgroup "elimination"

215+ [ benchPureSink value "id" id

216+ , benchIOSink value "foldl'" unfoldFold

217+ , benchIOSink value "read" unfoldReadDrain

218+ , benchIOSink value "readRev" unfoldReadRevDrain

219+ , benchIOSink value "toStream" toStreamDDrain

220+ , benchIOSink value "toStreamRev" toStreamDRevDrain

221+ ]

222+ ]

223+

224+o_n_heap_serial :: Int -> [Benchmark]

225+o_n_heap_serial value =

226+ [ bgroup "elimination"

227+ [

228+ -- Converting the stream to an array

229+ benchFold "writeN" (Stream.fold (MArray.writeN value))

230+ (sourceUnfoldrM value)

231+ ]

232+ ]

233+

234+o_1_space_transformation :: Int -> [Benchmark]

235+o_1_space_transformation value =

236+ [ bgroup "transformation"

237+ [ benchIOSink value "scanl'" (scanl' value 1)

238+ , benchIOSink value "scanl1'" (scanl1' value 1)

239+ , benchIOSink value "map" (map value 1)

240+ ]

241+ ]

242+

243+o_1_space_transformationX4 :: Int -> [Benchmark]

244+o_1_space_transformationX4 value =

245+ [ bgroup "transformationX4"

246+ [ benchIOSink value "scanl'" (scanl' value 4)

247+ , benchIOSink value "scanl1'" (scanl1' value 4)

248+ , benchIOSink value "map" (map value 4)

249+ ]

250+ ]

251+

252+o_1_space_serial_marray ::

253+ Int -> (MutArray Int, Array.Array Int) -> [Benchmark]

254+o_1_space_serial_marray value ~(array, indices) =

255+ [ benchIO' "partitionBy (< 0)" (const (return array))

256+ $ MArray.partitionBy (< 0)

257+ , benchIO' "partitionBy (> 0)" (const (return array))

258+ $ MArray.partitionBy (> 0)

259+ , benchIO' "partitionBy (< value/2)" (const (return array))

260+ $ MArray.partitionBy (< (value `div` 2))

261+ , benchIO' "partitionBy (> value/2)" (const (return array))

262+ $ MArray.partitionBy (> (value `div` 2))

263+ , benchIO' "strip (< value/2 || > value/2)" (const (return array))

264+ $ MArray.strip (\x -> x < value `div` 2 || x > value `div` 2)

265+ , benchIO' "strip (> 0)" (const (return array))

266+ $ MArray.strip (> 0)

267+ , benchIO' "modifyIndices (+ 1)" (const (return indices))

268+ $ Stream.fold (MArray.modifyIndices array (\_idx val -> val + 1))

269+ . Stream.unfold Array.reader

270+ ]

271+

272+-------------------------------------------------------------------------------

273+-- Driver

274+-------------------------------------------------------------------------------

275+

276+moduleName :: String

277+moduleName = "Data.MutArray"

278+

279+main :: IO ()

280+main = do

281+ runWithCLIOptsEnv defaultStreamSize alloc allBenchmarks

282+

283+ where

284+

285+ alloc value = do

286+ marr <- MArray.fromStream (sourceUnfoldrM value 0 :: Stream.Stream IO Int)

287+ indices <- Array.fromStream (sourceUnfoldrM value 0 :: Stream.Stream IO Int)

288+ return (marr, indices)

289+

290+ allBenchmarks array value =

291+ [ bgroup (o_1_space_prefix moduleName)

292+ $ concat

293+ [ o_1_space_serial_marray value array

294+ , o_1_space_generation value

295+ , o_1_space_elimination value

296+ , o_1_space_transformation value

297+ , o_1_space_transformationX4 value

298+ ]

299+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

300+ ]

benchmark/Streamly/Benchmark/Data/Parser.hs+652−180

@@ -1,3 +1,10 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

3+#undef FUSION_CHECK

4+#ifdef FUSION_CHECK

5+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}

6+#endif

18-- |

29-- Module : Streamly.Benchmark.Data.Parser

@@ -7,43 +14,42 @@

714

815{-# LANGUAGE CPP #-}

916{-# LANGUAGE FlexibleContexts #-}

17+{-# LANGUAGE ScopedTypeVariables #-}

18+{-# OPTIONS_GHC -Wno-orphans #-}

1019

1120module Main

1221 (

1322 main

1423 ) where

1524

25+import Control.Applicative ((<|>))

1626import Control.DeepSeq (NFData(..))

17−import Control.Monad.Catch (MonadCatch)

18−import Data.Foldable (asum)

27+import Data.Function ((&))

1928import Data.Functor (($>))

20−import Data.Maybe (fromMaybe)

2129import Data.Monoid (Sum(..))

2230import GHC.Magic (inline)

23−#if __GLASGOW_HASKELL__ >= 802

2431import GHC.Magic (noinline)

25−#else

26−#define noinline

27−#endif

2832import System.IO (Handle)

2933import System.Random (randomRIO)

30−import Prelude

31− hiding (any, all, take, sequence, sequence_, sequenceA, takeWhile)

34+import Streamly.Internal.Data.Fold (Fold(..))

35+import Streamly.Internal.Data.Parser

36+ (ParseError(..), Parser(..), Initial(..), Step(..))

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

38+import Prelude hiding

39+ (any, all, take, sequence, sequence_, sequenceA, takeWhile, dropWhile, span)

3240

33−import qualified Data.Traversable as TR

34−import qualified Data.Foldable as F

3541import qualified Control.Applicative as AP

42+import qualified Data.Foldable as F

43+import qualified Data.Traversable as TR

3644import qualified Streamly.FileSystem.Handle as Handle

37−import qualified Streamly.Prelude as S

38−import qualified Streamly.Internal.Data.Array.Foreign as Array

39−import qualified Streamly.Internal.Data.Fold as FL

45+import qualified Streamly.Internal.Data.Array as Array

46+import qualified Streamly.Internal.Data.Fold as Fold

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

41−import qualified Streamly.Internal.Data.Stream.IsStream as IP

48+import qualified Streamly.Data.Stream as Stream

4249import qualified Streamly.Internal.Data.Producer as Producer

43−import qualified Streamly.Internal.Data.Producer.Source as Source

50+import qualified Streamly.Internal.Data.Stream as Stream

4451

45−import Gauge hiding (env)

46−import Streamly.Prelude (SerialT)

52+import Test.Tasty.Bench hiding (env)

4753import Streamly.Benchmark.Common

4854import Streamly.Benchmark.Common.Handle

4955

@@ -54,19 +60,59 @@ import Streamly.Benchmark.Common.Handle

5460-- XXX these can be moved to the common module

5561

5662{-# INLINE sourceUnfoldrM #-}

57−sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int

58−sourceUnfoldrM value n = S.unfoldrM step n

63+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

64+sourceUnfoldrM value n = Stream.unfoldrM step n

5965 where

6066 step cnt =

6167 if cnt > n + value

6268 then return Nothing

6369 else return (Just (cnt, cnt + 1))

6470

71+-- | Generates something like this: { { \{ \{ } }. The stream consists of

72+-- three parts, the first part is contains a sequence of `{`. The second part

73+-- contains a sequence pf escaped values `\{`. The third part contains a

74+-- sequence of `}`.

75+{-# INLINE sourceEscapedFrames #-}

76+sourceEscapedFrames ::

77+ Monad m

78+ => Int

79+ -> Int

80+ -> Stream m Char

81+sourceEscapedFrames value n = Stream.unfoldrM step n

82+ where

83+

84+ bs = '\\'

85+ cbOpen = '{'

86+ cbClose = '}'

87+ value1 = value `div` 4

88+

89+ step cnt

90+ | cnt > 4 * value1 = return Nothing

91+ | cnt <= value1 = return $ Just (cbOpen, cnt + 1)

92+ | cnt > 3 * value1 = return $ Just (cbClose, cnt + 1)

93+ | otherwise =

94+ return

95+ $ Just

96+ $ if (cnt - value1) `mod` 2 == 1

97+ then (bs, cnt + 1)

98+ else (cbOpen, cnt + 1)

99+

100+{-# INLINE benchIOSrc #-}

101+benchIOSrc

102+ :: NFData b

103+ => (Int -> Int -> Stream IO a)

104+ -> Int

105+ -> String

106+ -> (Stream IO a -> IO b)

107+ -> Benchmark

108+benchIOSrc src value name f =

109+ bench name $ nfIO $ randomRIO (1,1) >>= f . src value

110+

65111-- | Takes a fold method, and uses it with a default source.

66112{-# INLINE benchIOSink #-}

67113benchIOSink

68− :: (S.IsStream t, NFData b)

69− => Int -> String -> (t IO Int -> IO b) -> Benchmark

114+ :: NFData b

115+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

70116benchIOSink value name f =

71117 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

72118

@@ -75,184 +121,451 @@ benchIOSink value name f =

75121-------------------------------------------------------------------------------

76122

77123{-# INLINE takeBetween #-}

78−takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()

79−takeBetween value = IP.parse (PR.takeBetween 0 value FL.drain)

124+takeBetween :: Monad m => Int -> Stream m a -> m (Either ParseError ())

125+takeBetween value = Stream.parse (PR.takeBetween 0 value Fold.drain)

80126

81127{-# INLINE takeEQ #-}

82−takeEQ :: MonadCatch m => Int -> SerialT m a -> m ()

83−takeEQ value = IP.parse (PR.takeEQ value FL.drain)

128+takeEQ :: Monad m => Int -> Stream m a -> m (Either ParseError ())

129+takeEQ value = Stream.parse (PR.takeEQ value Fold.drain)

84130

85−{-# INLINE drainWhile #-}

86−drainWhile :: MonadCatch m => Int -> SerialT m Int -> m ()

87−drainWhile value = IP.parse (PR.drainWhile (<= value))

131+{-# INLINE takeGE #-}

132+takeGE :: Monad m => Int -> Stream m a -> m (Either ParseError ())

133+takeGE value = Stream.parse (PR.takeGE value Fold.drain)

88134

89−{-# INLINE sliceBeginWith #-}

90−sliceBeginWith :: MonadCatch m => Int -> SerialT m Int -> m ()

91−sliceBeginWith value stream = do

92− stream1 <- return . fromMaybe (S.yield (value + 1)) =<< S.tail stream

93− let stream2 = value `S.cons` stream1

94− IP.parse (PR.sliceBeginWith (== value) FL.drain) stream2

135+{-# INLINE dropWhile #-}

136+dropWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

137+dropWhile value = Stream.parse (PR.dropWhile (<= value))

138+

139+{-# INLINE takeStartBy #-}

140+takeStartBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

141+takeStartBy value stream = do

142+ let stream2 = value `Stream.cons` stream

143+ Stream.parse (PR.takeStartBy (== value) Fold.drain) stream2

144+

145+takeFramedByEsc_ :: Monad m => Int -> Stream m Char -> m (Either ParseError ())

146+takeFramedByEsc_ _ = Stream.parse parser

147+

148+ where

149+

150+ isEsc = (== '\\')

151+ isBegin = (== '{')

152+ isEnd = (== '}')

153+

154+ parser = PR.takeFramedByEsc_ isEsc isBegin isEnd Fold.drain

155+

156+{-# INLINE listEqBy #-}

157+listEqBy :: Int -> Stream IO Int -> IO (Either ParseError [Int])

158+listEqBy len = Stream.parse (PR.listEqBy (==) [1 .. len])

159+

160+{-# INLINE streamEqBy #-}

161+streamEqBy :: Int -> Stream IO Int -> IO (Either ParseError ())

162+streamEqBy len = Stream.parse (PR.streamEqBy (==) (Stream.enumerateFromTo 1 len))

95163

96164{-# INLINE takeWhile #-}

97−takeWhile :: MonadCatch m => Int -> SerialT m Int -> m ()

98−takeWhile value = IP.parse (PR.takeWhile (<= value) FL.drain)

165+takeWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

166+takeWhile value = Stream.parse (PR.takeWhile (<= value) Fold.drain)

167+

168+takeWhileP :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

169+takeWhileP value =

170+ Stream.parse (PR.takeWhileP (<= value) (PR.takeWhile (<= value - 1) Fold.drain))

171+

172+{-# INLINE takeP #-}

173+takeP :: Monad m => Int -> Stream m a -> m (Either ParseError ())

174+takeP value = Stream.parse (PR.takeP value (PR.fromFold Fold.drain))

99175

100176{-# INLINE groupBy #-}

101−groupBy :: MonadCatch m => SerialT m Int -> m ()

102−groupBy = IP.parse (PR.groupBy (<=) FL.drain)

177+groupBy :: Monad m => Stream m Int -> m (Either ParseError ())

178+groupBy = Stream.parse (PR.groupBy (<=) Fold.drain)

103179

104180{-# INLINE groupByRolling #-}

105−groupByRolling :: MonadCatch m => SerialT m Int -> m ()

106−groupByRolling = IP.parse (PR.groupByRolling (<=) FL.drain)

181+groupByRolling :: Monad m => Stream m Int -> m (Either ParseError ())

182+groupByRolling = Stream.parse (PR.groupByRolling (<=) Fold.drain)

107183

108184{-# INLINE wordBy #-}

109−wordBy :: MonadCatch m => Int -> SerialT m Int -> m ()

110−wordBy value = IP.parse (PR.wordBy (>= value) FL.drain)

185+wordBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

186+wordBy value = Stream.parse (PR.wordBy (>= value) Fold.drain)

187+

188+{-# INLINE sepByWords #-}

189+sepByWords :: Monad m => Stream m Int -> m (Either ParseError ())

190+sepByWords = Stream.parse (wrds even Fold.drain)

191+ where

192+ wrds p = PR.sepBy (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)

193+

194+{-# INLINE sepByAllWords #-}

195+sepByAllWords :: Monad m => Stream m Int -> m (Either ParseError ())

196+sepByAllWords = Stream.parse (wrds even Fold.drain)

197+ where

198+ wrds p = PR.sepByAll (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)

199+

200+-- Returning a list to compare with the sepBy1 in ParserK

201+{-# INLINE sepBy1 #-}

202+sepBy1 :: Monad m => Stream m Int -> m (Either ParseError [Int])

203+sepBy1 xs = do

204+ Stream.parse (PR.sepBy1 (PR.satisfy odd) (PR.satisfy even) Fold.toList) xs

205+

206+{-# INLINE sepByWords1 #-}

207+sepByWords1 :: Monad m => Stream m Int -> m (Either ParseError ())

208+sepByWords1 = Stream.parse (wrds even Fold.drain)

209+ where

210+ wrds p = PR.sepBy1 (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)

211+

212+{-# INLINE deintercalate #-}

213+deintercalate :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

214+deintercalate _ = Stream.parse (partition even)

215+

216+ where

217+

218+ partition p =

219+ PR.deintercalate

220+ (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain

221+

222+{-# INLINE deintercalate1 #-}

223+deintercalate1 :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

224+deintercalate1 _ = Stream.parse (partition even)

225+

226+ where

227+

228+ partition p =

229+ PR.deintercalate1

230+ (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain

231+

232+{-# INLINE deintercalateAll #-}

233+deintercalateAll :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

234+deintercalateAll _ = Stream.parse (partition even)

235+

236+ where

237+

238+ partition p =

239+ PR.deintercalateAll

240+ (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain

111241

112242{-# INLINE manyWordByEven #-}

113−manyWordByEven :: MonadCatch m => SerialT m Int -> m ()

114−manyWordByEven = IP.parse (PR.many (PR.wordBy (Prelude.even) FL.drain) FL.drain)

243+manyWordByEven :: Monad m => Stream m Int -> m (Either ParseError ())

244+manyWordByEven = Stream.parse (PR.many (PR.wordBy even Fold.drain) Fold.drain)

115245

116246{-# INLINE many #-}

117−many :: MonadCatch m => SerialT m Int -> m Int

118−many = IP.parse (PR.many (PR.satisfy (> 0)) FL.length)

247+many :: Monad m => Stream m Int -> m (Either ParseError Int)

248+many = Stream.parse (PR.many (PR.satisfy (> 0)) Fold.length)

119249

120250{-# INLINE manyAlt #-}

121−manyAlt :: MonadCatch m => SerialT m Int -> m Int

251+manyAlt :: Monad m => Stream m Int -> m Int

122252manyAlt xs = do

123− x <- IP.parse (AP.many (PR.satisfy (> 0))) xs

253+ x <- Stream.parse (AP.many (PR.satisfy (> 0))) xs

124254 return $ Prelude.length x

125255

126256{-# INLINE some #-}

127−some :: MonadCatch m => SerialT m Int -> m Int

128−some = IP.parse (PR.some (PR.satisfy (> 0)) FL.length)

257+some :: Monad m => Stream m Int -> m (Either ParseError Int)

258+some = Stream.parse (PR.some (PR.satisfy (> 0)) Fold.length)

129259

130260{-# INLINE someAlt #-}

131−someAlt :: MonadCatch m => SerialT m Int -> m Int

261+someAlt :: Monad m => Stream m Int -> m Int

132262someAlt xs = do

133− x <- IP.parse (AP.some (PR.satisfy (> 0))) xs

263+ x <- Stream.parse (AP.some (PR.satisfy (> 0))) xs

134264 return $ Prelude.length x

135265

136266{-# INLINE manyTill #-}

137−manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int

267+manyTill :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)

138268manyTill value =

139− IP.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) FL.length)

269+ Stream.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) Fold.length)

140270

141−{-# INLINE splitAp #-}

142−splitAp :: MonadCatch m

143− => Int -> SerialT m Int -> m ((), ())

144−splitAp value =

145− IP.parse

271+{-# INLINE splitAp2 #-}

272+splitAp2 :: Monad m

273+ => Int -> Stream m Int -> m (Either ParseError ((), ()))

274+splitAp2 value =

275+ Stream.parse

146276 ((,)

147− <$> PR.drainWhile (<= (value `div` 2))

148− <*> PR.drainWhile (<= value)

277+ <$> PR.dropWhile (<= (value `div` 2))

278+ <*> PR.dropWhile (<= value)

279+ )

280+

281+{-# INLINE splitAp4 #-}

282+splitAp4 :: Monad m

283+ => Int -> Stream m Int -> m (Either ParseError ())

284+splitAp4 value =

285+ Stream.parse

286+ ( (\() () () () -> ())

287+ <$> PR.dropWhile (<= (value * 1 `div` 4))

288+ <*> PR.dropWhile (<= (value * 2 `div` 4))

289+ <*> PR.dropWhile (<= (value * 3 `div` 4))

290+ <*> PR.dropWhile (<= value)

291+ )

292+

293+{-# INLINE splitAp8 #-}

294+splitAp8 :: Monad m

295+ => Int -> Stream m Int -> m (Either ParseError ())

296+splitAp8 value =

297+ Stream.parse

298+ ( (\() () () () () () () () -> ())

299+ <$> PR.dropWhile (<= (value * 1 `div` 8))

300+ <*> PR.dropWhile (<= (value * 2 `div` 8))

301+ <*> PR.dropWhile (<= (value * 3 `div` 8))

302+ <*> PR.dropWhile (<= (value * 4 `div` 8))

303+ <*> PR.dropWhile (<= (value * 5 `div` 8))

304+ <*> PR.dropWhile (<= (value * 6 `div` 8))

305+ <*> PR.dropWhile (<= (value * 7 `div` 8))

306+ <*> PR.dropWhile (<= value)

149307 )

150308

151309{-# INLINE splitApBefore #-}

152−splitApBefore :: MonadCatch m

153− => Int -> SerialT m Int -> m ()

310+splitApBefore :: Monad m

311+ => Int -> Stream m Int -> m (Either ParseError ())

154312splitApBefore value =

155− IP.parse

156− ( PR.drainWhile (<= (value `div` 2))

157− *> PR.drainWhile (<= value)

313+ Stream.parse

314+ ( PR.dropWhile (<= (value `div` 2))

315+ *> PR.dropWhile (<= value)

158316 )

159317

160318{-# INLINE splitApAfter #-}

161−splitApAfter :: MonadCatch m

162− => Int -> SerialT m Int -> m ()

319+splitApAfter :: Monad m

320+ => Int -> Stream m Int -> m (Either ParseError ())

163321splitApAfter value =

164− IP.parse

165− ( PR.drainWhile (<= (value `div` 2))

166− <* PR.drainWhile (<= value)

322+ Stream.parse

323+ ( PR.dropWhile (<= (value `div` 2))

324+ <* PR.dropWhile (<= value)

167325 )

168326

169−{-# INLINE serialWith #-}

170−serialWith :: MonadCatch m

171− => Int -> SerialT m Int -> m ((), ())

172−serialWith value =

173− IP.parse

174− (PR.serialWith (,)

175− (PR.drainWhile (<= (value `div` 2)))

176− (PR.drainWhile (<= value))

327+{-# INLINE splitWith2 #-}

328+splitWith2 :: Monad m

329+ => Int -> Stream m Int -> m (Either ParseError ((), ()))

330+splitWith2 value =

331+ Stream.parse

332+ (PR.splitWith (,)

333+ (PR.dropWhile (<= (value `div` 2)))

334+ (PR.dropWhile (<= value))

177335 )

178336

179337{-# INLINE split_ #-}

180−split_ :: MonadCatch m

181− => Int -> SerialT m Int -> m ()

338+split_ :: Monad m

339+ => Int -> Stream m Int -> m (Either ParseError ())

182340split_ value =

183− IP.parse

341+ Stream.parse

184342 (PR.split_

185− (PR.drainWhile (<= (value `div` 2)))

186− (PR.drainWhile (<= value))

343+ (PR.dropWhile (<= (value `div` 2)))

344+ (PR.dropWhile (<= value))

345+ )

346+

347+-- XXX dropWhile with applicative does not fuse

348+-- PR.dropWhile (<= (value * 1 `div` 4)) *> PR.die "alt"

349+{-# INLINE takeWhileFail #-}

350+takeWhileFail :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b

351+takeWhileFail predicate (Fold fstep finitial _ ffinal) =

352+ Parser step initial extract

353+

354+ where

355+

356+ initial = do

357+ res <- finitial

358+ return $ case res of

359+ Fold.Partial s -> IPartial s

360+ Fold.Done b -> IDone b

361+

362+ step s a =

363+ if predicate a

364+ then do

365+ fres <- fstep s a

366+ return

367+ $ case fres of

368+ Fold.Partial s1 -> Partial 0 s1

369+ Fold.Done b -> Done 0 b

370+ else return $ Error "fail"

371+

372+ extract s = fmap (Done 0) (ffinal s)

373+

374+{-# INLINE alt2 #-}

375+alt2 :: Monad m

376+ => Int -> Stream m Int -> m (Either ParseError ())

377+alt2 value =

378+ Stream.parse

379+ (PR.alt

380+ (takeWhileFail (<= (value `div` 2)) Fold.drain)

381+ (PR.dropWhile (<= value))

187382 )

188383

189−{-# INLINE sliceSepByP #-}

190−sliceSepByP :: MonadCatch m

191− => Int -> SerialT m Int -> m()

192−sliceSepByP value = IP.parse (PR.sliceSepByP (>= value) (PR.fromFold FL.drain))

384+{-# INLINE alt4 #-}

385+alt4 :: Monad m

386+ => Int -> Stream m Int -> m (Either ParseError ())

387+alt4 value =

388+ Stream.parse

389+ ( takeWhileFail (<= (value * 1 `div` 4)) Fold.drain

390+ <|> takeWhileFail (<= (value * 2 `div` 4)) Fold.drain

391+ <|> takeWhileFail (<= (value * 3 `div` 4)) Fold.drain

392+ <|> PR.dropWhile (<= value)

393+ )

394+

395+{-# INLINE alt8 #-}

396+alt8 :: Monad m

397+ => Int -> Stream m Int -> m (Either ParseError ())

398+alt8 value =

399+ Stream.parse

400+ ( takeWhileFail (<= (value * 1 `div` 8)) Fold.drain

401+ <|> takeWhileFail (<= (value * 2 `div` 8)) Fold.drain

402+ <|> takeWhileFail (<= (value * 3 `div` 8)) Fold.drain

403+ <|> takeWhileFail (<= (value * 4 `div` 8)) Fold.drain

404+ <|> takeWhileFail (<= (value * 5 `div` 8)) Fold.drain

405+ <|> takeWhileFail (<= (value * 6 `div` 8)) Fold.drain

406+ <|> takeWhileFail (<= (value * 7 `div` 8)) Fold.drain

407+ <|> PR.dropWhile (<= value)

408+ )

193409

410+{-# INLINE alt16 #-}

411+alt16 :: Monad m

412+ => Int -> Stream m Int -> m (Either ParseError ())

413+alt16 value =

414+ Stream.parse

415+ ( takeWhileFail (<= (value * 1 `div` 16)) Fold.drain

416+ <|> takeWhileFail (<= (value * 2 `div` 16)) Fold.drain

417+ <|> takeWhileFail (<= (value * 3 `div` 16)) Fold.drain

418+ <|> takeWhileFail (<= (value * 4 `div` 16)) Fold.drain

419+ <|> takeWhileFail (<= (value * 5 `div` 16)) Fold.drain

420+ <|> takeWhileFail (<= (value * 6 `div` 16)) Fold.drain

421+ <|> takeWhileFail (<= (value * 8 `div` 16)) Fold.drain

422+ <|> takeWhileFail (<= (value * 9 `div` 16)) Fold.drain

423+ <|> takeWhileFail (<= (value * 10 `div` 16)) Fold.drain

424+ <|> takeWhileFail (<= (value * 11 `div` 16)) Fold.drain

425+ <|> takeWhileFail (<= (value * 12 `div` 16)) Fold.drain

426+ <|> takeWhileFail (<= (value * 13 `div` 16)) Fold.drain

427+ <|> takeWhileFail (<= (value * 14 `div` 16)) Fold.drain

428+ <|> takeWhileFail (<= (value * 15 `div` 16)) Fold.drain

429+ <|> PR.dropWhile (<= value)

430+ )

431+

432+{-# INLINE altSmall #-}

433+altSmall :: Monad m

434+ => Int -> Stream m Int -> m ()

435+altSmall value =

436+ Stream.fold Fold.drain .

437+ Stream.parseMany

438+ (PR.alt

439+ (PR.satisfy (>= value) *> PR.die "alt")

440+ (PR.satisfy (<= value))

441+ )

442+

443+{-# INLINE monad #-}

444+monad :: Monad m

445+ => Int -> Stream m Int -> m (Either ParseError ())

446+monad value =

447+ Stream.parse

448+ $ do

449+ PR.dropWhile (<= (value `div` 2))

450+ PR.dropWhile (<= value)

451+

452+{-# INLINE monad4 #-}

453+monad4 :: Monad m

454+ => Int -> Stream m Int -> m (Either ParseError ())

455+monad4 value =

456+ Stream.parse $ do

457+ PR.dropWhile (<= (value `div` 4))

458+ PR.dropWhile (<= (value `div` 2))

459+ PR.dropWhile (<= (value * 3 `div` 4))

460+ PR.dropWhile (<= value)

461+

462+{-# INLINE monad8 #-}

463+monad8 :: Monad m

464+ => Int -> Stream m Int -> m (Either ParseError ())

465+monad8 value =

466+ Stream.parse $ do

467+ PR.dropWhile (<= (value * 1 `div` 8))

468+ PR.dropWhile (<= (value * 2 `div` 8))

469+ PR.dropWhile (<= (value * 3 `div` 8))

470+ PR.dropWhile (<= (value * 4 `div` 8))

471+ PR.dropWhile (<= (value * 5 `div` 8))

472+ PR.dropWhile (<= (value * 6 `div` 8))

473+ PR.dropWhile (<= (value * 7 `div` 8))

474+ PR.dropWhile (<= value)

475+

476+{-# INLINE monad16 #-}

477+monad16 :: Monad m

478+ => Int -> Stream m Int -> m (Either ParseError ())

479+monad16 value =

480+ Stream.parse $ do

481+ PR.dropWhile (<= (value * 1 `div` 16))

482+ PR.dropWhile (<= (value * 2 `div` 16))

483+ PR.dropWhile (<= (value * 3 `div` 16))

484+ PR.dropWhile (<= (value * 4 `div` 16))

485+ PR.dropWhile (<= (value * 5 `div` 16))

486+ PR.dropWhile (<= (value * 6 `div` 16))

487+ PR.dropWhile (<= (value * 7 `div` 16))

488+ PR.dropWhile (<= (value * 8 `div` 16))

489+ PR.dropWhile (<= (value * 9 `div` 16))

490+ PR.dropWhile (<= (value * 10 `div` 16))

491+ PR.dropWhile (<= (value * 11 `div` 16))

492+ PR.dropWhile (<= (value * 12 `div` 16))

493+ PR.dropWhile (<= (value * 13 `div` 16))

494+ PR.dropWhile (<= (value * 14 `div` 16))

495+ PR.dropWhile (<= (value * 15 `div` 16))

496+ PR.dropWhile (<= value)

497+

498+{-# INLINE takeEndBy_ #-}

499+takeEndBy_ :: Monad m

500+ => Int -> Stream m Int -> m (Either ParseError ())

501+takeEndBy_ value = Stream.parse (PR.takeEndBy_ (>= value) (PR.fromFold Fold.drain))

502+

503+{-

194504{-# INLINE teeAllAny #-}

195−teeAllAny :: MonadCatch m

196− => Int -> SerialT m Int -> m ((), ())

505+teeAllAny :: Monad m

506+ => Int -> Stream m Int -> m ((), ())

197507teeAllAny value =

198− IP.parse

508+ Stream.parse

199509 (PR.teeWith (,)

200− (PR.drainWhile (<= value))

201− (PR.drainWhile (<= value))

510+ (PR.dropWhile (<= value))

511+ (PR.dropWhile (<= value))

202512 )

203513

204514{-# INLINE teeFstAllAny #-}

205−teeFstAllAny :: MonadCatch m

206− => Int -> SerialT m Int -> m ((), ())

515+teeFstAllAny :: Monad m

516+ => Int -> Stream m Int -> m ((), ())

207517teeFstAllAny value =

208− IP.parse

518+ Stream.parse

209519 (PR.teeWithFst (,)

210− (PR.drainWhile (<= value))

211− (PR.drainWhile (<= value))

520+ (PR.dropWhile (<= value))

521+ (PR.dropWhile (<= value))

212522 )

213523

214524{-# INLINE shortestAllAny #-}

215−shortestAllAny :: MonadCatch m

216− => Int -> SerialT m Int -> m ()

525+shortestAllAny :: Monad m

526+ => Int -> Stream m Int -> m (Either ParseError ())

217527shortestAllAny value =

218− IP.parse

528+ Stream.parse

219529 (PR.shortest

220− (PR.drainWhile (<= value))

221− (PR.drainWhile (<= value))

530+ (PR.dropWhile (<= value))

531+ (PR.dropWhile (<= value))

222532 )

223533

224534{-# INLINE longestAllAny #-}

225−longestAllAny :: MonadCatch m

226− => Int -> SerialT m Int -> m ()

535+longestAllAny :: Monad m

536+ => Int -> Stream m Int -> m (Either ParseError ())

227537longestAllAny value =

228− IP.parse

538+ Stream.parse

229539 (PR.longest

230− (PR.drainWhile (<= value))

231− (PR.drainWhile (<= value))

540+ (PR.dropWhile (<= value))

541+ (PR.dropWhile (<= value))

232542 )

233−

234−parseManyChunksOfSum :: Int -> Handle -> IO Int

235−parseManyChunksOfSum n inh =

236− S.length

237− $ IP.parseMany

238− (PR.fromFold $ FL.take n FL.sum)

239− (S.unfold Handle.read inh)

543+-}

240544

241545-------------------------------------------------------------------------------

242−-- Parsing with unfolds

546+-- Spanning

243547-------------------------------------------------------------------------------

244548

245−{-# INLINE parseManyUnfoldArrays #-}

246−parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()

247−parseManyUnfoldArrays count arrays = do

248− let src = Source.source (Just (Producer.OuterLoop arrays))

249− let parser = PR.fromFold (FL.take count FL.drain)

250− let readSrc =

251− Source.producer

252− $ Producer.concat Producer.fromList Array.producer

253− let streamParser =

254− Producer.simplify (Source.parseMany parser readSrc)

255− S.drain $ S.unfold streamParser src

549+{-# INLINE span #-}

550+span :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))

551+span value = Stream.parse (PR.span (<= (value `div` 2)) Fold.drain Fold.drain)

552+

553+{-# INLINE spanBy #-}

554+spanBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))

555+spanBy value =

556+ Stream.parse (PR.spanBy (\_ i -> i <= (value `div` 2)) Fold.drain Fold.drain)

557+

558+{-# INLINE spanByRolling #-}

559+spanByRolling :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))

560+spanByRolling value =

561+ Stream.parse (PR.spanByRolling (\_ i -> i <= value `div` 2) Fold.drain Fold.drain)

562+

563+parseManyChunksOfSum :: Int -> Handle -> IO Int

564+parseManyChunksOfSum n inh =

565+ Stream.fold Fold.length

566+ $ Stream.parseMany

567+ (PR.fromFold $ Fold.take n Fold.sum)

568+ (Stream.unfold Handle.reader inh)

256569

257570-------------------------------------------------------------------------------

258571-- Parsers in which -fspec-constr-recursive=16 is problematic

@@ -263,57 +576,129 @@ parseManyUnfoldArrays count arrays = do

263576-- not have to rely on it.

264577--

265578{-# INLINE lookAhead #-}

266−lookAhead :: MonadCatch m => Int -> SerialT m Int -> m ()

579+lookAhead :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

267580lookAhead value =

268− IP.parse (PR.lookAhead (PR.takeWhile (<= value) FL.drain) $> ())

581+ Stream.parse (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())

269582

583+-- XXX The timing of this increased 3x after the stepify extract changes.

584+{-# INLINE sequenceA_ #-}

585+sequenceA_ :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

586+sequenceA_ value =

587+ Stream.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

588+

589+-- quadratic complexity

270590{-# INLINE sequenceA #-}

271−sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

591+sequenceA :: Monad m => Int -> Stream m Int -> m Int

272592sequenceA value xs = do

273− x <- IP.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

593+ x <- Stream.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

274594 return $ length x

275595

276−{-# INLINE sequenceA_ #-}

277−sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()

278−sequenceA_ value =

279− IP.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

280−

596+-- quadratic complexity

281597{-# INLINE sequence #-}

282−sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

598+sequence :: Monad m => Int -> Stream m Int -> m Int

283599sequence value xs = do

284− x <- IP.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

600+ x <- Stream.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

285601 return $ length x

286602

287603{-# INLINE sequence_ #-}

288−sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()

289−sequence_ value =

290− IP.parse (F.sequence_ $ replicate value (PR.satisfy (> 0)))

604+sequence_ :: Monad m => Int -> Stream m Int -> m (Either ParseError ())

605+sequence_ value xs =

606+ Stream.parse (foldr f (return ()) (replicate value (PR.takeBetween 0 1 Fold.drain))) xs

607+

608+ where

609+

610+ {-# INLINE f #-}

611+ f m k = m >>= (\_ -> k)

291612

613+-- choice using the "Alternative" instance with direct style parser type has

614+-- quadratic performance complexity.

615+--

616+{-# INLINE choiceAsum #-}

617+choiceAsum :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)

618+choiceAsum value =

619+ Stream.parse (F.asum (replicate value (PR.satisfy (< 0)))

620+ AP.<|> PR.satisfy (> 0))

621+

622+{-

292623{-# INLINE choice #-}

293−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

624+choice :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)

294625choice value =

295− IP.parse (asum (replicate value (PR.satisfy (< 0)))

296− AP.<|> PR.satisfy (> 0))

626+ Stream.parse

627+ (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))

628+-}

629+

630+-------------------------------------------------------------------------------

631+-- Parsing with unfolds

632+-------------------------------------------------------------------------------

633+

634+{-# INLINE parseManyUnfoldArrays #-}

635+parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()

636+parseManyUnfoldArrays count arrays = do

637+ let src = Producer.source (Just (Producer.OuterLoop arrays))

638+ let parser = PR.fromFold (Fold.take count Fold.drain)

639+ let readSrc =

640+ Producer.producer

641+ $ Producer.concat Producer.fromList Array.producer

642+ let streamParser =

643+ Producer.simplify (Producer.parseMany parser readSrc)

644+ Stream.fold Fold.drain $ Stream.unfold streamParser src

297645

298646-------------------------------------------------------------------------------

299647-- Stream transformation

300648-------------------------------------------------------------------------------

301649

302650{-# INLINE parseMany #-}

303−parseMany :: MonadCatch m => Int -> SerialT m Int -> m ()

651+parseMany :: Monad m => Int -> Stream m Int -> m ()

304652parseMany n =

305− S.drain

306− . S.map getSum

307− . IP.parseMany (PR.fromFold $ FL.take n FL.mconcat)

308− . S.map Sum

653+ Stream.fold Fold.drain

654+ . fmap getSum

655+ . Stream.catRights . Stream.parseMany (PR.fromFold $ Fold.take n Fold.mconcat)

656+ . fmap Sum

657+

658+{-# INLINE parseManyGroupBy #-}

659+parseManyGroupBy :: Monad m => (Int -> Int -> Bool) -> Stream m Int -> m ()

660+parseManyGroupBy cmp =

661+ Stream.fold Fold.drain . Stream.parseMany (PR.groupBy cmp Fold.drain)

662+

663+{-# INLINE parseManyGroupsRolling #-}

664+parseManyGroupsRolling :: Monad m => Bool -> Stream m Int -> m ()

665+parseManyGroupsRolling b =

666+ Stream.fold Fold.drain

667+ . Stream.parseMany (PR.groupByRolling (\_ _ -> b) Fold.drain)

668+

669+{-# INLINE parseManyGroupsRollingEither #-}

670+parseManyGroupsRollingEither :: Monad m =>

671+ (Int -> Int -> Bool) -> Int -> m ()

672+parseManyGroupsRollingEither cmp value = do

673+ sourceUnfoldrM value 1

674+ & Stream.parseMany (PR.groupByRollingEither cmp Fold.drain Fold.drain)

675+ & Stream.fold Fold.drain

676+

677+{-# INLINE parseManyGroupsRollingEitherAlt #-}

678+parseManyGroupsRollingEitherAlt :: Monad m =>

679+ (Int -> Int -> Bool) -> Int -> m ()

680+parseManyGroupsRollingEitherAlt cmp value = do

681+ sourceUnfoldrM value 1

682+ -- Make the input unsorted.

683+ & fmap (\x -> if even x then x + 2 else x)

684+ & Stream.parseMany (PR.groupByRollingEither cmp Fold.drain Fold.drain)

685+ & Stream.fold Fold.drain

309686

310687{-# INLINE parseIterate #-}

311−parseIterate :: MonadCatch m => Int -> SerialT m Int -> m ()

688+parseIterate :: Monad m => Int -> Stream m Int -> m ()

312689parseIterate n =

313− S.drain

314− . S.map getSum

315− . IP.parseIterate (PR.fromFold . FL.take n . FL.sconcat) (Sum 0)

316− . S.map Sum

690+ Stream.fold Fold.drain

691+ . fmap getSum

692+ . Stream.catRights

693+ . Stream.parseIterate

694+ (PR.fromFold . Fold.take n . Fold.sconcat)

695+ (Sum 0)

696+ . fmap Sum

697+

698+{-# INLINE concatSequence #-}

699+concatSequence :: Monad m => Stream m Int -> m (Either ParseError ())

700+concatSequence =

701+ Stream.parse $ PR.sequence (Stream.repeat PR.one) Fold.drain

317702

318703-------------------------------------------------------------------------------

319704-- Benchmarks

@@ -322,40 +707,95 @@ parseIterate n =

322707moduleName :: String

323708moduleName = "Data.Parser"

324709

710+instance NFData ParseError where

711+ {-# INLINE rnf #-}

712+ rnf (ParseError x) = rnf x

713+

325714o_1_space_serial :: Int -> [Benchmark]

326715o_1_space_serial value =

327716 [ benchIOSink value "takeBetween" $ takeBetween value

328− , benchIOSink value "takeEQ" $ takeEQ value

329717 , benchIOSink value "takeWhile" $ takeWhile value

330− , benchIOSink value "drainWhile" $ drainWhile value

331− , benchIOSink value "sliceBeginWith" $ sliceBeginWith value

718+ , benchIOSink value "takeWhileP" $ takeWhileP value

719+ , benchIOSink value "takeP" $ takeP value

720+ , benchIOSink value "dropWhile" $ dropWhile value

721+ , benchIOSink value "takeStartBy" $ takeStartBy value

722+ , benchIOSink value "takeEndBy_" $ takeEndBy_ value

332723 , benchIOSink value "groupBy" $ groupBy

333724 , benchIOSink value "groupByRolling" $ groupByRolling

334725 , benchIOSink value "wordBy" $ wordBy value

335− , benchIOSink value "splitAp" $ splitAp value

726+ , benchIOSink value "sepBy (words)" sepByWords

727+ , benchIOSink value "sepByAll (words)" sepByAllWords

728+ , benchIOSink value "sepBy1 (words)" sepByWords1

729+ , benchIOSink value "deintercalate" $ deintercalate value

730+ , benchIOSink value "deintercalate1" $ deintercalate1 value

731+ , benchIOSink value "deintercalateAll" $ deintercalateAll value

732+ -- Applicative and Monad

733+ , benchIOSink value "splitAp2" $ splitAp2 value

734+ , benchIOSink value "splitAp4" $ splitAp4 value

735+ , benchIOSink value "splitAp8" $ splitAp8 value

336736 , benchIOSink value "splitApBefore" $ splitApBefore value

337737 , benchIOSink value "splitApAfter" $ splitApAfter value

338− , benchIOSink value "serialWith" $ serialWith value

339− , benchIOSink value "sliceSepByP" $ sliceSepByP value

738+ , benchIOSink value "splitWith2" $ splitWith2 value

739+ , benchIOSink value "span" $ span value

740+ , benchIOSink value "spanBy" $ spanBy value

741+ , benchIOSink value "spanByRolling" $ spanByRolling value

742+ , benchIOSink value "monad2" $ monad value

743+ , benchIOSink value "monad4" $ monad4 value

744+ , benchIOSink value "monad8" $ monad8 value

745+ -- Alternative

746+ , benchIOSink value "alt2parseMany" $ altSmall value

747+ , benchIOSink value "alt2" $ alt2 value

748+ , benchIOSink value "alt4" $ alt4 value

749+ , benchIOSink value "alt8" $ alt8 value

750+ , benchIOSink value "alt16" $ alt16 value

340751 , benchIOSink value "many" many

341752 , benchIOSink value "many (wordBy even)" $ manyWordByEven

342753 , benchIOSink value "some" some

343754 , benchIOSink value "manyTill" $ manyTill value

344− , benchIOSink value "tee" $ teeAllAny value

345− , benchIOSink value "teeFst" $ teeFstAllAny value

346− , benchIOSink value "shortest" $ shortestAllAny value

347− , benchIOSink value "longest" $ longestAllAny value

755+ , benchIOSink value "parseMany" $ parseMany value

348756 , benchIOSink value "parseMany (take 1)" (parseMany 1)

349757 , benchIOSink value "parseMany (take all)" (parseMany value)

758+ , benchIOSink value "parseMany (groupBy (<))" (parseManyGroupBy (<))

759+ , benchIOSink value "parseMany (groupBy (==))" (parseManyGroupBy (==))

760+ , benchIOSink value "parseMany groupRollingBy (bound groups)"

761+ $ parseManyGroupsRolling False

762+ , benchIOSink value "parseMany groupRollingBy (1 group)"

763+ $ parseManyGroupsRolling True

764+ , bench "parseMany groupRollingByEither (Left)"

765+ $ nfIO $ parseManyGroupsRollingEitherLeft

766+ , bench "parseMany groupRollingByEither (Right)"

767+ $ nfIO $ parseManyGroupsRollingEitherRight

768+ , bench "parseMany groupRollingByEither (Alternating)"

769+ $ nfIO $ parseManyGroupsRollingEitherAlt1

350770 , benchIOSink value "parseIterate (take 1)" (parseIterate 1)

351771 , benchIOSink value "parseIterate (take all)" (parseIterate value)

772+ , benchIOSink value "concatSequence" concatSequence

773+ {-

774+ , benchIOSink value "tee" $ teeAllAny value

775+ , benchIOSink value "teeFst" $ teeFstAllAny value

776+ , benchIOSink value "shortest" $ shortestAllAny value

777+ , benchIOSink value "longest" $ longestAllAny value

778+ -}

779+ , benchIOSink value "streamEqBy" (streamEqBy value)

352780 ]

353781

782+ where

783+

784+ {-# NOINLINE parseManyGroupsRollingEitherLeft #-}

785+ parseManyGroupsRollingEitherLeft = parseManyGroupsRollingEither (<) value

786+

787+ {-# NOINLINE parseManyGroupsRollingEitherRight #-}

788+ parseManyGroupsRollingEitherRight = parseManyGroupsRollingEither (>) value

789+

790+ {-# NOINLINE parseManyGroupsRollingEitherAlt1 #-}

791+ parseManyGroupsRollingEitherAlt1 =

792+ parseManyGroupsRollingEitherAlt (>) value

793+

354794o_1_space_filesystem :: BenchEnv -> [Benchmark]

355795o_1_space_filesystem env =

356− [ mkBench ("S.parseMany (FL.take " ++ show (bigSize env) ++ " FL.sum)") env

796+ [ mkBench ("S.parseMany (Fold.take " ++ show (bigSize env) ++ " Fold.sum)") env

357797 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh

358− , mkBench "S.parseMany (FL.take 1 FL.sum)" env

798+ , mkBench "S.parseMany (Fold.take 1 Fold.sum)" env

359799 $ \inh _ -> inline parseManyChunksOfSum 1 inh

360800 ]

361801

@@ -370,25 +810,38 @@ o_1_space_serial_unfold bound arrays =

370810o_n_heap_serial :: Int -> [Benchmark]

371811o_n_heap_serial value =

372812 [

813+ benchIOSink value "takeEQ" $ takeEQ value

814+ , benchIOSink value "takeGE" $ takeGE value

815+

373816 -- lookahead benchmark holds the entire input till end

374− benchIOSink value "lookAhead" $ lookAhead value

817+ , benchIOSink value "lookAhead" $ lookAhead value

375818

376− -- accumulates the results in a list

377− , benchIOSink value "sequence" $ sequence value

378− , benchIOSink value "sequenceA" $ sequenceA value

819+ -- o-n-heap because of backtracking

820+ , benchIOSrc sourceEscapedFrames value "takeFramedByEsc_"

821+ $ takeFramedByEsc_ value

379822

380− -- XXX why should this take O(n) heap, it discards the results?

381− , benchIOSink value "sequence_" $ sequence_ value

382− , benchIOSink value "sequenceA_" $ sequenceA_ value

383823 -- non-linear time complexity (parserD)

384824 , benchIOSink value "split_" $ split_ value

385− -- XXX why O(n) heap?

386− , benchIOSink value "choice" $ choice value

825+ -- XXX Takes lot of space when run on a long stream, why?

826+ , benchIOSink value "monad16" $ monad16 value

387827

388828 -- These show non-linear time complexity.

389829 -- They accumulate the results in a list.

830+ , benchIOSink value "sepBy1" sepBy1

390831 , benchIOSink value "manyAlt" manyAlt

391832 , benchIOSink value "someAlt" someAlt

833+ , benchIOSink value "listEqBy" (listEqBy value)

834+ ]

835+

836+-- accumulate results in a list in IO

837+o_n_space_serial :: Int -> [Benchmark]

838+o_n_space_serial value =

839+ [ benchIOSink value "sequenceA/100" $ sequenceA (value `div` 100)

840+ , benchIOSink value "sequenceA_/100" $ sequenceA_ (value `div` 100)

841+ , benchIOSink value "sequence/100" $ sequence (value `div` 100)

842+ , benchIOSink value "sequence_/100" $ sequence_ (value `div` 100)

843+ , benchIOSink value "choice (asum)/100" $ choiceAsum (value `div` 100)

844+ -- , benchIOSink value "choice/100" $ choice (value `div` 100)

392845 ]

393846

394847-------------------------------------------------------------------------------

@@ -397,14 +850,15 @@ o_n_heap_serial value =

397850

398851main :: IO ()

399852main = do

400− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

853+#ifndef FUSION_CHECK

401854 env <- mkHandleBenchEnv

402− arrays <- IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0

403− value `seq` runMode (mode cfg) cfg benches (allBenchmarks env value arrays)

855+ runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)

404856

405857 where

406858

407− allBenchmarks env value arrays =

859+ alloc value = Stream.fold Fold.toList $ Stream.chunksOf 100 $ sourceUnfoldrM value 0

860+

861+ allBenchmarks env arrays value =

408862 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

409863 , bgroup

410864 (o_1_space_prefix moduleName ++ "/filesystem")

@@ -412,4 +866,22 @@ main = do

412866 , bgroup (o_1_space_prefix moduleName)

413867 (o_1_space_serial_unfold value arrays)

414868 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

869+ , bgroup (o_n_space_prefix moduleName) (o_n_space_serial value)

415870 ]

871+#else

872+ -- Enable FUSION_CHECK macro at the beginning of the file

873+ -- Enable one benchmark below, and run the benchmark

874+ -- Check the .dump-simpl output

875+ let value = 100000

876+ -- let input = sourceUnfoldrM value 1

877+ -- manyTill value input

878+ -- deintercalate value input

879+ -- deintercalate1 value input

880+ -- deintercalateAll value input

881+ -- sepByWords input

882+ -- sepByAllWords input

883+ -- sepBy1 input

884+ -- sepByWords1 input

885+ takeFramedByEsc_ value (sourceEscapedFrames value 1)

886+ return ()

887+#endif

benchmark/Streamly/Benchmark/Data/Parser/ParserD.hsdeleted−378

@@ -1,378 +0,0 @@

1−-- |

2−-- Module : Streamly.Benchmark.Data.ParserD

4−--

5−-- License : BSD-3-Clause

6−-- Maintainer : streamly@composewell.com

7−

8−{-# LANGUAGE FlexibleContexts #-}

9−{-# LANGUAGE ScopedTypeVariables #-}

10−{-# OPTIONS_GHC -fspec-constr-recursive=4 #-}

11−

12−module Main

13− (

14− main

15− ) where

16−

17−import Control.DeepSeq (NFData(..))

18−import Control.Monad.Catch (MonadCatch, MonadThrow)

19−import Data.Foldable (asum)

20−import Data.Functor (($>))

21−import Data.Maybe (fromMaybe)

22−import System.Random (randomRIO)

23−import Prelude hiding (any, all, take, sequence, sequenceA, sequence_, takeWhile, span)

24−

25−import qualified Data.Traversable as TR

26−import qualified Data.Foldable as F

27−import qualified Control.Applicative as AP

28−import qualified Streamly.Prelude as S

29−import qualified Streamly.Internal.Data.Array.Foreign as Array

30−import qualified Streamly.Internal.Data.Fold as FL

31−import qualified Streamly.Internal.Data.Parser.ParserD as PR

32−import qualified Streamly.Internal.Data.Producer as Producer

33−import qualified Streamly.Internal.Data.Producer.Source as Source

34−import qualified Streamly.Internal.Data.Stream.IsStream as IP

35−

36−import Gauge

37−import Streamly.Prelude (SerialT, MonadAsync, IsStream)

38−import Streamly.Benchmark.Common

39−

40−-------------------------------------------------------------------------------

41−-- Utilities

42−-------------------------------------------------------------------------------

43−

44−-- XXX these can be moved to the common module

45−

46−{-# INLINE sourceUnfoldrM #-}

47−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

48−sourceUnfoldrM value n = S.unfoldrM step n

49− where

50− step cnt =

51− if cnt > n + value

52− then return Nothing

53− else return (Just (cnt, cnt + 1))

54−

55−-- | Takes a fold method, and uses it with a default source.

56−{-# INLINE benchIOSink #-}

57−benchIOSink

58− :: (IsStream t, NFData b)

59− => Int -> String -> (t IO Int -> IO b) -> Benchmark

60−benchIOSink value name f =

61− bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

62−

63−-------------------------------------------------------------------------------

64−-- Parsers

65−-------------------------------------------------------------------------------

66−

67−{-# INLINE drainWhile #-}

68−drainWhile :: MonadThrow m => (a -> Bool) -> PR.Parser m a ()

69−drainWhile p = PR.takeWhile p FL.drain

70−

71−{-# INLINE sliceBeginWith #-}

72−sliceBeginWith :: MonadCatch m => Int -> SerialT m Int -> m ()

73−sliceBeginWith value stream = do

74− stream1 <- return . fromMaybe (S.yield (value + 1)) =<< S.tail stream

75− let stream2 = value `S.cons` stream1

76− IP.parseD (PR.sliceBeginWith (== value) FL.drain) stream2

77−

78−{-# INLINE takeWhile #-}

79−takeWhile :: MonadThrow m => Int -> SerialT m Int -> m ()

80−takeWhile value = IP.parseD (drainWhile (<= value))

81−

82−{-# INLINE groupBy #-}

83−groupBy :: MonadThrow m => SerialT m Int -> m ()

84−groupBy = IP.parseD (PR.groupBy (<=) FL.drain)

85−

86−{-# INLINE groupByRolling #-}

87−groupByRolling :: MonadThrow m => SerialT m Int -> m ()

88−groupByRolling = IP.parseD (PR.groupByRolling (<=) FL.drain)

89−

90−{-# INLINE wordBy #-}

91−wordBy :: MonadThrow m => Int -> SerialT m Int -> m ()

92−wordBy value = IP.parseD (PR.wordBy (>= value) FL.drain)

93−

94−{-# INLINE manyWordByEven #-}

95−manyWordByEven :: MonadCatch m => SerialT m Int -> m ()

96−manyWordByEven =

97− IP.parseD (PR.many (PR.wordBy (Prelude.even) FL.drain) FL.drain)

98−

99−{-# INLINE many #-}

100−many :: MonadCatch m => SerialT m Int -> m Int

101−many = IP.parseD (PR.many (PR.satisfy (> 0)) FL.length)

102−

103−{-# INLINE manyAlt #-}

104−manyAlt :: MonadCatch m => SerialT m Int -> m Int

105−manyAlt xs = do

106− x <- IP.parseD (AP.many (PR.satisfy (> 0))) xs

107− return $ Prelude.length x

108−

109−{-# INLINE some #-}

110−some :: MonadCatch m => SerialT m Int -> m Int

111−some = IP.parseD (PR.some (PR.satisfy (> 0)) FL.length)

112−

113−{-# INLINE someAlt #-}

114−someAlt :: MonadCatch m => SerialT m Int -> m Int

115−someAlt xs = do

116− x <- IP.parseD (AP.some (PR.satisfy (> 0))) xs

117− return $ Prelude.length x

118−

119−{-#INLINE sliceSepByP #-}

120−sliceSepByP :: MonadCatch m => Int -> SerialT m Int -> m ()

121−sliceSepByP value = IP.parseD (PR.sliceSepByP (>= value) (PR.fromFold FL.drain))

122−

123−{-# INLINE manyTill #-}

124−manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int

125−manyTill value =

126− let p = PR.satisfy (> 0)

127− pcond = PR.satisfy (== value)

128− in IP.parseD (PR.manyTill FL.length p pcond)

129−

130−{-# INLINE serialWith #-}

131−serialWith :: MonadThrow m

132− => Int -> SerialT m Int -> m ((), ())

133−serialWith value =

134− IP.parseD

135− ((,)

136− <$> drainWhile (<= (value `div` 2))

137− <*> drainWhile (<= value)

138− )

139−

140−{-# INLINE teeAllAny #-}

141−teeAllAny :: MonadThrow m

142− => Int -> SerialT m Int -> m ((), ())

143−teeAllAny value =

144− IP.parseD

145− (PR.teeWith (,)

146− (drainWhile (<= value))

147− (drainWhile (<= value))

148− )

149−

150−{-# INLINE teeFstAllAny #-}

151−teeFstAllAny :: MonadThrow m

152− => Int -> SerialT m Int -> m ((), ())

153−teeFstAllAny value =

154− IP.parseD

155− (PR.teeWithFst (,)

156− (drainWhile (<= value))

157− (drainWhile (<= value))

158− )

159−

160−{-# INLINE shortestAllAny #-}

161−shortestAllAny :: MonadThrow m

162− => Int -> SerialT m Int -> m ()

163−shortestAllAny value =

164− IP.parseD

165− (PR.shortest

166− (drainWhile (<= value))

167− (drainWhile (<= value))

168− )

169−

170−{-# INLINE longestAllAny #-}

171−longestAllAny :: MonadCatch m

172− => Int -> SerialT m Int -> m ()

173−longestAllAny value =

174− IP.parseD

175− (PR.longest

176− (drainWhile (<= value))

177− (drainWhile (<= value))

178− )

179−

180−-------------------------------------------------------------------------------

181−-- Spanning

182−-------------------------------------------------------------------------------

183−

184−{-# INLINE span #-}

185−span :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

186−span value = IP.parseD (PR.span (<= (value `div` 2)) FL.drain FL.drain)

187−

188−{-# INLINE spanBy #-}

189−spanBy :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

190−spanBy value =

191− IP.parseD (PR.spanBy (\_ i -> i <= (value `div` 2)) FL.drain FL.drain)

192−

193−{-# INLINE spanByRolling #-}

194−spanByRolling :: MonadThrow m => Int -> SerialT m Int -> m ((), ())

195−spanByRolling value =

196− IP.parseD (PR.spanByRolling (\_ i -> i <= value `div` 2) FL.drain FL.drain)

197−

198−-------------------------------------------------------------------------------

199−-- Nested

200−-------------------------------------------------------------------------------

201−

202−{-# INLINE parseMany #-}

203−parseMany :: MonadThrow m => Int -> SerialT m Int -> m ()

204−parseMany value = IP.drain . IP.parseManyD (drainWhile (<= value + 1))

205−

206−{-# INLINE parseManyGroups #-}

207−parseManyGroups :: MonadThrow m => Bool -> SerialT m Int -> m ()

208−parseManyGroups b = IP.drain . IP.parseManyD (PR.groupBy (\_ _ -> b) FL.drain)

209−

210−{-# INLINE parseManyGroupsRolling #-}

211−parseManyGroupsRolling :: MonadThrow m => Bool -> SerialT m Int -> m ()

212−parseManyGroupsRolling b =

213− IP.drain . IP.parseManyD (PR.groupByRolling (\_ _ -> b) FL.drain)

214−

215−-------------------------------------------------------------------------------

216−-- Parsing with unfolds

217−-------------------------------------------------------------------------------

218−

219−{-# INLINE parseManyUnfoldArrays #-}

220−parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()

221−parseManyUnfoldArrays count arrays = do

222− let src = Source.source (Just (Producer.OuterLoop arrays))

223− let parser = PR.fromFold (FL.take count FL.drain)

224− let readSrc =

225− Source.producer

226− $ Producer.concat Producer.fromList Array.producer

227− let streamParser =

228− Producer.simplify (Source.parseManyD parser readSrc)

229− S.drain $ S.unfold streamParser src

230−

231−-------------------------------------------------------------------------------

232−-- Parsers in which -fspec-constr-recursive=16 is problematic

233−-------------------------------------------------------------------------------

234−

235−-- XXX -fspec-constr-recursive=16 makes GHC go beserk when compiling these.

236−-- We need to fix GHC so that we can have better control over that option or do

237−-- not have to rely on it.

238−--

239−{-# INLINE lookAhead #-}

240−lookAhead :: MonadThrow m => Int -> SerialT m Int -> m ()

241−lookAhead value =

242− IP.parseD (PR.lookAhead (PR.takeWhile (<= value) FL.drain) $> ())

243−

244−{-# INLINE sequenceA_ #-}

245−sequenceA_ :: MonadThrow m => Int -> SerialT m Int -> m ()

246−sequenceA_ value =

247− IP.parseD (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))

248−

249−-- quadratic complexity

250−{-# INLINE sequenceA #-}

251−sequenceA :: MonadThrow m => Int -> SerialT m Int -> m Int

252−sequenceA value xs = do

253− x <- IP.parseD (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs

254− return $ length x

255−

256−-- quadratic complexity

257−{-# INLINE sequence #-}

258−sequence :: MonadThrow m => Int -> SerialT m Int -> m Int

259−sequence value xs = do

260− x <- IP.parseD (TR.sequence (replicate value (PR.satisfy (> 0)))) xs

261− return $ length x

262−

263−{-# INLINE sequence_ #-}

264−sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()

265−sequence_ value xs =

266− IP.parseD (foldr f (return ()) (replicate value (PR.takeBetween 0 1 FL.drain))) xs

267−

268− where

269−

270− {-# INLINE f #-}

271− f m k = m >>= (\_ -> k)

272−

273−-- choice using the "Alternative" instance with direct style parser type has

274−-- quadratic performance complexity.

275−--

276−{-# INLINE choice #-}

277−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

278−choice value =

279− IP.parseD (asum (replicate value (PR.satisfy (< 0)))

280− AP.<|> PR.satisfy (> 0))

281−

282−-------------------------------------------------------------------------------

283−-- Benchmarks

284−-------------------------------------------------------------------------------

285−

286−moduleName :: String

287−moduleName = "Data.Parser.ParserD"

288−

289−o_1_space_serial :: Int -> [Benchmark]

290−o_1_space_serial value =

291− [ benchIOSink value "takeWhile" $ takeWhile value

292− , benchIOSink value "sliceBeginWith" $ sliceBeginWith value

293− , benchIOSink value "groupBy" $ groupBy

294− , benchIOSink value "groupByRolling" $ groupByRolling

295− , benchIOSink value "wordBy" $ wordBy value

296− , benchIOSink value "serialWith" $ serialWith value

297− , benchIOSink value "many" many

298− , benchIOSink value "many (wordBy even)" $ manyWordByEven

299− , benchIOSink value "some" some

300− , benchIOSink value "sliceSepByP" $ sliceSepByP value

301− , benchIOSink value "manyTill" $ manyTill value

302− , benchIOSink value "tee (all,any)" $ teeAllAny value

303− , benchIOSink value "teeFst (all,any)" $ teeFstAllAny value

304− , benchIOSink value "shortest (all,any)" $ shortestAllAny value

305− , benchIOSink value "longest (all,any)" $ longestAllAny value

306− ]

307−

308−o_1_space_serial_spanning :: Int -> [Benchmark]

309−o_1_space_serial_spanning value =

310− [ benchIOSink value "span" $ span value

311− , benchIOSink value "spanBy" $ spanBy value

312− , benchIOSink value "spanByRolling" $ spanByRolling value

313− ]

314−

315−o_1_space_serial_nested :: Int -> [Benchmark]

316−o_1_space_serial_nested value =

317− [ benchIOSink value "parseMany" $ parseMany value

318− , benchIOSink value "parseMany groupBy (bound groups)"

319− $ (parseManyGroups False)

320− , benchIOSink value "parseMany groupRollingBy (bound groups)"

321− $ (parseManyGroupsRolling False)

322− , benchIOSink value "parseMany groupBy (1 group)" $ (parseManyGroups True)

323− , benchIOSink value "parseMany groupRollingBy (1 group)"

324− $ (parseManyGroupsRolling True)

325− ]

326−

327−o_1_space_serial_unfold :: Int -> [Array.Array Int] -> [Benchmark]

328−o_1_space_serial_unfold bound arrays =

329− [ bench "parseMany/Unfold/1000 arrays/1 parse"

330− $ nfIO $ parseManyUnfoldArrays bound arrays

331− , bench "parseMany/Unfold/1000 arrays/100000 parses"

332− $ nfIO $ parseManyUnfoldArrays 1 arrays

333− ]

334−

335−o_n_heap_serial :: Int -> [Benchmark]

336−o_n_heap_serial value =

337− [

338− -- lookahead benchmark holds the entire input till end

339− benchIOSink value "lookAhead" $ lookAhead value

340−

341− -- These show non-linear time complexity

342− -- They accumulate the results in a list.

343− , benchIOSink value "manyAlt" manyAlt

344− , benchIOSink value "someAlt" someAlt

345− ]

346−

347−-- accumulate results in a list in IO

348−o_n_space_serial :: Int -> [Benchmark]

349−o_n_space_serial value =

350− [ benchIOSink value "sequenceA/100" $ sequenceA (value `div` 100)

351− , benchIOSink value "sequenceA_/100" $ sequenceA_ (value `div` 100)

352− , benchIOSink value "sequence/100" $ sequence (value `div` 100)

353− , benchIOSink value "sequence_/100" $ sequence_ (value `div` 100)

354− , benchIOSink value "choice/100" $ choice (value `div` 100)

355− ]

356−

357−-------------------------------------------------------------------------------

358−-- Driver

359−-------------------------------------------------------------------------------

360−

361−main :: IO ()

362−main = do

363− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

364− arraysSmall <- IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0

365− value `seq` runMode (mode cfg) cfg benches

366− (allBenchmarks value arraysSmall)

367−

368− where

369−

370− allBenchmarks value arraysSmall =

371− [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

372− , bgroup (o_1_space_prefix moduleName) (o_1_space_serial_spanning value)

373− , bgroup (o_1_space_prefix moduleName) (o_1_space_serial_nested value)

374− , bgroup (o_1_space_prefix moduleName)

375− (o_1_space_serial_unfold value arraysSmall)

376− , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

377− , bgroup (o_n_space_prefix moduleName) (o_n_space_serial value)

378− ]

benchmark/Streamly/Benchmark/Data/Parser/ParserK.hsdeleted−165

@@ -1,165 +0,0 @@

1−-- |

2−-- Module : Streamly.Benchmark.Data.ParserK

4−--

5−-- License : BSD-3-Clause

6−-- Maintainer : streamly@composewell.com

7−

8−{-# LANGUAGE CPP #-}

9−{-# LANGUAGE FlexibleContexts #-}

10−

11−module Main

12− (

13− main

14− ) where

15−

16−import Control.DeepSeq (NFData(..))

17−import Control.Monad.Catch (MonadCatch)

18−import Data.Foldable (asum)

19−import System.Random (randomRIO)

20−import Prelude hiding (any, all, take, sequence, sequenceA, takeWhile)

21−

22−import qualified Control.Applicative as AP

23−import qualified Data.Foldable as F

24−import qualified Data.Traversable as TR

25−import qualified Streamly.Prelude as S

26−import qualified Streamly.Internal.Data.Fold as FL

27−import qualified Streamly.Internal.Data.Parser.ParserK.Type as PR

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

29−import qualified Streamly.Internal.Data.Stream.IsStream as IP

30−

31−import Gauge

32−import Streamly.Prelude (SerialT, MonadAsync, IsStream)

33−import Streamly.Benchmark.Common

34−

35−-------------------------------------------------------------------------------

36−-- Utilities

37−-------------------------------------------------------------------------------

38−

39−-- XXX these can be moved to the common module

40−

41−{-# INLINE sourceUnfoldrM #-}

42−sourceUnfoldrM :: (IsStream t, MonadAsync m) => Int -> Int -> t m Int

43−sourceUnfoldrM value n = S.unfoldrM step n

44− where

45− step cnt =

46− if cnt > n + value

47− then return Nothing

48− else return (Just (cnt, cnt + 1))

49−

50−-- | Takes a fold method, and uses it with a default source.

51−{-# INLINE benchIOSink #-}

52−benchIOSink

53− :: (IsStream t, NFData b)

54− => Int -> String -> (t IO Int -> IO b) -> Benchmark

55−benchIOSink value name f =

56− bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

57−

58−-------------------------------------------------------------------------------

59−-- Parsers

60−-------------------------------------------------------------------------------

61−

62−#ifdef FROM_PARSERK

63−#define PARSE_OP (IP.parseD . PR.fromParserK)

64−#else

65−#define PARSE_OP IP.parseK

66−#endif

67−

68−{-# INLINE satisfy #-}

69−satisfy :: MonadCatch m => (a -> Bool) -> PR.Parser m a a

70−satisfy = PR.toParserK . PRD.satisfy

71−

72−{-# INLINE takeWhile #-}

73−takeWhile :: MonadCatch m => (a -> Bool) -> PR.Parser m a ()

74−takeWhile p = PR.toParserK $ PRD.takeWhile p FL.drain

75−

76−{-# INLINE takeWhileK #-}

77−takeWhileK :: MonadCatch m => Int -> SerialT m Int -> m ()

78−takeWhileK value = PARSE_OP (takeWhile (<= value))

79−

80−{-# INLINE splitApp #-}

81−splitApp :: MonadCatch m

82− => Int -> SerialT m Int -> m ((), ())

83−splitApp value =

84− PARSE_OP ((,) <$> takeWhile (<= (value `div` 2)) <*> takeWhile (<= value))

85−

86−{-# INLINE sequenceA #-}

87−sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

88−sequenceA value xs = do

89− let parser = satisfy (> 0)

90− list = Prelude.replicate value parser

91− x <- PARSE_OP (TR.sequenceA list) xs

92− return $ Prelude.length x

93−

94−{-# INLINE sequenceA_ #-}

95−sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()

96−sequenceA_ value xs = do

97− let parser = satisfy (> 0)

98− list = Prelude.replicate value parser

99− PARSE_OP (F.sequenceA_ list) xs

100−

101−{-# INLINE sequence #-}

102−sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

103−sequence value xs = do

104− let parser = satisfy (> 0)

105− list = Prelude.replicate value parser

106− x <- PARSE_OP (TR.sequence list) xs

107− return $ Prelude.length x

108−

109−{-# INLINE manyAlt #-}

110−manyAlt :: MonadCatch m => SerialT m Int -> m Int

111−manyAlt xs = do

112− x <- PARSE_OP (AP.many (satisfy (> 0))) xs

113− return $ Prelude.length x

114−

115−{-# INLINE someAlt #-}

116−someAlt :: MonadCatch m => SerialT m Int -> m Int

117−someAlt xs = do

118− x <- PARSE_OP (AP.some (satisfy (> 0))) xs

119− return $ Prelude.length x

120−

121−{-# INLINE choice #-}

122−choice :: MonadCatch m => Int -> SerialT m Int -> m Int

123−choice value =

124− PARSE_OP (asum (replicate value (satisfy (< 0)))

125− AP.<|> satisfy (> 0))

126−

127−-------------------------------------------------------------------------------

128−-- Benchmarks

129−-------------------------------------------------------------------------------

130−

131−moduleName :: String

132−moduleName = "Data.Parser.ParserK"

133−

134−o_1_space_serial :: Int -> [Benchmark]

135−o_1_space_serial value =

136− [ benchIOSink value "takeWhile" $ takeWhileK value

137− , benchIOSink value "splitApp" $ splitApp value

138− ]

139−

140−-- O(n) heap beacuse of accumulation of the list in strict IO monad?

141−o_n_heap_serial :: Int -> [Benchmark]

142−o_n_heap_serial value =

143− [ benchIOSink value "sequenceA" $ sequenceA value

144− , benchIOSink value "sequenceA_" $ sequenceA_ value

145− , benchIOSink value "sequence" $ sequence value

146− , benchIOSink value "manyAlt" manyAlt

147− , benchIOSink value "someAlt" someAlt

148− , benchIOSink value "choice" $ choice value

149− ]

150−

151−-------------------------------------------------------------------------------

152−-- Driver

153−-------------------------------------------------------------------------------

154−

155−main :: IO ()

156−main = do

157− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

158− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

159−

160− where

161−

162− allBenchmarks value =

163− [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

164− , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

165− ]

benchmark/Streamly/Benchmark/Data/ParserK.hsnew file+437

@@ -0,0 +1,437 @@

1+-- |

2+-- Module : Streamly.Benchmark.Data.ParserK

4+--

5+-- License : BSD-3-Clause

6+-- Maintainer : streamly@composewell.com

8+-- BENCH_CHUNKED -> adaptC

9+-- BENCH_CHUNKED_GENERIC -> adaptCG

10+-- BENCH_SINGULAR -> adapt

11+

12+{-# LANGUAGE CPP #-}

13+{-# LANGUAGE FlexibleContexts #-}

14+{-# OPTIONS_GHC -Wno-orphans #-}

15+

16+module Main

17+ (

18+ main

19+ ) where

20+

21+import Control.Applicative ((<|>))

22+import Control.DeepSeq (NFData(..))

23+import Control.Monad.IO.Class (MonadIO)

24+import Data.Foldable (asum)

25+#ifdef BENCH_CHUNKED

26+import Streamly.Data.Array (Array, Unbox)

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(..))

33+import Streamly.Data.StreamK (StreamK)

34+import Streamly.Internal.Data.Parser

35+ (ParseError(..), Parser(..), Initial(..), Step(..))

36+import Streamly.Internal.Data.Stream (Stream)

37+import System.Random (randomRIO)

38+import Prelude hiding

39+ (any, all, take, sequence, sequence_, sequenceA, takeWhile)

40+

41+import qualified Control.Applicative as AP

42+import qualified Data.Foldable as F

43+import qualified Data.Traversable as TR

44+import qualified Streamly.Data.Stream as Stream

45+import qualified Streamly.Data.Fold as FL

46+import qualified Streamly.Internal.Data.Fold as Fold

47+import qualified Streamly.Data.Parser as PRD

48+import qualified Streamly.Internal.Data.ParserK as PR

49+import qualified Streamly.Internal.Data.StreamK as StreamK

50+

51+import Test.Tasty.Bench

52+import Streamly.Benchmark.Common

53+

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+

94+-------------------------------------------------------------------------------

95+-- Utilities

96+-------------------------------------------------------------------------------

97+

98+-- XXX these can be moved to the common module

99+

100+{-# INLINE sourceUnfoldrM #-}

101+sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int

102+sourceUnfoldrM value n = Stream.unfoldrM step n

103+ where

104+ step cnt =

105+ if cnt > n + value

106+ then return Nothing

107+ else return (Just (cnt, cnt + 1))

108+

109+-- | Takes a fold method, and uses it with a default source.

110+{-# INLINE benchIOSink #-}

111+benchIOSink

112+ :: NFData b

113+ => Int -> String -> (StreamK IO PARSE_ELEM -> IO b) -> Benchmark

114+benchIOSink value name f =

115+ bench name $ nfIO $ randomRIO (1,1)

116+ >>= f

117+ . StreamK.fromStream

118+#ifdef BENCH_CHUNKED

119+ . Stream.chunksOf 4000

120+#endif

121+#ifdef BENCH_CHUNKED_GENERIC

122+ . GenArr.chunksOf 4000

123+#endif

124+ . sourceUnfoldrM value

125+

126+-------------------------------------------------------------------------------

127+-- Parsers

128+-------------------------------------------------------------------------------

129+

130+{-# INLINE one #-}

131+one :: MonadIO m =>

132+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError (Maybe Int))

133+one value = PARSE_OP p

134+

135+ where

136+

137+ p = do

138+ m <- PR.FROM_PARSER (PRD.fromFold FL.one)

139+ case m of

140+ Just i -> if i >= value then pure m else p

141+ Nothing -> pure Nothing

142+

143+{-# INLINE satisfy #-}

144+satisfy :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m a

145+satisfy = PR.FROM_PARSER . PRD.satisfy

146+

147+{-# INLINE takeWhile #-}

148+takeWhile :: CONSTRAINT_IO => (a -> Bool) -> PR.ParserK INPUT m ()

149+takeWhile p = PR.FROM_PARSER $ PRD.takeWhile p FL.drain

150+

151+{-# INLINE takeWhileK #-}

152+takeWhileK :: MonadIO m =>

153+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

154+takeWhileK value = PARSE_OP (takeWhile (<= value))

155+

156+{-# INLINE splitAp2 #-}

157+splitAp2 :: MonadIO m

158+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ((), ()))

159+splitAp2 value =

160+ PARSE_OP

161+ ((,)

162+ <$> takeWhile (<= (value `div` 2))

163+ <*> takeWhile (<= value)

164+ )

165+

166+{-# INLINE splitAp8 #-}

167+splitAp8 :: MonadIO m

168+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

169+splitAp8 value =

170+ PARSE_OP

171+ ( (\() () () () () () () () -> ())

172+ <$> takeWhile (<= ( value `div` 8))

173+ <*> takeWhile (<= ((value * 2) `div` 8))

174+ <*> takeWhile (<= ((value * 3) `div` 8))

175+ <*> takeWhile (<= ((value * 4) `div` 8))

176+ <*> takeWhile (<= ((value * 5) `div` 8))

177+ <*> takeWhile (<= ((value * 6) `div` 8))

178+ <*> takeWhile (<= ((value * 7) `div` 8))

179+ <*> takeWhile (<= value)

180+ )

181+

182+{-# INLINE sequenceA #-}

183+sequenceA :: MonadIO m => Int -> StreamK m PARSE_ELEM -> m Int

184+sequenceA value xs = do

185+ let parser = satisfy (> 0)

186+ list = Prelude.replicate value parser

187+ x <- PARSE_OP (TR.sequenceA list) xs

188+ return $ Prelude.length x

189+

190+{-# INLINE sequenceA_ #-}

191+sequenceA_ :: MonadIO m =>

192+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

193+sequenceA_ value xs = do

194+ let parser = satisfy (> 0)

195+ list = Prelude.replicate value parser

196+ PARSE_OP (F.sequenceA_ list) xs

197+

198+{-# INLINE sequence #-}

199+sequence :: MonadIO m => Int -> StreamK m PARSE_ELEM -> m Int

200+sequence value xs = do

201+ let parser = satisfy (> 0)

202+ list = Prelude.replicate value parser

203+ x <- PARSE_OP (TR.sequence list) xs

204+ return $ Prelude.length x

205+

206+{-# INLINE sequence_ #-}

207+sequence_ :: MonadIO m =>

208+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

209+sequence_ value =

210+ let parser = satisfy (> 0)

211+ list = Prelude.replicate value parser

212+ in PARSE_OP (F.sequence_ list)

213+

214+{-# INLINE takeWhileFailD #-}

215+takeWhileFailD :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b

216+takeWhileFailD predicate (Fold fstep finitial _ ffinal) =

217+ Parser step initial extract

218+

219+ where

220+

221+ initial = do

222+ res <- finitial

223+ return $ case res of

224+ Fold.Partial s -> IPartial s

225+ Fold.Done b -> IDone b

226+

227+ step s a =

228+ if predicate a

229+ then do

230+ fres <- fstep s a

231+ return

232+ $ case fres of

233+ Fold.Partial s1 -> Partial 0 s1

234+ Fold.Done b -> Done 0 b

235+ else return $ Error "fail"

236+

237+ extract s = fmap (Done 0) (ffinal s)

238+

239+{-# INLINE takeWhileFail #-}

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)

243+

244+{-# INLINE alt2 #-}

245+alt2 :: MonadIO m

246+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

247+alt2 value =

248+ PARSE_OP

249+ ( takeWhileFail (<= (value `div` 2)) Fold.drain

250+ <|> takeWhile (<= value)

251+ )

252+

253+{-# INLINE alt8 #-}

254+alt8 :: MonadIO m

255+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

256+alt8 value =

257+ PARSE_OP

258+ ( takeWhileFail (<= ( value `div` 8)) Fold.drain

259+ <|> takeWhileFail (<= ((value * 2) `div` 8)) Fold.drain

260+ <|> takeWhileFail (<= ((value * 3) `div` 8)) Fold.drain

261+ <|> takeWhileFail (<= ((value * 4) `div` 8)) Fold.drain

262+ <|> takeWhileFail (<= ((value * 5) `div` 8)) Fold.drain

263+ <|> takeWhileFail (<= ((value * 6) `div` 8)) Fold.drain

264+ <|> takeWhileFail (<= ((value * 7) `div` 8)) Fold.drain

265+ <|> takeWhile (<= value)

266+ )

267+

268+{-# INLINE alt16 #-}

269+alt16 :: MonadIO m

270+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

271+alt16 value =

272+ PARSE_OP

273+ ( takeWhileFail (<= ( value `div` 16)) Fold.drain

274+ <|> takeWhileFail (<= ((value * 2) `div` 16)) Fold.drain

275+ <|> takeWhileFail (<= ((value * 3) `div` 16)) Fold.drain

276+ <|> takeWhileFail (<= ((value * 4) `div` 16)) Fold.drain

277+ <|> takeWhileFail (<= ((value * 5) `div` 16)) Fold.drain

278+ <|> takeWhileFail (<= ((value * 6) `div` 16)) Fold.drain

279+ <|> takeWhileFail (<= ((value * 7) `div` 16)) Fold.drain

280+ <|> takeWhileFail (<= ((value * 8) `div` 16)) Fold.drain

281+ <|> takeWhileFail (<= ((value * 9) `div` 16)) Fold.drain

282+ <|> takeWhileFail (<= ((value * 10) `div` 16)) Fold.drain

283+ <|> takeWhileFail (<= ((value * 11) `div` 16)) Fold.drain

284+ <|> takeWhileFail (<= ((value * 12) `div` 16)) Fold.drain

285+ <|> takeWhileFail (<= ((value * 13) `div` 16)) Fold.drain

286+ <|> takeWhileFail (<= ((value * 14) `div` 16)) Fold.drain

287+ <|> takeWhileFail (<= ((value * 15) `div` 16)) Fold.drain

288+ <|> takeWhile (<= value)

289+ )

290+

291+{-# INLINE manyAlt #-}

292+manyAlt :: MonadIO m => StreamK m PARSE_ELEM -> m Int

293+manyAlt xs = do

294+ x <- PARSE_OP (AP.many (satisfy (> 0))) xs

295+ return $ Prelude.length x

296+

297+{-# INLINE someAlt #-}

298+someAlt :: MonadIO m => StreamK m PARSE_ELEM -> m Int

299+someAlt xs = do

300+ x <- PARSE_OP (AP.some (satisfy (> 0))) xs

301+ return $ Prelude.length x

302+

303+{-# INLINE choice #-}

304+choice :: MonadIO m =>

305+ Int -> StreamK m PARSE_ELEM -> m (Either ParseError Int)

306+choice value =

307+ PARSE_OP (asum (replicate value (satisfy (< 0)))

308+ AP.<|> satisfy (> 0))

309+

310+{-# INLINE monad2 #-}

311+monad2 :: MonadIO m

312+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

313+monad2 value =

314+ PARSE_OP $ do

315+ takeWhile (<= (value `div` 2))

316+ takeWhile (<= value)

317+

318+{-# INLINE monad4 #-}

319+monad4 :: MonadIO m

320+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

321+monad4 value =

322+ PARSE_OP $ do

323+ takeWhile (<= ( value `div` 4))

324+ takeWhile (<= ((value * 2) `div` 4))

325+ takeWhile (<= ((value * 3) `div` 4))

326+ takeWhile (<= value)

327+

328+{-# INLINE monad8 #-}

329+monad8 :: MonadIO m

330+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

331+monad8 value =

332+ PARSE_OP $ do

333+ takeWhile (<= ( value `div` 8))

334+ takeWhile (<= ((value * 2) `div` 8))

335+ takeWhile (<= ((value * 3) `div` 8))

336+ takeWhile (<= ((value * 4) `div` 8))

337+ takeWhile (<= ((value * 5) `div` 8))

338+ takeWhile (<= ((value * 6) `div` 8))

339+ takeWhile (<= ((value * 7) `div` 8))

340+ takeWhile (<= value)

341+

342+{-# INLINE monad16 #-}

343+monad16 :: MonadIO m

344+ => Int -> StreamK m PARSE_ELEM -> m (Either ParseError ())

345+monad16 value =

346+ PARSE_OP $ do

347+ takeWhile (<= ( value `div` 16))

348+ takeWhile (<= ((value * 2) `div` 16))

349+ takeWhile (<= ((value * 3) `div` 16))

350+ takeWhile (<= ((value * 4) `div` 16))

351+ takeWhile (<= ((value * 5) `div` 16))

352+ takeWhile (<= ((value * 6) `div` 16))

353+ takeWhile (<= ((value * 7) `div` 16))

354+ takeWhile (<= ((value * 8) `div` 16))

355+ takeWhile (<= ((value * 9) `div` 16))

356+ takeWhile (<= ((value * 10) `div` 16))

357+ takeWhile (<= ((value * 11) `div` 16))

358+ takeWhile (<= ((value * 12) `div` 16))

359+ takeWhile (<= ((value * 13) `div` 16))

360+ takeWhile (<= ((value * 14) `div` 16))

361+ takeWhile (<= ((value * 15) `div` 16))

362+ takeWhile (<= value)

363+

364+-------------------------------------------------------------------------------

365+-- Benchmarks

366+-------------------------------------------------------------------------------

367+

368+moduleName :: String

369+moduleName = MODULE_NAME

370+

371+instance NFData ParseError where

372+ {-# INLINE rnf #-}

373+ rnf (ParseError x) = rnf x

374+

375+o_1_space_serial :: Int -> [Benchmark]

376+o_1_space_serial value =

377+ [ benchIOSink value "drain" (Stream.fold Fold.drain . StreamK.toStream)

378+ , benchIOSink value "takeWhile" $ takeWhileK value

379+ , benchIOSink value "splitAp2" $ splitAp2 value

380+ , benchIOSink value "splitAp8" $ splitAp8 value

381+ , benchIOSink value "alt2" $ alt2 value

382+ , benchIOSink value "alt8" $ alt8 value

383+ , benchIOSink value "alt16" $ alt16 value

384+ , benchIOSink value "monad2" $ monad2 value

385+ , benchIOSink value "monad4" $ monad4 value

386+ , benchIOSink value "monad8" $ monad8 value

387+ , benchIOSink value "monad16" $ monad16 value

388+ ]

389+

390+{-# INLINE sepBy1 #-}

391+sepBy1 :: MonadIO m => StreamK m PARSE_ELEM -> m Int

392+sepBy1 xs = do

393+ x <- PARSE_OP (parser (satisfy odd) (satisfy even)) xs

394+ return $ Prelude.length x

395+

396+ where

397+

398+ parser p sep = do

399+ x <- p

400+ fmap (x :) $ AP.many (sep >> p)

401+

402+-- O(n) heap beacuse of accumulation of the list in strict IO monad?

403+o_n_heap_serial :: Int -> [Benchmark]

404+o_n_heap_serial value =

405+ [

406+ -- accumulates the results in a list

407+ -- XXX why should this take O(n) heap, it discards the results?

408+ benchIOSink value "sequence_" $ sequence_ value

409+ , benchIOSink value "sequenceA_" $ sequenceA_ value

410+ , benchIOSink value "sequence" $ sequence value

411+ , benchIOSink value "sequenceA" $ sequenceA value

412+ , benchIOSink value "manyAlt" manyAlt

413+ , benchIOSink value "sepBy1" sepBy1

414+ , benchIOSink value "someAlt" someAlt

415+ , benchIOSink value "choice" $ choice value

416+ ]

417+

418+-- O(n) heap beacuse of accumulation of the list in strict IO monad?

419+o_1_space_recursive :: Int -> [Benchmark]

420+o_1_space_recursive value =

421+ [ benchIOSink value "one (recursive)" $ one value

422+ ]

423+

424+-------------------------------------------------------------------------------

425+-- Driver

426+-------------------------------------------------------------------------------

427+

428+main :: IO ()

429+main = runWithCLIOpts defaultStreamSize allBenchmarks

430+

431+ where

432+

433+ allBenchmarks value =

434+ [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)

435+ , bgroup (o_1_space_prefix moduleName) (o_1_space_recursive value)

436+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)

437+ ]

benchmark/Streamly/Benchmark/Data/Ring/Unboxed.hsnew file+69

@@ -0,0 +1,69 @@

1+-- |

2+-- Module : Streamly.Benchmark.Data.Ring.Unboxed

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

7+{-# LANGUAGE FlexibleContexts #-}

8+{-# LANGUAGE RankNTypes #-}

9+{-# LANGUAGE ScopedTypeVariables #-}

10+

11+module Main (main) where

12+

13+import Control.Monad (void)

14+import GHC.Ptr (Ptr(..))

15+import qualified Streamly.Internal.Data.Array as Array

16+import qualified Streamly.Internal.Data.Ring as Ring

17+import qualified Data.Foldable as P

18+

19+import Test.Tasty.Bench

20+import Streamly.Benchmark.Common

21+

22+import Prelude as P

23+

24+-------------------------------------------------------------------------------

25+-- Benchmark ops

26+-------------------------------------------------------------------------------

27+

28+unsafeEqArrayN :: (Int, Array.Array Int, (Ring.Ring Int, Ptr Int)) -> Bool

29+unsafeEqArrayN (value, arr, (ring, rh)) = Ring.unsafeEqArrayN ring rh arr value

30+

31+unsafeEqArray :: (Array.Array Int, (Ring.Ring Int, Ptr Int)) -> Bool

32+unsafeEqArray (arr, (ring, rh)) = Ring.unsafeEqArray ring rh arr

33+

34+-------------------------------------------------------------------------------

35+-- Benchmark groups

36+-------------------------------------------------------------------------------

37+

38+o_1_space_serial ::

39+ Int -> Array.Array Int -> (Ring.Ring Int, Ptr Int) -> [Benchmark]

40+o_1_space_serial value arr (ring, rh) =

41+ [ bench "unsafeEqArrayN" $ nf unsafeEqArrayN (value, arr, (ring, rh))

42+ , bench "unsafeEqArray" $ nf unsafeEqArray (arr, (ring, rh))

43+ ]

44+

45+-------------------------------------------------------------------------------

46+-- Main

47+-------------------------------------------------------------------------------

48+

49+moduleName :: String

50+moduleName = "Data.Ring.Unboxed"

51+

52+main :: IO ()

53+main = do

54+ runWithCLIOptsEnv defaultStreamSize alloc allBenchmarks

55+

56+ where

57+

58+ alloc value = do

59+ let input = [1 .. value] :: [Int]

60+ let arr = Array.fromList input

61+ (ring, rh) <- Ring.new value

62+ void $ P.foldlM (Ring.unsafeInsert ring) rh input

63+ return (arr, (ring, rh))

64+

65+ allBenchmarks (arr, (ring, rh)) value =

66+ [ bgroup

67+ (o_1_space_prefix moduleName)

68+ (o_1_space_serial value arr (ring, rh))

69+ ]

benchmark/Streamly/Benchmark/Data/Serialize.hsnew file+591

@@ -0,0 +1,591 @@

1+{-# LANGUAGE TemplateHaskell #-}

2+{- HLINT ignore -}

4+#undef FUSION_CHECK

5+#ifdef FUSION_CHECK

6+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}

7+#endif

9+-- |

10+-- Module : Streamly.Benchmark.Data.Serialize

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 #-}

3+module Streamly.Benchmark.Data.Serialize.RecCompatible

4+ ( RecCompatible(..)

5+ , valRecCompatible

6+ ) where

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 #-}

3+module Streamly.Benchmark.Data.Serialize.RecNonCompatible

4+ ( RecNonCompatible(..)

5+ , valRecNonCompatible

6+ ) where

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 #-}

3+module Streamly.Benchmark.Data.Serialize.TH (genLargeRecord) where

5+--------------------------------------------------------------------------------

6+-- Imports

7+--------------------------------------------------------------------------------

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.hsnew file+114

@@ -0,0 +1,114 @@

1+-- |

2+-- Module : Data.Stream

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

7+{-# LANGUAGE CPP #-}

8+{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE ScopedTypeVariables #-}

10+{-# LANGUAGE RankNTypes #-}

11+

12+#undef FUSION_CHECK

13+#ifdef FUSION_CHECK

14+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}

15+#endif

16+

17+module Main (main) where

18+

19+import Streamly.Benchmark.Common.Handle (mkHandleBenchEnv)

20+

21+import qualified Stream.Eliminate as Elimination

22+#ifndef USE_STREAMLY_CORE

23+import qualified Stream.Exceptions as Exceptions

24+#endif

25+import qualified Stream.Expand as NestedStream

26+import qualified Stream.Generate as Generation

27+import qualified Stream.Lift as Lift

28+import qualified Stream.Reduce as NestedFold

29+#ifdef USE_PRELUDE

30+import qualified Stream.Split as Split

31+#endif

32+import qualified Stream.Transform as Transformation

33+

34+import Streamly.Benchmark.Common

35+

36+#ifdef FUSION_CHECK

37+import Data.Function ((&))

38+import Streamly.Data.Stream (Stream)

39+import qualified Streamly.Internal.Data.Stream as Stream

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

41+import qualified Data.Foldable as Foldable

42+import Stream.Common

43+#endif

44+

45+moduleName :: String

46+#ifdef USE_STREAMK

47+moduleName = "Data.Stream.StreamDK"

48+#else

49+moduleName = "Data.Stream"

50+#endif

51+

52+-------------------------------------------------------------------------------

53+-- Main

54+-------------------------------------------------------------------------------

55+

56+-- In addition to gauge options, the number of elements in the stream can be

57+-- passed using the --stream-size option.

58+--

59+main :: IO ()

60+main = do

61+#ifndef FUSION_CHECK

62+ env <- mkHandleBenchEnv

63+ runWithCLIOpts defaultStreamSize (allBenchmarks env)

64+

65+ where

66+

67+ allBenchmarks env size = Prelude.concat

68+ [ Generation.benchmarks moduleName size

69+ , Elimination.benchmarks moduleName size

70+#ifndef USE_STREAMLY_CORE

71+ , Exceptions.benchmarks moduleName env size

72+#endif

73+#ifdef USE_PRELUDE

74+ , Split.benchmarks moduleName env

75+#endif

76+ , Transformation.benchmarks moduleName size

77+ , NestedFold.benchmarks moduleName size

78+ , Lift.benchmarks moduleName size

79+ , NestedStream.benchmarks moduleName size

80+ ]

81+#else

82+ -- Enable FUSION_CHECK macro at the beginning of the file

83+ -- Enable one benchmark below, and run the benchmark

84+ -- Check the .dump-simpl output

85+ let value = 100000

86+ let input = sourceUnfoldrM value 1

87+

88+ -- Stream.foldr (:) [] input >>= print . Prelude.length

89+ -- Stream.fold (Fold.foldr' (:) []) input >>= print . Prelude.length

90+

91+ -- Stream.toList input >>= print . Prelude.length

92+ -- Stream.fold Fold.toList input >>= print . Prelude.length

93+

94+ -- We can automatically assert that these generate identical core

95+

96+ -- Stream.drain input >>= print

97+ -- Stream.fold Fold.drain input >>= print

98+

99+ -- Stream.last input >>= print

100+ -- Stream.fold Fold.latest input >>= print

101+

102+ -- Stream.length input >>= print

103+ -- Stream.fold Fold.length input >>= print

104+

105+ -- Stream.maximum input >>= print

106+ -- Stream.fold Fold.maximum input >>= print

107+

108+ -- Stream.head input >>= print

109+ -- Stream.fold Fold.one input >>= print

110+

111+ -- composeN 4 (Stream.scanl' (+) 0) input

112+ composeN 4 (Stream.scan (Fold.foldl' (+) 0)) input

113+ return ()

114+#endif

benchmark/Streamly/Benchmark/Data/Stream/Common.hsnew file+518

@@ -0,0 +1,518 @@

1+{-# LANGUAGE ConstraintKinds #-}

2+{-# LANGUAGE CPP #-}

3+{-# LANGUAGE FlexibleContexts #-}

4+{-# LANGUAGE ScopedTypeVariables #-}

6+-- |

7+-- Module : Stream.Common

9+-- License : BSD-3-Clause

10+-- Maintainer : streamly@composewell.com

11+

12+#ifdef USE_PRELUDE

13+{-# OPTIONS_GHC -Wno-deprecations #-}

14+#endif

15+

16+module Stream.Common

17+ ( MonadAsync

18+

19+ , fromStream

20+ , toStream

21+

22+ -- Generation

23+ , fromListM

24+ , fromFoldableM

25+

26+ , append

27+ , append2

28+

29+ -- Elimination

30+ , drain

31+ , foldl'

32+ , scanl'

33+

34+ -- Benchmark stream generation

35+ , sourceUnfoldr

36+ , sourceUnfoldrM

37+ , sourceUnfoldrAction

38+ , sourceConcatMapId

39+ , sourceFromFoldable

40+

41+ -- Benchmark stream elimination

42+ , benchIOSink

43+ , benchIOSrc

44+ , benchIO

45+

46+ -- Benchmarking functions

47+#ifdef USE_STREAMK

48+ , concatStreamsWith

49+ , mergeMapWith

50+#endif

51+ , apDiscardFst

52+ , apDiscardSnd

53+ , apLiftA2

54+ , toNullAp

55+ , monadThen

56+ , toNullM

57+ , toNullM3

58+ , filterAllOutM

59+ , filterAllInM

60+ , filterSome

61+ , breakAfterSome

62+ , toListM

63+ , toListSome

64+ , composeN

65+ , mapN

66+ , mapM

67+ , transformMapM

68+ , transformComposeMapM

69+ , transformTeeMapM

70+ , transformZipMapM

71+ )

72+where

73+

74+#if !MIN_VERSION_base(4,18,0)

75+import Control.Applicative (liftA2)

76+#endif

77+import Control.DeepSeq (NFData)

78+import Control.Exception (try)

79+import GHC.Exception (ErrorCall)

80+import System.Random (randomRIO)

81+

82+import qualified Streamly.Internal.Data.Fold as Fold

83+import qualified Streamly.Internal.Data.Pipe as Pipe

84+

85+#ifdef USE_PRELUDE

86+import Streamly.Prelude (foldl', scanl')

87+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

88+import qualified Streamly.Prelude as Stream

89+import qualified Streamly.Prelude as StreamK

90+import Streamly.Benchmark.Prelude

91+ ( composeN, sourceConcatMapId, benchIOSink

92+ , concatStreamsWith

93+ )

94+#else

95+import Streamly.Internal.Data.Stream (Stream)

96+import qualified Streamly.Internal.Data.Stream as D

97+#ifdef USE_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

101+#else

102+import qualified Streamly.Internal.Data.Stream as Stream

103+import qualified Streamly.Internal.Data.Stream as StreamK

104+#endif

105+#endif

106+

107+import Test.Tasty.Bench

108+import Prelude hiding (Foldable(..), mapM, replicate)

109+

110+#ifdef USE_STREAMK

111+toStream :: Applicative m => StreamK m a -> Stream m a

112+toStream = StreamK.toStream

113+

114+fromStream :: Monad m => Stream m a -> StreamK m a

115+fromStream = StreamK.fromStream

116+#else

117+fromStream :: a -> a

118+fromStream = id

119+

120+toStream :: a -> a

121+toStream = id

122+#endif

123+

124+#ifdef USE_PRELUDE

125+type Stream = Stream.SerialT

126+type MonadAsync m = Stream.MonadAsync m

127+mkCross = id

128+unCross = id

129+#else

130+type MonadAsync = Monad

131+

132+#ifdef USE_STREAMK

133+mkCross :: StreamK m a -> StreamK.CrossStreamK m a

134+mkCross = StreamK.mkCross

135+

136+unCross :: StreamK.CrossStreamK m a -> StreamK m a

137+unCross = StreamK.unCross

138+#else

139+mkCross :: Stream m a -> Stream.CrossStream m a

140+mkCross = Stream.mkCross

141+

142+unCross :: Stream.CrossStream m a -> Stream m a

143+unCross = Stream.unCross

144+#endif

145+#endif

146+

147+#ifdef USE_PRELUDE

148+{-# INLINE append #-}

149+append :: Monad m => Stream m a -> Stream m a -> Stream m a

150+append = Stream.serial

151+#else

152+#ifdef USE_STREAMK

153+append :: StreamK m a -> StreamK m a -> StreamK m a

154+append = StreamK.append

155+#else

156+append :: Monad m => Stream m a -> Stream m a -> Stream m a

157+append = Stream.append

158+#endif

159+#endif

160+

161+{-# INLINE append2 #-}

162+append2 :: Monad m => Stream m a -> Stream m a -> Stream m a

163+#ifdef USE_PRELUDE

164+append2 = Stream.append

165+#else

166+append2 = D.append

167+#endif

168+

169+{-# INLINE drain #-}

170+drain :: Monad m => Stream m a -> m ()

171+{-# INLINE toList #-}

172+toList :: Monad m => Stream m a -> m [a]

173+#ifdef USE_PRELUDE

174+drain = Stream.drain

175+toList = Stream.toList

176+#else

177+drain = Stream.fold Fold.drain

178+toList = Stream.fold Fold.toList

179+#endif

180+

181+{-# INLINE fromListM #-}

182+fromListM :: MonadAsync m => [m a] -> Stream m a

183+#ifdef USE_PRELUDE

184+fromListM = Stream.fromListM

185+#else

186+fromListM = Stream.sequence . Stream.fromList

187+#endif

188+

189+{-# INLINE fromFoldableM #-}

190+fromFoldableM :: MonadAsync m => [m a] -> Stream m a

191+#ifdef USE_PRELUDE

192+fromFoldableM = Stream.fromFoldableM

193+#else

194+fromFoldableM = Stream.sequence . toStream . StreamK.fromFoldable

195+#endif

196+

197+{-# INLINE sourceUnfoldrM #-}

198+sourceUnfoldrM :: MonadAsync m => Int -> Int -> Stream m Int

199+sourceUnfoldrM count start = Stream.unfoldrM step start

200+

201+ where

202+

203+ step cnt =

204+ if cnt > start + count

205+ then return Nothing

206+ else return (Just (cnt, cnt + 1))

207+

208+{-# INLINE sourceUnfoldr #-}

209+sourceUnfoldr :: Monad m => Int -> Int -> Stream m Int

210+sourceUnfoldr count start = Stream.unfoldr step start

211+

212+ where

213+

214+ step cnt =

215+ if cnt > start + count

216+ then Nothing

217+ else Just (cnt, cnt + 1)

218+

219+{-# INLINE sourceUnfoldrAction #-}

220+sourceUnfoldrAction :: (Monad m1, Monad m) => Int -> Int -> Stream m (m1 Int)

221+sourceUnfoldrAction value n = Stream.unfoldr step n

222+

223+ where

224+

225+ step cnt =

226+ if cnt > n + value

227+ then Nothing

228+ else Just (return cnt, cnt + 1)

229+

230+{-# INLINE sourceFromFoldable #-}

231+sourceFromFoldable :: Monad m => Int -> Int -> Stream m Int

232+sourceFromFoldable value n = toStream $ StreamK.fromFoldable [n..n+value]

233+

234+#ifndef USE_PRELUDE

235+{-# INLINE benchIOSink #-}

236+benchIOSink

237+ :: (NFData b)

238+ => Int -> String -> (Stream IO Int -> IO b) -> Benchmark

239+benchIOSink value name f =

240+ bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value

241+#endif

242+

243+-- | Takes a source, and uses it with a default drain/fold method.

244+{-# INLINE benchIOSrc #-}

245+benchIOSrc

246+ :: String

247+ -> (Int -> Stream IO a)

248+ -> Benchmark

249+benchIOSrc name f =

250+ bench name $ nfIO $ randomRIO (1,1) >>= drain . f

251+

252+{-# NOINLINE benchIO #-}

253+benchIO :: (NFData b) => String -> (Int -> IO b) -> Benchmark

254+benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f

255+

256+#ifndef USE_PRELUDE

257+#ifdef USE_STREAMK

258+{-# INLINE concatStreamsWith #-}

259+concatStreamsWith

260+ :: (StreamK IO Int -> StreamK IO Int -> StreamK IO Int)

261+ -> Int

262+ -> Int

263+ -> Int

264+ -> IO ()

265+concatStreamsWith op outer inner n =

266+ drain $ toStream $ StreamK.concatMapWith op

267+ (fromStream . sourceUnfoldrM inner)

268+ (fromStream $ sourceUnfoldrM outer n)

269+

270+{-# INLINE mergeMapWith #-}

271+mergeMapWith

272+ :: (StreamK IO Int -> StreamK IO Int -> StreamK IO Int)

273+ -> Int

274+ -> Int

275+ -> Int

276+ -> IO ()

277+mergeMapWith op outer inner n =

278+ drain $ toStream $ StreamK.mergeMapWith op

279+ (fromStream . sourceUnfoldrM inner)

280+ (fromStream $ sourceUnfoldrM outer n)

281+#endif

282+

283+{-# INLINE sourceConcatMapId #-}

284+sourceConcatMapId :: (Monad m)

285+ => Int -> Int -> Stream m (Stream m Int)

286+sourceConcatMapId value n =

287+ Stream.fromList $ fmap (D.fromEffect . return) [n..n+value]

288+#endif

289+

290+{-# INLINE apDiscardFst #-}

291+apDiscardFst :: MonadAsync m =>

292+ Int -> Int -> m ()

293+apDiscardFst linearCount start = drain $ toStream $ unCross $

294+ mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

295+ *> mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

296+

297+ where

298+

299+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

300+

301+{-# INLINE apDiscardSnd #-}

302+apDiscardSnd :: MonadAsync m => Int -> Int -> m ()

303+apDiscardSnd linearCount start = drain $ toStream $ unCross $

304+ mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

305+ <* mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

306+

307+ where

308+

309+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

310+

311+{-# INLINE apLiftA2 #-}

312+apLiftA2 :: MonadAsync m => Int -> Int -> m ()

313+apLiftA2 linearCount start = drain $ toStream $ unCross $

314+ liftA2 (+) (mkCross (fromStream $ sourceUnfoldrM nestedCount2 start))

315+ (mkCross (fromStream $ sourceUnfoldrM nestedCount2 start))

316+

317+ where

318+

319+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

320+

321+{-# INLINE toNullAp #-}

322+toNullAp :: MonadAsync m => Int -> Int -> m ()

323+toNullAp linearCount start = drain $ toStream $ unCross $

324+ (+) <$> mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

325+ <*> mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

326+

327+ where

328+

329+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

330+

331+{-# INLINE monadThen #-}

332+monadThen :: MonadAsync m => Int -> Int -> m ()

333+monadThen linearCount start = drain $ toStream $ unCross $ do

334+ mkCross (fromStream $ sourceUnfoldrM nestedCount2 start) >>

335+ mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

336+

337+ where

338+

339+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

340+

341+{-# INLINE toNullM #-}

342+toNullM :: MonadAsync m => Int -> Int -> m ()

343+toNullM linearCount start = drain $ toStream $ unCross $ do

344+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

345+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

346+ return $ x + y

347+

348+ where

349+

350+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

351+

352+{-# INLINE toNullM3 #-}

353+toNullM3 :: MonadAsync m => Int -> Int -> m ()

354+toNullM3 linearCount start = drain $ toStream $ unCross $ do

355+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount3 start)

356+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount3 start)

357+ z <- mkCross (fromStream $ sourceUnfoldrM nestedCount3 start)

358+ return $ x + y + z

359+ where

360+ nestedCount3 = round (fromIntegral linearCount**(1/3::Double))

361+

362+{-# INLINE filterAllOutM #-}

363+filterAllOutM :: MonadAsync m => Int -> Int -> m ()

364+filterAllOutM linearCount start = drain $ toStream $ unCross $ do

365+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

366+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

367+ let s = x + y

368+ if s < 0

369+ then return s

370+ else mkCross StreamK.nil

371+ where

372+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

373+

374+{-# INLINE filterAllInM #-}

375+filterAllInM :: MonadAsync m => Int -> Int -> m ()

376+filterAllInM linearCount start = drain $ toStream $ unCross $ do

377+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

378+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

379+ let s = x + y

380+ if s > 0

381+ then return s

382+ else mkCross StreamK.nil

383+ where

384+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

385+

386+{-# INLINE filterSome #-}

387+filterSome :: MonadAsync m => Int -> Int -> m ()

388+filterSome linearCount start = drain $ toStream $ unCross $ do

389+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

390+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

391+ let s = x + y

392+ if s > 1100000

393+ then return s

394+ else mkCross StreamK.nil

395+ where

396+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

397+

398+{-# INLINE breakAfterSome #-}

399+breakAfterSome :: Int -> Int -> IO ()

400+breakAfterSome linearCount start = do

401+ (_ :: Either ErrorCall ()) <- try $ drain $ toStream $ unCross $ do

402+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

403+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

404+ let s = x + y

405+ if s > 1100000

406+ then error "break"

407+ else return s

408+ return ()

409+ where

410+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

411+

412+{-# INLINE toListM #-}

413+toListM :: MonadAsync m => Int -> Int -> m [Int]

414+toListM linearCount start = toList $ toStream $ unCross $ do

415+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

416+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

417+ return $ x + y

418+ where

419+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

420+

421+-- Taking a specified number of elements is very expensive in logict so we have

422+-- a test to measure the same.

423+{-# INLINE toListSome #-}

424+toListSome :: MonadAsync m => Int -> Int -> m [Int]

425+toListSome linearCount start =

426+ toList $ Stream.take 10000 $ toStream $ unCross $ do

427+ x <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

428+ y <- mkCross (fromStream $ sourceUnfoldrM nestedCount2 start)

429+ return $ x + y

430+ where

431+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

432+

433+#ifndef USE_PRELUDE

434+{-# INLINE composeN #-}

435+composeN ::

436+ (Monad m)

437+ => Int

438+ -> (Stream m Int -> Stream m Int)

439+ -> Stream m Int

440+ -> m ()

441+composeN n f =

442+ case n of

443+ 1 -> drain . f

444+ 2 -> drain . f . f

445+ 3 -> drain . f . f . f

446+ 4 -> drain . f . f . f . f

447+ _ -> undefined

448+#endif

449+

450+{-# INLINE mapN #-}

451+mapN ::

452+ Monad m

453+ => Int

454+ -> Stream m Int

455+ -> m ()

456+mapN n = composeN n $ fmap (+ 1)

457+

458+{-# INLINE mapM #-}

459+mapM ::

460+ MonadAsync m

461+ => Int

462+ -> Stream m Int

463+ -> m ()

464+mapM n = composeN n $ Stream.mapM return

465+

466+#ifndef USE_PRELUDE

467+foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b

468+foldl' f z = Stream.fold (Fold.foldl' f z)

469+

470+scanl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b

471+scanl' f z = Stream.scan (Fold.foldl' f z)

472+#endif

473+

474+{-# INLINE transformMapM #-}

475+transformMapM ::

476+ (Monad m)

477+ => Int

478+ -> Stream m Int

479+ -> m ()

480+transformMapM n = composeN n $ Stream.transform (Pipe.mapM return)

481+

482+{-# INLINE transformComposeMapM #-}

483+transformComposeMapM ::

484+ (Monad m)

485+ => Int

486+ -> Stream m Int

487+ -> m ()

488+transformComposeMapM n =

489+ composeN n $

490+ Stream.transform

491+ (Pipe.mapM (\x -> return (x + 1)) `Pipe.compose`

492+ Pipe.mapM (\x -> return (x + 2)))

493+

494+{-# INLINE transformTeeMapM #-}

495+transformTeeMapM ::

496+ (Monad m)

497+ => Int

498+ -> Stream m Int

499+ -> m ()

500+transformTeeMapM n =

501+ composeN n $

502+ Stream.transform

503+ (Pipe.mapM (\x -> return (x + 1)) `Pipe.tee`

504+ Pipe.mapM (\x -> return (x + 2)))

505+

506+{-# INLINE transformZipMapM #-}

507+transformZipMapM ::

508+ (Monad m)

509+ => Int

510+ -> Stream m Int

511+ -> m ()

512+transformZipMapM n =

513+ composeN n $

514+ Stream.transform

515+ (Pipe.zipWith

516+ (+)

517+ (Pipe.mapM (\x -> return (x + 1)))

518+ (Pipe.mapM (\x -> return (x + 2))))

benchmark/Streamly/Benchmark/Data/Stream/Concurrent.hsnew file+20

@@ -0,0 +1,20 @@

1+{-# LANGUAGE FlexibleContexts #-}

2+-- |

3+-- Module : Main

5+--

6+-- License : BSD3

7+-- Maintainer : streamly@composewell.com

9+import Stream.ConcurrentCommon (allBenchmarks)

10+import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)

11+

12+moduleName :: String

13+moduleName = "Data.Stream.Concurrent"

14+

15+-------------------------------------------------------------------------------

16+-- Main

17+-------------------------------------------------------------------------------

18+

19+main :: IO ()

20+main = runWithCLIOpts defaultStreamSize (allBenchmarks moduleName False id)

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentCommon.hsnew file+208

@@ -0,0 +1,208 @@

1+{-# LANGUAGE FlexibleContexts #-}

2+-- |

3+-- Module : Main

5+--

6+-- License : BSD3

7+-- Maintainer : streamly@composewell.com

9+module Stream.ConcurrentCommon

10+ ( allBenchmarks

11+ )

12+where

13+

14+import Stream.Common

15+ (composeN, benchIO, benchIOSink, benchIOSrc, sourceUnfoldrM)

16+import Streamly.Data.Stream (Stream)

17+import Streamly.Internal.Data.Stream.Prelude (MonadAsync, Config)

18+

19+import qualified Data.List as List

20+import qualified Streamly.Data.Fold as Fold

21+import qualified Streamly.Data.Stream as Stream

22+import qualified Streamly.Internal.Data.Stream.Prelude as Async

23+

24+import Test.Tasty.Bench

25+import Prelude hiding (mapM)

26+import Streamly.Benchmark.Common

27+

28+-- XXX Write inspection tests to make sure no dictionaries are being passed

29+-- around to find specialization issues. Could be really bad for perf.

30+

31+-------------------------------------------------------------------------------

32+-- Mapping

33+-------------------------------------------------------------------------------

34+

35+{-# INLINE mapM #-}

36+mapM ::

37+ MonadAsync m

38+ => (Config -> Config)

39+ -> Int

40+ -> Stream m Int

41+ -> m ()

42+mapM f n = composeN n $ Async.parMapM f return

43+

44+o_1_space_mapping :: Int -> (Config -> Config) -> [Benchmark]

45+o_1_space_mapping value f =

46+ [ bgroup "mapping"

47+ [ benchIOSink value "mapM" $ mapM f 1

48+ ]

49+ ]

50+

51+-------------------------------------------------------------------------------

52+-- Size conserving transformations (reordering, buffering, etc.)

53+-------------------------------------------------------------------------------

54+

55+o_n_heap_buffering :: Int -> (Config -> Config) -> [Benchmark]

56+o_n_heap_buffering value f =

57+ [ bgroup "buffered"

58+ [ benchIOSink value "mkAsync"

59+ (Stream.fold Fold.drain . Async.parEval f)

60+ ]

61+ ]

62+

63+-------------------------------------------------------------------------------

64+-- Joining

65+-------------------------------------------------------------------------------

66+

67+{-# INLINE async2 #-}

68+async2 :: (Config -> Config) -> Int -> Int -> IO ()

69+async2 f count n =

70+ Stream.fold Fold.drain

71+ $ Async.parTwo f

72+ (sourceUnfoldrM count n) (sourceUnfoldrM count (n + 1))

73+

74+{-# INLINE concatAsync2 #-}

75+concatAsync2 :: (Config -> Config) -> Int -> Int -> IO ()

76+concatAsync2 f count n =

77+ Stream.fold Fold.drain

78+ $ Async.parConcat f

79+ $ Stream.fromList

80+ [sourceUnfoldrM count n, sourceUnfoldrM count (n + 1)]

81+

82+o_1_space_joining :: Int -> (Config -> Config) -> [Benchmark]

83+o_1_space_joining value f =

84+ [ bgroup "joining"

85+ [ benchIOSrc1 "async (2 of n/2)" (async2 f (value `div` 2))

86+ , benchIOSrc1 "concat async (2 of n/2)" (concatAsync2 f (value `div` 2))

87+ ]

88+ ]

89+

90+-------------------------------------------------------------------------------

91+-- Concat

92+-------------------------------------------------------------------------------

93+

94+{-# INLINE sourceFoldMapWith #-}

95+sourceFoldMapWith :: (Config -> Config) -> Int -> Int -> Stream IO Int

96+sourceFoldMapWith f value n =

97+ Async.parConcatMap f Stream.fromPure $ Stream.fromList [n..n+value]

98+

99+{-# INLINE sourceFoldMapWithStream #-}

100+sourceFoldMapWithStream :: (Config -> Config) -> Int -> Int -> Stream IO Int

101+sourceFoldMapWithStream f value n =

102+ Async.parConcatMap f Stream.fromPure

103+ $ Stream.enumerateFromTo n (n + value)

104+

105+{-# INLINE concatFoldableWith #-}

106+concatFoldableWith :: (Config -> Config) -> Int -> Int -> Stream IO Int

107+concatFoldableWith f value n =

108+ let step x =

109+ if x <= n + value

110+ then Just (Stream.fromPure x, x + 1)

111+ else Nothing

112+ list = List.unfoldr step n

113+ in Async.parConcat f (Stream.fromList list)

114+

115+o_1_space_concatFoldable :: Int -> (Config -> Config) -> [Benchmark]

116+o_1_space_concatFoldable value f =

117+ [ bgroup "concat-foldable"

118+ [ benchIOSrc "foldMapWith (<>) (List)"

119+ (sourceFoldMapWith f value)

120+ , benchIOSrc "foldMapWith (<>) (Stream)"

121+ (sourceFoldMapWithStream f value)

122+ , benchIOSrc "S.concatFoldableWith (<>) (List)"

123+ (concatFoldableWith f value)

124+ ]

125+ ]

126+

127+{-# INLINE concatMapStreamsWith #-}

128+concatMapStreamsWith

129+ :: (Config -> Config)

130+ -> Int

131+ -> Int

132+ -> Int

133+ -> IO ()

134+concatMapStreamsWith f outer inner n =

135+ Stream.fold Fold.drain

136+ $ Async.parConcatMap f (sourceUnfoldrM inner) (sourceUnfoldrM outer n)

137+

138+{-# INLINE concatFmapStreamsWith #-}

139+concatFmapStreamsWith

140+ :: (Config -> Config)

141+ -> Int

142+ -> Int

143+ -> Int

144+ -> IO ()

145+concatFmapStreamsWith f outer inner n =

146+ Stream.fold Fold.drain

147+ $ Async.parConcat f

148+ $ fmap (sourceUnfoldrM inner) (sourceUnfoldrM outer n)

149+

150+o_1_space_concatMap :: Int -> (Config -> Config) -> [Benchmark]

151+o_1_space_concatMap value f =

152+ value2 `seq`

153+ [ bgroup "concat"

154+ [ benchIO "parConcatMap (n of 1)"

155+ (concatMapStreamsWith f value 1)

156+ , benchIO "parConcatMap (sqrt x of sqrt x)"

157+ (concatMapStreamsWith f value2 value2)

158+ , benchIO "parConcatMap (1 of n)"

159+ (concatMapStreamsWith f 1 value)

160+ , benchIO "concat . fmap (n of 1)"

161+ (concatFmapStreamsWith f value 1)

162+ ]

163+ ]

164+

165+ where

166+

167+ value2 = round $ sqrt (fromIntegral value :: Double)

168+

169+-------------------------------------------------------------------------------

170+-- Monadic outer product

171+-------------------------------------------------------------------------------

172+

173+{-# INLINE toNullAp #-}

174+toNullAp :: (Config -> Config) -> Int -> Int -> IO ()

175+toNullAp f linearCount start =

176+ Stream.fold Fold.drain

177+ $ Async.parApply f

178+ (fmap (+) (sourceUnfoldrM nestedCount2 start))

179+ (sourceUnfoldrM nestedCount2 start)

180+

181+ where

182+

183+ nestedCount2 = round (fromIntegral linearCount**(1/2::Double))

184+

185+o_1_space_outerProduct :: Int -> (Config -> Config) -> [Benchmark]

186+o_1_space_outerProduct value f =

187+ [ bgroup "monad-outer-product"

188+ [ benchIO "toNullAp" $ toNullAp f value

189+ ]

190+ ]

191+

192+-------------------------------------------------------------------------------

193+-- Benchmark sets

194+-------------------------------------------------------------------------------

195+

196+allBenchmarks :: String -> Bool -> (Config -> Config) -> Int -> [Benchmark]

197+allBenchmarks moduleName wide modifier value =

198+ [ bgroup (o_1_space_prefix moduleName) $ concat

199+ [ o_1_space_mapping value modifier

200+ , o_1_space_concatFoldable value modifier

201+ , o_1_space_concatMap value modifier

202+ , o_1_space_joining value modifier

203+ ] ++ if wide then [] else o_1_space_outerProduct value modifier

204+ , bgroup (o_n_heap_prefix moduleName) $ concat

205+ [ if wide then o_1_space_outerProduct value modifier else []

206+ , o_n_heap_buffering value modifier

207+ ]

208+ ]

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentEager.hsnew file+25

@@ -0,0 +1,25 @@

1+{-# LANGUAGE FlexibleContexts #-}

2+-- |

3+-- Module : Main

5+--

6+-- License : BSD3

7+-- Maintainer : streamly@composewell.com

9+import Stream.ConcurrentCommon (allBenchmarks)

10+import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)

11+

12+import qualified Streamly.Internal.Data.Stream.Prelude as Async

13+

14+moduleName :: String

15+moduleName = "Data.Stream.ConcurrentEager"

16+

17+-------------------------------------------------------------------------------

18+-- Main

19+-------------------------------------------------------------------------------

20+

21+main :: IO ()

22+main =

23+ runWithCLIOpts

24+ defaultStreamSize

25+ (allBenchmarks moduleName True (Async.eager True))

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentInterleaved.hsnew file+25

@@ -0,0 +1,25 @@

1+{-# LANGUAGE FlexibleContexts #-}

2+-- |

3+-- Module : Main

5+--

6+-- License : BSD3

7+-- Maintainer : streamly@composewell.com

9+import Stream.ConcurrentCommon (allBenchmarks)

10+import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)

11+

12+import qualified Streamly.Internal.Data.Stream.Prelude as Async

13+

14+moduleName :: String

15+moduleName = "Data.Stream.ConcurrentInterleaved"

16+

17+-------------------------------------------------------------------------------

18+-- Main

19+-------------------------------------------------------------------------------

20+

21+main :: IO ()

22+main =

23+ runWithCLIOpts

24+ defaultStreamSize

25+ (allBenchmarks moduleName True (Async.interleaved True))

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentOrdered.hsnew file+25

@@ -0,0 +1,25 @@

1+{-# LANGUAGE FlexibleContexts #-}

2+-- |

3+-- Module : Main

5+--

6+-- License : BSD3

7+-- Maintainer : streamly@composewell.com

9+import Stream.ConcurrentCommon (allBenchmarks)

10+import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)

11+

12+import qualified Streamly.Internal.Data.Stream.Prelude as Async

13+

14+moduleName :: String

15+moduleName = "Data.Stream.ConcurrentOrdered"

16+

17+-------------------------------------------------------------------------------

18+-- Main

19+-------------------------------------------------------------------------------

20+

21+main :: IO ()

22+main =

23+ runWithCLIOpts

24+ defaultStreamSize

25+ (allBenchmarks moduleName False (Async.ordered True))

benchmark/Streamly/Benchmark/Prelude/Serial/Elimination.hs → benchmark/Streamly/Benchmark/Data/Stream/Eliminate.hsrenamed+187−122

@@ -1,14 +1,20 @@

11-- |

2−-- Module : Serial.Elimination

2+-- Module : Stream.Eliminate

44-- License : BSD-3-Clause

55-- Maintainer : streamly@composewell.com

77{-# LANGUAGE CPP #-}

88{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE FlexibleInstances #-}

910{-# LANGUAGE ScopedTypeVariables #-}

1011{-# LANGUAGE RankNTypes #-}

1112

13+{-# OPTIONS_GHC -Wno-orphans #-}

14+#ifdef USE_PRELUDE

15+{-# OPTIONS_GHC -Wno-deprecations #-}

16+#endif

17+

1218#ifdef __HADDOCK_VERSION__

1319#undef INSPECTION

1420#endif

@@ -18,7 +24,7 @@

1824{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1925#endif

2026

21−module Serial.Elimination (benchmarks) where

27+module Stream.Eliminate (benchmarks) where

2228

2329import Control.DeepSeq (NFData(..))

2430import Data.Functor.Identity (Identity, runIdentity)

@@ -26,28 +32,45 @@ import System.Random (randomRIO)

2632

2733import qualified Data.Foldable as F

2834import qualified GHC.Exts as GHC

35+import qualified Streamly.Internal.Data.Fold as Fold

2936

3037#ifdef INSPECTION

3138import GHC.Types (SPEC(..))

3239import Test.Inspection

33−

34−import qualified Streamly.Internal.Data.Stream.StreamD as D

40+import qualified Streamly.Internal.Data.Stream as D

3541#endif

3642

37−import qualified Streamly.Prelude as S

38−import qualified Streamly.Internal.Data.Stream.IsStream as Internal

43+#ifdef USE_PRELUDE

44+import Streamly.Prelude (fromSerial)

45+import Streamly.Benchmark.Prelude

46+import qualified Streamly.Internal.Data.Stream.IsStream as S

47+import qualified Streamly.Internal.Data.Stream.IsStream as StreamK

48+#else

49+import Stream.Common

50+import Streamly.Internal.Data.Stream (Stream)

51+import qualified Streamly.Internal.Data.Stream as S

52+#ifdef USE_STREAMK

53+import Streamly.Internal.Data.StreamK (StreamK)

54+import qualified Streamly.Data.StreamK as StreamK

55+#else

56+import qualified Streamly.Internal.Data.Stream as StreamK

57+#endif

58+#endif

3959

40−import Gauge

41−import Streamly.Prelude (SerialT, IsStream, fromSerial)

60+import Test.Tasty.Bench

4261import Streamly.Benchmark.Common

43−import Streamly.Benchmark.Prelude

4462import Prelude hiding (length, sum, or, and, any, all, notElem, elem, (!!),

4563 lookup, repeat, minimum, maximum, product, last, mapM_, init)

4664import qualified Prelude

4765

66+#ifdef USE_PRELUDE

67+type Stream = S.SerialT

68+fromStream = id

69+

4870{-# INLINE repeat #-}

4971repeat :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

5072repeat count = S.take count . S.repeat

73+#endif

5174

5275-------------------------------------------------------------------------------

5376-- Elimination

@@ -60,90 +83,92 @@ repeat count = S.take count . S.repeat

6083{-# INLINE foldableFoldl' #-}

6184foldableFoldl' :: Int -> Int -> Int

6285foldableFoldl' value n =

63− F.foldl' (+) 0 (sourceUnfoldr value n :: S.SerialT Identity Int)

86+ F.foldl' (+) 0 (sourceUnfoldr value n :: Stream Identity Int)

6487

6588{-# INLINE foldableFoldrElem #-}

6689foldableFoldrElem :: Int -> Int -> Bool

6790foldableFoldrElem value n =

6891 F.foldr (\x xs -> x == value || xs)

6992 False

70− (sourceUnfoldr value n :: S.SerialT Identity Int)

93+ (sourceUnfoldr value n :: Stream Identity Int)

7194

7295{-# INLINE foldableSum #-}

7396foldableSum :: Int -> Int -> Int

7497foldableSum value n =

75− Prelude.sum (sourceUnfoldr value n :: S.SerialT Identity Int)

98+ Prelude.sum (sourceUnfoldr value n :: Stream Identity Int)

7699

77100{-# INLINE foldableProduct #-}

78101foldableProduct :: Int -> Int -> Int

79102foldableProduct value n =

80− Prelude.product (sourceUnfoldr value n :: S.SerialT Identity Int)

103+ Prelude.product (sourceUnfoldr value n :: Stream Identity Int)

81104

82105{-# INLINE _foldableNull #-}

83106_foldableNull :: Int -> Int -> Bool

84107_foldableNull value n =

85− Prelude.null (sourceUnfoldr value n :: S.SerialT Identity Int)

108+ Prelude.null (sourceUnfoldr value n :: Stream Identity Int)

86109

87110{-# INLINE foldableElem #-}

88111foldableElem :: Int -> Int -> Bool

89112foldableElem value n =

90− value `Prelude.elem` (sourceUnfoldr value n :: S.SerialT Identity Int)

113+ value `Prelude.elem` (sourceUnfoldr value n :: Stream Identity Int)

91114

92115{-# INLINE foldableNotElem #-}

93116foldableNotElem :: Int -> Int -> Bool

94117foldableNotElem value n =

95− value `Prelude.notElem` (sourceUnfoldr value n :: S.SerialT Identity Int)

118+ value `Prelude.notElem` (sourceUnfoldr value n :: Stream Identity Int)

96119

97120{-# INLINE foldableFind #-}

98121foldableFind :: Int -> Int -> Maybe Int

99122foldableFind value n =

100− F.find (== (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)

123+ F.find (== (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

101124

102125{-# INLINE foldableAll #-}

103126foldableAll :: Int -> Int -> Bool

104127foldableAll value n =

105− Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)

128+ Prelude.all (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

106129

107130{-# INLINE foldableAny #-}

108131foldableAny :: Int -> Int -> Bool

109132foldableAny value n =

110− Prelude.any (> (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)

133+ Prelude.any (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

111134

135+{- HLINT ignore "Use all"-}

112136{-# INLINE foldableAnd #-}

113137foldableAnd :: Int -> Int -> Bool

114138foldableAnd value n =

115− Prelude.and $ S.map

116− (<= (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)

139+ Prelude.and $ fmap

140+ (<= (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

117141

142+{- HLINT ignore "Use any"-}

118143{-# INLINE foldableOr #-}

119144foldableOr :: Int -> Int -> Bool

120145foldableOr value n =

121− Prelude.or $ S.map

122− (> (value + 1)) (sourceUnfoldr value n :: S.SerialT Identity Int)

146+ Prelude.or $ fmap

147+ (> (value + 1)) (sourceUnfoldr value n :: Stream Identity Int)

123148

124149{-# INLINE foldableLength #-}

125150foldableLength :: Int -> Int -> Int

126151foldableLength value n =

127− Prelude.length (sourceUnfoldr value n :: S.SerialT Identity Int)

152+ Prelude.length (sourceUnfoldr value n :: Stream Identity Int)

128153

129154{-# INLINE foldableMin #-}

130155foldableMin :: Int -> Int -> Int

131156foldableMin value n =

132− Prelude.minimum (sourceUnfoldr value n :: S.SerialT Identity Int)

157+ Prelude.minimum (sourceUnfoldr value n :: Stream Identity Int)

133158

134159{-# INLINE ordInstanceMin #-}

135−ordInstanceMin :: SerialT Identity Int -> SerialT Identity Int

160+ordInstanceMin :: Stream Identity Int -> Stream Identity Int

136161ordInstanceMin src = min src src

137162

138163{-# INLINE foldableMax #-}

139164foldableMax :: Int -> Int -> Int

140165foldableMax value n =

141− Prelude.maximum (sourceUnfoldr value n :: S.SerialT Identity Int)

166+ Prelude.maximum (sourceUnfoldr value n :: Stream Identity Int)

142167

143168{-# INLINE foldableMinBy #-}

144169foldableMinBy :: Int -> Int -> Int

145170foldableMinBy value n =

146− F.minimumBy compare (sourceUnfoldr value n :: S.SerialT Identity Int)

171+ F.minimumBy compare (sourceUnfoldr value n :: Stream Identity Int)

147172

148173{-# INLINE foldableListMinBy #-}

149174foldableListMinBy :: Int -> Int -> Int

@@ -152,30 +177,30 @@ foldableListMinBy value n = F.minimumBy compare [1..value+n]

152177{-# INLINE foldableMaxBy #-}

153178foldableMaxBy :: Int -> Int -> Int

154179foldableMaxBy value n =

155− F.maximumBy compare (sourceUnfoldr value n :: S.SerialT Identity Int)

180+ F.maximumBy compare (sourceUnfoldr value n :: Stream Identity Int)

156181

157182{-# INLINE foldableToList #-}

158183foldableToList :: Int -> Int -> [Int]

159184foldableToList value n =

160− F.toList (sourceUnfoldr value n :: S.SerialT Identity Int)

185+ F.toList (sourceUnfoldr value n :: Stream Identity Int)

161186

162187{-# INLINE foldableMapM_ #-}

163188foldableMapM_ :: Monad m => Int -> Int -> m ()

164189foldableMapM_ value n =

165− F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: S.SerialT Identity Int)

190+ F.mapM_ (\_ -> return ()) (sourceUnfoldr value n :: Stream Identity Int)

166191

167192{-# INLINE foldableSequence_ #-}

168193foldableSequence_ :: Int -> Int -> IO ()

169194foldableSequence_ value n =

170− F.sequence_ (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))

195+ F.sequence_ (sourceUnfoldrAction value n :: Stream Identity (IO Int))

171196

172197{-# INLINE _foldableMsum #-}

173198_foldableMsum :: Int -> Int -> IO Int

174199_foldableMsum value n =

175− F.msum (sourceUnfoldrAction value n :: S.SerialT Identity (IO Int))

200+ F.msum (sourceUnfoldrAction value n :: Stream Identity (IO Int))

176201

177202{-# INLINE showInstance #-}

178−showInstance :: SerialT Identity Int -> String

203+showInstance :: Stream Identity Int -> String

179204showInstance = show

180205

181206o_1_space_elimination_foldable :: Int -> [Benchmark]

@@ -192,6 +217,9 @@ o_1_space_elimination_foldable value =

192217 , bench "minimum" $ nf (foldableMin value) 1

193218 , benchPureSink value "min (ord)" ordInstanceMin

194219 , bench "maximum" $ nf (foldableMax value) 1

220+ , bench "minimumBy" $ nf (`foldableMinBy` 1) value

221+ , bench "maximumBy" $ nf (`foldableMaxBy` 1) value

222+ , bench "minimumByList" $ nf (`foldableListMinBy` 1) value

195223 , bench "length . toList"

196224 $ nf (Prelude.length . foldableToList value) 1

197225 , bench "notElem" $ nf (foldableNotElem value) 1

@@ -214,34 +242,25 @@ o_1_space_elimination_foldable value =

214242 ]

215243 ]

216244

217−o_n_space_elimination_foldable :: Int -> [Benchmark]

218−o_n_space_elimination_foldable value =

219− -- Head recursive strict right folds.

220− [ bgroup "foldl"

221− -- XXX the definitions of minimumBy and maximumBy in Data.Foldable use

222− -- foldl1 which does not work in constant memory for our

223− -- implementation. It works in constant memory for lists but even for

224− -- lists it takes 15x more time compared to our foldl' based

225− -- implementation.

226− [ bench "minimumBy" $ nf (`foldableMinBy` 1) value

227− , bench "maximumBy" $ nf (`foldableMaxBy` 1) value

228− , bench "minimumByList" $ nf (`foldableListMinBy` 1) value

229− ]

230− ]

231−

232245-------------------------------------------------------------------------------

233246-- Stream folds

234247-------------------------------------------------------------------------------

235248

249+#ifndef USE_PRELUDE

250+instance NFData a => NFData (Stream Identity a) where

251+ {-# INLINE rnf #-}

252+ rnf xs = runIdentity $ S.fold (Fold.foldl' (\_ x -> rnf x) ()) xs

253+#endif

254+

236255{-# INLINE benchPureSink #-}

237256benchPureSink :: NFData b

238− => Int -> String -> (SerialT Identity Int -> b) -> Benchmark

257+ => Int -> String -> (Stream Identity Int -> b) -> Benchmark

239258benchPureSink value name = benchPure name (sourceUnfoldr value)

240259

241260{-# INLINE benchHoistSink #-}

242261benchHoistSink

243− :: (IsStream t, NFData b)

244− => Int -> String -> (t Identity Int -> IO b) -> Benchmark

262+ :: (NFData b)

263+ => Int -> String -> (Stream Identity Int -> IO b) -> Benchmark

245264benchHoistSink value name f =

246265 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

247266

@@ -249,8 +268,8 @@ benchHoistSink value name f =

249268-- we can't use it as it requires MonadAsync constraint.

250269{-# INLINE benchIdentitySink #-}

251270benchIdentitySink

252− :: (IsStream t, NFData b)

253− => Int -> String -> (t Identity Int -> Identity b) -> Benchmark

271+ :: (NFData b)

272+ => Int -> String -> (Stream Identity Int -> Identity b) -> Benchmark

254273benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

255274

256275-------------------------------------------------------------------------------

@@ -258,23 +277,29 @@ benchIdentitySink value name f = bench name $ nf (f . sourceUnfoldr value) 1

258277-------------------------------------------------------------------------------

259278

260279{-# INLINE uncons #-}

261−uncons :: Monad m => SerialT m Int -> m ()

280+#ifdef USE_STREAMK

281+uncons :: Monad m => StreamK m Int -> m ()

282+#else

283+uncons :: Monad m => Stream m Int -> m ()

284+#endif

262285uncons s = do

263− r <- S.uncons s

286+ r <- StreamK.uncons s

264287 case r of

265288 Nothing -> return ()

266289 Just (_, t) -> uncons t

267290

291+#ifdef USE_PRELUDE

268292{-# INLINE init #-}

269−init :: Monad m => SerialT m a -> m ()

293+init :: Monad m => Stream m a -> m ()

270294init s = S.init s >>= Prelude.mapM_ S.drain

271295

272296{-# INLINE mapM_ #-}

273−mapM_ :: Monad m => SerialT m Int -> m ()

297+mapM_ :: Monad m => Stream m Int -> m ()

274298mapM_ = S.mapM_ (\_ -> return ())

299+#endif

275300

276301{-# INLINE foldrMElem #-}

277−foldrMElem :: Monad m => Int -> SerialT m Int -> m Bool

302+foldrMElem :: Monad m => Int -> Stream m Int -> m Bool

278303foldrMElem e =

279304 S.foldrM

280305 (\x xs ->

@@ -283,155 +308,187 @@ foldrMElem e =

283308 else xs)

284309 (return False)

285310

311+#ifdef USE_STREAMK

286312{-# INLINE foldrToStream #-}

287−foldrToStream :: Monad m => SerialT m Int -> m (SerialT Identity Int)

288−foldrToStream = S.foldr S.cons S.nil

313+foldrToStream :: Monad m => Stream m Int -> m (StreamK Identity Int)

314+foldrToStream = S.foldr StreamK.cons StreamK.nil

315+#else

316+-- {-# INLINE foldrToStream #-}

317+-- foldrToStream :: Monad m => Stream m Int -> m (Stream Identity Int)

318+-- foldrToStream = S.foldr S.cons S.nil

319+#endif

289320

290321{-# INLINE foldrMBuild #-}

291−foldrMBuild :: Monad m => SerialT m Int -> m [Int]

322+foldrMBuild :: Monad m => Stream m Int -> m [Int]

292323foldrMBuild = S.foldrM (\x xs -> (x :) <$> xs) (return [])

293324

325+#ifdef USE_PRELUDE

294326{-# INLINE foldl'Reduce #-}

295−foldl'Reduce :: Monad m => SerialT m Int -> m Int

327+foldl'Reduce :: Monad m => Stream m Int -> m Int

296328foldl'Reduce = S.foldl' (+) 0

297329

298330{-# INLINE foldl1'Reduce #-}

299−foldl1'Reduce :: Monad m => SerialT m Int -> m (Maybe Int)

331+foldl1'Reduce :: Monad m => Stream m Int -> m (Maybe Int)

300332foldl1'Reduce = S.foldl1' (+)

301333

302334{-# INLINE foldlM'Reduce #-}

303−foldlM'Reduce :: Monad m => SerialT m Int -> m Int

335+foldlM'Reduce :: Monad m => Stream m Int -> m Int

304336foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) (return 0)

305337

306338{-# INLINE last #-}

307−last :: Monad m => SerialT m Int -> m (Maybe Int)

339+last :: Monad m => Stream m Int -> m (Maybe Int)

308340last = S.last

309341

310342{-# INLINE _head #-}

311−_head :: Monad m => SerialT m Int -> m (Maybe Int)

343+_head :: Monad m => Stream m Int -> m (Maybe Int)

312344_head = S.head

313345

314346{-# INLINE elem #-}

315−elem :: Monad m => Int -> SerialT m Int -> m Bool

347+elem :: Monad m => Int -> Stream m Int -> m Bool

316348elem value = S.elem (value + 1)

317349

318350{-# INLINE notElem #-}

319−notElem :: Monad m => Int -> SerialT m Int -> m Bool

351+notElem :: Monad m => Int -> Stream m Int -> m Bool

320352notElem value = S.notElem (value + 1)

321353

322354{-# INLINE length #-}

323−length :: Monad m => SerialT m Int -> m Int

355+length :: Monad m => Stream m Int -> m Int

324356length = S.length

325357

326358{-# INLINE all #-}

327−all :: Monad m => Int -> SerialT m Int -> m Bool

359+all :: Monad m => Int -> Stream m Int -> m Bool

328360all value = S.all (<= (value + 1))

329361

330362{-# INLINE any #-}

331−any :: Monad m => Int -> SerialT m Int -> m Bool

363+any :: Monad m => Int -> Stream m Int -> m Bool

332364any value = S.any (> (value + 1))

333365

334366{-# INLINE and #-}

335−and :: Monad m => Int -> SerialT m Int -> m Bool

367+and :: Monad m => Int -> Stream m Int -> m Bool

336368and value = S.and . S.map (<= (value + 1))

337369

338370{-# INLINE or #-}

339−or :: Monad m => Int -> SerialT m Int -> m Bool

371+or :: Monad m => Int -> Stream m Int -> m Bool

340372or value = S.or . S.map (> (value + 1))

341373

342374{-# INLINE find #-}

343−find :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

375+find :: Monad m => Int -> Stream m Int -> m (Maybe Int)

344376find value = S.find (== (value + 1))

345377

346378{-# INLINE findM #-}

347−findM :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

379+findM :: Monad m => Int -> Stream m Int -> m (Maybe Int)

348380findM value = S.findM (\z -> return $ z == (value + 1))

349381

350382{-# INLINE findIndex #-}

351−findIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

383+findIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)

352384findIndex value = S.findIndex (== (value + 1))

353385

354386{-# INLINE elemIndex #-}

355−elemIndex :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

387+elemIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)

356388elemIndex value = S.elemIndex (value + 1)

357389

358390{-# INLINE maximum #-}

359−maximum :: Monad m => SerialT m Int -> m (Maybe Int)

391+maximum :: Monad m => Stream m Int -> m (Maybe Int)

360392maximum = S.maximum

361393

362394{-# INLINE minimum #-}

363−minimum :: Monad m => SerialT m Int -> m (Maybe Int)

395+minimum :: Monad m => Stream m Int -> m (Maybe Int)

364396minimum = S.minimum

365397

366398{-# INLINE sum #-}

367−sum :: Monad m => SerialT m Int -> m Int

399+sum :: Monad m => Stream m Int -> m Int

368400sum = S.sum

369401

370402{-# INLINE product #-}

371−product :: Monad m => SerialT m Int -> m Int

403+product :: Monad m => Stream m Int -> m Int

372404product = S.product

373405

374406{-# INLINE minimumBy #-}

375−minimumBy :: Monad m => SerialT m Int -> m (Maybe Int)

407+minimumBy :: Monad m => Stream m Int -> m (Maybe Int)

376408minimumBy = S.minimumBy compare

377409

378410{-# INLINE maximumBy #-}

379−maximumBy :: Monad m => SerialT m Int -> m (Maybe Int)

411+maximumBy :: Monad m => Stream m Int -> m (Maybe Int)

380412maximumBy = S.maximumBy compare

381413

382414{-# INLINE the #-}

383−the :: Monad m => SerialT m Int -> m (Maybe Int)

415+the :: Monad m => Stream m Int -> m (Maybe Int)

384416the = S.the

385417

386418{-# INLINE drainN #-}

387−drainN :: Monad m => Int -> SerialT m Int -> m ()

419+drainN :: Monad m => Int -> Stream m Int -> m ()

388420drainN = S.drainN

389421

390422{-# INLINE drainWhile #-}

391−drainWhile :: Monad m => SerialT m Int -> m ()

423+drainWhile :: Monad m => Stream m Int -> m ()

392424drainWhile = S.drainWhile (const True)

393425

394426{-# INLINE (!!) #-}

395−(!!) :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

396−(!!) = flip (Internal.!!)

427+(!!) :: Monad m => Int -> Stream m Int -> m (Maybe Int)

428+(!!) = flip (S.!!)

397429

398430{-# INLINE lookup #-}

399−lookup :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

431+lookup :: Monad m => Int -> Stream m Int -> m (Maybe Int)

400432lookup val = S.lookup val . S.map (\x -> (x, x))

433+#endif

401434

402435o_1_space_elimination_folds :: Int -> [Benchmark]

403436o_1_space_elimination_folds value =

404437 [ bgroup "elimination"

405438 -- Basic folds

406− [ bgroup "reduce"

439+ [

440+#ifdef USE_PRELUDE

441+ bgroup "reduce"

407442 [ bgroup

408443 "IO"

409444 [ benchIOSink value "foldl'" foldl'Reduce

410445 , benchIOSink value "foldl1'" foldl1'Reduce

411446 , benchIOSink value "foldlM'" foldlM'Reduce

412447 ]

448+

413449 , bgroup

414450 "Identity"

415451 [ benchIdentitySink value "foldl'" foldl'Reduce

416452 , benchIdentitySink value "foldl1'" foldl1'Reduce

417453 , benchIdentitySink value "foldlM'" foldlM'Reduce

418454 ]

419− ]

420− , bgroup "build"

455+ ] ,

456+#endif

457+ bgroup "build"

421458 [ bgroup "IO"

422459 [ benchIOSink value "foldrMElem" (foldrMElem value)

423460 ]

424461 , bgroup "Identity"

425462 [ benchIdentitySink value "foldrMElem" (foldrMElem value)

463+#ifdef USE_STREAMK

426464 , benchIdentitySink value "foldrToStreamLength"

427− (S.length . runIdentity . foldrToStream)

465+ (S.fold Fold.length . toStream . runIdentity . foldrToStream)

466+ {-

467+ , benchIdentitySink 16 "foldrToStreamLength (16)"

468+ (S.fold Fold.length . toStream . runIdentity . foldrToStream)

469+ -}

470+#else

471+ {-

472+ , benchIdentitySink 16 "foldrToStreamLength (16)"

473+ (S.fold Fold.length . runIdentity . foldrToStream)

474+ -}

475+#endif

476+ {-

477+ , benchPureSink 16 "foldrMToListLength (16)"

478+ (Prelude.length . runIdentity . foldrMBuild)

479+ -}

428480 , benchPureSink value "foldrMToListLength"

429481 (Prelude.length . runIdentity . foldrMBuild)

430482 ]

431483 ]

432484

433485 -- deconstruction

434− , benchIOSink value "uncons" uncons

486+ , benchIOSink value "uncons" (uncons . fromStream)

487+#ifndef USE_PRELUDE

488+ , benchHoistSink value "length . generalizeInner"

489+ (S.fold Fold.length . S.generalizeInner)

490+#endif

491+#ifdef USE_PRELUDE

435492 , benchIOSink value "init" init

436493

437494 -- draining

@@ -445,8 +502,6 @@ o_1_space_elimination_folds value =

445502 -- , benchIOSink value "head" head

446503 , benchIOSink value "last" last

447504 , benchIOSink value "length" length

448− , benchHoistSink value "length . generally"

449− (length . Internal.generally)

450505 , benchIOSink value "sum" sum

451506 , benchIOSink value "product" product

452507 , benchIOSink value "maximumBy" maximumBy

@@ -470,8 +525,8 @@ o_1_space_elimination_folds value =

470525 , benchIOSink value "any" (any value)

471526 , benchIOSink value "and" (and value)

472527 , benchIOSink value "or" (or value)

528+#endif

473529

474− , benchPureSink value "showsPrec pure streams" showInstance

475530 -- length is used to check for foldr/build fusion

476531 , benchPureSink value "length . IsList.toList" (Prelude.length . GHC.toList)

477532 ]

@@ -481,12 +536,13 @@ o_1_space_elimination_folds value =

481536-- Buffered Transformations by fold

482537-------------------------------------------------------------------------------

483538

539+#ifdef USE_PRELUDE

484540{-# INLINE foldl'Build #-}

485−foldl'Build :: Monad m => SerialT m Int -> m [Int]

541+foldl'Build :: Monad m => Stream m Int -> m [Int]

486542foldl'Build = S.foldl' (flip (:)) []

487543

488544{-# INLINE foldlM'Build #-}

489−foldlM'Build :: Monad m => SerialT m Int -> m [Int]

545+foldlM'Build :: Monad m => Stream m Int -> m [Int]

490546foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) (return [])

491547

492548o_n_heap_elimination_foldl :: Int -> [Benchmark]

@@ -500,6 +556,7 @@ o_n_heap_elimination_foldl value =

500556 , benchIdentitySink value "foldlM'/build/Identity" foldlM'Build

501557 ]

502558 ]

559+#endif

503560

504561-- For comparisons

505562{-# INLINE showInstanceList #-}

@@ -513,11 +570,13 @@ o_n_heap_elimination_buffered value =

513570 -- XXX can the outputs be streaming? Can we have special read/show

514571 -- style type classes, readM/showM supporting streaming effects?

515572 [ bench "showPrec Haskell lists" $ nf showInstanceList (mkList value)

573+ -- XXX This is not o-1-space for GHC-8.10

574+ , benchPureSink value "showsPrec pure streams" showInstance

516575 ]

517576 ]

518577

519578{-# INLINE foldrMReduce #-}

520−foldrMReduce :: Monad m => SerialT m Int -> m Int

579+foldrMReduce :: Monad m => Stream m Int -> m Int

521580foldrMReduce = S.foldrM (\x xs -> (x +) <$> xs) (return 0)

522581

523582o_n_space_elimination_foldr :: Int -> [Benchmark]

@@ -533,12 +592,14 @@ o_n_space_elimination_foldr value =

533592 ]

534593 ]

535594

595+#ifdef USE_PRELUDE

536596o_n_heap_elimination_toList :: Int -> [Benchmark]

537597o_n_heap_elimination_toList value =

538598 [ bgroup "toList"

539599 -- Converting the stream to a list or pure stream in a strict monad

540− [ benchIOSink value "toListRev" Internal.toListRev

541− , benchIOSink value "toStreamRev" Internal.toStreamRev

600+ [ benchIOSink value "toListRev" S.toListRev

601+ , benchIOSink value "toStreamRev"

602+ (S.toStreamRev :: (Stream IO Int -> IO (Stream Identity Int)))

542603 ]

543604 ]

544605

@@ -547,9 +608,13 @@ o_n_space_elimination_toList value =

547608 [ bgroup "toList"

548609 -- Converting the stream to a list or pure stream in a strict monad

549610 [ benchIOSink value "toList" S.toList

550− , benchIOSink value "toStream" Internal.toStream

611+#ifndef USE_PRELUDE

612+ , benchIOSink value "toStream"

613+ (S.toStream :: (Stream IO Int -> IO (Stream Identity Int)))

614+#endif

551615 ]

552616 ]

617+#endif

553618

554619-------------------------------------------------------------------------------

555620-- Multi-stream folds

@@ -560,7 +625,7 @@ o_n_space_elimination_toList value =

560625-------------------------------------------------------------------------------

561626

562627{-# INLINE eqBy' #-}

563−eqBy' :: (Monad m, Eq a) => SerialT m a -> m Bool

628+eqBy' :: (Monad m, Eq a) => Stream m a -> m Bool

564629eqBy' src = S.eqBy (==) src src

565630

566631{-# INLINE eqByPure #-}

@@ -574,15 +639,15 @@ inspect $ 'eqByPure `hasNoType` ''D.Step

574639#endif

575640

576641{-# INLINE eqInstance #-}

577−eqInstance :: SerialT Identity Int -> Bool

642+eqInstance :: Stream Identity Int -> Bool

578643eqInstance src = src == src

579644

580645{-# INLINE eqInstanceNotEq #-}

581−eqInstanceNotEq :: SerialT Identity Int -> Bool

646+eqInstanceNotEq :: Stream Identity Int -> Bool

582647eqInstanceNotEq src = src /= src

583648

584649{-# INLINE cmpBy' #-}

585−cmpBy' :: (Monad m, Ord a) => SerialT m a -> m Ordering

650+cmpBy' :: (Monad m, Ord a) => Stream m a -> m Ordering

586651cmpBy' src = S.cmpBy compare src src

587652

588653{-# INLINE cmpByPure #-}

@@ -596,7 +661,7 @@ inspect $ 'cmpByPure `hasNoType` ''D.Step

596661#endif

597662

598663{-# INLINE ordInstance #-}

599−ordInstance :: SerialT Identity Int -> Bool

664+ordInstance :: Stream Identity Int -> Bool

600665ordInstance src = src < src

601666

602667o_1_space_elimination_multi_stream_pure :: Int -> [Benchmark]

@@ -611,15 +676,15 @@ o_1_space_elimination_multi_stream_pure value =

611676 ]

612677

613678{-# INLINE isPrefixOf #-}

614−isPrefixOf :: Monad m => SerialT m Int -> m Bool

679+isPrefixOf :: Monad m => Stream m Int -> m Bool

615680isPrefixOf src = S.isPrefixOf src src

616681

617682{-# INLINE isSubsequenceOf #-}

618−isSubsequenceOf :: Monad m => SerialT m Int -> m Bool

683+isSubsequenceOf :: Monad m => Stream m Int -> m Bool

619684isSubsequenceOf src = S.isSubsequenceOf src src

620685

621686{-# INLINE stripPrefix #-}

622−stripPrefix :: Monad m => SerialT m Int -> m ()

687+stripPrefix :: Monad m => Stream m Int -> m ()

623688stripPrefix src = do

624689 _ <- S.stripPrefix src src

625690 return ()

@@ -670,14 +735,14 @@ benchmarks moduleName size =

670735 , o_1_space_elimination_multi_stream_pure size

671736 , o_1_space_elimination_multi_stream size

672737 ]

673− , bgroup (o_n_heap_prefix moduleName) $ concat

674− [ o_n_heap_elimination_foldl size

675− , o_n_heap_elimination_toList size

676− , o_n_heap_elimination_buffered size

677− ]

678− , bgroup (o_n_space_prefix moduleName) $ concat

679− [ o_n_space_elimination_foldable size

680− , o_n_space_elimination_toList size

681− , o_n_space_elimination_foldr size

682− ]

738+

739+ , bgroup (o_n_heap_prefix moduleName) $

740+ o_n_heap_elimination_buffered size

741+#ifdef USE_PRELUDE

742+ ++ o_n_heap_elimination_foldl size

743+ ++ o_n_heap_elimination_toList size

744+ ++ o_n_space_elimination_toList size

745+#endif

746+ , bgroup (o_n_space_prefix moduleName) $

747+ o_n_space_elimination_foldr size

683748 ]

benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hsnew file+371

@@ -0,0 +1,371 @@

1+-- |

2+-- Module : Stream.Exceptions

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

6+-- Stability : experimental

7+-- Portability : GHC

9+{-# LANGUAGE CPP #-}

10+{-# LANGUAGE FlexibleContexts #-}

11+{-# LANGUAGE ScopedTypeVariables #-}

12+

13+#ifdef USE_PRELUDE

14+{-# OPTIONS_GHC -Wno-deprecations #-}

15+#endif

16+

17+#ifdef __HADDOCK_VERSION__

18+#undef INSPECTION

19+#endif

20+

21+#ifdef INSPECTION

22+{-# LANGUAGE TemplateHaskell #-}

23+{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

24+#endif

25+

26+module Stream.Exceptions (benchmarks) where

27+

28+import Control.Exception (Exception, throwIO)

29+import Stream.Common (drain)

30+

31+import qualified Data.IORef as Ref

32+import qualified Data.Map.Strict as Map

33+

34+import Control.Exception (SomeException)

35+import System.IO (Handle, hClose, hPutChar)

36+import qualified Streamly.FileSystem.Handle as FH

37+import qualified Streamly.Internal.FileSystem.Handle as IFH

38+import qualified Streamly.Internal.Data.Unfold as IUF

39+import qualified Streamly.Internal.Data.Unfold.Prelude as IUF

40+

41+#ifdef USE_PRELUDE

42+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

43+#else

44+import qualified Streamly.Internal.Data.Stream as Stream

45+import qualified Streamly.Internal.Data.Stream.Prelude as Stream

46+#endif

47+

48+import Test.Tasty.Bench hiding (env)

49+import Prelude hiding (last, length)

50+import Streamly.Benchmark.Common

51+import Streamly.Benchmark.Common.Handle

52+

53+#ifdef INSPECTION

54+import Control.Monad.Catch (MonadCatch)

55+import Test.Inspection

56+

57+import qualified Streamly.Internal.Data.Stream as D

58+#endif

59+

60+#ifdef USE_PRELUDE

61+type Stream = Stream.SerialT

62+toStreamD = Stream.toStream

63+fromStreamD = Stream.fromStream

64+#else

65+type Stream = Stream.Stream

66+toStreamD :: a -> a

67+toStreamD = id

68+fromStreamD :: a -> a

69+fromStreamD = id

70+#endif

71+

72+afterUnsafe :: IO b -> Stream IO a -> Stream IO a

73+finallyUnsafe :: IO b -> Stream IO a -> Stream IO a

74+bracketUnsafe :: IO b -> (b -> IO c) -> (b -> Stream IO a) -> Stream IO a

75+#ifdef USE_PRELUDE

76+afterUnsafe = Stream.after_

77+finallyUnsafe = Stream.finally_

78+bracketUnsafe = Stream.bracket_

79+#else

80+afterUnsafe = Stream.afterUnsafe

81+finallyUnsafe = Stream.finallyUnsafe

82+bracketUnsafe = Stream.bracketUnsafe

83+#endif

84+

85+-------------------------------------------------------------------------------

86+-- stream exceptions

87+-------------------------------------------------------------------------------

88+

89+data BenchException

90+ = BenchException1

91+ | BenchException2

92+ deriving (Show, Eq, Ord)

93+

94+instance Exception BenchException

95+

96+retryNoneSimple :: Int -> Int -> IO ()

97+retryNoneSimple length from =

98+ drain

99+ $ Stream.retry

100+ (Map.singleton BenchException1 length)

101+ (const Stream.nil)

102+ source

103+

104+ where

105+

106+ source = Stream.enumerateFromTo from (from + length)

107+

108+retryNone :: Int -> Int -> IO ()

109+retryNone length from = do

110+ ref <- Ref.newIORef (0 :: Int)

111+ drain

112+ $ Stream.retry (Map.singleton BenchException1 length) (const Stream.nil)

113+ $ source ref

114+

115+ where

116+

117+ source ref =

118+ Stream.replicateM (from + length)

119+ $ Ref.modifyIORef' ref (+ 1) >> Ref.readIORef ref

120+

121+retryAll :: Int -> Int -> IO ()

122+retryAll length from = do

123+ ref <- Ref.newIORef 0

124+ drain

125+ $ Stream.retry

126+ (Map.singleton BenchException1 (length + from)) (const Stream.nil)

127+ $ source ref

128+

129+ where

130+

131+ source ref =

132+ Stream.fromEffect

133+ $ do

134+ Ref.modifyIORef' ref (+ 1)

135+ val <- Ref.readIORef ref

136+ if val >= length

137+ then return length

138+ else throwIO BenchException1

139+

140+retryUnknown :: Int -> Int -> IO ()

141+retryUnknown length from = do

142+ drain

143+ $ Stream.retry (Map.singleton BenchException1 length) (const source)

144+ $ throwIO BenchException2 `Stream.before` Stream.nil

145+

146+ where

147+

148+ source = Stream.enumerateFromTo from (from + length)

149+

150+

151+o_1_space_serial_exceptions :: Int -> [Benchmark]

152+o_1_space_serial_exceptions length =

153+ [ bgroup

154+ "exceptions/serial"

155+ [ benchIOSrc1 "retryNoneSimple" (retryNoneSimple length)

156+ , benchIOSrc1 "retryNone" (retryNone length)

157+ , benchIOSrc1 "retryAll" (retryAll length)

158+ , benchIOSrc1 "retryUnknown" (retryUnknown length)

159+ ]

160+ ]

161+

162+-- XXX Move these to FileSystem.Handle benchmarks

163+

164+-------------------------------------------------------------------------------

165+-- copy stream exceptions

166+-------------------------------------------------------------------------------

167+

168+-- | Send the file contents to /dev/null with exception handling

169+readWriteOnExceptionStream :: Handle -> Handle -> IO ()

170+readWriteOnExceptionStream inh devNull =

171+ let readEx = Stream.onException (hClose inh) (Stream.unfold FH.reader inh)

172+ in Stream.fold (FH.write devNull) readEx

173+

174+#ifdef INSPECTION

175+inspect $ hasNoTypeClasses 'readWriteOnExceptionStream

176+#endif

177+

178+-- | Send the file contents to /dev/null with exception handling

179+readWriteHandleExceptionStream :: Handle -> Handle -> IO ()

180+readWriteHandleExceptionStream inh devNull =

181+ let handler (_e :: SomeException) =

182+ return $ Stream.fromEffect (hClose inh >> return 10)

183+ readEx = Stream.handle handler (Stream.unfold FH.reader inh)

184+ in Stream.fold (FH.write devNull) readEx

185+

186+#ifdef INSPECTION

187+inspect $ hasNoTypeClasses 'readWriteHandleExceptionStream

188+#endif

189+

190+-- | Send the file contents to /dev/null with exception handling

191+readWriteFinally_Stream :: Handle -> Handle -> IO ()

192+readWriteFinally_Stream inh devNull =

193+ let readEx =

194+ finallyUnsafe (hClose inh) (Stream.unfold FH.reader inh)

195+ in Stream.fold (FH.write devNull) readEx

196+

197+#ifdef INSPECTION

198+inspect $ hasNoTypeClasses 'readWriteFinally_Stream

199+#endif

200+

201+readWriteFinallyStream :: Handle -> Handle -> IO ()

202+readWriteFinallyStream inh devNull =

203+ let readEx = Stream.finally (hClose inh) (Stream.unfold FH.reader inh)

204+ in Stream.fold (FH.write devNull) readEx

205+

206+-- | Send the file contents to /dev/null with exception handling

207+fromToBytesBracket_Stream :: Handle -> Handle -> IO ()

208+fromToBytesBracket_Stream inh devNull =

209+ let readEx = bracketUnsafe (return ()) (\_ -> hClose inh)

210+ (\_ -> fromStreamD $ IFH.read inh)

211+ in IFH.putBytes devNull (toStreamD readEx)

212+

213+#ifdef INSPECTION

214+inspect $ hasNoTypeClasses 'fromToBytesBracket_Stream

215+#endif

216+

217+fromToBytesBracketStream :: Handle -> Handle -> IO ()

218+fromToBytesBracketStream inh devNull =

219+ let readEx = Stream.bracket (return ()) (\_ -> hClose inh)

220+ (\_ -> fromStreamD $ IFH.read inh)

221+ in IFH.putBytes devNull (toStreamD readEx)

222+

223+readWriteBeforeAfterStream :: Handle -> Handle -> IO ()

224+readWriteBeforeAfterStream inh devNull =

225+ let readEx =

226+ Stream.after (hClose inh)

227+ $ Stream.before (hPutChar devNull 'A') (Stream.unfold FH.reader inh)

228+ in Stream.fold (FH.write devNull) readEx

229+

230+#ifdef INSPECTION

231+inspect $ 'readWriteBeforeAfterStream `hasNoType` ''D.Step

232+#endif

233+

234+readWriteAfterStream :: Handle -> Handle -> IO ()

235+readWriteAfterStream inh devNull =

236+ let readEx = Stream.after (hClose inh) (Stream.unfold FH.reader inh)

237+ in Stream.fold (FH.write devNull) readEx

238+

239+#ifdef INSPECTION

240+inspect $ 'readWriteAfterStream `hasNoType` ''D.Step

241+#endif

242+

243+readWriteAfter_Stream :: Handle -> Handle -> IO ()

244+readWriteAfter_Stream inh devNull =

245+ let readEx = afterUnsafe (hClose inh) (Stream.unfold FH.reader inh)

246+ in Stream.fold (FH.write devNull) readEx

247+

248+#ifdef INSPECTION

249+inspect $ hasNoTypeClasses 'readWriteAfter_Stream

250+inspect $ 'readWriteAfter_Stream `hasNoType` ''D.Step

251+#endif

252+

253+o_1_space_copy_stream_exceptions :: BenchEnv -> [Benchmark]

254+o_1_space_copy_stream_exceptions env =

255+ [ bgroup "exceptions"

256+ [ mkBenchSmall "Stream.onException" env $ \inh _ ->

257+ readWriteOnExceptionStream inh (nullH env)

258+ , mkBenchSmall "Stream.handle" env $ \inh _ ->

259+ readWriteHandleExceptionStream inh (nullH env)

260+ , mkBenchSmall "Stream.finally_" env $ \inh _ ->

261+ readWriteFinally_Stream inh (nullH env)

262+ , mkBenchSmall "Stream.finally" env $ \inh _ ->

263+ readWriteFinallyStream inh (nullH env)

264+ , mkBenchSmall "Stream.after . Stream.before" env $ \inh _ ->

265+ readWriteBeforeAfterStream inh (nullH env)

266+ , mkBenchSmall "Stream.after" env $ \inh _ ->

267+ readWriteAfterStream inh (nullH env)

268+ , mkBenchSmall "Stream.after_" env $ \inh _ ->

269+ readWriteAfter_Stream inh (nullH env)

270+ ]

271+ , bgroup "exceptions/fromToBytes"

272+ [ mkBenchSmall "Stream.bracket_" env $ \inh _ ->

273+ fromToBytesBracket_Stream inh (nullH env)

274+ , mkBenchSmall "Stream.bracket" env $ \inh _ ->

275+ fromToBytesBracketStream inh (nullH env)

276+ ]

277+ ]

278+

279+ -------------------------------------------------------------------------------

280+-- Exceptions readChunks

281+-------------------------------------------------------------------------------

282+

283+-- | Send the file contents to /dev/null with exception handling

284+readChunksOnException :: Handle -> Handle -> IO ()

285+readChunksOnException inh devNull =

286+ let readEx = IUF.onException (\_ -> hClose inh) FH.chunkReader

287+ in IUF.fold (IFH.writeChunks devNull) readEx inh

288+

289+#ifdef INSPECTION

290+#if __GLASGOW_HASKELL__ >= 906

291+inspect $ hasNoTypeClassesExcept 'readChunksOnException [''MonadCatch]

292+#else

293+inspect $ hasNoTypeClasses 'readChunksOnException

294+#endif

295+#endif

296+

297+-- | Send the file contents to /dev/null with exception handling

298+readChunksBracket_ :: Handle -> Handle -> IO ()

299+readChunksBracket_ inh devNull =

300+ let readEx = IUF.bracket_ return (\_ -> hClose inh) FH.chunkReader

301+ in IUF.fold (IFH.writeChunks devNull) readEx inh

302+

303+#ifdef INSPECTION

304+#if __GLASGOW_HASKELL__ >= 906

305+inspect $ hasNoTypeClassesExcept 'readChunksBracket_ [''MonadCatch]

306+#else

307+inspect $ hasNoTypeClasses 'readChunksBracket_

308+#endif

309+#endif

310+

311+readChunksBracket :: Handle -> Handle -> IO ()

312+readChunksBracket inh devNull =

313+ let readEx = IUF.bracket return (\_ -> hClose inh) FH.chunkReader

314+ in IUF.fold (IFH.writeChunks devNull) readEx inh

315+

316+o_1_space_copy_exceptions_readChunks :: BenchEnv -> [Benchmark]

317+o_1_space_copy_exceptions_readChunks env =

318+ [ bgroup "exceptions/readChunks"

319+ [ mkBench "UF.onException" env $ \inH _ ->

320+ readChunksOnException inH (nullH env)

321+ , mkBench "UF.bracket_" env $ \inH _ ->

322+ readChunksBracket_ inH (nullH env)

323+ , mkBench "UF.bracket" env $ \inH _ ->

324+ readChunksBracket inH (nullH env)

325+ ]

326+ ]

327+

328+-------------------------------------------------------------------------------

329+-- Exceptions toChunks

330+-------------------------------------------------------------------------------

331+

332+-- | Send the file contents to /dev/null with exception handling

333+toChunksBracket_ :: Handle -> Handle -> IO ()

334+toChunksBracket_ inh devNull =

335+ let readEx = bracketUnsafe

336+ (return ())

337+ (\_ -> hClose inh)

338+ (\_ -> fromStreamD $ IFH.readChunks inh)

339+ in Stream.fold (IFH.writeChunks devNull) readEx

340+

341+#ifdef INSPECTION

342+inspect $ hasNoTypeClasses 'toChunksBracket_

343+#endif

344+

345+toChunksBracket :: Handle -> Handle -> IO ()

346+toChunksBracket inh devNull =

347+ let readEx = Stream.bracket

348+ (return ())

349+ (\_ -> hClose inh)

350+ (\_ -> fromStreamD $ IFH.readChunks inh)

351+ in Stream.fold (IFH.writeChunks devNull) readEx

352+

353+o_1_space_copy_exceptions_toChunks :: BenchEnv -> [Benchmark]

354+o_1_space_copy_exceptions_toChunks env =

355+ [ bgroup "exceptions/toChunks"

356+ [ mkBench "Stream.bracket_" env $ \inH _ ->

357+ toChunksBracket_ inH (nullH env)

358+ , mkBench "Stream.bracket" env $ \inH _ ->

359+ toChunksBracket inH (nullH env)

360+ ]

361+ ]

362+

363+benchmarks :: String -> BenchEnv -> Int -> [Benchmark]

364+benchmarks moduleName _env size =

365+ [ bgroup (o_1_space_prefix moduleName) $ concat

366+ [ o_1_space_serial_exceptions size

367+ , o_1_space_copy_exceptions_readChunks _env

368+ , o_1_space_copy_exceptions_toChunks _env

369+ , o_1_space_copy_stream_exceptions _env

370+ ]

371+ ]

benchmark/Streamly/Benchmark/Prelude/Serial/Nested.hs → benchmark/Streamly/Benchmark/Data/Stream/Expand.hsrenamed+263−186

@@ -1,5 +1,5 @@

11-- |

2−-- Module : Serial.Nested

2+-- Module : Stream.Expand

44-- License : BSD-3-Clause

55-- Maintainer : streamly@composewell.com

@@ -8,6 +8,11 @@

88{-# LANGUAGE FlexibleContexts #-}

99{-# LANGUAGE ScopedTypeVariables #-}

1010{-# LANGUAGE RankNTypes #-}

11+{-# LANGUAGE TupleSections #-}

12+

13+#ifdef USE_PRELUDE

14+{-# OPTIONS_GHC -Wno-deprecations #-}

15+#endif

1116

1217#ifdef __HADDOCK_VERSION__

1318#undef INSPECTION

@@ -18,33 +23,47 @@

1823{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1924#endif

2025

21−module Serial.Nested (benchmarks) where

22−

23−import Control.Monad.Trans.Class (lift)

24−

25−import qualified Control.Applicative as AP

26+module Stream.Expand (benchmarks) where

2627

2728#ifdef INSPECTION

2829import GHC.Types (SPEC(..))

2930import Test.Inspection

3031

31−import qualified Streamly.Internal.Data.Stream.StreamD as D

32+import qualified Streamly.Internal.Data.Stream as D

3233#endif

3334

34−import qualified Streamly.Prelude as S

35−import qualified Streamly.Internal.Data.Stream.IsStream as Internal

35+import qualified Stream.Common as Common

3636import qualified Streamly.Internal.Data.Unfold as UF

3737

38−import Gauge

39−import Streamly.Prelude (SerialT, fromSerial, serial)

40−import Streamly.Benchmark.Common

38+#ifdef USE_PRELUDE

39+import qualified Streamly.Internal.Data.Stream.IsStream as S

40+import qualified Streamly.Internal.Data.Stream.IsStream as StreamK

4141import Streamly.Benchmark.Prelude

42+ ( sourceFoldMapM, sourceFoldMapWith, sourceFoldMapWithM

43+ , sourceFoldMapWithStream, concatFoldableWith, concatForFoldableWith)

44+#else

45+import qualified Streamly.Internal.Data.Stream as S

46+#ifdef USE_STREAMK

47+import Streamly.Internal.Data.Stream (Stream)

48+import Streamly.Internal.Data.StreamK (StreamK, CrossStreamK)

49+import qualified Control.Applicative as AP

50+import qualified Streamly.Internal.Data.Fold as Fold

51+import qualified Streamly.Internal.Data.StreamK as StreamK

52+#else

53+import qualified Streamly.Internal.Data.Stream as StreamK

54+#endif

55+#endif

56+

57+import Test.Tasty.Bench

58+import Stream.Common

59+import Streamly.Benchmark.Common

4260import Prelude hiding (concatMap)

4361

4462-------------------------------------------------------------------------------

4563-- Iteration/looping utilities

4664-------------------------------------------------------------------------------

4765

66+#ifdef USE_STREAMK

4867{-# INLINE iterateN #-}

4968iterateN :: (Int -> a -> a) -> a -> Int -> a

5069iterateN g initial count = f count initial

@@ -56,13 +75,18 @@ iterateN g initial count = f count initial

5675

5776-- Iterate a transformation over a singleton stream

5877{-# INLINE iterateSingleton #-}

59−iterateSingleton :: S.MonadAsync m

60− => (Int -> SerialT m Int -> SerialT m Int)

78+iterateSingleton :: Applicative m =>

79+ (Int -> CrossStreamK m Int -> CrossStreamK m Int)

6180 -> Int

6281 -> Int

63− -> SerialT m Int

64−iterateSingleton g count n = iterateN g (return n) count

82+ -> Stream m Int

83+iterateSingleton g count n =

84+ toStream

85+ $ StreamK.unCross

86+ $ iterateN g (StreamK.mkCross (StreamK.fromPure n)) count

87+#endif

6588

89+{-

6690-- XXX need to check why this is slower than the explicit recursion above, even

6791-- if the above code is written in a foldr like head recursive way. We also

6892-- need to try this with foldlM' once #150 is fixed.

@@ -70,12 +94,13 @@ iterateSingleton g count n = iterateN g (return n) count

7094-- foldrM and any related fusion issues.

7195{-# INLINE _iterateSingleton #-}

7296_iterateSingleton ::

73− S.MonadAsync m

74− => (Int -> SerialT m Int -> SerialT m Int)

97+ Monad m

98+ => (Int -> Stream m Int -> Stream m Int)

7599 -> Int

76100 -> Int

77− -> SerialT m Int

101+ -> Stream m Int

78102_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

103+-}

79104

80105-------------------------------------------------------------------------------

81106-- Multi-Stream

@@ -88,84 +113,28 @@ _iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

88113{-# INLINE serial2 #-}

89114serial2 :: Int -> Int -> IO ()

90115serial2 count n =

91− S.drain $

92− S.serial (sourceUnfoldrM count n) (sourceUnfoldrM count (n + 1))

116+ drain $ toStream $

117+ Common.append

118+ (fromStream $ sourceUnfoldrM count n)

119+ (fromStream $ sourceUnfoldrM count (n + 1))

93120

94121{-# INLINE serial4 #-}

95122serial4 :: Int -> Int -> IO ()

96123serial4 count n =

97− S.drain $

98− S.serial

99− (S.serial (sourceUnfoldrM count n) (sourceUnfoldrM count (n + 1)))

100− (S.serial

101− (sourceUnfoldrM count (n + 2))

102− (sourceUnfoldrM count (n + 3)))

103−

104−{-# INLINE append2 #-}

105−append2 :: Int -> Int -> IO ()

106−append2 count n =

107− S.drain $

108− Internal.append (sourceUnfoldrM count n) (sourceUnfoldrM count (n + 1))

109−

110−{-# INLINE append4 #-}

111−append4 :: Int -> Int -> IO ()

112−append4 count n =

113− S.drain $

114− Internal.append

115− (Internal.append

116− (sourceUnfoldrM count n)

117− (sourceUnfoldrM count (n + 1)))

118− (Internal.append

119− (sourceUnfoldrM count (n + 2))

120− (sourceUnfoldrM count (n + 3)))

121−

122−#ifdef INSPECTION

123−inspect $ hasNoTypeClasses 'append2

124−inspect $ 'append2 `hasNoType` ''SPEC

125−inspect $ 'append2 `hasNoType` ''D.AppendState

126−#endif

127−

128−-------------------------------------------------------------------------------

129−-- Merging

130−-------------------------------------------------------------------------------

131−

132−{-# INLINE mergeBy #-}

133−mergeBy :: Int -> Int -> IO ()

134−mergeBy count n =

135− S.drain $

136− S.mergeBy

137− compare

138− (sourceUnfoldrM count n)

139− (sourceUnfoldrM count (n + 1))

140−

141−{-# INLINE mergeByM #-}

142−mergeByM :: Int -> Int -> IO ()

143−mergeByM count n =

144− S.drain $

145− S.mergeByM

146− (\a b -> return $ compare a b)

147− (sourceUnfoldrM count n)

148− (sourceUnfoldrM count (n + 1))

149−

150−#ifdef INSPECTION

151−inspect $ hasNoTypeClasses 'mergeBy

152−inspect $ 'mergeBy `hasNoType` ''SPEC

153−inspect $ 'mergeBy `hasNoType` ''D.Step

154−

155−inspect $ hasNoTypeClasses 'mergeByM

156−inspect $ 'mergeByM `hasNoType` ''SPEC

157−inspect $ 'mergeByM `hasNoType` ''D.Step

158−#endif

124+ drain $ toStream $

125+ Common.append

126+ (Common.append

127+ (fromStream $ sourceUnfoldrM count n)

128+ (fromStream $ sourceUnfoldrM count (n + 1)))

129+ (Common.append

130+ (fromStream $ sourceUnfoldrM count (n + 2))

131+ (fromStream $ sourceUnfoldrM count (n + 3)))

159132

160133o_1_space_joining :: Int -> [Benchmark]

161134o_1_space_joining value =

162135 [ bgroup "joining"

163136 [ benchIOSrc1 "serial (2,x/2)" (serial2 (value `div` 2))

164− , benchIOSrc1 "append (2,x/2)" (append2 (value `div` 2))

165137 , benchIOSrc1 "serial (2,2,x/4)" (serial4 (value `div` 4))

166− , benchIOSrc1 "append (2,2,x/4)" (append4 (value `div` 4))

167− , benchIOSrc1 "mergeBy (2,x/2)" (mergeBy (value `div` 2))

168− , benchIOSrc1 "mergeByM (2,x/2)" (mergeByM (value `div` 2))

169138 ]

170139 ]

171140

@@ -173,22 +142,24 @@ o_1_space_joining value =

173142-- Concat Foldable containers

174143-------------------------------------------------------------------------------

175144

145+#ifdef USE_PRELUDE

176146o_1_space_concatFoldable :: Int -> [Benchmark]

177147o_1_space_concatFoldable value =

178148 [ bgroup "concat-foldable"

179− [ benchIOSrc fromSerial "foldMapWith (<>) (List)"

149+ [ benchIOSrc "foldMapWith (<>) (List)"

180150 (sourceFoldMapWith value)

181− , benchIOSrc fromSerial "foldMapWith (<>) (Stream)"

151+ , benchIOSrc "foldMapWith (<>) (Stream)"

182152 (sourceFoldMapWithStream value)

183− , benchIOSrc fromSerial "foldMapWithM (<>) (List)"

153+ , benchIOSrc "foldMapWithM (<>) (List)"

184154 (sourceFoldMapWithM value)

185− , benchIOSrc fromSerial "S.concatFoldableWith (<>) (List)"

155+ , benchIOSrc "S.concatFoldableWith (<>) (List)"

186156 (concatFoldableWith value)

187− , benchIOSrc fromSerial "S.concatForFoldableWith (<>) (List)"

157+ , benchIOSrc "S.concatForFoldableWith (<>) (List)"

188158 (concatForFoldableWith value)

189− , benchIOSrc fromSerial "foldMapM (List)" (sourceFoldMapM value)

159+ , benchIOSrc "foldMapM (List)" (sourceFoldMapM value)

190160 ]

191161 ]

162+#endif

192163

193164-------------------------------------------------------------------------------

194165-- Concat

@@ -199,14 +170,15 @@ o_1_space_concatFoldable value =

199170{-# INLINE concatMap #-}

200171concatMap :: Int -> Int -> Int -> IO ()

201172concatMap outer inner n =

202− S.drain $ S.concatMap

203− (\_ -> sourceUnfoldrM inner n)

204− (sourceUnfoldrM outer n)

173+ drain $ toStream $ StreamK.concatMap

174+ (\_ -> fromStream $ sourceUnfoldrM inner n)

175+ (fromStream $ sourceUnfoldrM outer n)

205176

177+#ifndef USE_STREAMK

206178{-# INLINE concatMapM #-}

207179concatMapM :: Int -> Int -> Int -> IO ()

208180concatMapM outer inner n =

209− S.drain $ S.concatMapM

181+ drain $ S.concatMapM

210182 (\_ -> return $ sourceUnfoldrM inner n)

211183 (sourceUnfoldrM outer n)

212184

@@ -214,18 +186,23 @@ concatMapM outer inner n =

214186inspect $ hasNoTypeClasses 'concatMap

215187inspect $ 'concatMap `hasNoType` ''SPEC

216188#endif

189+#endif

217190

218191-- concatMap unfoldr/unfoldr

219192

220193{-# INLINE concatMapPure #-}

221194concatMapPure :: Int -> Int -> Int -> IO ()

222195concatMapPure outer inner n =

223− S.drain $ S.concatMap

224− (\_ -> sourceUnfoldr inner n)

225− (sourceUnfoldr outer n)

196+ drain $ toStream $ StreamK.concatMap

197+ (\_ -> fromStream $ sourceUnfoldr inner n)

198+ (fromStream $ sourceUnfoldr outer n)

226199

227200#ifdef INSPECTION

201+#if __GLASGOW_HASKELL__ >= 906

202+inspect $ hasNoTypeClassesExcept 'concatMapPure [''Applicative]

203+#else

228204inspect $ hasNoTypeClasses 'concatMapPure

205+#endif

229206inspect $ 'concatMapPure `hasNoType` ''SPEC

230207#endif

231208

@@ -234,58 +211,53 @@ inspect $ 'concatMapPure `hasNoType` ''SPEC

234211{-# INLINE concatMapRepl #-}

235212concatMapRepl :: Int -> Int -> Int -> IO ()

236213concatMapRepl outer inner n =

237− S.drain $ S.concatMap (S.replicate inner) (sourceUnfoldrM outer n)

214+ drain $ toStream $ StreamK.concatMap

215+ (fromStream . S.replicate inner) (fromStream $ sourceUnfoldrM outer n)

238216

239217#ifdef INSPECTION

218+#if __GLASGOW_HASKELL__ >= 906

219+inspect $ hasNoTypeClassesExcept 'concatMapRepl [''Applicative]

220+#else

240221inspect $ hasNoTypeClasses 'concatMapRepl

222+#endif

241223inspect $ 'concatMapRepl `hasNoType` ''SPEC

242224#endif

243225

244226-- concatMapWith

245227

228+#ifdef USE_STREAMK

246229{-# INLINE concatMapWithSerial #-}

247230concatMapWithSerial :: Int -> Int -> Int -> IO ()

248−concatMapWithSerial = concatStreamsWith S.serial

231+concatMapWithSerial = concatStreamsWith Common.append

249232

250233#ifdef INSPECTION

251234inspect $ hasNoTypeClasses 'concatMapWithSerial

252235inspect $ 'concatMapWithSerial `hasNoType` ''SPEC

253236#endif

254237

238+{-

255239{-# INLINE concatMapWithAppend #-}

256240concatMapWithAppend :: Int -> Int -> Int -> IO ()

257−concatMapWithAppend = concatStreamsWith Internal.append

241+concatMapWithAppend = concatStreamsWith Common.append2

258242

259243#ifdef INSPECTION

260244inspect $ hasNoTypeClasses 'concatMapWithAppend

261245inspect $ 'concatMapWithAppend `hasNoType` ''SPEC

262246#endif

247+-}

263248

264−-- concatPairWith

265−

266−{-# INLINE concatPairWithAppend #-}

267−concatPairWithAppend :: Int -> Int -> Int -> IO ()

268−concatPairWithAppend = concatPairsWith Internal.append

269−

270−{-# INLINE concatPairWithInterleave #-}

271−concatPairWithInterleave :: Int -> Int -> Int -> IO ()

272−concatPairWithInterleave = concatPairsWith Internal.interleave

273−

274−{-# INLINE concatPairWithInterleaveSuffix #-}

275−concatPairWithInterleaveSuffix :: Int -> Int -> Int -> IO ()

276−concatPairWithInterleaveSuffix = concatPairsWith Internal.interleaveSuffix

249+-- mergeMapWith

277250

278−{-# INLINE concatPairWithInterleaveInfix #-}

279−concatPairWithInterleaveInfix :: Int -> Int -> Int -> IO ()

280−concatPairWithInterleaveInfix = concatPairsWith Internal.interleaveInfix

251+{-# INLINE mergeMapWithSerial #-}

252+mergeMapWithSerial :: Int -> Int -> Int -> IO ()

253+mergeMapWithSerial = mergeMapWith Common.append

281254

282−{-# INLINE concatPairWithInterleaveMin #-}

283−concatPairWithInterleaveMin :: Int -> Int -> Int -> IO ()

284−concatPairWithInterleaveMin = concatPairsWith Internal.interleaveMin

285−

286−{-# INLINE concatPairWithRoundrobin #-}

287−concatPairWithRoundrobin :: Int -> Int -> Int -> IO ()

288−concatPairWithRoundrobin = concatPairsWith Internal.roundrobin

255+{-

256+{-# INLINE mergeMapWithAppend #-}

257+mergeMapWithAppend :: Int -> Int -> Int -> IO ()

258+mergeMapWithAppend = mergeMapWith Common.append2

259+-}

260+#endif

289261

290262-- unfoldMany

291263

@@ -294,10 +266,11 @@ concatPairWithRoundrobin = concatPairsWith Internal.roundrobin

294266{-# INLINE unfoldManyRepl #-}

295267unfoldManyRepl :: Int -> Int -> Int -> IO ()

296268unfoldManyRepl outer inner n =

297− S.drain

269+ drain

298270 $ S.unfoldMany

299− (UF.lmap return (UF.replicateM inner))

300− (sourceUnfoldrM outer n)

271+ UF.replicateM

272+ (fmap ((inner,) . return) (sourceUnfoldrM outer n))

273+

301274

302275#ifdef INSPECTION

303276inspect $ hasNoTypeClasses 'unfoldManyRepl

@@ -315,10 +288,6 @@ o_1_space_concat value = sqrtVal `seq`

315288 , benchIOSrc1 "concatMapPure (1 of n)"

316289 (concatMapPure 1 value)

317290

318− -- This is for comparison with foldMapWith

319− , benchIOSrc fromSerial "concatMapId (n of 1) (fromFoldable)"

320− (S.concatMap id . sourceConcatMapId value)

321−

322291 , benchIOSrc1 "concatMap (n of 1)"

323292 (concatMap value 1)

324293 , benchIOSrc1 "concatMap (sqrt n of sqrt n)"

@@ -326,16 +295,25 @@ o_1_space_concat value = sqrtVal `seq`

326295 , benchIOSrc1 "concatMap (1 of n)"

327296 (concatMap 1 value)

328297

298+#ifndef USE_STREAMK

299+ -- This is for comparison with foldMapWith

300+ , benchIOSrc "concatMapId (n of 1) (fromFoldable)"

301+ (S.concatMap id . sourceConcatMapId value)

302+

329303 , benchIOSrc1 "concatMapM (n of 1)"

330304 (concatMapM value 1)

331305 , benchIOSrc1 "concatMapM (sqrt n of sqrt n)"

332306 (concatMapM sqrtVal sqrtVal)

333307 , benchIOSrc1 "concatMapM (1 of n)"

334308 (concatMapM 1 value)

309+#endif

335310

311+#ifdef USE_STREAMK

312+ {-

336313 -- This is for comparison with foldMapWith

337− , benchIOSrc fromSerial "concatMapWithId (n of 1) (fromFoldable)"

338− (S.concatMapWith serial id . sourceConcatMapId value)

314+ , benchIOSrc "concatMapWithId (n of 1) (fromFoldable)"

315+ (toStream . S.concatMapWith Common.append id . sourceConcatMapId value)

316+ -}

339317

340318 , benchIOSrc1 "concatMapWith (n of 1)"

341319 (concatMapWithSerial value 1)

@@ -344,41 +322,54 @@ o_1_space_concat value = sqrtVal `seq`

344322 , benchIOSrc1 "concatMapWith (1 of n)"

345323 (concatMapWithSerial 1 value)

346324

325+ {-

347326 -- quadratic with number of outer streams

348327 , benchIOSrc1 "concatMapWithAppend (2 of n/2)"

349328 (concatMapWithAppend 2 (value `div` 2))

329+ -}

330+#endif

350331

351332 -- concatMap vs unfoldMany

352333 , benchIOSrc1 "concatMapRepl (sqrt n of sqrt n)"

353334 (concatMapRepl sqrtVal sqrtVal)

354335 , benchIOSrc1 "unfoldManyRepl (sqrt n of sqrt n)"

355336 (unfoldManyRepl sqrtVal sqrtVal)

337+ ]

338+ ]

356339

357− -------------------concatPairsWith-----------------

358−

359− , benchIOSrc1 "concatPairWithAppend"

360− (concatPairWithAppend 2 (value `div` 2))

361− , benchIOSrc1 "concatPairWithInterleave"

362− (concatPairWithInterleave 2 (value `div` 2))

363−

364− , benchIOSrc1 "concatPairWithInterleaveSuffix"

365− (concatPairWithInterleaveSuffix 2 (value `div` 2))

366−

367− , benchIOSrc1 "concatPairWithInterleaveInfix"

368− (concatPairWithInterleaveInfix 2 (value `div` 2))

369−

370− , benchIOSrc1 "concatPairWithInterleaveMin"

371− (concatPairWithInterleaveMin 2 (value `div` 2))

340+ where

372341

373− , benchIOSrc1 "concatPairWithRoundrobin"

374− (concatPairWithRoundrobin 2 (value `div` 2))

342+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

375343

344+#ifdef USE_STREAMK

345+o_n_space_merge :: Int -> [Benchmark]

346+o_n_space_merge value = sqrtVal `seq`

347+ [ bgroup "concat"

348+ [

349+ -------------------mergeMapWith-----------------

350+

351+ -- Use large number of streams to check scalability

352+

353+ benchIOSrc1 "mergeMapWithSerial (n of 1)"

354+ (mergeMapWithSerial value 1)

355+ , benchIOSrc1 "mergeMapWithSerial (sqrtVal of sqrtVal)"

356+ (mergeMapWithSerial sqrtVal sqrtVal)

357+ , benchIOSrc1 "mergeMapWithSerial (2 of n/2)"

358+ (mergeMapWithSerial 2 (value `div` 2))

359+

360+ {-

361+ , benchIOSrc1 "mergeMapWithAppend (n of 1)"

362+ (mergeMapWithAppend value 1)

363+ , benchIOSrc1 "mergeMapWithAppend (sqrtVal of sqrtVal)"

364+ (mergeMapWithAppend sqrtVal sqrtVal)

365+ -}

376366 ]

377367 ]

378368

379369 where

380370

381371 sqrtVal = round $ sqrt (fromIntegral value :: Double)

372+#endif

382373

383374-------------------------------------------------------------------------------

384375-- Applicative

@@ -387,26 +378,28 @@ o_1_space_concat value = sqrtVal `seq`

387378o_1_space_applicative :: Int -> [Benchmark]

388379o_1_space_applicative value =

389380 [ bgroup "Applicative"

390− [ benchIO "(*>) (sqrt n x sqrt n)" $ apDiscardFst value fromSerial

391− , benchIO "(<*) (sqrt n x sqrt n)" $ apDiscardSnd value fromSerial

392− , benchIO "(<*>) (sqrt n x sqrt n)" $ toNullAp value fromSerial

393− , benchIO "liftA2 (sqrt n x sqrt n)" $ apLiftA2 value fromSerial

381+ [ benchIO "(*>) (sqrt n x sqrt n)" $ apDiscardFst value

382+ , benchIO "(<*) (sqrt n x sqrt n)" $ apDiscardSnd value

383+ , benchIO "(<*>) (sqrt n x sqrt n)" $ toNullAp value

384+ , benchIO "liftA2 (sqrt n x sqrt n)" $ apLiftA2 value

394385 ]

395386 ]

396387

388+#ifdef USE_STREAMK

397389o_n_space_applicative :: Int -> [Benchmark]

398390o_n_space_applicative value =

399− [ bgroup "Applicative"

400− [ benchIOSrc fromSerial "(*>) (n times)" $

391+ [ bgroup "iterated"

392+ [ benchIOSrc "(*>) (n times)" $

401393 iterateSingleton ((*>) . pure) value

402− , benchIOSrc fromSerial "(<*) (n times)" $

394+ , benchIOSrc "(<*) (n times)" $

403395 iterateSingleton (\x xs -> xs <* pure x) value

404− , benchIOSrc fromSerial "(<*>) (n times)" $

396+ , benchIOSrc "(<*>) (n times)" $

405397 iterateSingleton (\x xs -> pure (+ x) <*> xs) value

406− , benchIOSrc fromSerial "liftA2 (n times)" $

398+ , benchIOSrc "liftA2 (n times)" $

407399 iterateSingleton (AP.liftA2 (+) . pure) value

408400 ]

409401 ]

402+#endif

410403

411404-------------------------------------------------------------------------------

412405-- Monad

@@ -415,48 +408,122 @@ o_n_space_applicative value =

415408o_1_space_monad :: Int -> [Benchmark]

416409o_1_space_monad value =

417410 [ bgroup "Monad"

418− [ benchIO "(>>) (sqrt n x sqrt n)" $ monadThen value fromSerial

419− , benchIO "(>>=) (sqrt n x sqrt n)" $ toNullM value fromSerial

411+ [ benchIO "(>>) (sqrt n x sqrt n)" $ monadThen value

412+ , benchIO "(>>=) (sqrt n x sqrt n)" $ toNullM value

420413 , benchIO "(>>=) (sqrt n x sqrt n) (filterAllOut)" $

421− filterAllOutM value fromSerial

414+ filterAllOutM value

422415 , benchIO "(>>=) (sqrt n x sqrt n) (filterAllIn)" $

423− filterAllInM value fromSerial

416+ filterAllInM value

424417 , benchIO "(>>=) (sqrt n x sqrt n) (filterSome)" $

425− filterSome value fromSerial

418+ filterSome value

426419 , benchIO "(>>=) (sqrt n x sqrt n) (breakAfterSome)" $

427− breakAfterSome value fromSerial

420+ breakAfterSome value

428421 , benchIO "(>>=) (cubert n x cubert n x cubert n)" $

429− toNullM3 value fromSerial

422+ toNullM3 value

430423 ]

431424 ]

432425

426+#ifdef USE_STREAMK

433427-- This is a good benchmark but inefficient way to compute primes. As we see a

434428-- new prime we keep appending a division filter for all the future numbers.

435429{-# INLINE sieve #-}

436−sieve :: Monad m => SerialT m Int -> SerialT m Int

437−sieve s = do

438− r <- lift $ S.uncons s

430+sieve :: Monad m => StreamK m Int -> StreamK m Int

431+sieve s = StreamK.concatEffect $ do

432+ r <- StreamK.uncons s

439433 case r of

440434 Just (prime, rest) ->

441− prime `S.cons` sieve (S.filter (\n -> n `mod` prime /= 0) rest)

442− Nothing -> S.nil

435+ -- XXX Use K.filter or rewrite to K.filter

436+ let f = S.filter (\n -> n `mod` prime /= 0)

437+ in pure $ prime `StreamK.cons` sieve (fromStream $ f $ toStream rest)

438+ Nothing -> pure StreamK.nil

439+

440+o_n_space_iterated :: Int -> [Benchmark]

441+o_n_space_iterated value =

442+ [ bgroup "iterated"

443+ [

444+ benchIO "concatEffect prime sieve (n/4)"

445+ (\n ->

446+ S.fold Fold.sum

447+ $ toStream

448+ $ sieve

449+ $ fromStream

450+ $ S.enumerateFromTo 2 (value `div` 4 + n))

451+ , benchIOSrc "(>>) (n times)" $

452+ iterateSingleton ((>>) . pure) value

453+ , benchIOSrc "(>>=) (n times)" $

454+ iterateSingleton (\x xs -> xs >>= \y -> return (x + y)) value

455+ ]

456+ ]

457+#endif

443458

444459o_n_space_monad :: Int -> [Benchmark]

445460o_n_space_monad value =

446461 [ bgroup "Monad"

447− [ benchIOSrc fromSerial "(>>) (n times)" $

448− iterateSingleton ((>>) . pure) value

449− , benchIOSrc fromSerial "(>>=) (n times)" $

450− iterateSingleton (\x xs -> xs >>= \y -> return (x + y)) value

451− , benchIO "(>>=) (sqrt n x sqrt n) (toList)" $

452− toListM value fromSerial

462+ [ benchIO "(>>=) (sqrt n x sqrt n) (toList)" $

463+ toListM value

453464 , benchIO "(>>=) (sqrt n x sqrt n) (toListSome)" $

454− toListSome value fromSerial

455− , benchIO "naive prime sieve (n/4)"

456− (\n -> S.sum $ sieve $ S.enumerateFromTo 2 (value `div` 4 + n))

465+ toListSome value

457466 ]

458467 ]

459468

469+-------------------------------------------------------------------------------

470+-- Joining

471+-------------------------------------------------------------------------------

472+

473+{-

474+toKv :: Int -> (Int, Int)

475+toKv p = (p, p)

476+

477+{-# INLINE joinWith #-}

478+joinWith :: Common.MonadAsync m =>

479+ ((Int -> Int -> Bool) -> Stream m Int -> Stream m Int -> Stream m b)

480+ -> Int

481+ -> Int

482+ -> m ()

483+joinWith j val i =

484+ drain $ j (==) (sourceUnfoldrM val i) (sourceUnfoldrM val (val `div` 2))

485+

486+{-# INLINE joinMapWith #-}

487+joinMapWith :: Common.MonadAsync m =>

488+ (Stream m (Int, Int) -> Stream m (Int, Int) -> Stream m b)

489+ -> Int

490+ -> Int

491+ -> m ()

492+joinMapWith j val i =

493+ drain

494+ $ j

495+ (fmap toKv (sourceUnfoldrM val i))

496+ (fmap toKv (sourceUnfoldrM val (val `div` 2)))

497+

498+o_n_heap_buffering :: Int -> [Benchmark]

499+o_n_heap_buffering value =

500+ [ bgroup "buffered"

501+ [

502+ benchIOSrc1 "joinInnerGeneric (sqrtVal)"

503+ $ joinWith S.joinInnerGeneric sqrtVal

504+ , benchIOSrc1 "joinInner"

505+ $ joinMapWith S.joinInner halfVal

506+ , benchIOSrc1 "joinLeftGeneric (sqrtVal)"

507+ $ joinWith S.joinLeftGeneric sqrtVal

508+ , benchIOSrc1 "joinLeft "

509+ $ joinMapWith S.joinLeft halfVal

510+ , benchIOSrc1 "joinOuterGeneric (sqrtVal)"

511+ $ joinWith S.joinOuterGeneric sqrtVal

512+ , benchIOSrc1 "joinOuter"

513+ $ joinMapWith S.joinOuter halfVal

514+ , benchIOSrc1 "filterInStreamGenericBy (sqrtVal)"

515+ $ joinWith S.filterInStreamGenericBy sqrtVal

516+ , benchIOSrc1 "filterInStreamAscBy"

517+ $ joinMapWith (S.filterInStreamAscBy compare) halfVal

518+ ]

519+ ]

520+

521+ where

522+

523+ halfVal = value `div` 2

524+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

525+-}

526+

460527-------------------------------------------------------------------------------

461528-- Main

462529-------------------------------------------------------------------------------

@@ -464,23 +531,33 @@ o_n_space_monad value =

464531-- In addition to gauge options, the number of elements in the stream can be

465532-- passed using the --stream-size option.

466533--

534+{-# ANN benchmarks "HLint: ignore" #-}

467535benchmarks :: String -> Int -> [Benchmark]

468536benchmarks moduleName size =

469537 [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat

470538 [

471539 -- multi-stream

472540 o_1_space_joining size

541+#ifdef USE_PRELUDE

473542 , o_1_space_concatFoldable size

543+#endif

474544 , o_1_space_concat size

475−

476545 , o_1_space_applicative size

477546 , o_1_space_monad size

478−

479547 ]

480548 , bgroup (o_n_space_prefix moduleName) $ Prelude.concat

481549 [

482550 -- multi-stream

483− o_n_space_applicative size

484− , o_n_space_monad size

551+ o_n_space_monad size

552+#ifdef USE_STREAMK

553+ , o_n_space_merge size

554+ , o_n_space_iterated size

555+ , o_n_space_applicative size

556+#endif

485557 ]

558+ {-

559+ , bgroup (o_n_heap_prefix moduleName) $

560+ -- multi-stream

561+ o_n_heap_buffering size

562+ -}

486563 ]

benchmark/Streamly/Benchmark/Data/Stream/Generate.hsnew file+278

@@ -0,0 +1,278 @@

1+-- |

2+-- Module : Stream.Generate

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

7+{-# LANGUAGE CPP #-}

8+{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE FlexibleInstances #-}

10+{-# LANGUAGE ScopedTypeVariables #-}

11+{-# LANGUAGE RankNTypes #-}

12+

13+{-# OPTIONS_GHC -Wno-orphans #-}

14+#ifdef USE_PRELUDE

15+{-# OPTIONS_GHC -Wno-deprecations #-}

16+#endif

17+

18+module Stream.Generate (benchmarks) where

19+

20+import Control.DeepSeq (NFData(..))

21+import Data.Functor.Identity (Identity(..))

22+

23+import qualified GHC.Exts as GHC

24+import qualified Streamly.Internal.Data.Fold as Fold

25+

26+#ifdef USE_PRELUDE

27+import Streamly.Prelude (MonadAsync)

28+import Stream.Common hiding (MonadAsync)

29+import Streamly.Benchmark.Prelude (sourceFromFoldableM, absTimes)

30+import qualified Streamly.Prelude as S

31+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

32+#else

33+import Stream.Common

34+import Streamly.Internal.Data.Stream (Stream)

35+import qualified Streamly.Internal.Data.Stream as Stream

36+#ifdef USE_STREAMK

37+import System.IO.Unsafe (unsafeInterleaveIO)

38+import qualified Streamly.Internal.Data.StreamK as StreamK

39+import qualified Stream.Common as Common

40+#endif

41+#endif

42+

43+import Test.Tasty.Bench

44+import Streamly.Benchmark.Common

45+import qualified Prelude

46+

47+import Prelude hiding (repeat, replicate, iterate)

48+

49+-------------------------------------------------------------------------------

50+-- Generation

51+-------------------------------------------------------------------------------

52+

53+#ifdef USE_PRELUDE

54+type Stream = Stream.SerialT

55+toStreamD = Stream.toStream

56+#else

57+toStreamD :: a -> a

58+toStreamD = id

59+#endif

60+

61+-------------------------------------------------------------------------------

62+-- fromList

63+-------------------------------------------------------------------------------

64+

65+{-# INLINE sourceFromList #-}

66+sourceFromList :: Monad m => Int -> Int -> Stream m Int

67+sourceFromList value n = Stream.fromList [n..n+value]

68+

69+{-# INLINE sourceFromListM #-}

70+sourceFromListM :: MonadAsync m => Int -> Int -> Stream m Int

71+sourceFromListM value n = fromListM (fmap return [n..n+value])

72+

73+{-# INLINE sourceIsList #-}

74+sourceIsList :: Int -> Int -> Stream Identity Int

75+sourceIsList value n = GHC.fromList [n..n+value]

76+

77+{-# INLINE sourceIsString #-}

78+sourceIsString :: Int -> Int -> Stream Identity Char

79+sourceIsString value n = GHC.fromString (Prelude.replicate (n + value) 'a')

80+

81+{-# INLINE readInstance #-}

82+readInstance :: String -> Stream Identity Int

83+readInstance str =

84+ let r = reads str

85+ in case r of

86+ [(x,"")] -> x

87+ _ -> error "readInstance: no parse"

88+

89+-- For comparisons

90+{-# INLINE readInstanceList #-}

91+readInstanceList :: String -> [Int]

92+readInstanceList str =

93+ let r = reads str

94+ in case r of

95+ [(x,"")] -> x

96+ _ -> error "readInstance: no parse"

97+

98+{-# INLINE repeat #-}

99+repeat :: Monad m => Int -> Int -> Stream m Int

100+repeat count = Stream.take count . Stream.repeat

101+

102+{-# INLINE replicate #-}

103+replicate :: Monad m => Int -> Int -> Stream m Int

104+replicate = Stream.replicate

105+

106+-------------------------------------------------------------------------------

107+-- enumerate

108+-------------------------------------------------------------------------------

109+

110+{-# INLINE sourceIntFromTo #-}

111+sourceIntFromTo :: Monad m => Int -> Int -> Stream m Int

112+sourceIntFromTo value n = Stream.enumerateFromTo n (n + value)

113+

114+{-# INLINE sourceIntFromThenTo #-}

115+sourceIntFromThenTo :: Monad m => Int -> Int -> Stream m Int

116+sourceIntFromThenTo value n = Stream.enumerateFromThenTo n (n + 1) (n + value)

117+

118+{-# INLINE sourceFracFromTo #-}

119+sourceFracFromTo :: Monad m => Int -> Int -> Stream m Double

120+sourceFracFromTo value n =

121+ Stream.enumerateFromTo (fromIntegral n) (fromIntegral (n + value))

122+

123+{-# INLINE sourceFracFromThenTo #-}

124+sourceFracFromThenTo :: Monad m => Int -> Int -> Stream m Double

125+sourceFracFromThenTo value n = Stream.enumerateFromThenTo (fromIntegral n)

126+ (fromIntegral n + 1.0001) (fromIntegral (n + value))

127+

128+{-# INLINE sourceIntegerFromStep #-}

129+sourceIntegerFromStep :: Monad m => Int -> Int -> Stream m Integer

130+sourceIntegerFromStep value n =

131+ Stream.take value $ Stream.enumerateFromThen (fromIntegral n) (fromIntegral n + 1)

132+

133+{-# INLINE enumerateFrom #-}

134+enumerateFrom :: Monad m => Int -> Int -> Stream m Int

135+enumerateFrom count = Stream.take count . Stream.enumerateFrom

136+

137+{-# INLINE enumerateFromTo #-}

138+enumerateFromTo :: Monad m => Int -> Int -> Stream m Int

139+enumerateFromTo = sourceIntFromTo

140+

141+{-# INLINE enumerateFromThen #-}

142+enumerateFromThen :: Monad m => Int -> Int -> Stream m Int

143+enumerateFromThen count inp = Stream.take count $ Stream.enumerateFromThen inp (inp + 1)

144+

145+{-# INLINE enumerateFromThenTo #-}

146+enumerateFromThenTo :: Monad m => Int -> Int -> Stream m Int

147+enumerateFromThenTo = sourceIntFromThenTo

148+

149+-- n ~ 1

150+{-# INLINE enumerate #-}

151+enumerate :: Monad m => Int -> Int -> Stream m Int

152+enumerate count n = Stream.take (count + n) Stream.enumerate

153+

154+-- n ~ 1

155+{-# INLINE enumerateTo #-}

156+enumerateTo :: Monad m => Int -> Int -> Stream m Int

157+enumerateTo count n = Stream.enumerateTo (minBound + count + n)

158+

159+{-# INLINE iterate #-}

160+iterate :: Monad m => Int -> Int -> Stream m Int

161+iterate count = Stream.take count . Stream.iterate (+1)

162+

163+{-# INLINE iterateM #-}

164+iterateM :: MonadAsync m => Int -> Int -> Stream m Int

165+iterateM count = Stream.take count . Stream.iterateM (return . (+1)) . return

166+

167+{-# INLINE repeatM #-}

168+repeatM :: MonadAsync m => Int -> Int -> Stream m Int

169+repeatM count = Stream.take count . Stream.repeatM . return

170+

171+{-# INLINE replicateM #-}

172+replicateM :: MonadAsync m => Int -> Int -> Stream m Int

173+replicateM count = Stream.replicateM count . return

174+

175+#ifdef USE_PRELUDE

176+{-# INLINE fromIndices #-}

177+fromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

178+fromIndices value n = S.take value $ S.fromIndices (+ n)

179+

180+{-# INLINE fromIndicesM #-}

181+fromIndicesM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

182+fromIndicesM value n = S.take value $ S.fromIndicesM (return <$> (+ n))

183+#endif

184+

185+#ifdef USE_STREAMK

186+{-# INLINE mfixUnfold #-}

187+mfixUnfold :: Int -> Int -> Stream IO (Int, Int)

188+mfixUnfold count start = toStream $ StreamK.mfix f

189+ where

190+ f action = StreamK.unCross $ do

191+ let incr n act = fmap ((+n) . snd) $ unsafeInterleaveIO act

192+ x <- StreamK.mkCross (fromStream $ Common.fromListM [incr 1 action, incr 2 action])

193+ y <- StreamK.mkCross (fromStream $ Common.sourceUnfoldr count start)

194+ return (x, y)

195+#endif

196+

197+o_1_space_generation :: Int -> [Benchmark]

198+o_1_space_generation value =

199+ [ bgroup "generation"

200+ [ benchIOSrc "unfoldr" (sourceUnfoldr value)

201+ , benchIOSrc "unfoldrM" (sourceUnfoldrM value)

202+ , benchIOSrc "repeat" (repeat value)

203+ , benchIOSrc "replicate" (replicate value)

204+ , benchIOSrc "iterate" (iterate value)

205+ , benchIOSrc "iterateM" (iterateM value)

206+ , benchIOSrc "intFromTo" (sourceIntFromTo value)

207+ , benchIOSrc "intFromThenTo" (sourceIntFromThenTo value)

208+ , benchIOSrc "integerFromStep" (sourceIntegerFromStep value)

209+ , benchIOSrc "fracFromThenTo" (sourceFracFromThenTo value)

210+ , benchIOSrc "fracFromTo" (sourceFracFromTo value)

211+ , benchIOSrc "fromList" (sourceFromList value)

212+ , benchIOSrc "fromListM" (sourceFromListM value)

213+ , benchPureSrc "IsList.fromList" (toStreamD . sourceIsList value)

214+ , benchPureSrc "IsString.fromString" (toStreamD . sourceIsString value)

215+ , benchIOSrc "enumerateFrom" (enumerateFrom value)

216+ , benchIOSrc "enumerateFromTo" (enumerateFromTo value)

217+ , benchIOSrc "enumerateFromThen" (enumerateFromThen value)

218+ , benchIOSrc "enumerateFromThenTo" (enumerateFromThenTo value)

219+ , benchIOSrc "enumerate" (enumerate value)

220+ , benchIOSrc "enumerateTo" (enumerateTo value)

221+ , benchIOSrc "repeatM" (repeatM value)

222+ , benchIOSrc "replicateM" (replicateM value)

223+#ifdef USE_PRELUDE

224+ , benchIOSrc "fromIndices" (fromIndices value)

225+ , benchIOSrc "fromIndicesM" (fromIndicesM value)

226+#endif

227+

228+ -- These essentially test cons and consM

229+#ifdef USE_STREAMK

230+ , benchIOSrc "fromFoldable" (sourceFromFoldable value)

231+ -- , benchIOSrc "fromFoldable 16" (sourceFromFoldable 16)

232+#else

233+ -- , benchIOSrc "fromFoldable 16" (sourceFromFoldable 16)

234+#endif

235+

236+#ifdef USE_PRELUDE

237+ , benchIOSrc "fromFoldableM" (sourceFromFoldableM value)

238+ , benchIOSrc "absTimes" $ absTimes value

239+#endif

240+#ifdef USE_STREAMK

241+ , Common.benchIOSrc "mfix_10" (mfixUnfold 10)

242+ , Common.benchIOSrc "mfix_100" (mfixUnfold 100)

243+ , Common.benchIOSrc "mfix_1000" (mfixUnfold 1000)

244+#endif

245+ ]

246+ ]

247+

248+#ifndef USE_PRELUDE

249+instance NFData a => NFData (Stream Identity a) where

250+ {-# INLINE rnf #-}

251+ rnf xs = runIdentity $ Stream.fold (Fold.foldl' (\_ x -> rnf x) ()) xs

252+#endif

253+

254+o_n_heap_generation :: Int -> [Benchmark]

255+o_n_heap_generation value =

256+ [ bgroup "buffered"

257+ -- Buffers the output of show/read.

258+ -- XXX can the outputs be streaming? Can we have special read/show

259+ -- style type classes, readM/showM supporting streaming effects?

260+ [ bench "readsPrec pure streams" $

261+ nf readInstance (mkString value)

262+ , bench "readsPrec Haskell lists" $

263+ nf readInstanceList (mkListString value)

264+ ]

265+ ]

266+

267+-------------------------------------------------------------------------------

268+-- Main

269+-------------------------------------------------------------------------------

270+

271+-- In addition to gauge options, the number of elements in the stream can be

272+-- passed using the --stream-size option.

273+--

274+benchmarks :: String -> Int -> [Benchmark]

275+benchmarks moduleName size =

276+ [ bgroup (o_1_space_prefix moduleName) (o_1_space_generation size)

277+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_generation size)

278+ ]

benchmark/Streamly/Benchmark/Data/Stream/Lift.hsnew file+146

@@ -0,0 +1,146 @@

1+-- |

2+-- Module : Stream.Lift

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

7+{-# LANGUAGE CPP #-}

8+{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE ScopedTypeVariables #-}

10+{-# LANGUAGE RankNTypes #-}

11+

12+#ifdef USE_PRELUDE

13+{-# OPTIONS_GHC -Wno-deprecations #-}

14+#endif

15+

16+module Stream.Lift (benchmarks) where

17+

18+import Control.DeepSeq (NFData(..))

19+import Control.Monad.State.Strict (StateT, get, put)

20+import Data.Functor.Identity (Identity)

21+import Stream.Common (sourceUnfoldr, sourceUnfoldrM, benchIOSrc)

22+import System.Random (randomRIO)

23+

24+import qualified Stream.Common as Common

25+import qualified Streamly.Internal.Data.Fold as Fold

26+

27+#ifdef USE_PRELUDE

28+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

29+#else

30+import Streamly.Internal.Data.Stream (Stream)

31+import qualified Streamly.Internal.Data.Stream as Stream

32+#ifdef USE_STREAMK

33+import Stream.Common (benchIO, drain)

34+import Streamly.Internal.Data.StreamK (StreamK)

35+import qualified Streamly.Internal.Data.StreamK as StreamK

36+import qualified Control.Monad.State.Strict as State

37+#endif

38+#endif

39+

40+import Test.Tasty.Bench

41+import Streamly.Benchmark.Common

42+import Prelude hiding (reverse, tail)

43+

44+#ifdef USE_PRELUDE

45+type Stream = Stream.SerialT

46+#endif

47+

48+-------------------------------------------------------------------------------

49+-- Monad transformation (hoisting etc.)

50+-------------------------------------------------------------------------------

51+

52+{-# INLINE sourceUnfoldrState #-}

53+sourceUnfoldrState :: Common.MonadAsync m =>

54+ Int -> Int -> Stream (StateT Int m) Int

55+sourceUnfoldrState value n = Stream.unfoldrM step n

56+ where

57+ step cnt =

58+ if cnt > n + value

59+ then return Nothing

60+ else do

61+ s <- get

62+ put (s + 1)

63+ return (Just (s, cnt + 1))

64+

65+{-# INLINE evalStateT #-}

66+evalStateT :: Common.MonadAsync m => Int -> Int -> Stream m Int

67+evalStateT value n =

68+ Stream.evalStateT (return 0) (sourceUnfoldrState value n)

69+

70+{-# INLINE withState #-}

71+withState :: Common.MonadAsync m => Int -> Int -> Stream m Int

72+withState value n =

73+ Stream.evalStateT

74+ (return (0 :: Int)) (Stream.liftInner (sourceUnfoldrM value n))

75+

76+{-# INLINE benchHoistSink #-}

77+benchHoistSink

78+ :: (NFData b)

79+ => Int -> String -> (Stream Identity Int -> IO b) -> Benchmark

80+benchHoistSink value name f =

81+ bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldr value

82+

83+o_1_space_hoisting :: Int -> [Benchmark]

84+o_1_space_hoisting value =

85+ [ bgroup "hoisting"

86+ [ benchIOSrc "evalState" (evalStateT value)

87+ , benchIOSrc "withState" (withState value)

88+#ifndef USE_PRELUDE

89+ , benchHoistSink value "generalizeInner"

90+ ((\xs -> Stream.fold Fold.length xs :: IO Int)

91+ . Stream.generalizeInner)

92+#endif

93+ ]

94+ ]

95+

96+#ifdef USE_STREAMK

97+{-# INLINE iterateStateIO #-}

98+iterateStateIO ::

99+ Monad m

100+ => Int

101+ -> StateT Int m Int

102+iterateStateIO n = do

103+ x <- get

104+ if x > n

105+ then do

106+ put (x - 1)

107+ iterateStateIO n

108+ else return x

109+

110+-- XXX This is basically testing the perf of concatEffect, change it to just

111+-- use concatEffect and move it along with other concatMap benchmarks.

112+{-# INLINE iterateStateT #-}

113+iterateStateT :: Int -> StreamK (StateT Int IO) Int

114+iterateStateT n = StreamK.concatEffect $ do

115+ x <- get

116+ if x > n

117+ then do

118+ put (x - 1)

119+ return $ iterateStateT n

120+ else return $ StreamK.fromPure x

121+

122+o_n_heap_transformer :: Int -> [Benchmark]

123+o_n_heap_transformer value =

124+ [ bgroup "transformer"

125+ [ benchIO "StateT Int IO (n times) (baseline)" $ \n ->

126+ State.evalStateT (iterateStateIO n) value

127+ , benchIO "Stream (StateT Int IO) (n times)" $ \n ->

128+ State.evalStateT (drain $ Common.toStream (iterateStateT n)) value

129+ ]

130+ ]

131+#endif

132+

133+-------------------------------------------------------------------------------

134+-- Main

135+-------------------------------------------------------------------------------

136+

137+-- In addition to gauge options, the number of elements in the stream can be

138+-- passed using the --stream-size option.

139+--

140+benchmarks :: String -> Int -> [Benchmark]

141+benchmarks moduleName size =

142+ [ bgroup (o_1_space_prefix moduleName) (o_1_space_hoisting size)

143+#ifdef USE_STREAMK

144+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_transformer size)

145+#endif

146+ ]

benchmark/Streamly/Benchmark/Data/Stream/Reduce.hsnew file+588

@@ -0,0 +1,588 @@

1+-- |

2+-- Module : Stream.Reduce

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

7+{-# LANGUAGE CPP #-}

8+{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE ScopedTypeVariables #-}

10+{-# LANGUAGE DeriveAnyClass #-}

11+{-# LANGUAGE DeriveGeneric #-}

12+{-# LANGUAGE RankNTypes #-}

13+

14+#ifdef USE_PRELUDE

15+{-# OPTIONS_GHC -Wno-deprecations #-}

16+#endif

17+

18+module Stream.Reduce (benchmarks) where

19+

20+import Control.DeepSeq (NFData(..))

21+import Control.Monad.IO.Class (MonadIO(..))

22+import Data.Monoid (Sum(..))

23+import GHC.Generics (Generic)

24+

25+import qualified Streamly.Internal.Data.Refold.Type as Refold

26+import qualified Streamly.Internal.Data.Fold as FL

27+import qualified Stream.Common as Common

28+

29+#ifndef USE_STREAMLY_CORE

30+import Data.HashMap.Strict (HashMap)

31+import Data.Proxy (Proxy(..))

32+import Streamly.Internal.Data.IsMap.HashMap ()

33+#endif

34+

35+#ifdef USE_PRELUDE

36+import Control.Monad (when)

37+import qualified Streamly.Internal.Data.Stream.IsStream as S

38+import qualified Streamly.Prelude as S

39+import Streamly.Prelude (fromSerial)

40+import Streamly.Benchmark.Prelude hiding

41+ ( benchIO, benchIOSrc, sourceUnfoldrM, apDiscardFst, apDiscardSnd, apLiftA2

42+ , toNullAp, monadThen, toNullM, toNullM3, filterAllInM, filterAllOutM

43+ , filterSome, breakAfterSome, toListM, toListSome, transformMapM

44+ , transformComposeMapM, transformTeeMapM, transformZipMapM)

45+#else

46+

47+import Streamly.Internal.Data.Stream (Stream)

48+import qualified Streamly.Internal.Data.Stream as S

49+#ifndef USE_STREAMLY_CORE

50+import qualified Streamly.Data.Stream.Prelude as S

51+import qualified Streamly.Internal.Data.Stream.Prelude as S

52+#endif

53+

54+#ifdef USE_STREAMK

55+import Streamly.Internal.Data.StreamK (StreamK)

56+import qualified Streamly.Internal.Data.Parser as PR

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

58+#else

59+import qualified Streamly.Internal.Data.Stream as K

60+#endif

61+

62+#endif

63+

64+import Test.Tasty.Bench

65+import Streamly.Benchmark.Common

66+import Stream.Common

67+import Prelude hiding (reverse, tail)

68+

69+#ifdef USE_PRELUDE

70+type Stream = S.SerialT

71+#endif

72+

73+-- Apply transformation g count times on a stream of length len

74+#ifdef USE_STREAMK

75+{-# INLINE iterateSource #-}

76+iterateSource ::

77+ MonadAsync m

78+ => (StreamK m Int -> StreamK m Int)

79+ -> Int

80+ -> Int

81+ -> Int

82+ -> StreamK m Int

83+iterateSource g count len n = f count (fromStream $ sourceUnfoldrM len n)

84+

85+ where

86+

87+ f (0 :: Int) stream = stream

88+ f i stream = f (i - 1) (g stream)

89+#else

90+{-# INLINE iterateSource #-}

91+iterateSource ::

92+ MonadAsync m

93+ => (Stream m Int -> Stream m Int)

94+ -> Int

95+ -> Int

96+ -> Int

97+ -> Stream m Int

98+iterateSource g count len n = f count (sourceUnfoldrM len n)

99+

100+ where

101+

102+ f (0 :: Int) stream = stream

103+ f i stream = f (i - 1) (g stream)

104+#endif

105+

106+-------------------------------------------------------------------------------

107+-- Grouping transformations

108+-------------------------------------------------------------------------------

109+

110+{-# INLINE groups #-}

111+groups :: MonadIO m => Stream m Int -> m ()

112+groups =

113+#ifdef USE_PRELUDE

114+ Common.drain . S.groups FL.drain

115+#else

116+ Common.drain . S.groupsWhile (==) FL.drain

117+#endif

118+

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

136+

137+

138+{-# INLINE groupsByRollingLT #-}

139+groupsByRollingLT :: MonadIO m => Stream m Int -> m ()

140+groupsByRollingLT =

141+#ifdef USE_PRELUDE

142+ Common.drain . S.groupsByRolling (<) FL.drain

143+#else

144+ Common.drain . S.groupsRollingBy (<) FL.drain

145+#endif

146+

147+{-# INLINE groupsByRollingEq #-}

148+groupsByRollingEq :: MonadIO m => Stream m Int -> m ()

149+groupsByRollingEq =

150+#ifdef USE_PRELUDE

151+ Common.drain . S.groupsByRolling (==) FL.drain

152+#else

153+ Common.drain . S.groupsRollingBy (==) FL.drain

154+#endif

155+

156+{-# INLINE foldMany #-}

157+foldMany :: Monad m => Stream m Int -> m ()

158+foldMany =

159+ Common.drain

160+ . fmap getSum

161+ . S.foldMany (FL.take 2 FL.mconcat)

162+ . fmap Sum

163+

164+{-# INLINE foldManyPost #-}

165+foldManyPost :: Monad m => Stream m Int -> m ()

166+foldManyPost =

167+ Common.drain

168+ . fmap getSum

169+ . S.foldManyPost (FL.take 2 FL.mconcat)

170+ . fmap Sum

171+

172+{-# INLINE refoldMany #-}

173+refoldMany :: Monad m => Stream m Int -> m ()

174+refoldMany =

175+ Common.drain

176+ . fmap getSum

177+ . S.refoldMany (Refold.take 2 Refold.sconcat) (return mempty)

178+ . fmap Sum

179+

180+{-# INLINE foldIterateM #-}

181+foldIterateM :: Monad m => Stream m Int -> m ()

182+foldIterateM =

183+ Common.drain

184+ . fmap getSum

185+ . S.foldIterateM

186+ (return . FL.take 2 . FL.sconcat) (return (Sum 0))

187+ . fmap Sum

188+

189+{-# INLINE refoldIterateM #-}

190+refoldIterateM :: Monad m => Stream m Int -> m ()

191+refoldIterateM =

192+ Common.drain

193+ . fmap getSum

194+ . S.refoldIterateM

195+ (Refold.take 2 Refold.sconcat) (return (Sum 0))

196+ . fmap Sum

197+

198+#ifdef USE_STREAMK

199+{-# INLINE parseBreak #-}

200+parseBreak :: Monad m => StreamK m Int -> m ()

201+parseBreak s = do

202+ r <- K.parseDBreak PR.one s

203+ case r of

204+ (Left _, _) -> return ()

205+ (Right _, s1) -> parseBreak s1

206+#endif

207+

208+o_1_space_grouping :: Int -> [Benchmark]

209+o_1_space_grouping value =

210+ -- Buffering operations using heap proportional to group/window sizes.

211+ [ bgroup "grouping"

212+ [

213+ benchIOSink value "groups" groups

214+ , benchIOSink value "groupsWhileLT" groupsWhileLT

215+ , benchIOSink value "groupsWhileEq" groupsWhileEq

216+ , benchIOSink value "groupsByRollingLT" groupsByRollingLT

217+ , benchIOSink value "groupsByRollingEq" groupsByRollingEq

218+ ,

219+

220+ -- XXX parseMany/parseIterate benchmarks are in the Parser/ParserD

221+ -- modules we can bring those here. chunksOf benchmarks are in

222+ -- Parser/ParserD/Array.Stream/FileSystem.Handle.

223+ benchIOSink value "foldMany" foldMany

224+ , benchIOSink value "foldManyPost" foldManyPost

225+ , benchIOSink value "refoldMany" refoldMany

226+ , benchIOSink value "foldIterateM" foldIterateM

227+ , benchIOSink value "refoldIterateM" refoldIterateM

228+#ifdef USE_STREAMK

229+ , benchIOSink value "parseBreak (recursive)" (parseBreak . fromStream)

230+#endif

231+

232+#ifndef USE_STREAMLY_CORE

233+ , benchIOSink value "classifySessionsOf (10000 buckets)"

234+ (classifySessionsOf (getKey 10000))

235+ , benchIOSink value "classifySessionsOf (64 buckets)"

236+ (classifySessionsOf (getKey 64))

237+ , benchIOSink value "classifySessionsOfHash (10000 buckets)"

238+ (classifySessionsOfHash (getKey 10000))

239+ , benchIOSink value "classifySessionsOfHash (64 buckets)"

240+ (classifySessionsOfHash (getKey 64))

241+#endif

242+ ]

243+ ]

244+

245+#ifndef USE_STREAMLY_CORE

246+ where

247+

248+ getKey :: Int -> Int -> Int

249+ getKey n = (`mod` n)

250+#endif

251+

252+-------------------------------------------------------------------------------

253+-- Size conserving transformations (reordering, buffering, etc.)

254+-------------------------------------------------------------------------------

255+

256+#ifndef USE_PRELUDE

257+{-# INLINE reverse #-}

258+reverse :: MonadIO m => Int -> Stream m Int -> m ()

259+reverse n = composeN n (toStream . K.reverse . fromStream)

260+

261+{-# INLINE reverse' #-}

262+reverse' :: MonadIO m => Int -> Stream m Int -> m ()

263+reverse' n = composeN n S.reverseUnbox

264+#endif

265+

266+o_n_heap_buffering :: Int -> [Benchmark]

267+o_n_heap_buffering value =

268+ [ bgroup "buffered"

269+ [

270+#ifndef USE_PRELUDE

271+ -- Reversing a stream

272+ benchIOSink value "reverse" (reverse 1)

273+ , benchIOSink value "reverse'" (reverse' 1)

274+#else

275+ benchIOSink value "mkAsync" (mkAsync fromSerial)

276+#endif

277+ ]

278+ ]

279+

280+-------------------------------------------------------------------------------

281+-- Grouping/Splitting

282+-------------------------------------------------------------------------------

283+

284+#ifndef USE_STREAMLY_CORE

285+{-# INLINE classifySessionsOf #-}

286+classifySessionsOf :: S.MonadAsync m => (Int -> Int) -> Stream m Int -> m ()

287+classifySessionsOf getKey =

288+ Common.drain

289+ . S.classifySessionsOf

290+ (const (return False)) 3 (FL.take 10 FL.sum)

291+ . S.timestamped

292+ . fmap (\x -> (getKey x, x))

293+

294+{-# INLINE classifySessionsOfHash #-}

295+classifySessionsOfHash :: S.MonadAsync m =>

296+ (Int -> Int) -> Stream m Int -> m ()

297+classifySessionsOfHash getKey =

298+ Common.drain

299+ . S.classifySessionsByGeneric

300+ (Proxy :: Proxy (HashMap k))

301+ 1 False (const (return False)) 3 (FL.take 10 FL.sum)

302+ . S.timestamped

303+ . fmap (\x -> (getKey x, x))

304+#endif

305+

306+-------------------------------------------------------------------------------

307+-- Mixed Transformation

308+-------------------------------------------------------------------------------

309+

310+{-# INLINE scanMap #-}

311+scanMap :: MonadIO m => Int -> Stream m Int -> m ()

312+scanMap n = composeN n $ fmap (subtract 1) . Common.scanl' (+) 0

313+

314+{-# INLINE dropMap #-}

315+dropMap :: MonadIO m => Int -> Stream m Int -> m ()

316+dropMap n = composeN n $ fmap (subtract 1) . S.drop 1

317+

318+{-# INLINE dropScan #-}

319+dropScan :: MonadIO m => Int -> Stream m Int -> m ()

320+dropScan n = composeN n $ Common.scanl' (+) 0 . S.drop 1

321+

322+{-# INLINE takeDrop #-}

323+takeDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

324+takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)

325+

326+{-# INLINE takeScan #-}

327+takeScan :: MonadIO m => Int -> Int -> Stream m Int -> m ()

328+takeScan value n = composeN n $ Common.scanl' (+) 0 . S.take (value + 1)

329+

330+{-# INLINE takeMap #-}

331+takeMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

332+takeMap value n = composeN n $ fmap (subtract 1) . S.take (value + 1)

333+

334+{-# INLINE filterDrop #-}

335+filterDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()

336+filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))

337+

338+{-# INLINE filterTake #-}

339+filterTake :: MonadIO m => Int -> Int -> Stream m Int -> m ()

340+filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))

341+

342+{-# INLINE filterScan #-}

343+filterScan :: MonadIO m => Int -> Stream m Int -> m ()

344+filterScan n = composeN n $ Common.scanl' (+) 0 . S.filter (<= maxBound)

345+

346+#ifdef USE_PRELUDE

347+{-# INLINE filterScanl1 #-}

348+filterScanl1 :: MonadIO m => Int -> Stream m Int -> m ()

349+filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)

350+#endif

351+

352+{-# INLINE filterMap #-}

353+filterMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()

354+filterMap value n = composeN n $ fmap (subtract 1) . S.filter (<= (value + 1))

355+

356+-------------------------------------------------------------------------------

357+-- Scan and fold

358+-------------------------------------------------------------------------------

359+

360+data Pair a b =

361+ Pair !a !b

362+ deriving (Generic, NFData)

363+

364+{-# INLINE sumProductFold #-}

365+sumProductFold :: Monad m => Stream m Int -> m (Pair Int Int)

366+sumProductFold =

367+ Common.foldl' (\(Pair s p) x -> Pair (s + x) (p * x)) (Pair 0 1)

368+

369+{-# INLINE sumProductScan #-}

370+sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)

371+sumProductScan =

372+ Common.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p * x)) (Pair 0 1) .

373+ Common.scanl' (\(s, _) x -> (s + x, x)) (0, 0)

374+

375+{-# INLINE foldl'ReduceMap #-}

376+foldl'ReduceMap :: Monad m => Stream m Int -> m Int

377+foldl'ReduceMap = fmap (+ 1) . Common.foldl' (+) 0

378+

379+o_1_space_transformations_mixed :: Int -> [Benchmark]

380+o_1_space_transformations_mixed value =

381+ -- scanl-map and foldl-map are equivalent to the scan and fold in the foldl

382+ -- library. If scan/fold followed by a map is efficient enough we may not

383+ -- need monolithic implementations of these.

384+ [ bgroup "mixed"

385+ [ benchIOSink value "scanl-map" (scanMap 1)

386+ , benchIOSink value "foldl-map" foldl'ReduceMap

387+ , benchIOSink value "sum-product-fold" sumProductFold

388+ , benchIOSink value "sum-product-scan" sumProductScan

389+ ]

390+ ]

391+

392+o_1_space_transformations_mixedX4 :: Int -> [Benchmark]

393+o_1_space_transformations_mixedX4 value =

394+ [ bgroup "mixedX4"

395+ [ benchIOSink value "scan-map" (scanMap 4)

396+ , benchIOSink value "drop-map" (dropMap 4)

397+ , benchIOSink value "drop-scan" (dropScan 4)

398+ , benchIOSink value "take-drop" (takeDrop value 4)

399+ , benchIOSink value "take-scan" (takeScan value 4)

400+ , benchIOSink value "take-map" (takeMap value 4)

401+ , benchIOSink value "filter-drop" (filterDrop value 4)

402+ , benchIOSink value "filter-take" (filterTake value 4)

403+ , benchIOSink value "filter-scan" (filterScan 4)

404+#ifdef USE_PRELUDE

405+ , benchIOSink value "filter-scanl1" (filterScanl1 4)

406+#endif

407+ , benchIOSink value "filter-map" (filterMap value 4)

408+ ]

409+ ]

410+

411+-------------------------------------------------------------------------------

412+-- Iterating a transformation over and over again

413+-------------------------------------------------------------------------------

414+

415+#ifdef USE_STREAMK

416+{-

417+-- this is quadratic

418+{-# INLINE iterateScan #-}

419+iterateScan :: MonadAsync m => Int -> Int -> Int -> Stream m Int

420+iterateScan count len = toStream . iterateSource (K.scanl' (+) 0) count len

421+-}

422+

423+{-# INLINE iterateMapM #-}

424+iterateMapM :: MonadAsync m => Int -> Int -> Int -> Stream m Int

425+iterateMapM count len = toStream . iterateSource (K.mapM return) count len

426+

427+{-# INLINE iterateFilterEven #-}

428+iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> Stream m Int

429+iterateFilterEven count len =

430+ toStream . iterateSource (K.filter even) count len

431+

432+{-# INLINE iterateTakeAll #-}

433+iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

434+iterateTakeAll value count len =

435+ toStream . iterateSource (K.take (value + 1)) count len

436+

437+{-# INLINE iterateDropOne #-}

438+iterateDropOne :: MonadAsync m => Int -> Int -> Int -> Stream m Int

439+iterateDropOne count len = toStream . iterateSource (K.drop 1) count len

440+

441+{-# INLINE iterateDropWhileTrue #-}

442+iterateDropWhileTrue :: MonadAsync m

443+ => Int -> Int -> Int -> Int -> Stream m Int

444+iterateDropWhileTrue value count len =

445+ toStream . iterateSource (K.dropWhile (<= (value + 1))) count len

446+

447+{-# INLINE iterateDropWhileFalse #-}

448+iterateDropWhileFalse :: MonadAsync m

449+ => Int -> Int -> Int -> Int -> Stream m Int

450+iterateDropWhileFalse value count len =

451+ toStream . iterateSource (K.dropWhile (> (value + 1))) count len

452+

453+#else

454+

455+-- this is quadratic

456+{-# INLINE iterateScan #-}

457+iterateScan :: MonadAsync m => Int -> Int -> Int -> Stream m Int

458+iterateScan = iterateSource (Common.scanl' (+) 0)

459+

460+#ifdef USE_PRELUDE

461+-- this is quadratic

462+{-# INLINE iterateScanl1 #-}

463+iterateScanl1 :: MonadAsync m => Int -> Int -> Int -> Stream m Int

464+iterateScanl1 = iterateSource (S.scanl1' (+))

465+#endif

466+

467+{-# INLINE iterateMapM #-}

468+iterateMapM :: MonadAsync m => Int -> Int -> Int -> Stream m Int

469+iterateMapM = iterateSource (S.mapM return)

470+

471+{-# INLINE iterateFilterEven #-}

472+iterateFilterEven :: MonadAsync m => Int -> Int -> Int -> Stream m Int

473+iterateFilterEven = iterateSource (S.filter even)

474+

475+{-# INLINE iterateTakeAll #-}

476+iterateTakeAll :: MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

477+iterateTakeAll value = iterateSource (S.take (value + 1))

478+

479+{-# INLINE iterateDropOne #-}

480+iterateDropOne :: MonadAsync m => Int -> Int -> Int -> Stream m Int

481+iterateDropOne = iterateSource (S.drop 1)

482+

483+{-# INLINE iterateDropWhileTrue #-}

484+iterateDropWhileTrue :: MonadAsync m

485+ => Int -> Int -> Int -> Int -> Stream m Int

486+iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1)))

487+#endif

488+

489+#ifdef USE_PRELUDE

490+{-# INLINE tail #-}

491+tail :: Monad m => Stream m a -> m ()

492+tail s = S.tail s >>= mapM_ tail

493+

494+{-# INLINE nullHeadTail #-}

495+nullHeadTail :: Monad m => Stream m Int -> m ()

496+nullHeadTail s = do

497+ r <- S.null s

498+ when (not r) $ do

499+ _ <- S.head s

500+ S.tail s >>= mapM_ nullHeadTail

501+#endif

502+

503+-- Head recursive operations.

504+o_n_stack_iterated :: Int -> [Benchmark]

505+o_n_stack_iterated value = by10 `seq` by100 `seq`

506+ [ bgroup "iterated"

507+ [ benchIOSrc "mapM (n/10 x 10)" $ iterateMapM by10 10

508+#ifndef USE_STREAMK

509+ , benchIOSrc "scanl' (quadratic) (n/100 x 100)" $

510+ iterateScan by100 100

511+#endif

512+#ifdef USE_PRELUDE

513+ , benchIOSrc "scanl1' (n/10 x 10)" $ iterateScanl1 by10 10

514+#endif

515+ , benchIOSrc "filterEven (n/10 x 10)" $

516+ iterateFilterEven by10 10

517+ , benchIOSrc "takeAll (n/10 x 10)" $

518+ iterateTakeAll value by10 10

519+ , benchIOSrc "dropOne (n/10 x 10)" $ iterateDropOne by10 10

520+#ifdef USE_STREAMK

521+ , benchIOSrc "dropWhileFalse (n/10 x 10)" $

522+ iterateDropWhileFalse value by10 10

523+#endif

524+ , benchIOSrc "dropWhileTrue (n/10 x 10)" $

525+ iterateDropWhileTrue value by10 10

526+#ifdef USE_PRELUDE

527+ , benchIOSink value "tail" tail

528+ , benchIOSink value "nullHeadTail" nullHeadTail

529+#endif

530+ ]

531+ ]

532+

533+ where

534+

535+ by10 = value `div` 10

536+ by100 = value `div` 100

537+

538+-------------------------------------------------------------------------------

539+-- Pipes

540+-------------------------------------------------------------------------------

541+

542+o_1_space_pipes :: Int -> [Benchmark]

543+o_1_space_pipes value =

544+ [ bgroup "pipes"

545+ [ benchIOSink value "mapM" (transformMapM 1)

546+ , benchIOSink value "compose" (transformComposeMapM 1)

547+ , benchIOSink value "tee" (transformTeeMapM 1)

548+#ifdef DEVBUILD

549+ -- XXX this take 1 GB memory to compile

550+ , benchIOSink value "zip" (transformZipMapM 1)

551+#endif

552+ ]

553+ ]

554+

555+o_1_space_pipesX4 :: Int -> [Benchmark]

556+o_1_space_pipesX4 value =

557+ [ bgroup "pipesX4"

558+ [ benchIOSink value "mapM" (transformMapM 4)

559+ , benchIOSink value "compose" (transformComposeMapM 4)

560+ , benchIOSink value "tee" (transformTeeMapM 4)

561+#ifdef DEVBUILD

562+ -- XXX this take 1 GB memory to compile

563+ , benchIOSink value "zip" (transformZipMapM 4)

564+#endif

565+ ]

566+ ]

567+

568+-------------------------------------------------------------------------------

569+-- Main

570+-------------------------------------------------------------------------------

571+

572+-- In addition to gauge options, the number of elements in the stream can be

573+-- passed using the --stream-size option.

574+--

575+benchmarks :: String -> Int -> [Benchmark]

576+benchmarks moduleName size =

577+ [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat

578+ [ o_1_space_grouping size

579+ , o_1_space_transformations_mixed size

580+ , o_1_space_transformations_mixedX4 size

581+

582+ -- pipes

583+ , o_1_space_pipes size

584+ , o_1_space_pipesX4 size

585+ ]

586+ , bgroup (o_n_stack_prefix moduleName) (o_n_stack_iterated size)

587+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_buffering size)

588+ ]

benchmark/Streamly/Benchmark/Prelude/Serial/Split.hs → benchmark/Streamly/Benchmark/Data/Stream/Split.hsrenamed+25−12

@@ -1,5 +1,7 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

2−-- Module : Streamly.Benchmark.Prelude.Serial.Split

4+-- Module : Stream.Split

46-- License : BSD-3-Clause

57-- Maintainer : streamly@composewell.com

@@ -18,14 +20,14 @@

1820{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1921#endif

2022

21−module Serial.Split (benchmarks) where

23+module Stream.Split (benchmarks) where

2224

2325import Data.Char (ord)

2426import Data.Word (Word8)

2527import System.IO (Handle)

2628

2729import qualified Streamly.FileSystem.Handle as FH

28−import qualified Streamly.Internal.Data.Array.Foreign as A

30+import qualified Streamly.Internal.Data.Array as A

2931import qualified Streamly.Internal.Data.Fold as FL

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

3133import qualified Streamly.Internal.Data.Stream.IsStream as IP

@@ -33,15 +35,15 @@ import qualified Streamly.Internal.FileSystem.Handle as IFH

3335import qualified Streamly.Internal.Unicode.Stream as IUS

3436import qualified Streamly.Prelude as S

3537

36−import Gauge hiding (env)

38+import Test.Tasty.Bench hiding (env)

3739import Prelude hiding (last, length)

3840import Streamly.Benchmark.Common

3941import Streamly.Benchmark.Common.Handle

4042

4143#ifdef INSPECTION

42−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))

44+import Streamly.Internal.Data.Stream (Step(..))

4345

44−import qualified Streamly.Internal.Data.Array.Foreign.Mut.Type as MA

46+import qualified Streamly.Internal.Data.MutArray as MA

4547import qualified Streamly.Internal.Data.Unfold as IUF

4648

4749import Test.Inspection

@@ -67,7 +69,7 @@ splitOn inh =

6769inspect $ hasNoTypeClasses 'splitOn

6870inspect $ 'splitOn `hasNoType` ''Step

6971inspect $ 'splitOn `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

70−inspect $ 'splitOn `hasNoType` ''MA.ReadUState -- FH.read/A.read

72+inspect $ 'splitOn `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read

7173#endif

7274

7375-- | Split suffix on line feed.

@@ -80,7 +82,7 @@ splitOnSuffix inh =

8082inspect $ hasNoTypeClasses 'splitOnSuffix

8183inspect $ 'splitOnSuffix `hasNoType` ''Step

8284inspect $ 'splitOnSuffix `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

83−inspect $ 'splitOnSuffix `hasNoType` ''MA.ReadUState -- FH.read/A.read

85+inspect $ 'splitOnSuffix `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read

8486#endif

8587

8688-- | Split suffix with line feed.

@@ -93,7 +95,7 @@ splitWithSuffix inh =

9395inspect $ hasNoTypeClasses 'splitWithSuffix

9496inspect $ 'splitWithSuffix `hasNoType` ''Step

9597inspect $ 'splitWithSuffix `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

96−inspect $ 'splitWithSuffix `hasNoType` ''MA.ReadUState -- FH.read/A.read

98+inspect $ 'splitWithSuffix `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read

9799#endif

98100

99101-- | Split on line feed.

@@ -124,7 +126,7 @@ wordsBy inh =

124126inspect $ hasNoTypeClasses 'wordsBy

125127inspect $ 'wordsBy `hasNoType` ''Step

126128inspect $ 'wordsBy `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

127−inspect $ 'wordsBy `hasNoType` ''MA.ReadUState -- FH.read/A.read

129+inspect $ 'wordsBy `hasNoType` ''MA.ArrayUnsafe -- FH.read/A.read

128130#endif

129131

130132-- | Split on a word8 sequence.

@@ -141,7 +143,7 @@ splitOnSeq str inh =

141143-- | Split on a word8 sequence.

142144splitOnSeq100k :: Handle -> IO Int

143145splitOnSeq100k inh = do

144− arr <- A.fromStream $ S.replicate 100000 123

146+ arr <- A.fromStream $ IP.toStream $ S.fromSerial $ S.replicate 100000 123

145147 (S.length $ IP.splitOnSeq arr FL.drain

146148 $ S.unfold FH.read inh) -- >>= print

147149

@@ -156,6 +158,12 @@ splitOnSuffixSeq str inh =

156158-- inspect $ 'splitOnSuffixSeq `hasNoType` ''Step

157159#endif

158160

161+-- | Split on suffix sequence.

162+splitWithSuffixSeq :: String -> Handle -> IO Int

163+splitWithSuffixSeq str inh =

164+ S.length $ IP.splitWithSuffixSeq (toarr str) FL.drain

165+ $ S.unfold FH.read inh -- >>= print

166+

159167o_1_space_reduce_read_split :: BenchEnv -> [Benchmark]

160168o_1_space_reduce_read_split env =

161169 [ bgroup "split"

@@ -185,6 +193,8 @@ o_1_space_reduce_read_split env =

185193 splitOnSeq "\r\n" inh

186194 , mkBench "S.splitOnSuffixSeq \"\\r\\n\" FL.drain" env $ \inh _ ->

187195 splitOnSuffixSeq "\r\n" inh

196+ , mkBench "S.splitWithSuffixSeq \"\\r\\n\" FL.drain" env $ \inh _ ->

197+ splitWithSuffixSeq "\r\n" inh

188198 , mkBench "S.splitOnSeq \"aa\" FL.drain" env $ \inh _ ->

189199 splitOnSeq "aa" inh

190200 , mkBench "S.splitOnSeq \"aaaa\" FL.drain" env $ \inh _ ->

@@ -201,6 +211,8 @@ o_1_space_reduce_read_split env =

201211 env $ \inh _ -> splitOnSeq100k inh

202212 , mkBenchSmall "S.splitOnSuffixSeq \"abcdefghijklmnopqrstuvwxyz\" FL.drain"

203213 env $ \inh _ -> splitOnSuffixSeq "abcdefghijklmnopqrstuvwxyz" inh

214+ , mkBenchSmall "S.splitWithSuffixSeq \"abcdefghijklmnopqrstuvwxyz\" FL.drain"

215+ env $ \inh _ -> splitWithSuffixSeq "abcdefghijklmnopqrstuvwxyz" inh

204216 ]

205217 ]

206218

@@ -208,8 +220,9 @@ o_1_space_reduce_read_split env =

208220splitOnSeqUtf8 :: String -> Handle -> IO Int

209221splitOnSeqUtf8 str inh =

210222 (S.length $ IP.splitOnSeq (A.fromList str) FL.drain

223+ $ IP.fromStream

211224 $ IUS.decodeUtf8Arrays

212− $ IFH.toChunks inh) -- >>= print

225+ $ IFH.readChunks inh) -- >>= print

213226

214227o_1_space_reduce_toChunks_split :: BenchEnv -> [Benchmark]

215228o_1_space_reduce_toChunks_split env =

benchmark/Streamly/Benchmark/Data/Stream/StreamD.hs+46−5

@@ -8,6 +8,8 @@

88{-# LANGUAGE CPP #-}

99{-# LANGUAGE FlexibleContexts #-}

1010{-# LANGUAGE ScopedTypeVariables #-}

11+{-# LANGUAGE TupleSections #-}

12+{-# OPTIONS_GHC -Wno-orphans #-}

1113

1214#ifdef __HADDOCK_VERSION__

1315#undef INSPECTION

@@ -20,15 +22,19 @@

2022

2123module Main (main) where

2224

25+#if !MIN_VERSION_base(4,18,0)

26+import Control.Applicative (liftA2)

27+#endif

2328import Control.Monad (when)

2429import Data.Maybe (isJust)

25−import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)

30+import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)

2631import System.Random (randomRIO)

2732import Prelude hiding (tail, mapM_, foldl, last, map, mapM, concatMap, zip)

2833

2934import qualified Prelude as P

30−import qualified Streamly.Internal.Data.Stream.StreamD as S

35+import qualified Streamly.Internal.Data.Stream as S

3136import qualified Streamly.Internal.Data.Unfold as UF

37+import qualified Streamly.Internal.Data.Fold as FL

3238

3339import Streamly.Benchmark.Common

3440

@@ -125,6 +131,12 @@ uncons s = do

125131 Nothing -> return ()

126132 Just (_, t) -> uncons t

127133

134+{-# INLINE foldBreak #-}

135+foldBreak :: Monad m => Stream m Int -> m ()

136+foldBreak s = do

137+ (r, s1) <- S.foldBreak (FL.take 1 FL.length) s

138+ when (r /= 0) $ foldBreak s1

139+

128140{-# INLINE tail #-}

129141tail :: Monad m => Stream m a -> m ()

130142tail s = S.tail s >>= P.mapM_ tail

@@ -314,6 +326,34 @@ filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)

314326-- Nested Composition

315327-------------------------------------------------------------------------------

316328

329+instance Monad f => Applicative (S.Stream f) where

330+ {-# INLINE pure #-}

331+ pure = S.fromPure

332+

333+ {-# INLINE (<*>) #-}

334+ (<*>) = S.crossApply

335+

336+ {-# INLINE liftA2 #-}

337+ liftA2 f x = (<*>) (fmap f x)

338+

339+ {-# INLINE (*>) #-}

340+ (*>) = S.crossApplySnd

341+

342+ {-# INLINE (<*) #-}

343+ (<*) = S.crossApplyFst

344+

345+-- NOTE: even though concatMap for StreamD is 4x faster compared to StreamK,

346+-- the monad instance does not seem to be significantly faster.

347+instance Monad m => Monad (S.Stream m) where

348+ {-# INLINE return #-}

349+ return = pure

350+

351+ {-# INLINE (>>=) #-}

352+ (>>=) = flip S.concatMap

353+

354+ {-# INLINE (>>) #-}

355+ (>>) = (*>)

356+

317357{-# INLINE toNullApNested #-}

318358toNullApNested :: Monad m => Stream m Int -> m ()

319359toNullApNested s = runStream $ do

@@ -409,8 +449,8 @@ unfoldManyRepl :: Int -> Int -> Int -> IO ()

409449unfoldManyRepl outer inner n =

410450 S.drain

411451 $ S.unfoldMany

412− (UF.lmap return (UF.replicateM inner))

413− (sourceUnfoldrMN outer n)

452+ UF.replicateM

453+ (S.map ((inner,) . return) (sourceUnfoldrMN outer n))

414454

415455#ifdef INSPECTION

416456inspect $ hasNoTypeClasses 'unfoldManyRepl

@@ -423,7 +463,7 @@ inspect $ 'unfoldManyRepl `hasNoType` ''SPEC

423463-------------------------------------------------------------------------------

424464

425465moduleName :: String

426−moduleName = "Data.Stream.StreamD"

466+moduleName = "Data.StreamD"

427467

428468o_1_space :: [Benchmark]

429469o_1_space =

@@ -439,6 +479,7 @@ o_1_space =

439479 [ benchFold "toNull" toNull sourceUnfoldrM

440480 , benchFold "mapM_" mapM_ sourceUnfoldrM

441481 , benchFold "uncons" uncons sourceUnfoldrM

482+ , benchFold "foldBreak" foldBreak sourceUnfoldrM

442483 , benchFold "foldl'" foldl sourceUnfoldrM

443484 , benchFold "last" last sourceUnfoldrM

444485 ]

benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs+127−48

@@ -8,6 +8,7 @@

88{-# LANGUAGE CPP #-}

99{-# LANGUAGE FlexibleContexts #-}

1010{-# LANGUAGE ScopedTypeVariables #-}

11+{-# OPTIONS_GHC -Wno-orphans #-}

1112

1213#ifdef __HADDOCK_VERSION__

1314#undef INSPECTION

@@ -20,19 +21,23 @@

2021

2122module Main (main) where

2223

24+#if !MIN_VERSION_base(4,18,0)

25+import Control.Applicative (liftA2)

26+#endif

2327import Control.Monad (when)

2428import Data.Maybe (isJust)

2529import System.Random (randomRIO)

2630import Prelude hiding

27− (tail, mapM_, foldl, last, map, mapM, concatMap, zipWith, init)

31+ ( Foldable(..), tail, mapM_, last, map, mapM, concatMap, zipWith, init, iterate

32+ , repeat, replicate

33+ )

2834

2935import qualified Prelude as P

3036import qualified Data.List as List

3137

32−import qualified Streamly.Internal.Data.Stream.StreamK as S

33−import qualified Streamly.Internal.Data.SVar as S

38+import qualified Streamly.Internal.Data.StreamK as S

3439

35−import Gauge (bench, nfIO, bgroup, Benchmark, defaultMain)

40+import Test.Tasty.Bench (bench, nfIO, bgroup, Benchmark, defaultMain)

3641

3742import Streamly.Benchmark.Common

3843

@@ -44,12 +49,6 @@ import Test.Inspection

4449

4550Benchmarks that need to be added

4651

47−-- repeat

48−-- repeatM

49−-- replicate

50−-- replicateM

51−-- iterate

52−-- iterateM

5352-- fromList

5453

5554-- bindWith

@@ -118,7 +117,7 @@ Benchmarks that need to be added

118117-- Stream generation and elimination

119118-------------------------------------------------------------------------------

120119

121−type Stream m a = S.Stream m a

120+type Stream m a = S.StreamK m a

122121

123122{-# INLINE unfoldr #-}

124123unfoldr :: Int -> Int -> Stream m Int

@@ -130,36 +129,64 @@ unfoldr streamLen n = S.unfoldr step n

130129 else Just (cnt, cnt + 1)

131130

132131{-# INLINE unfoldrM #-}

133−unfoldrM :: S.MonadAsync m => Int -> Int -> Stream m Int

134−unfoldrM streamLen n = S.unfoldrM step n

132+unfoldrM :: Monad m => Int -> Int -> Stream m Int

133+unfoldrM streamLen n = S.unfoldrMWith S.consM step n

135134 where

136135 step cnt =

137136 if cnt > n + streamLen

138137 then return Nothing

139138 else return (Just (cnt, cnt + 1))

140139

140+{-# INLINE repeat #-}

141+repeat :: Int -> Int -> Stream m Int

142+repeat streamLen = S.take streamLen . S.repeat

143+

144+{-# INLINE repeatM #-}

145+repeatM :: Monad m => Int -> Int -> Stream m Int

146+repeatM streamLen = S.take streamLen . S.repeatM . return

147+

148+{-# INLINE replicate #-}

149+replicate :: Int -> Int -> Stream m Int

150+replicate = S.replicate

151+

152+{-# INLINE replicateM #-}

153+replicateM :: Monad m => Int -> Int -> Stream m Int

154+replicateM streamLen = S.replicateMWith S.consM streamLen . return

155+

156+{-# INLINE iterate #-}

157+iterate :: Int -> Int -> Stream m Int

158+iterate streamLen = S.take streamLen . S.iterate (+1)

159+

160+{-# INLINE iterateM #-}

161+iterateM :: Monad m => Int -> Int -> Stream m Int

162+iterateM streamLen = S.take streamLen . S.iterateM (return . (+1)) . return

163+

141164{-# INLINE fromFoldable #-}

142165fromFoldable :: Int -> Int -> Stream m Int

143166fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]

144167

145168{-# INLINE fromFoldableM #-}

146−fromFoldableM :: S.MonadAsync m => Int -> Int -> Stream m Int

169+fromFoldableM :: Monad m => Int -> Int -> Stream m Int

147170fromFoldableM streamLen n =

148− 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])

149172

150173{-# INLINABLE concatMapFoldableWith #-}

151−concatMapFoldableWith :: (S.IsStream t, Foldable f)

152− => (t m b -> t m b -> t m b) -> (a -> t m b) -> f a -> t m b

153−concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil

174+concatMapFoldableWith :: P.Foldable f

175+ => (Stream m b -> Stream m b -> Stream m b)

176+ -> (a -> Stream m b)

177+ -> f a

178+ -> Stream m b

179+concatMapFoldableWith f g = P.foldr (f . g) S.nil

154180

155181{-# INLINE concatMapFoldableSerial #-}

156182concatMapFoldableSerial :: Int -> Int -> Stream m Int

157−concatMapFoldableSerial streamLen n = concatMapFoldableWith S.serial S.yield [n..n+streamLen]

183+concatMapFoldableSerial streamLen n =

184+ concatMapFoldableWith S.append S.fromPure [n..n+streamLen]

158185

159186{-# INLINE concatMapFoldableSerialM #-}

160187concatMapFoldableSerialM :: Monad m => Int -> Int -> Stream m Int

161188concatMapFoldableSerialM streamLen n =

162− concatMapFoldableWith S.serial (S.yieldM . return) [n..n+streamLen]

189+ concatMapFoldableWith S.append (S.fromEffect . return) [n..n+streamLen]

163190

164191-------------------------------------------------------------------------------

165192-- Elimination

@@ -182,13 +209,13 @@ uncons s = do

182209 Just (_, t) -> uncons t

183210

184211{-# INLINE init #-}

185−init :: (Monad m, S.IsStream t) => t m a -> m ()

212+init :: Monad m => Stream m a -> m ()

186213init s = do

187214 t <- S.init s

188215 P.mapM_ S.drain t

189216

190217{-# INLINE tail #-}

191−tail :: (Monad m, S.IsStream t) => t m a -> m ()

218+tail :: Monad m => Stream m a -> m ()

192219tail s = S.tail s >>= P.mapM_ tail

193220

194221{-# INLINE nullTail #-}

@@ -244,11 +271,11 @@ fmapK :: Monad m => Int -> Stream m Int -> m ()

244271fmapK n = composeN n $ P.fmap (+ 1)

245272

246273{-# INLINE mapM #-}

247−mapM :: S.MonadAsync m => Int -> Stream m Int -> m ()

248−mapM n = composeN n $ S.mapM return

274+mapM :: Monad m => Int -> Stream m Int -> m ()

275+mapM n = composeN n $ S.mapMWith S.consM return

249276

250277{-# INLINE mapMSerial #-}

251−mapMSerial :: S.MonadAsync m => Int -> Stream m Int -> m ()

278+mapMSerial :: Monad m => Int -> Stream m Int -> m ()

252279mapMSerial n = composeN n $ S.mapMSerial return

253280

254281{-# INLINE filterEven #-}

@@ -300,7 +327,7 @@ foldlS :: Monad m => Int -> Stream m Int -> m ()

300327foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil

301328

302329{-# INLINE intersperse #-}

303−intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()

330+intersperse :: Monad m => Int -> Int -> Stream m Int -> m ()

304331intersperse streamLen n = composeN n $ S.intersperse streamLen

305332

306333-------------------------------------------------------------------------------

@@ -309,8 +336,7 @@ intersperse streamLen n = composeN n $ S.intersperse streamLen

309336

310337{-# INLINE iterateSource #-}

311338iterateSource

312− :: S.MonadAsync m

313− => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int

339+ :: Monad m => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int

314340iterateSource iterStreamLen g i n = f i (unfoldrM iterStreamLen n)

315341 where

316342 f (0 :: Int) m = g m

@@ -318,43 +344,60 @@ iterateSource iterStreamLen g i n = f i (unfoldrM iterStreamLen n)

318344

319345-- this is quadratic

320346{-# INLINE iterateScan #-}

321−iterateScan :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

322−iterateScan iterStreamLen maxIters = iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)

347+iterateScan :: Monad m => Int -> Int -> Int -> Stream m Int

348+iterateScan iterStreamLen maxIters =

349+ iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)

323350

324351-- this is quadratic

325352{-# INLINE iterateDropWhileFalse #-}

326−iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

353+iterateDropWhileFalse :: Monad m => Int -> Int -> Int -> Int -> Stream m Int

327354iterateDropWhileFalse streamLen iterStreamLen maxIters =

328355 iterateSource iterStreamLen (S.dropWhile (> streamLen)) (maxIters `div` 10)

329356

330357{-# INLINE iterateMapM #-}

331−iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

332−iterateMapM iterStreamLen maxIters = iterateSource iterStreamLen (S.mapM return) maxIters

358+iterateMapM :: Monad m => Int -> Int -> Int -> Stream m Int

359+iterateMapM iterStreamLen =

360+ iterateSource iterStreamLen (S.mapMWith S.consM return)

333361

334362{-# INLINE iterateFilterEven #-}

335−iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

336−iterateFilterEven iterStreamLen maxIters = iterateSource iterStreamLen (S.filter even) maxIters

363+iterateFilterEven :: Monad m => Int -> Int -> Int -> Stream m Int

364+iterateFilterEven iterStreamLen = iterateSource iterStreamLen (S.filter even)

337365

338366{-# INLINE iterateTakeAll #-}

339−iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

340−iterateTakeAll streamLen iterStreamLen maxIters = iterateSource iterStreamLen (S.take streamLen) maxIters

367+iterateTakeAll :: Monad m => Int -> Int -> Int -> Int -> Stream m Int

368+iterateTakeAll streamLen iterStreamLen =

369+ iterateSource iterStreamLen (S.take streamLen)

341370

342371{-# INLINE iterateDropOne #-}

343−iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

344−iterateDropOne iterStreamLen maxIters = iterateSource iterStreamLen (S.drop 1) maxIters

372+iterateDropOne :: Monad m => Int -> Int -> Int -> Stream m Int

373+iterateDropOne iterStreamLen = iterateSource iterStreamLen (S.drop 1)

345374

346375{-# INLINE iterateDropWhileTrue #-}

347−iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

348−iterateDropWhileTrue streamLen iterStreamLen maxIters = iterateSource iterStreamLen (S.dropWhile (<= streamLen)) maxIters

376+iterateDropWhileTrue ::

377+ Monad m => Int -> Int -> Int -> Int -> Stream m Int

378+iterateDropWhileTrue streamLen iterStreamLen =

379+ iterateSource iterStreamLen (S.dropWhile (<= streamLen))

349380

350381-------------------------------------------------------------------------------

351382-- Zipping

352383-------------------------------------------------------------------------------

353384

354385{-# INLINE zipWith #-}

355−zipWith :: S.MonadAsync m => Stream m Int -> m ()

386+zipWith :: Monad m => Stream m Int -> m ()

356387zipWith src = drain $ S.zipWith (,) src src

357388

389+{-# INLINE zipWithM #-}

390+zipWithM :: Monad m => Stream m Int -> m ()

391+zipWithM src = drain $ S.zipWithM (curry return) src src

392+

393+{-# INLINE sortByK #-}

394+sortByK :: (a -> a -> Ordering) -> Stream m a -> Stream m a

395+sortByK f = S.mergeMapWith (S.mergeBy f) S.fromPure

396+

397+{-# INLINE sortBy #-}

398+sortBy :: Monad m => Stream m Int -> m ()

399+sortBy = drain . sortByK compare

400+

358401-------------------------------------------------------------------------------

359402-- Mixed Composition

360403-------------------------------------------------------------------------------

@@ -446,12 +489,12 @@ inspect $ hasNoTypeClasses 'concatMapRepl

446489sourceConcatMapId :: Monad m

447490 => Int -> Int -> Stream m (Stream m Int)

448491sourceConcatMapId val n =

449− S.fromFoldable $ fmap (S.yieldM . return) [n..n+val]

492+ S.fromFoldable $ fmap (S.fromEffect . return) [n..n+val]

450493

451494{-# INLINE concatMapBySerial #-}

452495concatMapBySerial :: Int -> Int -> Int -> IO ()

453496concatMapBySerial outer inner n =

454− S.drain $ S.concatMapBy S.serial

497+ S.drain $ S.concatMapWith S.append

455498 (unfoldrM inner)

456499 (unfoldrM outer n)

457500

@@ -459,6 +502,32 @@ concatMapBySerial outer inner n =

459502-- Nested Composition

460503-------------------------------------------------------------------------------

461504

505+instance Monad m => Applicative (S.StreamK m) where

506+ {-# INLINE pure #-}

507+ pure = S.fromPure

508+

509+ {-# INLINE (<*>) #-}

510+ (<*>) = S.crossApply

511+

512+ {-# INLINE liftA2 #-}

513+ liftA2 f x = (<*>) (fmap f x)

514+

515+ {-# INLINE (*>) #-}

516+ (*>) = S.crossApplySnd

517+

518+ {-# INLINE (<*) #-}

519+ (<*) = S.crossApplyFst

520+

521+-- NOTE: even though concatMap for StreamD is 3x faster compared to StreamK,

522+-- the monad instance of StreamD is slower than StreamK after foldr/build

523+-- fusion.

524+instance Monad m => Monad (S.StreamK m) where

525+ {-# INLINE return #-}

526+ return = pure

527+

528+ {-# INLINE (>>=) #-}

529+ (>>=) = flip S.concatMap

530+

462531{-# INLINE drainApplicative #-}

463532drainApplicative :: Monad m => Stream m Int -> m ()

464533drainApplicative s = drain $ do

@@ -565,13 +634,19 @@ filterAllInNestedList str = do

565634-------------------------------------------------------------------------------

566635

567636moduleName :: String

568−moduleName = "Data.Stream.StreamK"

637+moduleName = "Data.StreamK"

569638

570639o_1_space_generation :: Int -> Benchmark

571640o_1_space_generation streamLen =

572641 bgroup "generation"

573− [ benchFold "unfoldr" drain (unfoldr streamLen)

574− , benchFold "unfoldrM" drain (unfoldrM streamLen)

642+ [ benchFold "unfoldr" drain (unfoldr streamLen)

643+ , benchFold "unfoldrM" drain (unfoldrM streamLen)

644+ , benchFold "repeat" drain (repeat streamLen)

645+ , benchFold "repeatM" drain (repeatM streamLen)

646+ , benchFold "replicate" drain (replicate streamLen)

647+ , benchFold "replicateM" drain (replicateM streamLen)

648+ , benchFold "iterate" drain (iterate streamLen)

649+ , benchFold "iterateM" drain (iterateM streamLen)

575650

576651 , benchFold "fromFoldable" drain (fromFoldable streamLen)

577652 , benchFold "fromFoldableM" drain (fromFoldableM streamLen)

@@ -655,7 +730,9 @@ o_1_space_concat streamLen =

655730

656731 -- This is for comparison with concatMapFoldableWith

657732 , benchIOSrc1 "concatMapWithId (n of 1) (fromFoldable)"

658− (S.drain . S.concatMapBy S.serial id . sourceConcatMapId streamLen)

733+ (S.drain

734+ . S.concatMapWith S.append id

735+ . sourceConcatMapId streamLen)

659736

660737 , benchIOSrc1 "concatMapBy serial (n of 1)"

661738 (concatMapBySerial streamLen 1)

@@ -663,6 +740,7 @@ o_1_space_concat streamLen =

663740 (concatMapBySerial streamLen2 streamLen2)

664741 , benchIOSrc1 "concatMapBy serial (1 of n)"

665742 (concatMapBySerial 1 streamLen)

743+ , benchFold "sortBy" sortBy (unfoldrM streamLen)

666744 ]

667745 where

668746 streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop

@@ -699,6 +777,7 @@ o_1_space_zipping :: Int -> Benchmark

699777o_1_space_zipping streamLen =

700778 bgroup "zipping"

701779 [ benchFold "zipWith" zipWith (unfoldrM streamLen)

780+ , benchFold "zipWithM" zipWithM (unfoldrM streamLen)

702781 ]

703782

704783o_1_space_mixed :: Int -> Benchmark

benchmark/Streamly/Benchmark/Data/Stream/StreamDK.hs → benchmark/Streamly/Benchmark/Data/Stream/StreamKAlt.hsrenamed+8−6

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Streamly.Benchmark.Data.Stream.StreamDK

@@ -16,12 +18,12 @@ import Prelude hiding ()

1618-- import qualified Prelude as P

1719-- import qualified Data.List as List

1820

19−import qualified Streamly.Internal.Data.Stream.StreamDK as S

20−-- import qualified Streamly.Internal.Data.Stream.Prelude as SP

21+import qualified Streamly.Internal.Data.StreamK.Alt as S

22+-- import qualified Streamly.Internal.Data.Stream.Common as SP

2123-- import qualified Streamly.Internal.Data.SVar as S

2224

2325import Streamly.Benchmark.Common

24−import Gauge (bgroup, Benchmark, defaultMain)

26+import Test.Tasty.Bench (bgroup, Benchmark, defaultMain)

2527

2628value :: Int

2729value = 100000

@@ -104,11 +106,11 @@ sourceFromFoldableM n = S.fromFoldableM (Prelude.fmap return [n..n+value])

104106{-

105107{-# INLINE sourceFoldMapWith #-}

106108sourceFoldMapWith :: Int -> Stream m Int

107−sourceFoldMapWith n = SP.foldMapWith S.serial S.yield [n..n+value]

109+sourceFoldMapWith n = SP.foldMapWith S.serial S.fromPure [n..n+value]

108110

109111{-# INLINE sourceFoldMapWithM #-}

110112sourceFoldMapWithM :: Monad m => Int -> Stream m Int

111−sourceFoldMapWithM n = SP.foldMapWith S.serial (S.yieldM . return) [n..n+value]

113+sourceFoldMapWithM n = SP.foldMapWith S.serial (S.fromEffect . return) [n..n+value]

112114-}

113115

114116-------------------------------------------------------------------------------

@@ -450,4 +452,4 @@ o_1_space =

450452 ]

451453

452454main :: IO ()

453−main = defaultMain $ concat [o_1_space]

455+main = defaultMain [o_1_space]

benchmark/Streamly/Benchmark/Data/Stream/ToStreamK.hsnew file+938

@@ -0,0 +1,938 @@

1+-- |

2+-- Module : Streamly.Benchmark.Data.StreamK

4+--

5+-- License : BSD3

6+-- Maintainer : streamly@composewell.com

8+{-# LANGUAGE CPP #-}

9+{-# LANGUAGE FlexibleContexts #-}

10+{-# LANGUAGE ScopedTypeVariables #-}

11+{-# OPTIONS_GHC -Wno-orphans #-}

12+

13+#ifdef __HADDOCK_VERSION__

14+#undef INSPECTION

15+#endif

16+

17+#ifdef INSPECTION

18+{-# LANGUAGE TemplateHaskell #-}

19+{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

20+#endif

21+

22+module Main (main) where

23+

24+-- import Control.Applicative (liftA2)

25+-- import Control.Monad (when)

26+-- import Data.Maybe (isJust)

27+-- import System.Random (randomRIO)

28+import Prelude hiding

29+ ( tail, mapM_, foldl, last, map, mapM, concatMap, zipWith, init, iterate

30+ , repeat, replicate

31+ )

32+

33+import qualified Prelude as P

34+-- import qualified Data.List as List

35+

36+import qualified Streamly.Internal.Data.StreamK as S

37+import qualified Streamly.Internal.Data.Stream as D

38+import qualified Streamly.Internal.Data.Fold as Fold

39+

40+import Test.Tasty.Bench (bgroup, Benchmark, defaultMain)

41+

42+import Streamly.Benchmark.Common

43+

44+#ifdef INSPECTION

45+import Test.Inspection

46+#endif

47+

48+-------------------------------------------------------------------------------

49+-- Stream generation and elimination

50+-------------------------------------------------------------------------------

51+

52+type Stream m a = S.Stream m a

53+

54+{-# INLINE unfoldrD #-}

55+unfoldrD :: Monad m => Int -> Int -> Stream m Int

56+unfoldrD streamLen n = D.toStreamK (D.unfoldr step n)

57+ where

58+ step cnt =

59+ if cnt > n + streamLen

60+ then Nothing

61+ else Just (cnt, cnt + 1)

62+

63+{-# INLINE unfoldrMD #-}

64+unfoldrMD :: Monad m => Int -> Int -> Stream m Int

65+unfoldrMD streamLen n = D.toStreamK (D.unfoldrM step n)

66+ where

67+ step cnt =

68+ if cnt > n + streamLen

69+ then return Nothing

70+ else return (Just (cnt, cnt + 1))

71+

72+{-

73+{-# INLINE unfoldrK #-}

74+unfoldrK :: Int -> Int -> Stream m Int

75+unfoldrK streamLen n = S.unfoldr step n

76+ where

77+ step cnt =

78+ if cnt > n + streamLen

79+ then Nothing

80+ else Just (cnt, cnt + 1)

81+-}

82+

83+{-# INLINE unfoldrMK #-}

84+unfoldrMK :: Monad m => Int -> Int -> Stream m Int

85+unfoldrMK streamLen n = S.unfoldrMWith S.consM step n

86+ where

87+ step cnt =

88+ if cnt > n + streamLen

89+ then return Nothing

90+ else return (Just (cnt, cnt + 1))

91+

92+{-# INLINE repeat #-}

93+repeat :: Monad m => Int -> Int -> Stream m Int

94+repeat streamLen = S.take streamLen . D.toStreamK . D.repeat

95+

96+{-# INLINE repeatM #-}

97+repeatM :: Monad m => Int -> Int -> Stream m Int

98+repeatM streamLen = S.take streamLen . D.toStreamK . D.repeatM . return

99+

100+{-# INLINE replicate #-}

101+replicate :: Monad m => Int -> Int -> Stream m Int

102+replicate x y = D.toStreamK $ D.replicate x y

103+

104+{-# INLINE replicateM #-}

105+replicateM :: Monad m => Int -> Int -> Stream m Int

106+replicateM streamLen = D.toStreamK . D.replicateM streamLen . return

107+

108+{-# INLINE iterate #-}

109+iterate :: Monad m => Int -> Int -> Stream m Int

110+iterate streamLen = S.take streamLen . D.toStreamK . D.iterate (+1)

111+

112+{-# INLINE iterateM #-}

113+iterateM :: Monad m => Int -> Int -> Stream m Int

114+iterateM streamLen = S.take streamLen . D.toStreamK . D.iterateM (return . (+1)) . return

115+

116+{-# INLINE fromFoldable #-}

117+fromFoldable :: Int -> Int -> Stream m Int

118+fromFoldable streamLen n = S.fromFoldable [n..n+streamLen]

119+

120+{-# INLINE fromFoldableM #-}

121+fromFoldableM :: Monad m => Int -> Int -> Stream m Int

122+fromFoldableM streamLen n =

123+ Prelude.foldr (S.consM . return) S.nil [n .. n + streamLen]

124+

125+{-

126+{-# INLINABLE concatMapFoldableWith #-}

127+concatMapFoldableWith :: Foldable f

128+ => (Stream m b -> Stream m b -> Stream m b)

129+ -> (a -> Stream m b)

130+ -> f a

131+ -> Stream m b

132+concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil

133+-}

134+

135+{-# INLINE concatMapFoldableSerial #-}

136+concatMapFoldableSerial :: Monad m => Int -> Int -> Stream m Int

137+concatMapFoldableSerial streamLen n =

138+ D.toStreamK $ D.concatMap D.fromPure $ D.fromStreamK $ S.fromList [n..n+streamLen]

139+

140+{-# INLINE concatMapFoldableSerialM #-}

141+concatMapFoldableSerialM :: Monad m => Int -> Int -> Stream m Int

142+concatMapFoldableSerialM streamLen n =

143+ -- concatMapFoldableWith S.serial (S.fromEffect . return) [n..n+streamLen]

144+ D.toStreamK $ D.concatMap (D.fromEffect . return) $ D.fromStreamK $ S.fromList [n..n+streamLen]

145+

146+-------------------------------------------------------------------------------

147+-- Elimination

148+-------------------------------------------------------------------------------

149+

150+{-# INLINE drainD #-}

151+drainD :: Monad m => Stream m a -> m ()

152+drainD = D.drain . D.fromStreamK

153+

154+{-# INLINE drain #-}

155+drain :: Monad m => Stream m a -> m ()

156+drain = S.drain

157+

158+{-# INLINE mapM_ #-}

159+mapM_ :: Monad m => Stream m a -> m ()

160+mapM_ s = D.mapM_ (\_ -> return ()) $ D.fromStreamK s

161+

162+{-

163+{-# INLINE uncons #-}

164+uncons :: Monad m => Stream m Int -> m ()

165+uncons s = do

166+ r <- D.uncons $ D.fromStreamK s

167+ case r of

168+ Nothing -> return ()

169+ Just (_, t) -> uncons (D.toStreamK t)

170+

171+{-# INLINE init #-}

172+init :: Monad m => Stream m a -> m ()

173+init s = do

174+ t <- S.init s

175+ P.mapM_ S.drain t

176+

177+{-# INLINE tail #-}

178+tail :: Monad m => Stream m a -> m ()

179+tail s = S.tail s >>= P.mapM_ tail

180+

181+{-# INLINE nullTail #-}

182+nullTail :: Monad m => Stream m Int -> m ()

183+nullTail s = do

184+ r <- S.null s

185+ when (not r) $ S.tail s >>= P.mapM_ nullTail

186+

187+{-# INLINE headTail #-}

188+headTail :: Monad m => Stream m Int -> m ()

189+headTail s = do

190+ h <- S.head s

191+ when (isJust h) $ S.tail s >>= P.mapM_ headTail

192+-}

193+

194+{-# INLINE toList #-}

195+toList :: Monad m => Stream m Int -> m [Int]

196+toList = D.fold Fold.toList . D.fromStreamK

197+

198+{-# INLINE foldl' #-}

199+foldl' :: Monad m => Stream m Int -> m Int

200+foldl' = D.fold (Fold.foldl' (+) 0) . D.fromStreamK

201+

202+{-# INLINE last #-}

203+last :: Monad m => Stream m Int -> m (Maybe Int)

204+last = D.fold Fold.latest . D.fromStreamK

205+

206+-------------------------------------------------------------------------------

207+-- Transformation

208+-------------------------------------------------------------------------------

209+

210+{-# INLINE composeN #-}

211+composeN

212+ :: Monad m

213+ => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()

214+composeN n f =

215+ case n of

216+ 1 -> drain . f

217+ 2 -> drain . f . f

218+ 3 -> drain . f . f . f

219+ 4 -> drain . f . f . f . f

220+ _ -> undefined

221+

222+{-# INLINE scanl' #-}

223+scanl' :: Monad m => Int -> Stream m Int -> m ()

224+scanl' n =

225+ composeN n (D.toStreamK . D.scan (Fold.foldl' (+) 0) . D.fromStreamK)

226+

227+{-# INLINE map #-}

228+map :: Monad m => Int -> Stream m Int -> m ()

229+map n = composeN n (D.toStreamK . D.map (+ 1) . D.fromStreamK)

230+

231+{-

232+{-# INLINE fmapK #-}

233+fmapK :: Monad m => Int -> Stream m Int -> m ()

234+fmapK n = composeN n $ P.fmap (+ 1)

235+-}

236+

237+{-# INLINE mapM #-}

238+mapM :: Monad m => Int -> Stream m Int -> m ()

239+mapM n = composeN n (D.toStreamK . D.mapM return . D.fromStreamK)

240+

241+{-

242+{-# INLINE mapMSerial #-}

243+mapMSerial :: S.MonadAsync m => Int -> Stream m Int -> m ()

244+mapMSerial n = composeN n $ S.mapMSerial return

245+-}

246+

247+{-# INLINE filterEven #-}

248+filterEven :: Monad m => Int -> Stream m Int -> m ()

249+filterEven n = composeN n (D.toStreamK . D.filter even . D.fromStreamK)

250+

251+{-

252+{-# INLINE filterAllOut #-}

253+filterAllOut :: Monad m => Int -> Int -> Stream m Int -> m ()

254+filterAllOut streamLen n = composeN n $ S.filter (> streamLen)

255+

256+{-# INLINE filterAllIn #-}

257+filterAllIn :: Monad m => Int -> Int -> Stream m Int -> m ()

258+filterAllIn streamLen n = composeN n $ S.filter (<= streamLen)

259+

260+{-# INLINE _takeOne #-}

261+_takeOne :: Monad m => Int -> Stream m Int -> m ()

262+_takeOne n = composeN n $ S.take 1

263+

264+{-# INLINE takeAll #-}

265+takeAll :: Monad m => Int -> Int -> Stream m Int -> m ()

266+takeAll streamLen n = composeN n $ S.take streamLen

267+

268+{-# INLINE takeWhileTrue #-}

269+takeWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()

270+takeWhileTrue streamLen n = composeN n $ S.takeWhile (<= streamLen)

271+

272+{-# INLINE dropOne #-}

273+dropOne :: Monad m => Int -> Stream m Int -> m ()

274+dropOne n = composeN n $ S.drop 1

275+

276+{-# INLINE dropAll #-}

277+dropAll :: Monad m => Int -> Int -> Stream m Int -> m ()

278+dropAll streamLen n = composeN n $ S.drop streamLen

279+

280+{-# INLINE dropWhileTrue #-}

281+dropWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()

282+dropWhileTrue streamLen n = composeN n $ S.dropWhile (<= streamLen)

283+

284+{-# INLINE dropWhileFalse #-}

285+dropWhileFalse :: Monad m => Int -> Stream m Int -> m ()

286+dropWhileFalse n = composeN n $ S.dropWhile (<= 1)

287+-}

288+

289+{-

290+{-# INLINE foldrS #-}

291+foldrS :: Monad m => Int -> Stream m Int -> m ()

292+foldrS n = composeN n $ S.foldrS S.cons S.nil

293+

294+{-# INLINE foldlS #-}

295+foldlS :: Monad m => Int -> Stream m Int -> m ()

296+foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil

297+-}

298+

299+{-

300+{-# INLINE intersperse #-}

301+intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()

302+intersperse streamLen n = composeN n $ S.intersperse streamLen

303+-}

304+

305+-------------------------------------------------------------------------------

306+-- Iteration

307+-------------------------------------------------------------------------------

308+

309+{-

310+{-# INLINE iterateSource #-}

311+iterateSource

312+ :: S.MonadAsync m

313+ => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int

314+iterateSource iterStreamLen g i n = f i (unfoldrM iterStreamLen n)

315+ where

316+ f (0 :: Int) m = g m

317+ f x m = g (f (x P.- 1) m)

318+

319+-- this is quadratic

320+{-# INLINE iterateScan #-}

321+iterateScan :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

322+iterateScan iterStreamLen maxIters =

323+ iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)

324+

325+-- this is quadratic

326+{-# INLINE iterateDropWhileFalse #-}

327+iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

328+iterateDropWhileFalse streamLen iterStreamLen maxIters =

329+ iterateSource iterStreamLen (S.dropWhile (> streamLen)) (maxIters `div` 10)

330+

331+{-# INLINE iterateMapM #-}

332+iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

333+iterateMapM iterStreamLen =

334+ iterateSource iterStreamLen (S.mapMWith S.consM return)

335+

336+{-# INLINE iterateFilterEven #-}

337+iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

338+iterateFilterEven iterStreamLen = iterateSource iterStreamLen (S.filter even)

339+

340+{-# INLINE iterateTakeAll #-}

341+iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int

342+iterateTakeAll streamLen iterStreamLen =

343+ iterateSource iterStreamLen (S.take streamLen)

344+

345+{-# INLINE iterateDropOne #-}

346+iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int

347+iterateDropOne iterStreamLen = iterateSource iterStreamLen (S.drop 1)

348+

349+{-# INLINE iterateDropWhileTrue #-}

350+iterateDropWhileTrue :: S.MonadAsync m =>

351+ Int -> Int -> Int -> Int -> Stream m Int

352+iterateDropWhileTrue streamLen iterStreamLen =

353+ iterateSource iterStreamLen (S.dropWhile (<= streamLen))

354+-}

355+

356+-------------------------------------------------------------------------------

357+-- Zipping

358+-------------------------------------------------------------------------------

359+

360+{-

361+{-# INLINE zipWith #-}

362+zipWith :: Monad m => Stream m Int -> m ()

363+zipWith src = drain $ S.zipWith (,) src src

364+

365+{-# INLINE zipWithM #-}

366+zipWithM :: Monad m => Stream m Int -> m ()

367+zipWithM src = drain $ S.zipWithM (curry return) src src

368+

369+{-# INLINE sortByK #-}

370+sortByK :: (a -> a -> Ordering) -> Stream m a -> Stream m a

371+sortByK f = S.concatPairsWith (S.mergeBy f) S.fromPure

372+

373+{-# INLINE sortBy #-}

374+sortBy :: Monad m => Stream m Int -> m ()

375+sortBy = drain . sortByK compare

376+

377+-------------------------------------------------------------------------------

378+-- Mixed Composition

379+-------------------------------------------------------------------------------

380+

381+{-# INLINE scanMap #-}

382+scanMap :: Monad m => Int -> Stream m Int -> m ()

383+scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0

384+

385+{-# INLINE dropMap #-}

386+dropMap :: Monad m => Int -> Stream m Int -> m ()

387+dropMap n = composeN n $ S.map (subtract 1) . S.drop 1

388+

389+{-# INLINE dropScan #-}

390+dropScan :: Monad m => Int -> Stream m Int -> m ()

391+dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1

392+

393+{-# INLINE takeDrop #-}

394+takeDrop :: Monad m => Int -> Int -> Stream m Int -> m ()

395+takeDrop streamLen n = composeN n $ S.drop 1 . S.take streamLen

396+

397+{-# INLINE takeScan #-}

398+takeScan :: Monad m => Int -> Int -> Stream m Int -> m ()

399+takeScan streamLen n = composeN n $ S.scanl' (+) 0 . S.take streamLen

400+

401+{-# INLINE takeMap #-}

402+takeMap :: Monad m => Int -> Int -> Stream m Int -> m ()

403+takeMap streamLen n = composeN n $ S.map (subtract 1) . S.take streamLen

404+

405+{-# INLINE filterDrop #-}

406+filterDrop :: Monad m => Int -> Int -> Stream m Int -> m ()

407+filterDrop streamLen n = composeN n $ S.drop 1 . S.filter (<= streamLen)

408+

409+{-# INLINE filterTake #-}

410+filterTake :: Monad m => Int -> Int -> Stream m Int -> m ()

411+filterTake streamLen n = composeN n $ S.take streamLen . S.filter (<= streamLen)

412+

413+{-# INLINE filterScan #-}

414+filterScan :: Monad m => Int -> Stream m Int -> m ()

415+filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)

416+

417+{-# INLINE filterMap #-}

418+filterMap :: Monad m => Int -> Int -> Stream m Int -> m ()

419+filterMap streamLen n = composeN n $ S.map (subtract 1) . S.filter (<= streamLen)

420+-}

421+

422+-------------------------------------------------------------------------------

423+-- ConcatMap

424+-------------------------------------------------------------------------------

425+

426+-- concatMap unfoldrM/unfoldrM

427+

428+{-# INLINE concatMap #-}

429+concatMap :: Int -> Int -> Int -> IO ()

430+concatMap outer inner n =

431+ S.drain $ D.toStreamK $ D.concatMap

432+ (\_ -> D.fromStreamK $ unfoldrMK inner n)

433+ (D.fromStreamK $ unfoldrMK outer n)

434+

435+#ifdef INSPECTION

436+inspect $ hasNoTypeClasses 'concatMap

437+#endif

438+

439+-- concatMap unfoldr/unfoldr

440+

441+{-

442+{-# INLINE concatMapPure #-}

443+concatMapPure :: Int -> Int -> Int -> IO ()

444+concatMapPure outer inner n =

445+ S.drain $ S.concatMap

446+ (\_ -> unfoldr inner n)

447+ (unfoldr outer n)

448+

449+#ifdef INSPECTION

450+inspect $ hasNoTypeClasses 'concatMapPure

451+#endif

452+

453+-- concatMap replicate/unfoldrM

454+

455+{-# INLINE concatMapRepl #-}

456+concatMapRepl :: Int -> Int -> Int -> IO ()

457+concatMapRepl outer inner n =

458+ S.drain $ S.concatMap (S.replicate inner) (unfoldrM outer n)

459+

460+#ifdef INSPECTION

461+inspect $ hasNoTypeClasses 'concatMapRepl

462+#endif

463+

464+-- concatMapWith

465+

466+{-# INLINE sourceConcatMapId #-}

467+sourceConcatMapId :: Monad m

468+ => Int -> Int -> Stream m (Stream m Int)

469+sourceConcatMapId val n =

470+ S.fromFoldable $ fmap (S.fromEffect . return) [n..n+val]

471+

472+{-# INLINE concatMapBySerial #-}

473+concatMapBySerial :: Int -> Int -> Int -> IO ()

474+concatMapBySerial outer inner n =

475+ S.drain $ S.concatMapWith S.serial

476+ (unfoldrM inner)

477+ (unfoldrM outer n)

478+-}

479+

480+{-

481+-------------------------------------------------------------------------------

482+-- Nested Composition

483+-------------------------------------------------------------------------------

484+

485+instance Monad m => Applicative (S.Stream m) where

486+ {-# INLINE pure #-}

487+ pure = S.fromPure

488+

489+ {-# INLINE (<*>) #-}

490+ (<*>) = S.crossApply

491+

492+ {-# INLINE liftA2 #-}

493+ liftA2 f x = (<*>) (fmap f x)

494+

495+ {-# INLINE (*>) #-}

496+ (*>) = S.crossApplySnd

497+

498+ {-# INLINE (<*) #-}

499+ (<*) = S.crossApplyFst

500+

501+-- NOTE: even though concatMap for StreamD is 3x faster compared to StreamK,

502+-- the monad instance of StreamD is slower than StreamK after foldr/build

503+-- fusion.

504+instance Monad m => Monad (S.Stream m) where

505+ {-# INLINE return #-}

506+ return = pure

507+

508+ {-# INLINE (>>=) #-}

509+ (>>=) = flip S.concatMap

510+

511+{-# INLINE drainApplicative #-}

512+drainApplicative :: Monad m => Stream m Int -> m ()

513+drainApplicative s = drain $ do

514+ (+) <$> s <*> s

515+

516+{-# INLINE drainMonad #-}

517+drainMonad :: Monad m => Stream m Int -> m ()

518+drainMonad s = drain $ do

519+ x <- s

520+ y <- s

521+ return $ x + y

522+

523+{-# INLINE drainMonad3 #-}

524+drainMonad3 :: Monad m => Stream m Int -> m ()

525+drainMonad3 s = drain $ do

526+ x <- s

527+ y <- s

528+ z <- s

529+ return $ x + y + z

530+

531+{-# INLINE filterAllOutMonad #-}

532+filterAllOutMonad

533+ :: Monad m

534+ => Stream m Int -> m ()

535+filterAllOutMonad str = drain $ do

536+ x <- str

537+ y <- str

538+ let s = x + y

539+ if s < 0

540+ then return s

541+ else S.nil

542+

543+{-# INLINE filterAllInMonad #-}

544+filterAllInMonad

545+ :: Monad m

546+ => Stream m Int -> m ()

547+filterAllInMonad str = drain $ do

548+ x <- str

549+ y <- str

550+ let s = x + y

551+ if s > 0

552+ then return s

553+ else S.nil

554+

555+-------------------------------------------------------------------------------

556+-- Nested Composition Pure lists

557+-------------------------------------------------------------------------------

558+

559+-- There are several list benchmarks here for comparison with lists. It is easy

560+-- and convenient to see the comparisons when they are here, otherwise we'll

561+-- have to add a separate module for list benchmarks with the same names and

562+-- then add a comparison in bench.sh.

563+

564+{-# INLINE unfoldrList #-}

565+unfoldrList :: Int -> Int -> [Int]

566+unfoldrList maxval n = List.unfoldr step n

567+ where

568+ step cnt =

569+ if cnt > n + maxval

570+ then Nothing

571+ else Just (cnt, cnt + 1)

572+

573+{-# INLINE toNullApNestedList #-}

574+toNullApNestedList :: [Int] -> [Int]

575+toNullApNestedList s = (+) <$> s <*> s

576+

577+{-# INLINE toNullNestedList #-}

578+toNullNestedList :: [Int] -> [Int]

579+toNullNestedList s = do

580+ x <- s

581+ y <- s

582+ return $ x + y

583+

584+{-# INLINE toNullNestedList3 #-}

585+toNullNestedList3 :: [Int] -> [Int]

586+toNullNestedList3 s = do

587+ x <- s

588+ y <- s

589+ z <- s

590+ return $ x + y + z

591+

592+{-# INLINE filterAllOutNestedList #-}

593+filterAllOutNestedList :: [Int] -> [Int]

594+filterAllOutNestedList str = do

595+ x <- str

596+ y <- str

597+ let s = x + y

598+ if s < 0

599+ then return s

600+ else []

601+

602+{-# INLINE filterAllInNestedList #-}

603+filterAllInNestedList :: [Int] -> [Int]

604+filterAllInNestedList str = do

605+ x <- str

606+ y <- str

607+ let s = x + y

608+ if s > 0

609+ then return s

610+ else []

611+ -}

612+

613+-------------------------------------------------------------------------------

614+-- Benchmarks

615+-------------------------------------------------------------------------------

616+

617+moduleName :: String

618+moduleName = "Data.Stream.ToStreamK"

619+

620+-- Generation of StreamK using StreamD generation functions and eleminating

621+-- using StreamK drain.

622+o_1_space_generation :: Int -> Benchmark

623+o_1_space_generation streamLen =

624+ bgroup "generation"

625+ [ benchFold "unfoldr" drain (unfoldrD streamLen)

626+ , benchFold "unfoldrM" drain (unfoldrMD streamLen)

627+ , benchFold "repeat" drain (repeat streamLen)

628+ , benchFold "repeatM" drain (repeatM streamLen)

629+ , benchFold "replicate" drain (replicate streamLen)

630+ , benchFold "replicateM" drain (replicateM streamLen)

631+ , benchFold "iterate" drain (iterate streamLen)

632+ , benchFold "iterateM" drain (iterateM streamLen)

633+

634+ , benchFold "fromFoldable" drain (fromFoldable streamLen)

635+ , benchFold "fromFoldableM" drain (fromFoldableM streamLen)

636+

637+ -- appends

638+ , benchFold "concatMapFoldableWith" drain (concatMapFoldableSerial streamLen)

639+ , benchFold "concatMapFoldableWithM" drain (concatMapFoldableSerialM streamLen)

640+ ]

641+

642+-- Generating using StreamK and eliminating using StreamD folds.

643+o_1_space_elimination :: Int -> Benchmark

644+o_1_space_elimination streamLen =

645+ bgroup "elimination"

646+ [ benchFold "toNull" drainD (unfoldrMK streamLen)

647+ , benchFold "mapM_" mapM_ (unfoldrMK streamLen)

648+ -- , benchFold "uncons" uncons (unfoldrMK streamLen)

649+ -- , benchFold "init" init (unfoldrM streamLen)

650+ , benchFold "foldl'" foldl' (unfoldrMK streamLen)

651+ , benchFold "last" last (unfoldrMK streamLen)

652+ ]

653+

654+{-

655+o_1_space_nested :: Int -> Benchmark

656+o_1_space_nested streamLen =

657+ bgroup "nested"

658+ [ benchFold "drainApplicative" drainApplicative (unfoldrM streamLen2)

659+ , benchFold "drainMonad" drainMonad (unfoldrM streamLen2)

660+ , benchFold "drainMonad3" drainMonad3 (unfoldrM streamLen3)

661+ , benchFold "filterAllInMonad" filterAllInMonad (unfoldrM streamLen2)

662+ , benchFold "filterAllOutMonad" filterAllOutMonad (unfoldrM streamLen2)

663+ , benchFold "drainApplicative (pure)" drainApplicative (unfoldr streamLen2)

664+ , benchFold "drainMonad (pure)" drainMonad (unfoldr streamLen2)

665+ , benchFold "drainMonad3 (pure)" drainMonad3 (unfoldr streamLen3)

666+ , benchFold "filterAllInMonad (pure)" filterAllInMonad (unfoldr streamLen2)

667+ , benchFold "filterAllOutMonad (pure)" filterAllOutMonad (unfoldr streamLen2)

668+ ]

669+ where

670+ streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop

671+ streamLen3 = round (P.fromIntegral streamLen**(1/3::P.Double)) -- triple nested loop

672+-}

673+

674+-- Generate using StreamK and transform using StreamD transformation functions

675+-- and then drain using StreamK.

676+o_1_space_transformation :: Int -> Benchmark

677+o_1_space_transformation streamLen =

678+ bgroup "transformation"

679+ [ -- benchFold "foldrS" (foldrS 1) (unfoldrM streamLen)

680+ benchFold "scanl'" (scanl' 1) (unfoldrMK streamLen)

681+ , benchFold "map" (map 1) (unfoldrMK streamLen)

682+ -- , benchFold "fmap" (fmapK 1) (unfoldrM streamLen)

683+ , benchFold "mapM" (mapM 1) (unfoldrMK streamLen)

684+ -- , benchFold "mapMSerial" (mapMSerial 1) (unfoldrM streamLen)

685+ ]

686+

687+o_1_space_transformationX4 :: Int -> Benchmark

688+o_1_space_transformationX4 streamLen =

689+ bgroup "transformationX4"

690+ [ benchFold "scanl'" (scanl' 4) (unfoldrMK streamLen)

691+ , benchFold "map" (map 4) (unfoldrMK streamLen)

692+ -- , benchFold "fmap" (fmapK 4) (unfoldrMK streamLen)

693+ , benchFold "mapM" (mapM 4) (unfoldrMK streamLen)

694+ -- , benchFold "mapMSerial" (mapMSerial 4) (unfoldrM streamLen)

695+ -- XXX this is horribly slow

696+ -- , benchFold "concatMap" (concatMap 4) (unfoldrM streamLen16)

697+ ]

698+

699+-- Generate using K, fold using K, concat using D.concatMap

700+o_1_space_concat :: Int -> Benchmark

701+o_1_space_concat streamLen =

702+ bgroup "concat"

703+ [ {- benchIOSrc1 "concatMapPure (n of 1)"

704+ (concatMapPure streamLen 1)

705+ , benchIOSrc1 "concatMapPure (sqrt n of sqrt n)"

706+ (concatMapPure streamLen2 streamLen2)

707+ , benchIOSrc1 "concatMapPure (1 of n)"

708+ (concatMapPure 1 streamLen)

709+ -}

710+

711+ benchIOSrc1 "concatMap (n of 1)"

712+ (concatMap streamLen 1)

713+ , benchIOSrc1 "concatMap (sqrt n of sqrt n)"

714+ (concatMap streamLen2 streamLen2)

715+ , benchIOSrc1 "concatMap (1 of n)"

716+ (concatMap 1 streamLen)

717+

718+{-

719+ , benchIOSrc1 "concatMapRepl (sqrt n of sqrt n)"

720+ (concatMapRepl streamLen2 streamLen2)

721+

722+ -- This is for comparison with concatMapFoldableWith

723+ , benchIOSrc1 "concatMapWithId (n of 1) (fromFoldable)"

724+ (S.drain

725+ . S.concatMapWith S.serial id

726+ . sourceConcatMapId streamLen)

727+

728+ , benchIOSrc1 "concatMapBy serial (n of 1)"

729+ (concatMapBySerial streamLen 1)

730+ , benchIOSrc1 "concatMapBy serial (sqrt n of sqrt n)"

731+ (concatMapBySerial streamLen2 streamLen2)

732+ , benchIOSrc1 "concatMapBy serial (1 of n)"

733+ (concatMapBySerial 1 streamLen)

734+ , benchFold "sortBy" sortBy (unfoldrM streamLen)

735+ -}

736+ ]

737+ where

738+ streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop

739+

740+o_1_space_filtering :: Int -> Benchmark

741+o_1_space_filtering streamLen =

742+ bgroup "filtering"

743+ [ benchFold "filter-even" (filterEven 1) (unfoldrMK streamLen)

744+ {-

745+ , benchFold "filter-all-out" (filterAllOut streamLen 1) (unfoldrM streamLen)

746+ , benchFold "filter-all-in" (filterAllIn streamLen 1) (unfoldrM streamLen)

747+ , benchFold "take-all" (takeAll streamLen 1) (unfoldrM streamLen)

748+ , benchFold "takeWhile-true" (takeWhileTrue streamLen 1) (unfoldrM streamLen)

749+ , benchFold "drop-one" (dropOne 1) (unfoldrM streamLen)

750+ , benchFold "drop-all" (dropAll streamLen 1) (unfoldrM streamLen)

751+ , benchFold "dropWhile-true" (dropWhileTrue streamLen 1) (unfoldrM streamLen)

752+ , benchFold "dropWhile-false" (dropWhileFalse 1) (unfoldrM streamLen)

753+ -}

754+ ]

755+

756+o_1_space_filteringX4 :: Int -> Benchmark

757+o_1_space_filteringX4 streamLen =

758+ bgroup "filteringX4"

759+ [ benchFold "filter-even" (filterEven 4) (unfoldrMK streamLen)

760+ {-

761+ , benchFold "filter-all-out" (filterAllOut streamLen 4) (unfoldrM streamLen)

762+ , benchFold "filter-all-in" (filterAllIn streamLen 4) (unfoldrM streamLen)

763+ , benchFold "take-all" (takeAll streamLen 4) (unfoldrM streamLen)

764+ , benchFold "takeWhile-true" (takeWhileTrue streamLen 4) (unfoldrM streamLen)

765+ , benchFold "drop-one" (dropOne 4) (unfoldrM streamLen)

766+ , benchFold "drop-all" (dropAll streamLen 4) (unfoldrM streamLen)

767+ , benchFold "dropWhile-true" (dropWhileTrue streamLen 4) (unfoldrM streamLen)

768+ , benchFold "dropWhile-false" (dropWhileFalse 4) (unfoldrM streamLen)

769+ -}

770+ ]

771+

772+{-

773+o_1_space_zipping :: Int -> Benchmark

774+o_1_space_zipping streamLen =

775+ bgroup "zipping"

776+ [ benchFold "zipWith" zipWith (unfoldrM streamLen)

777+ , benchFold "zipWithM" zipWithM (unfoldrM streamLen)

778+ ]

779+

780+o_1_space_mixed :: Int -> Benchmark

781+o_1_space_mixed streamLen =

782+ bgroup "mixed"

783+ [ benchFold "scan-map" (scanMap 1) (unfoldrM streamLen)

784+ , benchFold "drop-map" (dropMap 1) (unfoldrM streamLen)

785+ , benchFold "drop-scan" (dropScan 1) (unfoldrM streamLen)

786+ , benchFold "take-drop" (takeDrop streamLen 1) (unfoldrM streamLen)

787+ , benchFold "take-scan" (takeScan streamLen 1) (unfoldrM streamLen)

788+ , benchFold "take-map" (takeMap streamLen 1) (unfoldrM streamLen)

789+ , benchFold "filter-drop" (filterDrop streamLen 1) (unfoldrM streamLen)

790+ , benchFold "filter-take" (filterTake streamLen 1) (unfoldrM streamLen)

791+ , benchFold "filter-scan" (filterScan 1) (unfoldrM streamLen)

792+ , benchFold "filter-map" (filterMap streamLen 1) (unfoldrM streamLen)

793+ ]

794+

795+o_1_space_mixedX2 :: Int -> Benchmark

796+o_1_space_mixedX2 streamLen =

797+ bgroup "mixedX2"

798+ [ benchFold "scan-map" (scanMap 2) (unfoldrM streamLen)

799+ , benchFold "drop-map" (dropMap 2) (unfoldrM streamLen)

800+ , benchFold "drop-scan" (dropScan 2) (unfoldrM streamLen)

801+ , benchFold "take-drop" (takeDrop streamLen 2) (unfoldrM streamLen)

802+ , benchFold "take-scan" (takeScan streamLen 2) (unfoldrM streamLen)

803+ , benchFold "take-map" (takeMap streamLen 2) (unfoldrM streamLen)

804+ , benchFold "filter-drop" (filterDrop streamLen 2) (unfoldrM streamLen)

805+ , benchFold "filter-take" (filterTake streamLen 2) (unfoldrM streamLen)

806+ , benchFold "filter-scan" (filterScan 2) (unfoldrM streamLen)

807+ , benchFold "filter-map" (filterMap streamLen 2) (unfoldrM streamLen)

808+ ]

809+

810+o_1_space_mixedX4 :: Int -> Benchmark

811+o_1_space_mixedX4 streamLen =

812+ bgroup "mixedX4"

813+ [ benchFold "scan-map" (scanMap 4) (unfoldrM streamLen)

814+ , benchFold "drop-map" (dropMap 4) (unfoldrM streamLen)

815+ , benchFold "drop-scan" (dropScan 4) (unfoldrM streamLen)

816+ , benchFold "take-drop" (takeDrop streamLen 4) (unfoldrM streamLen)

817+ , benchFold "take-scan" (takeScan streamLen 4) (unfoldrM streamLen)

818+ , benchFold "take-map" (takeMap streamLen 4) (unfoldrM streamLen)

819+ , benchFold "filter-drop" (filterDrop streamLen 4) (unfoldrM streamLen)

820+ , benchFold "filter-take" (filterTake streamLen 4) (unfoldrM streamLen)

821+ , benchFold "filter-scan" (filterScan 4) (unfoldrM streamLen)

822+ , benchFold "filter-map" (filterMap streamLen 4) (unfoldrM streamLen)

823+ ]

824+ -}

825+

826+{-

827+o_1_space_list :: Int -> Benchmark

828+o_1_space_list streamLen =

829+ bgroup "list"

830+ [ bgroup "elimination"

831+ [ benchList "last" (\xs -> [List.last xs]) (unfoldrList streamLen)

832+ ]

833+ , bgroup "nested"

834+ [ benchList "toNullAp" toNullApNestedList (unfoldrList streamLen2)

835+ , benchList "toNull" toNullNestedList (unfoldrList streamLen2)

836+ , benchList "toNull3" toNullNestedList3 (unfoldrList streamLen3)

837+ , benchList "filterAllIn" filterAllInNestedList (unfoldrList streamLen2)

838+ , benchList "filterAllOut" filterAllOutNestedList (unfoldrList streamLen2)

839+ ]

840+ ]

841+ where

842+

843+ streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop

844+ streamLen3 = round (P.fromIntegral streamLen**(1/3::P.Double)) -- triple nested loop

845+-}

846+

847+o_1_space :: Int -> Benchmark

848+o_1_space streamLen =

849+ bgroup (o_1_space_prefix moduleName)

850+ [ o_1_space_generation streamLen

851+ , o_1_space_elimination streamLen

852+ -- , o_1_space_nested streamLen

853+ , o_1_space_transformation streamLen

854+ , o_1_space_transformationX4 streamLen

855+ , o_1_space_concat streamLen

856+ , o_1_space_filtering streamLen

857+ , o_1_space_filteringX4 streamLen

858+ -- , o_1_space_zipping streamLen

859+ -- , o_1_space_mixed streamLen

860+ -- , o_1_space_mixedX2 streamLen

861+ -- , o_1_space_mixedX4 streamLen

862+ -- , o_1_space_list streamLen

863+ ]

864+

865+{-

866+o_n_heap :: Int -> Benchmark

867+o_n_heap streamLen =

868+ bgroup (o_n_heap_prefix moduleName)

869+ [ bgroup "transformation"

870+ [ benchFold "foldlS" (foldlS 1) (unfoldrM streamLen)

871+ ]

872+ ]

873+

874+{-# INLINE benchK #-}

875+benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark

876+benchK name f = bench name $ nfIO $ randomRIO (1,1) >>= drain . f

877+

878+o_n_stack :: Int -> Int -> Int -> Benchmark

879+o_n_stack streamLen iterStreamLen maxIters =

880+ bgroup (o_n_stack_prefix moduleName)

881+ [ bgroup "elimination"

882+ [ benchFold "tail" tail (unfoldrM streamLen)

883+ , benchFold "nullTail" nullTail (unfoldrM streamLen)

884+ , benchFold "headTail" headTail (unfoldrM streamLen)

885+ ]

886+ , bgroup "transformation"

887+ [

888+ -- XXX why do these need so much stack

889+ benchFold "intersperse" (intersperse streamLen 1) (unfoldrM streamLen2)

890+ , benchFold "interspersePure" (intersperse streamLen 1) (unfoldr streamLen2)

891+ ]

892+ , bgroup "transformationX4"

893+ [

894+ benchFold "intersperse" (intersperse streamLen 4) (unfoldrM streamLen16)

895+ ]

896+ , bgroup "iterated"

897+ [ benchK "mapM" (iterateMapM iterStreamLen maxIters)

898+ , benchK "scan(1/10)" (iterateScan iterStreamLen maxIters)

899+ , benchK "filterEven" (iterateFilterEven iterStreamLen maxIters)

900+ , benchK "takeAll" (iterateTakeAll streamLen iterStreamLen maxIters)

901+ , benchK "dropOne" (iterateDropOne iterStreamLen maxIters)

902+ , benchK "dropWhileFalse(1/10)" (iterateDropWhileFalse streamLen iterStreamLen maxIters)

903+ , benchK "dropWhileTrue" (iterateDropWhileTrue streamLen iterStreamLen maxIters)

904+ ]

905+ ]

906+ where

907+ streamLen2 = round (P.fromIntegral streamLen**(1/2::P.Double)) -- double nested loop

908+ streamLen16 = round (P.fromIntegral streamLen**(1/16::P.Double)) -- triple nested loop

909+-}

910+

911+o_n_space :: Int -> Benchmark

912+o_n_space streamLen =

913+ bgroup (o_n_space_prefix moduleName)

914+ [ bgroup "elimination"

915+ [ benchFold "toList" toList (unfoldrMK streamLen)

916+ ]

917+ ]

918+

919+{-

920+{-# INLINE benchList #-}

921+benchList :: P.String -> ([Int] -> [Int]) -> (Int -> [Int]) -> Benchmark

922+benchList name run f = bench name $ nfIO $ randomRIO (1,1) >>= return . run . f

923+-}

924+

925+main :: IO ()

926+main =

927+ defaultMain

928+ [ o_1_space streamLen

929+ -- , o_n_stack streamLen iterStreamLen maxIters

930+ -- , o_n_heap streamLen

931+ , o_n_space streamLen

932+ ]

933+

934+ where

935+

936+ streamLen = 100000

937+ -- maxIters = 10000

938+ -- iterStreamLen = 10

benchmark/Streamly/Benchmark/Prelude/Serial/Transformation1.hs → benchmark/Streamly/Benchmark/Data/Stream/Transform.hsrenamed+294−161

@@ -1,14 +1,20 @@

11-- |

2−-- Module : Serial.Transformation1

2+-- Module : Stream.Transform

44-- License : BSD-3-Clause

55-- Maintainer : streamly@composewell.com

77{-# LANGUAGE CPP #-}

88{-# LANGUAGE FlexibleContexts #-}

9+{-# LANGUAGE FlexibleInstances #-}

910{-# LANGUAGE ScopedTypeVariables #-}

1011{-# LANGUAGE RankNTypes #-}

1112

13+{-# OPTIONS_GHC -Wno-orphans #-}

14+#ifdef USE_PRELUDE

15+{-# OPTIONS_GHC -Wno-deprecations #-}

16+#endif

17+

1218#ifdef __HADDOCK_VERSION__

1319#undef INSPECTION

1420#endif

@@ -18,29 +24,48 @@

1824{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1925#endif

2026

21−module Serial.Transformation1 (benchmarks) where

27+module Stream.Transform (benchmarks) where

2228

23−import Control.DeepSeq (NFData(..))

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

25−import Data.Functor.Identity (Identity)

26−import Data.IORef (newIORef, modifyIORef')

27−import System.Random (randomRIO)

2830

29−#ifdef INSPECTION

30−import Test.Inspection

31−#endif

31+import System.Random (randomRIO)

3232

33−import qualified Streamly.Prelude as S

34−import qualified Streamly.Internal.Data.Stream.IsStream as Internal

3533import qualified Streamly.Internal.Data.Fold as FL

34+

35+import qualified Stream.Common as Common

36+import qualified Streamly.Internal.Data.Unfold as Unfold

37+

38+#ifdef USE_PRELUDE

39+import Control.DeepSeq (NFData(..))

40+import Data.Functor.Identity (Identity(..))

41+import qualified Prelude

42+import qualified Streamly.Internal.Data.Fold as Fold

43+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

44+import Streamly.Internal.Data.Time.Units

45+#else

46+import Streamly.Internal.Data.Stream (Stream)

47+import qualified Streamly.Internal.Data.Stream as Stream

48+#ifndef USE_STREAMLY_CORE

49+import qualified Streamly.Internal.Data.Stream.Prelude as Stream

50+#endif

51+#ifdef USE_STREAMK

52+import Control.DeepSeq (NFData(..))

53+import Data.Functor.Identity (Identity(..))

3654import qualified Prelude

55+import qualified Streamly.Internal.Data.Fold as Fold

56+import Streamly.Internal.Data.StreamK (StreamK)

57+import qualified Streamly.Internal.Data.StreamK as StreamK

58+#endif

59+#endif

3760

38−import Gauge

39−import Streamly.Prelude (SerialT, fromSerial, MonadAsync)

61+import Test.Tasty.Bench

62+import Stream.Common hiding (scanl')

4063import Streamly.Benchmark.Common

41−import Streamly.Benchmark.Prelude

42−import Streamly.Internal.Data.Time.Units

43−import Prelude hiding (sequence, mapM, fmap)

64+import Prelude hiding (sequence, mapM)

65+

66+#ifdef USE_PRELUDE

67+type Stream = Stream.SerialT

68+#endif

4469

4570-------------------------------------------------------------------------------

4671-- Pipelines (stream-to-stream transformations)

@@ -54,28 +79,36 @@ import Prelude hiding (sequence, mapM, fmap)

5479-- Traversable Instance

5580-------------------------------------------------------------------------------

5681

82+#ifdef USE_STREAMK

5783{-# INLINE traversableTraverse #-}

58−traversableTraverse :: SerialT Identity Int -> IO (SerialT Identity Int)

84+traversableTraverse :: StreamK Identity Int -> IO (StreamK Identity Int)

5985traversableTraverse = traverse return

6086

6187{-# INLINE traversableSequenceA #-}

62−traversableSequenceA :: SerialT Identity Int -> IO (SerialT Identity Int)

88+traversableSequenceA :: StreamK Identity Int -> IO (StreamK Identity Int)

6389traversableSequenceA = sequenceA . Prelude.fmap return

6490

6591{-# INLINE traversableMapM #-}

66−traversableMapM :: SerialT Identity Int -> IO (SerialT Identity Int)

92+traversableMapM :: StreamK Identity Int -> IO (StreamK Identity Int)

6793traversableMapM = Prelude.mapM return

6894

6995{-# INLINE traversableSequence #-}

70−traversableSequence :: SerialT Identity Int -> IO (SerialT Identity Int)

96+traversableSequence :: StreamK Identity Int -> IO (StreamK Identity Int)

7197traversableSequence = Prelude.sequence . Prelude.fmap return

7298

7399{-# INLINE benchPureSinkIO #-}

74100benchPureSinkIO

75101 :: NFData b

76− => Int -> String -> (SerialT Identity Int -> IO b) -> Benchmark

102+ => Int -> String -> (StreamK Identity Int -> IO b) -> Benchmark

77103benchPureSinkIO value name f =

78− bench name $ nfIO $ randomRIO (1, 1) >>= f . sourceUnfoldr value

104+ bench name

105+ $ nfIO $ randomRIO (1, 1) >>= f . fromStream . sourceUnfoldr value

106+

107+instance NFData a => NFData (StreamK Identity a) where

108+ {-# INLINE rnf #-}

109+ rnf xs =

110+ runIdentity

111+ $ Stream.fold (Fold.foldl' (\_ x -> rnf x) ()) (toStream xs)

79112

80113o_n_space_traversable :: Int -> [Benchmark]

81114o_n_space_traversable value =

@@ -88,113 +121,124 @@ o_n_space_traversable value =

88121 , benchPureSinkIO value "sequence" traversableSequence

89122 ]

90123 ]

124+#endif

91125

92126-------------------------------------------------------------------------------

93127-- maps and scans

94128-------------------------------------------------------------------------------

95129

130+#ifdef USE_PRELUDE

96131{-# INLINE scanl' #-}

97−scanl' :: MonadIO m => Int -> SerialT m Int -> m ()

98−scanl' n = composeN n $ S.scanl' (+) 0

132+scanl' :: MonadIO m => Int -> Stream m Int -> m ()

133+scanl' n = composeN n $ Stream.scanl' (+) 0

99134

100135{-# INLINE scanlM' #-}

101−scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

102−scanlM' n = composeN n $ S.scanlM' (\b a -> return $ b + a) (return 0)

136+scanlM' :: MonadIO m => Int -> Stream m Int -> m ()

137+scanlM' n = composeN n $ Stream.scanlM' (\b a -> return $ b + a) (return 0)

103138

104139{-# INLINE scanl1' #-}

105−scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()

106−scanl1' n = composeN n $ S.scanl1' (+)

140+scanl1' :: MonadIO m => Int -> Stream m Int -> m ()

141+scanl1' n = composeN n $ Stream.scanl1' (+)

107142

108143{-# INLINE scanl1M' #-}

109−scanl1M' :: MonadIO m => Int -> SerialT m Int -> m ()

110−scanl1M' n = composeN n $ S.scanl1M' (\b a -> return $ b + a)

144+scanl1M' :: MonadIO m => Int -> Stream m Int -> m ()

145+scanl1M' n = composeN n $ Stream.scanl1M' (\b a -> return $ b + a)

146+#endif

111147

112148{-# INLINE scan #-}

113−scan :: MonadIO m => Int -> SerialT m Int -> m ()

114−scan n = composeN n $ S.scan FL.sum

149+scan :: MonadIO m => Int -> Stream m Int -> m ()

150+scan n = composeN n $ Stream.scan FL.sum

115151

152+#ifdef USE_PRELUDE

116153{-# INLINE postscanl' #-}

117−postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()

118−postscanl' n = composeN n $ S.postscanl' (+) 0

154+postscanl' :: MonadIO m => Int -> Stream m Int -> m ()

155+postscanl' n = composeN n $ Stream.postscanl' (+) 0

119156

120157{-# INLINE postscanlM' #-}

121−postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

122−postscanlM' n = composeN n $ S.postscanlM' (\b a -> return $ b + a) (return 0)

158+postscanlM' :: MonadIO m => Int -> Stream m Int -> m ()

159+postscanlM' n = composeN n $ Stream.postscanlM' (\b a -> return $ b + a) (return 0)

160+#endif

123161

124162{-# INLINE postscan #-}

125−postscan :: MonadIO m => Int -> SerialT m Int -> m ()

126−postscan n = composeN n $ S.postscan FL.sum

163+postscan :: MonadIO m => Int -> Stream m Int -> m ()

164+postscan n = composeN n $ Stream.postscan FL.sum

127165

128166{-# INLINE sequence #-}

129−sequence ::

130− (S.IsStream t, S.MonadAsync m)

131− => (t m Int -> S.SerialT m Int)

132− -> t m (m Int)

133− -> m ()

134−sequence t = S.drain . t . S.sequence

167+sequence :: MonadAsync m => Stream m (m Int) -> m ()

168+sequence = Common.drain . Stream.sequence

135169

136170{-# INLINE tap #-}

137−tap :: MonadIO m => Int -> SerialT m Int -> m ()

138−tap n = composeN n $ S.tap FL.sum

139−

140−{-# INLINE tapRate #-}

141−tapRate :: Int -> SerialT IO Int -> IO ()

142−tapRate n str = do

143− cref <- newIORef 0

144− composeN n (Internal.tapRate 1 (\c -> modifyIORef' cref (c +))) str

171+tap :: MonadIO m => Int -> Stream m Int -> m ()

172+tap n = composeN n $ Stream.tap FL.sum

145173

174+#ifdef USE_PRELUDE

146175{-# INLINE pollCounts #-}

147−pollCounts :: Int -> SerialT IO Int -> IO ()

176+pollCounts :: Int -> Stream IO Int -> IO ()

148177pollCounts n =

149− composeN n (Internal.pollCounts (const True) f FL.drain)

178+ composeN n (Stream.pollCounts (const True) f)

150179

151180 where

152181

153− f = Internal.rollingMap (-) . Internal.delayPost 1

182+ f = Stream.drain . Stream.rollingMap2 (-) . Stream.delayPost 1

154183

155184{-# INLINE timestamped #-}

156−timestamped :: (S.MonadAsync m) => SerialT m Int -> m ()

157−timestamped = S.drain . Internal.timestamped

185+timestamped :: (MonadAsync m) => Stream m Int -> m ()

186+timestamped = Stream.drain . Stream.timestamped

187+#endif

158188

189+#ifdef USE_STREAMK

159190{-# INLINE foldrS #-}

160−foldrS :: MonadIO m => Int -> SerialT m Int -> m ()

161−foldrS n = composeN n $ Internal.foldrS S.cons S.nil

191+foldrS :: MonadIO m => Int -> Stream m Int -> m ()

192+foldrS n =

193+ composeN n (toStream . StreamK.foldrS StreamK.cons StreamK.nil . fromStream)

162194

163195{-# INLINE foldrSMap #-}

164−foldrSMap :: MonadIO m => Int -> SerialT m Int -> m ()

165−foldrSMap n = composeN n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil

196+foldrSMap :: MonadIO m => Int -> Stream m Int -> m ()

197+foldrSMap n =

198+ composeN n

199+ ( toStream

200+ . StreamK.foldrS (\x xs -> x + 1 `StreamK.cons` xs) StreamK.nil

201+ . fromStream

202+ )

203+#endif

166204

205+{-

167206{-# INLINE foldrT #-}

168−foldrT :: MonadIO m => Int -> SerialT m Int -> m ()

169−foldrT n = composeN n $ Internal.foldrT S.cons S.nil

207+foldrT :: MonadIO m => Int -> Stream m Int -> m ()

208+foldrT n = composeN n (unCrossStream . Stream.foldrT cns (CrossStream Stream.nil))

170209

171−{-# INLINE foldrTMap #-}

172−foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()

173−foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil

210+ where cns x (CrossStream xs) = CrossStream (Stream.cons x xs)

174211

212+{-# INLINE foldrTMap #-}

213+foldrTMap :: MonadIO m => Int -> Stream m Int -> m ()

214+foldrTMap n = composeN n $ Stream.foldrT (\x xs -> x + 1 `Stream.cons` xs) Stream.nil

215+-}

175216

176217{-# INLINE trace #-}

177−trace :: MonadAsync m => Int -> SerialT m Int -> m ()

178−trace n = composeN n $ Internal.trace return

218+trace :: MonadAsync m => Int -> Stream m Int -> m ()

219+trace n = composeN n $ Stream.trace return

179220

180221o_1_space_mapping :: Int -> [Benchmark]

181222o_1_space_mapping value =

182223 [ bgroup

183224 "mapping"

184225 [

226+#ifdef USE_STREAMK

185227 -- Right folds

186228 benchIOSink value "foldrS" (foldrS 1)

187229 , benchIOSink value "foldrSMap" (foldrSMap 1)

188− , benchIOSink value "foldrT" (foldrT 1)

189− , benchIOSink value "foldrTMap" (foldrTMap 1)

230+ ,

231+#endif

232+ -- , benchIOSink value "foldrT" (foldrT 1)

233+ -- , benchIOSink value "foldrTMap" (foldrTMap 1)

190234

191235 -- Mapping

192− , benchIOSink value "map" (mapN fromSerial 1)

236+ benchIOSink value "map" (mapN 1)

193237 , bench "sequence" $ nfIO $ randomRIO (1, 1000) >>= \n ->

194− sequence fromSerial (sourceUnfoldrAction value n)

195− , benchIOSink value "mapM" (mapM fromSerial 1)

238+ sequence (sourceUnfoldrAction value n)

239+ , benchIOSink value "mapM" (mapM 1)

196240 , benchIOSink value "tap" (tap 1)

197− , benchIOSink value "tapRate 1 second" (tapRate 1)

241+#ifdef USE_PRELUDE

198242 , benchIOSink value "pollCounts 1 second" (pollCounts 1)

199243 , benchIOSink value "timestamped" timestamped

200244

@@ -205,7 +249,7 @@ o_1_space_mapping value =

205249 , benchIOSink value "scanl1M'" (scanl1M' 1)

206250 , benchIOSink value "postscanl'" (postscanl' 1)

207251 , benchIOSink value "postscanlM'" (postscanlM' 1)

208−

252+#endif

209253 , benchIOSink value "scan" (scan 1)

210254 , benchIOSink value "postscan" (postscan 1)

211255 ]

@@ -214,36 +258,37 @@ o_1_space_mapping value =

214258o_1_space_mappingX4 :: Int -> [Benchmark]

215259o_1_space_mappingX4 value =

216260 [ bgroup "mappingX4"

217− [ benchIOSink value "map" (mapN fromSerial 4)

218− , benchIOSink value "mapM" (mapM fromSerial 4)

261+ [ benchIOSink value "map" (mapN 4)

262+ , benchIOSink value "mapM" (mapM 4)

219263 , benchIOSink value "trace" (trace 4)

220264

265+#ifdef USE_PRELUDE

221266 , benchIOSink value "scanl'" (scanl' 4)

222267 , benchIOSink value "scanl1'" (scanl1' 4)

223268 , benchIOSink value "scanlM'" (scanlM' 4)

224269 , benchIOSink value "scanl1M'" (scanl1M' 4)

225270 , benchIOSink value "postscanl'" (postscanl' 4)

226271 , benchIOSink value "postscanlM'" (postscanlM' 4)

227−

272+#endif

228273 ]

229274 ]

230275

231276{-# INLINE sieveScan #-}

232−sieveScan :: Monad m => SerialT m Int -> SerialT m Int

277+sieveScan :: Monad m => Stream m Int -> Stream m Int

233278sieveScan =

234− S.mapMaybe snd

235− . S.scanlM' (\(primes, _) n -> do

279+ Stream.mapMaybe snd

280+ . Stream.scan (FL.foldlM' (\(primes, _) n -> do

236281 return $

237282 let ps = takeWhile (\p -> p * p <= n) primes

238283 in if all (\p -> n `mod` p /= 0) ps

239284 then (primes ++ [n], Just n)

240− else (primes, Nothing)) (return ([2], Just 2))

285+ else (primes, Nothing)) (return ([2], Just 2)))

241286

242287o_n_space_mapping :: Int -> [Benchmark]

243288o_n_space_mapping value =

244289 [ bgroup "mapping"

245290 [ benchIO "naive prime sieve"

246− (\n -> S.sum $ sieveScan $ S.enumerateFromTo 2 (value + n))

291+ (\n -> Stream.fold FL.sum $ sieveScan $ Stream.enumerateFromTo 2 (value + n))

247292 ]

248293 ]

249294

@@ -254,8 +299,75 @@ o_n_space_mapping value =

254299o_1_space_functor :: Int -> [Benchmark]

255300o_1_space_functor value =

256301 [ bgroup "Functor"

257− [ benchIOSink value "fmap" (fmapN fromSerial 1)

258− , benchIOSink value "fmap x 4" (fmapN fromSerial 4)

302+ [ benchIOSink value "fmap" (mapN 1)

303+ , benchIOSink value "fmap x 4" (mapN 4)

304+ ]

305+ ]

306+

307+-------------------------------------------------------------------------------

308+-- Iteration/looping utilities

309+-------------------------------------------------------------------------------

310+

311+{-# INLINE iterateN #-}

312+iterateN :: (Int -> a -> a) -> a -> Int -> a

313+iterateN g initial count = f count initial

314+

315+ where

316+

317+ f (0 :: Int) x = x

318+ f i x = f (i - 1) (g i x)

319+

320+#ifdef USE_STREAMK

321+-- Iterate a transformation over a singleton stream

322+{-# INLINE iterateSingleton #-}

323+iterateSingleton :: Applicative m =>

324+ (Int -> StreamK m Int -> StreamK m Int)

325+ -> Int

326+ -> Int

327+ -> Stream m Int

328+iterateSingleton g count n = toStream $ iterateN g (StreamK.fromPure n) count

329+#else

330+-- Iterate a transformation over a singleton stream

331+{-# INLINE iterateSingleton #-}

332+iterateSingleton :: Applicative m =>

333+ (Int -> Stream m Int -> Stream m Int)

334+ -> Int

335+ -> Int

336+ -> Stream m Int

337+iterateSingleton g count n = iterateN g (Stream.fromPure n) count

338+#endif

339+

340+{-

341+-- XXX need to check why this is slower than the explicit recursion above, even

342+-- if the above code is written in a foldr like head recursive way. We also

343+-- need to try this with foldlM' once #150 is fixed.

344+-- However, it is perhaps best to keep the iteration benchmarks independent of

345+-- foldrM and any related fusion issues.

346+{-# INLINE _iterateSingleton #-}

347+_iterateSingleton ::

348+ Monad m

349+ => (Int -> Stream m Int -> Stream m Int)

350+ -> Int

351+ -> Int

352+ -> Stream m Int

353+_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

354+-}

355+

356+o_n_space_iterated :: Int -> [Benchmark]

357+o_n_space_iterated value =

358+ [ bgroup "iterated"

359+ [ benchIO "(+) (n times) (baseline)" $ \i0 ->

360+ iterateN (\i acc -> acc >>= \n -> return $ i + n) (return i0) value

361+ , benchIOSrc "(<$) (n times)" $

362+ iterateSingleton (<$) value

363+ , benchIOSrc "fmap (n times)" $

364+ iterateSingleton (fmap . (+)) value

365+ {-

366+ , benchIOSrc fromSerial "_(<$) (n times)" $

367+ _iterateSingleton (<$) value

368+ , benchIOSrc fromSerial "_fmap (n times)" $

369+ _iterateSingleton (fmap . (+)) value

370+ -}

259371 ]

260372 ]

261373

@@ -264,121 +376,129 @@ o_1_space_functor value =

264376-------------------------------------------------------------------------------

265377

266378{-# INLINE filterEven #-}

267−filterEven :: MonadIO m => Int -> SerialT m Int -> m ()

268−filterEven n = composeN n $ S.filter even

379+filterEven :: MonadIO m => Int -> Stream m Int -> m ()

380+filterEven n = composeN n $ Stream.filter even

269381

270382{-# INLINE filterAllOut #-}

271−filterAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

272−filterAllOut value n = composeN n $ S.filter (> (value + 1))

383+filterAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

384+filterAllOut value n = composeN n $ Stream.filter (> (value + 1))

273385

274386{-# INLINE filterAllIn #-}

275−filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

276−filterAllIn value n = composeN n $ S.filter (<= (value + 1))

387+filterAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

388+filterAllIn value n = composeN n $ Stream.filter (<= (value + 1))

277389

278390{-# INLINE filterMEven #-}

279−filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()

280−filterMEven n = composeN n $ S.filterM (return . even)

391+filterMEven :: MonadIO m => Int -> Stream m Int -> m ()

392+filterMEven n = composeN n $ Stream.filterM (return . even)

281393

282394{-# INLINE filterMAllOut #-}

283−filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

284−filterMAllOut value n = composeN n $ S.filterM (\x -> return $ x > (value + 1))

395+filterMAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()

396+filterMAllOut value n = composeN n $ Stream.filterM (\x -> return $ x > (value + 1))

285397

286398{-# INLINE filterMAllIn #-}

287−filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

288−filterMAllIn value n = composeN n $ S.filterM (\x -> return $ x <= (value + 1))

399+filterMAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()

400+filterMAllIn value n = composeN n $ Stream.filterM (\x -> return $ x <= (value + 1))

289401

290402{-# INLINE _takeOne #-}

291−_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()

292−_takeOne n = composeN n $ S.take 1

403+_takeOne :: MonadIO m => Int -> Stream m Int -> m ()

404+_takeOne n = composeN n $ Stream.take 1

293405

294406{-# INLINE takeAll #-}

295−takeAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

296−takeAll value n = composeN n $ S.take (value + 1)

407+takeAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

408+takeAll value n = composeN n $ Stream.take (value + 1)

297409

298410{-# INLINE takeWhileTrue #-}

299−takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

300−takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))

411+takeWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

412+takeWhileTrue value n = composeN n $ Stream.takeWhile (<= (value + 1))

301413

302414{-# INLINE takeWhileMTrue #-}

303−takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

304−takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

415+takeWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

416+takeWhileMTrue value n = composeN n $ Stream.takeWhileM (return . (<= (value + 1)))

305417

418+#if !defined(USE_STREAMLY_CORE) && !defined(USE_PRELUDE)

306419{-# INLINE takeInterval #-}

307−takeInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

308−takeInterval i n = composeN n (Internal.takeInterval i)

420+takeInterval :: Double -> Int -> Stream IO Int -> IO ()

421+takeInterval i n = composeN n (Stream.takeInterval i)

309422

423+-- Inspection testing is disabled for takeInterval

424+-- Enable it when looking at it throughly

310425#ifdef INSPECTION

311426-- inspect $ hasNoType 'takeInterval ''SPEC

312−inspect $ hasNoTypeClasses 'takeInterval

427+-- inspect $ hasNoTypeClasses 'takeInterval

313428-- inspect $ 'takeInterval `hasNoType` ''D.Step

314429#endif

315430

431+{-# INLINE dropInterval #-}

432+dropInterval :: Double -> Int -> Stream IO Int -> IO ()

433+dropInterval i n = composeN n (Stream.dropInterval i)

434+

435+-- Inspection testing is disabled for dropInterval

436+-- Enable it when looking at it throughly

437+#ifdef INSPECTION

438+-- inspect $ hasNoTypeClasses 'dropInterval

439+-- inspect $ 'dropInterval `hasNoType` ''D.Step

440+#endif

441+#endif

442+

316443{-# INLINE dropOne #-}

317−dropOne :: MonadIO m => Int -> SerialT m Int -> m ()

318−dropOne n = composeN n $ S.drop 1

444+dropOne :: MonadIO m => Int -> Stream m Int -> m ()

445+dropOne n = composeN n $ Stream.drop 1

319446

320447{-# INLINE dropAll #-}

321−dropAll :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

322−dropAll value n = composeN n $ S.drop (value + 1)

448+dropAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()

449+dropAll value n = composeN n $ Stream.drop (value + 1)

323450

324451{-# INLINE dropWhileTrue #-}

325−dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

326−dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))

452+dropWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

453+dropWhileTrue value n = composeN n $ Stream.dropWhile (<= (value + 1))

327454

328455{-# INLINE dropWhileMTrue #-}

329−dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

330−dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

456+dropWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()

457+dropWhileMTrue value n = composeN n $ Stream.dropWhileM (return . (<= (value + 1)))

331458

332459{-# INLINE dropWhileFalse #-}

333−dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

334−dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))

460+dropWhileFalse :: MonadIO m => Int -> Int -> Stream m Int -> m ()

461+dropWhileFalse value n = composeN n $ Stream.dropWhile (> (value + 1))

335462

463+#ifdef USE_PRELUDE

336464-- XXX Decide on the time interval

337465{-# INLINE _intervalsOfSum #-}

338−_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()

339−_intervalsOfSum i n = composeN n (S.intervalsOf i FL.sum)

340−

341−{-# INLINE dropInterval #-}

342−dropInterval :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

343−dropInterval i n = composeN n (Internal.dropInterval i)

344−

345−#ifdef INSPECTION

346−inspect $ hasNoTypeClasses 'dropInterval

347−-- inspect $ 'dropInterval `hasNoType` ''D.Step

466+_intervalsOfSum :: MonadAsync m => Double -> Int -> Stream m Int -> m ()

467+_intervalsOfSum i n = composeN n (Stream.intervalsOf i FL.sum)

348468#endif

349469

350470{-# INLINE findIndices #-}

351−findIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

352−findIndices value n = composeN n $ S.findIndices (== (value + 1))

471+findIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

472+findIndices value n = composeN n $ Stream.findIndices (== (value + 1))

353473

354474{-# INLINE elemIndices #-}

355−elemIndices :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

356−elemIndices value n = composeN n $ S.elemIndices (value + 1)

475+elemIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()

476+elemIndices value n = composeN n $ Stream.elemIndices (value + 1)

357477

358478{-# INLINE deleteBy #-}

359−deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

360−deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)

479+deleteBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

480+deleteBy value n = composeN n $ Stream.deleteBy (>=) (value + 1)

361481

362482-- uniq . uniq == uniq, composeN 2 ~ composeN 1

363483{-# INLINE uniq #-}

364−uniq :: MonadIO m => Int -> SerialT m Int -> m ()

365−uniq n = composeN n S.uniq

484+uniq :: MonadIO m => Int -> Stream m Int -> m ()

485+uniq n = composeN n Stream.uniq

366486

367487{-# INLINE mapMaybe #-}

368−mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()

488+mapMaybe :: MonadIO m => Int -> Stream m Int -> m ()

369489mapMaybe n =

370490 composeN n $

371− S.mapMaybe

491+ Stream.mapMaybe

372492 (\x ->

373493 if odd x

374494 then Nothing

375495 else Just x)

376496

377497{-# INLINE mapMaybeM #-}

378−mapMaybeM :: S.MonadAsync m => Int -> SerialT m Int -> m ()

498+mapMaybeM :: MonadAsync m => Int -> Stream m Int -> m ()

379499mapMaybeM n =

380500 composeN n $

381− S.mapMaybeM

501+ Stream.mapMaybeM

382502 (\x ->

383503 if odd x

384504 then return Nothing

@@ -397,18 +517,14 @@ o_1_space_filtering value =

397517

398518 -- Trimming

399519 , benchIOSink value "take-all" (takeAll value 1)

400− , benchIOSink

401− value

402− "takeInterval-all"

403− (takeInterval (NanoSecond64 maxBound) 1)

404520 , benchIOSink value "takeWhile-true" (takeWhileTrue value 1)

405521 -- , benchIOSink value "takeWhileM-true" (_takeWhileMTrue value 1)

406522 , benchIOSink value "drop-one" (dropOne 1)

407523 , benchIOSink value "drop-all" (dropAll value 1)

408− , benchIOSink

409− value

410− "dropInterval-all"

411− (dropInterval (NanoSecond64 maxBound) 1)

524+#if !defined(USE_STREAMLY_CORE) && !defined(USE_PRELUDE)

525+ , benchIOSink value "takeInterval-all" (takeInterval 10000 1)

526+ , benchIOSink value "dropInterval-all" (dropInterval 10000 1)

527+#endif

412528 , benchIOSink value "dropWhile-true" (dropWhileTrue value 1)

413529 -- , benchIOSink value "dropWhileM-true" (_dropWhileMTrue value 1)

414530 , benchIOSink

@@ -471,23 +587,35 @@ o_1_space_filteringX4 value =

471587-------------------------------------------------------------------------------

472588

473589{-# INLINE intersperse #-}

474−intersperse :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()

475−intersperse value n = composeN n $ S.intersperse (value + 1)

590+intersperse :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

591+intersperse value n = composeN n $ Stream.intersperse (value + 1)

476592

477593{-# INLINE intersperseM #-}

478−intersperseM :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()

479−intersperseM value n = composeN n $ S.intersperseM (return $ value + 1)

594+intersperseM :: MonadAsync m => Int -> Int -> Stream m Int -> m ()

595+intersperseM value n = composeN n $ Stream.intersperseM (return $ value + 1)

480596

481597{-# INLINE insertBy #-}

482−insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

483−insertBy value n = composeN n $ S.insertBy compare (value + 1)

598+insertBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()

599+insertBy value n = composeN n $ Stream.insertBy compare (value + 1)

600+

601+{-# INLINE interposeSuffix #-}

602+interposeSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

603+interposeSuffix value n =

604+ composeN n $ Stream.interposeSuffix (value + 1) Unfold.identity

605+

606+{-# INLINE intercalateSuffix #-}

607+intercalateSuffix :: Monad m => Int -> Int -> Stream m Int -> m ()

608+intercalateSuffix value n =

609+ composeN n $ Stream.intercalateSuffix Unfold.identity (value + 1)

484610

485611o_1_space_inserting :: Int -> [Benchmark]

486612o_1_space_inserting value =

487− [ bgroup "filtering"

613+ [ bgroup "inserting"

488614 [ benchIOSink value "intersperse" (intersperse value 1)

489615 , benchIOSink value "intersperseM" (intersperseM value 1)

490616 , benchIOSink value "insertBy" (insertBy value 1)

617+ , benchIOSink value "interposeSuffix" (interposeSuffix value 1)

618+ , benchIOSink value "intercalateSuffix" (intercalateSuffix value 1)

491619 ]

492620 ]

493621

@@ -504,12 +632,12 @@ o_1_space_insertingX4 value =

504632-------------------------------------------------------------------------------

505633

506634{-# INLINE indexed #-}

507−indexed :: MonadIO m => Int -> SerialT m Int -> m ()

508−indexed n = composeN n (S.map snd . S.indexed)

635+indexed :: MonadIO m => Int -> Stream m Int -> m ()

636+indexed n = composeN n (fmap snd . Stream.indexed)

509637

510638{-# INLINE indexedR #-}

511−indexedR :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

512−indexedR value n = composeN n (S.map snd . S.indexedR value)

639+indexedR :: MonadIO m => Int -> Int -> Stream m Int -> m ()

640+indexedR value n = composeN n (fmap snd . Stream.indexedR value)

513641

514642o_1_space_indexing :: Int -> [Benchmark]

515643o_1_space_indexing value =

@@ -548,7 +676,12 @@ benchmarks moduleName size =

548676 , o_1_space_indexingX4 size

549677 ]

550678 , bgroup (o_n_space_prefix moduleName) $ Prelude.concat

551− [ o_n_space_traversable size

552− , o_n_space_mapping size

679+ [

680+#ifdef USE_STREAMK

681+ o_n_space_traversable size

682+ ,

683+#endif

684+ o_n_space_mapping size

685+ , o_n_space_iterated size

553686 ]

554687 ]

benchmark/Streamly/Benchmark/Data/Unfold.hs+120−85

@@ -21,6 +21,8 @@ module Main (main) where

2121

2222import Control.DeepSeq (NFData(..))

2323import Control.Exception (SomeException, ErrorCall, try)

24+import Data.Char (ord)

25+import Data.Word (Word8)

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

2527import System.IO (Handle, hClose)

2628import System.Random (randomRIO)

@@ -29,17 +31,18 @@ import qualified Prelude

2931import qualified Streamly.FileSystem.Handle as FH

3032import qualified Streamly.Internal.Data.Fold as FL

3133import qualified Streamly.Internal.Data.Unfold as UF

32−import qualified Streamly.Internal.Data.Stream.IsStream as S

33−import qualified Streamly.Internal.Data.Stream.StreamD as D

34−import qualified Streamly.Internal.Data.Stream.StreamK as K

35−import qualified Streamly.Prelude as SP

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

3638

37−import Gauge hiding (env)

38−import Prelude hiding (concat, take, filter, zipWith, map, mapM, takeWhile)

39+import Test.Tasty.Bench hiding (env)

40+import Prelude hiding (take, filter, zipWith, map, mapM, takeWhile)

3941import Streamly.Benchmark.Common

4042import Streamly.Benchmark.Common.Handle

4143

4244#ifdef INSPECTION

45+import Control.Monad.Catch (MonadCatch)

4346import Test.Inspection

4447#endif

4548

@@ -54,7 +57,7 @@ benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f

5457-- generate numbers up to the argument value

5558{-# INLINE source #-}

5659source :: Monad m => Int -> Unfold m Int Int

57−source n = UF.enumerateFromToIntegral n

60+source n = UF.second n UF.enumerateFromToIntegral

5861

5962-------------------------------------------------------------------------------

6063-- Benchmark helpers

@@ -73,7 +76,7 @@ drainTransformation unf f seed = drainGeneration (f unf) seed

7376drainTransformationDefault ::

7477 Monad m => Int -> (Unfold m Int Int -> Unfold m c d) -> c -> m ()

7578drainTransformationDefault to =

76− drainTransformation (UF.enumerateFromToIntegral to)

79+ drainTransformation (UF.second to UF.enumerateFromToIntegral)

7780

7881{-# INLINE drainProduct #-}

7982drainProduct ::

@@ -96,7 +99,7 @@ drainProductDefault to = drainProduct src src

9699

97100 where

98101

99− src = UF.enumerateFromToIntegral to

102+ src = UF.second to UF.enumerateFromToIntegral

100103

101104-------------------------------------------------------------------------------

102105-- Operations on input

@@ -112,26 +115,26 @@ lmapM :: Monad m => Int -> Int -> m ()

112115lmapM size start =

113116 drainTransformationDefault (size + start) (UF.lmapM (return . (+) 1)) start

114117

115−{-# INLINE supply #-}

116−supply :: Monad m => Int -> Int -> m ()

117−supply size start =

118− drainTransformationDefault (size + start) (UF.supply start) undefined

118+{-# INLINE both #-}

119+both :: Monad m => Int -> Int -> m ()

120+both size start =

121+ drainTransformationDefault (size + start) (UF.both start) undefined

119122

120123

121−{-# INLINE supplyFirst #-}

122−supplyFirst :: Monad m => Int -> Int -> m ()

123−supplyFirst size start =

124+{-# INLINE first #-}

125+first :: Monad m => Int -> Int -> m ()

126+first size start =

124127 drainTransformation

125− (UF.take size UF.enumerateFromStepIntegral)

126− (UF.supplyFirst start)

128+ (UF.take size UF.enumerateFromThenIntegral)

129+ (UF.first start)

127130 1

128131

129−{-# INLINE supplySecond #-}

130−supplySecond :: Monad m => Int -> Int -> m ()

131−supplySecond size start =

132+{-# INLINE second #-}

133+second :: Monad m => Int -> Int -> m ()

134+second size start =

132135 drainTransformation

133− (UF.take size UF.enumerateFromStepIntegral)

134− (UF.supplySecond 1)

136+ (UF.take size UF.enumerateFromThenIntegral)

137+ (UF.second 1)

135138 start

136139

137140{-# INLINE discardFirst #-}

@@ -148,7 +151,7 @@ discardSecond size start =

148151swap :: Monad m => Int -> Int -> m ()

149152swap size start =

150153 drainTransformation

151− (UF.take size UF.enumerateFromStepIntegral)

154+ (UF.take size UF.enumerateFromThenIntegral)

152155 UF.swap

153156 (1, start)

154157

@@ -159,7 +162,7 @@ swap size start =

159162{-# INLINE fromStream #-}

160163fromStream :: Int -> Int -> IO ()

161164fromStream size start =

162− drainGeneration UF.fromStream (S.replicate size start :: S.SerialT IO Int)

165+ drainGeneration UF.fromStream (S.replicate size start :: S.Stream IO Int)

163166

164167-- XXX INVESTIGATE: Although the performance of this should be equivalant to

165168-- fromStream, this is considerably worse. More than 4x worse.

@@ -196,7 +199,7 @@ _identity _ start = drainGeneration UF.identity start

196199{-# INLINE _const #-}

197200_const :: Monad m => Int -> Int -> m ()

198201_const size start =

199− drainGeneration (UF.take size (UF.yieldM (return start))) undefined

202+ drainGeneration (UF.take size (UF.fromEffect (return start))) undefined

200203

201204{-# INLINE unfoldrM #-}

202205unfoldrM :: Monad m => Int -> Int -> m ()

@@ -229,7 +232,7 @@ _fromProducer = undefined

229232

230233{-# INLINE replicateM #-}

231234replicateM :: Monad m => Int -> Int -> m ()

232−replicateM size start = drainGeneration (UF.replicateM size) (return start)

235+replicateM size start = drainGeneration UF.replicateM (size, return start)

233236

234237{-# INLINE repeatM #-}

235238repeatM :: Monad m => Int -> Int -> m ()

@@ -245,15 +248,19 @@ fromIndicesM :: Monad m => Int -> Int -> m ()

245248fromIndicesM size start =

246249 drainGeneration (UF.take size (UF.fromIndicesM return)) start

247250

248−{-# INLINE enumerateFromStepIntegral #-}

249−enumerateFromStepIntegral :: Monad m => Int -> Int -> m ()

250−enumerateFromStepIntegral size start =

251− drainGeneration (UF.take size UF.enumerateFromStepIntegral) (start, 1)

251+{-# INLINE enumerateFromThenIntegral #-}

252+enumerateFromThenIntegral :: Monad m => Int -> Int -> m ()

253+enumerateFromThenIntegral size start =

254+ drainGeneration (UF.take size UF.enumerateFromThenIntegral) (start, 1)

252255

253256{-# INLINE enumerateFromToIntegral #-}

254257enumerateFromToIntegral :: Monad m => Int -> Int -> m ()

255258enumerateFromToIntegral size start =

256− drainGeneration (UF.enumerateFromToIntegral (size + start)) start

259+ drainGeneration

260+ ( UF.second

261+ (size + start)

262+ UF.enumerateFromToIntegral

263+ ) start

257264

258265{-# INLINE enumerateFromIntegral #-}

259266enumerateFromIntegral :: Monad m => Int -> Int -> m ()

@@ -263,24 +270,32 @@ enumerateFromIntegral size start =

263270{-# INLINE enumerateFromStepNum #-}

264271enumerateFromStepNum :: Monad m => Int -> Int -> m ()

265272enumerateFromStepNum size start =

266− drainGeneration (UF.take size (UF.enumerateFromStepNum 1)) start

273+ drainGeneration (UF.take size (UF.enumerateFromThenNum)) (start, 1)

267274

268−{-# INLINE numFrom #-}

269−numFrom :: Monad m => Int -> Int -> m ()

270−numFrom size start = drainGeneration (UF.take size UF.numFrom) start

275+{-# INLINE enumerateFromNum #-}

276+enumerateFromNum :: Monad m => Int -> Int -> m ()

277+enumerateFromNum size start = drainGeneration (UF.take size UF.enumerateFromNum) start

271278

272279{-# INLINE enumerateFromToFractional #-}

273280enumerateFromToFractional :: Monad m => Int -> Int -> m ()

274281enumerateFromToFractional size start =

275282 let intToDouble x = (fromInteger (fromIntegral x)) :: Double

276283 in drainGeneration

277− (UF.enumerateFromToFractional (intToDouble $ start + size))

284+ ( UF.second

285+ (intToDouble $ start + size)

286+ UF.enumerateFromToFractional

287+ )

278288 (intToDouble start)

279289

280290-------------------------------------------------------------------------------

281291-- Stream transformation

282292-------------------------------------------------------------------------------

283293

294+{-# INLINE postscan #-}

295+postscan :: Monad m => Int -> Int -> m ()

296+postscan size start =

297+ drainTransformationDefault (size + start) (UF.postscan FL.sum) start

298+

284299{-# INLINE map #-}

285300map :: Monad m => Int -> Int -> m ()

286301map size start = drainTransformationDefault (size + start) (UF.map (+1)) start

@@ -290,12 +305,12 @@ mapM :: Monad m => Int -> Int -> m ()

290305mapM size start =

291306 drainTransformationDefault (size + start) (UF.mapM (return . (+) 1)) start

292307

293−{-# INLINE mapMWithInput #-}

294−mapMWithInput :: Monad m => Int -> Int -> m ()

295−mapMWithInput size start =

308+{-# INLINE mapM2 #-}

309+mapM2 :: Monad m => Int -> Int -> m ()

310+mapM2 size start =

296311 drainTransformationDefault

297312 size

298− (UF.mapMWithInput (\a b -> return $ a + b))

313+ (UF.mapM2 (\a b -> return $ a + b))

299314 start

300315

301316-------------------------------------------------------------------------------

@@ -403,13 +418,16 @@ teeZipWith size start =

403418-- Applicative

404419-------------------------------------------------------------------------------

405420

421+nthRoot :: Double -> Int -> Int

422+nthRoot n value = round (fromIntegral value**(1/n))

423+

406424{-# INLINE toNullAp #-}

407425toNullAp :: Monad m => Int -> Int -> m ()

408426toNullAp value start =

409427 let end = start + nthRoot 2 value

410428 s = source end

411429 -- in UF.fold ((+) <$> s <*> s) FL.drain start

412− in UF.fold FL.drain ((+) `fmap` s `UF.apply` s) start

430+ in UF.fold FL.drain ((+) `fmap` s `UF.crossApply` s) start

413431

414432{-# INLINE _apDiscardFst #-}

415433_apDiscardFst :: Int -> Int -> m ()

@@ -423,9 +441,6 @@ _apDiscardSnd = undefined

423441-- Monad

424442-------------------------------------------------------------------------------

425443

426−nthRoot :: Double -> Int -> Int

427−nthRoot n value = round (fromIntegral value**(1/n))

428−

429444{-# INLINE concatMapM #-}

430445concatMapM :: Monad m => Int -> Int -> m ()

431446concatMapM value start =

@@ -434,8 +449,8 @@ concatMapM value start =

434449 where

435450

436451 val = nthRoot 2 value

437− unfoldInGen i = return (UF.enumerateFromToIntegral (i + val))

438− unfoldOut = UF.enumerateFromToIntegral (start + val)

452+ unfoldInGen i = return (UF.second (i + val) UF.enumerateFromToIntegral)

453+ unfoldOut = UF.second (start + val) UF.enumerateFromToIntegral

439454

440455{-# INLINE toNull #-}

441456toNull :: Monad m => Int -> Int -> m ()

@@ -450,7 +465,7 @@ toNull value start =

450465 -}

451466 u = src `UF.bind` \x ->

452467 src `UF.bind` \y ->

453− UF.yield (x + y)

468+ UF.fromPure (x + y)

454469 in UF.fold FL.drain u start

455470

456471

@@ -468,7 +483,7 @@ toNull3 value start =

468483 -}

469484 u = src `UF.bind` \x ->

470485 src `UF.bind` \y ->

471− UF.yield (x + y)

486+ UF.fromPure (x + y)

472487 in UF.fold FL.drain u start

473488

474489{-# INLINE toList #-}

@@ -484,7 +499,7 @@ toList value start = do

484499 -}

485500 u = src `UF.bind` \x ->

486501 src `UF.bind` \y ->

487− UF.yield (x + y)

502+ UF.fromPure (x + y)

488503 in UF.fold FL.toList u start

489504

490505{-# INLINE toListSome #-}

@@ -500,7 +515,7 @@ toListSome value start = do

500515 -}

501516 u = src `UF.bind` \x ->

502517 src `UF.bind` \y ->

503− UF.yield (x + y)

518+ UF.fromPure (x + y)

504519 in UF.fold FL.toList (UF.take 1000 u) start

505520

506521{-# INLINE filterAllOut #-}

@@ -517,7 +532,7 @@ filterAllOut value start = do

517532 src `UF.bind` \y ->

518533 let s = x + y

519534 in if s < 0

520− then UF.yield s

535+ then UF.fromPure s

521536 else UF.nilM (return . const ())

522537 in UF.fold FL.drain u start

523538

@@ -535,7 +550,7 @@ filterAllIn value start = do

535550 src `UF.bind` \y ->

536551 let s = x + y

537552 in if s > 0

538− then UF.yield s

553+ then UF.fromPure s

539554 else UF.nilM (return . const ())

540555 in UF.fold FL.drain u start

541556

@@ -553,7 +568,7 @@ filterSome value start = do

553568 src `UF.bind` \y ->

554569 let s = x + y

555570 in if s > 1100000

556− then UF.yield s

571+ then UF.fromPure s

557572 else UF.nilM (return . const ())

558573 in UF.fold FL.drain u start

559574

@@ -572,7 +587,7 @@ breakAfterSome value start =

572587 let s = x + y

573588 in if s > 1100000

574589 then error "break"

575− else UF.yield s

590+ else UF.fromPure s

576591 in do

577592 (_ :: Either ErrorCall ()) <- try $ UF.fold FL.drain u start

578593 return ()

@@ -586,9 +601,9 @@ concatCount :: Int -> Int

586601concatCount linearCount =

587602 round (((1 + 8 * fromIntegral linearCount)**(1/2::Double) - 1) / 2)

588603

589−{-# INLINE concat #-}

590−concat :: Monad m => Int -> Int -> m ()

591−concat linearCount start = do

604+{-# INLINE many #-}

605+many :: Monad m => Int -> Int -> m ()

606+many linearCount start = do

592607 let end = start + concatCount linearCount

593608 UF.fold FL.drain (UF.many (source end) (source end)) start

594609

@@ -605,9 +620,9 @@ o_1_space_transformation_input size =

605620 "transformation/input"

606621 [ benchIO "lmap" $ lmap size

607622 , benchIO "lmapM" $ lmapM size

608− , benchIO "supply" $ supply size

609− , benchIO "supplyFirst" $ supplyFirst size

610− , benchIO "supplySecond" $ supplySecond size

623+ , benchIO "both" $ both size

624+ , benchIO "first" $ first size

625+ , benchIO "second" $ second size

611626 , benchIO "discardFirst" $ discardFirst size

612627 , benchIO "discardSecond" $ discardSecond size

613628 , benchIO "swap" $ swap size

@@ -638,11 +653,11 @@ o_1_space_generation size =

638653 , benchIO "repeatM" $ repeatM size

639654 , benchIO "iterateM" $ iterateM size

640655 , benchIO "fromIndicesM" $ fromIndicesM size

641− , benchIO "enumerateFromStepIntegral" $ enumerateFromStepIntegral size

656+ , benchIO "enumerateFromThenIntegral" $ enumerateFromThenIntegral size

642657 , benchIO "enumerateFromToIntegral" $ enumerateFromToIntegral size

643658 , benchIO "enumerateFromIntegral" $ enumerateFromIntegral size

644659 , benchIO "enumerateFromStepNum" $ enumerateFromStepNum size

645− , benchIO "numFrom" $ numFrom size

660+ , benchIO "enumerateFromNum" $ enumerateFromNum size

646661 , benchIO "enumerateFromToFractional" $ enumerateFromToFractional size

647662 ]

648663 ]

@@ -653,7 +668,8 @@ o_1_space_transformation size =

653668 "transformation"

654669 [ benchIO "map" $ map size

655670 , benchIO "mapM" $ mapM size

656− , benchIO "mapMWithInput" $ mapMWithInput size

671+ , benchIO "mapM2" $ mapM2 size

672+ , benchIO "postscan" $ postscan size

657673 ]

658674 ]

659675

@@ -686,8 +702,17 @@ o_1_space_zip size =

686702 ]

687703 ]

688704

689−o_1_space_nested :: Int -> [Benchmark]

690−o_1_space_nested size =

705+lf :: Word8

706+lf = fromIntegral (ord '\n')

707+

708+-- | Split on line feed.

709+foldManySepBy :: Handle -> IO Int

710+foldManySepBy =

711+ let u = UF.foldMany (FL.takeEndBy_ (== lf) FL.drain) FH.reader

712+ in UF.fold FL.length u

713+

714+o_1_space_nested :: BenchEnv -> Int -> [Benchmark]

715+o_1_space_nested env size =

691716 [ bgroup

692717 "nested"

693718 [ benchIO "(<*>) (sqrt n x sqrt n)" $ toNullAp size

@@ -703,7 +728,9 @@ o_1_space_nested size =

703728 , benchIO "filterAllIn" $ filterAllIn size

704729 , benchIO "filterSome" $ filterSome size

705730

706− , benchIO "concat" $ concat size

731+ , benchIO "many" $ many size

732+ , mkBench "foldMany (Fold.takeEndBy_ (== lf) Fold.drain)" env

733+ $ \inh _ -> foldManySepBy inh

707734 ]

708735 ]

709736

@@ -722,11 +749,11 @@ o_n_space_nested size =

722749-- | Send the file contents to /dev/null with exception handling

723750readWriteOnExceptionUnfold :: Handle -> Handle -> IO ()

724751readWriteOnExceptionUnfold inh devNull =

725− let readEx = UF.onException (\_ -> hClose inh) FH.read

726− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

752+ let readEx = UF.onException (\_ -> hClose inh) FH.reader

753+ in S.fold (FH.write devNull) $ S.unfold readEx inh

727754

728755#ifdef INSPECTION

729−inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

756+-- inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

730757-- inspect $ 'readWriteOnExceptionUnfold `hasNoType` ''Step

731758#endif

732759

@@ -734,45 +761,54 @@ inspect $ hasNoTypeClasses 'readWriteOnExceptionUnfold

734761readWriteHandleExceptionUnfold :: Handle -> Handle -> IO ()

735762readWriteHandleExceptionUnfold inh devNull =

736763 let handler (_e :: SomeException) = hClose inh >> return 10

737− readEx = UF.handle (UF.functionM handler) FH.read

738− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

764+ readEx = UF.handle (UF.functionM handler) FH.reader

765+ in S.fold (FH.write devNull) $ S.unfold readEx inh

739766

740767#ifdef INSPECTION

741−inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

768+-- hasNoTypeClasses started failing in GHC 9.4.4

769+-- inspect $ hasNoTypeClasses 'readWriteHandleExceptionUnfold

742770-- inspect $ 'readWriteHandleExceptionUnfold `hasNoType` ''Step

743771#endif

744772

745773-- | Send the file contents to /dev/null with exception handling

746774readWriteFinally_Unfold :: Handle -> Handle -> IO ()

747775readWriteFinally_Unfold inh devNull =

748− let readEx = UF.finally_ (\_ -> hClose inh) FH.read

749− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

776+ let readEx = UF.finally_ (\_ -> hClose inh) FH.reader

777+ in S.fold (FH.write devNull) $ S.unfold readEx inh

750778

751779#ifdef INSPECTION

780+#if __GLASGOW_HASKELL__ >= 906

781+inspect $ hasNoTypeClassesExcept 'readWriteFinally_Unfold [''MonadCatch]

782+#else

752783inspect $ hasNoTypeClasses 'readWriteFinally_Unfold

784+#endif

753785-- inspect $ 'readWriteFinallyUnfold `hasNoType` ''Step

754786#endif

755787

756788readWriteFinallyUnfold :: Handle -> Handle -> IO ()

757789readWriteFinallyUnfold inh devNull =

758− let readEx = UF.finally (\_ -> hClose inh) FH.read

759− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

790+ let readEx = UF.finally (\_ -> hClose inh) FH.reader

791+ in S.fold (FH.write devNull) $ S.unfold readEx inh

760792

761793-- | Send the file contents to /dev/null with exception handling

762794readWriteBracket_Unfold :: Handle -> Handle -> IO ()

763795readWriteBracket_Unfold inh devNull =

764− let readEx = UF.bracket_ return (\_ -> hClose inh) FH.read

765− in SP.fold (FH.write devNull) $ SP.unfold readEx inh

796+ let readEx = UF.bracket_ return (\_ -> hClose inh) FH.reader

797+ in S.fold (FH.write devNull) $ S.unfold readEx inh

766798

767799#ifdef INSPECTION

800+#if __GLASGOW_HASKELL__ >= 906

801+inspect $ hasNoTypeClassesExcept 'readWriteBracket_Unfold [''MonadCatch]

802+#else

768803inspect $ hasNoTypeClasses 'readWriteBracket_Unfold

804+#endif

769805-- inspect $ 'readWriteBracketUnfold `hasNoType` ''Step

770806#endif

771807

772808readWriteBracketUnfold :: Handle -> Handle -> IO ()

773809readWriteBracketUnfold inh devNull =

774− let readEx = UF.bracket return (\_ -> hClose inh) FH.read

775− in SP.fold (FH.write devNull) $ S.unfold readEx inh

810+ let readEx = UF.bracket return (\_ -> hClose inh) FH.reader

811+ in S.fold (FH.write devNull) $ S.unfold readEx inh

776812

777813o_1_space_copy_read_exceptions :: BenchEnv -> [Benchmark]

778814o_1_space_copy_read_exceptions env =

@@ -799,13 +835,12 @@ o_1_space_copy_read_exceptions env =

799835

800836main :: IO ()

801837main = do

802− (size, cfg, benches) <- parseCLIOpts defaultStreamSize

803838 env <- mkHandleBenchEnv

804− size `seq` runMode (mode cfg) cfg benches (allBenchmarks size env)

839+ runWithCLIOpts defaultStreamSize (allBenchmarks env)

805840

806841 where

807842

808− allBenchmarks size env =

843+ allBenchmarks env size =

809844 [ bgroup (o_1_space_prefix moduleName)

810845 $ Prelude.concat

811846 [ o_1_space_transformation_input size

@@ -813,7 +848,7 @@ main = do

813848 , o_1_space_transformation size

814849 , o_1_space_filtering size

815850 , o_1_space_zip size

816− , o_1_space_nested size

851+ , o_1_space_nested env size

817852 , o_1_space_copy_read_exceptions env

818853 ]

819854 , bgroup (o_n_space_prefix moduleName)

benchmark/Streamly/Benchmark/FileSystem/Handle.hs+2−7

@@ -17,16 +17,12 @@

1717{-# LANGUAGE TemplateHaskell #-}

1818{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1919#endif

20−

21−#if __GLASGOW_HASKELL__ >= 800

22−#endif

23−

2420import Streamly.Benchmark.Common.Handle (mkHandleBenchEnv)

2521

2622import qualified Handle.ReadWrite as RW

2723import qualified Handle.Read as RO

2824

29−import Gauge hiding (env)

25+import Test.Tasty.Bench hiding (env)

3026import Prelude hiding (last, length)

3127import Streamly.Benchmark.Common

3228

@@ -43,9 +39,8 @@ moduleName = "FileSystem.Handle"

4339

4440main :: IO ()

4541main = do

46− (_, cfg, benches) <- parseCLIOpts defaultStreamSize

4742 env <- mkHandleBenchEnv

48− runMode (mode cfg) cfg benches (allBenchmarks env)

43+ defaultMain (allBenchmarks env)

4944

5045 where

5146

benchmark/Streamly/Benchmark/FileSystem/Handle/Read.hs+66−62

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Streamly.Benchmark.FileSystem.Handle

@@ -24,32 +26,29 @@ where

2426

2527import Data.Word (Word8)

2628import GHC.Magic (inline)

27−#if __GLASGOW_HASKELL__ >= 802

2829import GHC.Magic (noinline)

29−#else

30−#define noinline

31−#endif

3230import System.IO (Handle)

3331

32+import qualified Streamly.Data.Stream as Stream

33+import qualified Streamly.Data.Fold as Fold

3434import qualified Streamly.FileSystem.Handle as FH

35−import qualified Streamly.Internal.Data.Array.Foreign as A

36−import qualified Streamly.Internal.Data.Array.Foreign.Type as AT

35+import qualified Streamly.Internal.Data.Array as A

3736import qualified Streamly.Internal.Data.Fold as FL

38−import qualified Streamly.Internal.Data.Stream.IsStream 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

41−import qualified Streamly.Prelude as S

40+import 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.Foreign.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

@@ -63,49 +62,49 @@ import Test.Inspection

6362

6463-- | Get the last byte from a file bytestream.

6564readLast :: Handle -> IO (Maybe Word8)

66−readLast = S.last . S.unfold FH.read

65+readLast = S.fold Fold.last . S.unfold FH.reader

6766

6867#ifdef INSPECTION

6968inspect $ hasNoTypeClasses 'readLast

7069inspect $ 'readLast `hasNoType` ''Step -- S.unfold

7170inspect $ 'readLast `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

72−inspect $ 'readLast `hasNoType` ''MA.ReadUState -- 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

7675-- | Count the number of bytes in a file.

7776readCountBytes :: Handle -> IO Int

78−readCountBytes = S.length . S.unfold FH.read

77+readCountBytes = S.fold Fold.length . S.unfold FH.reader

7978

8079#ifdef INSPECTION

8180inspect $ hasNoTypeClasses 'readCountBytes

8281inspect $ 'readCountBytes `hasNoType` ''Step -- S.unfold

8382inspect $ 'readCountBytes `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

84−inspect $ 'readCountBytes `hasNoType` ''MA.ReadUState -- 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.

8887readCountLines :: Handle -> IO Int

8988readCountLines =

90− S.length

89+ S.fold Fold.length

9190 . IUS.lines FL.drain

9291 . SS.decodeLatin1

93− . S.unfold FH.read

92+ . S.unfold FH.reader

9493

9594#ifdef INSPECTION

9695inspect $ hasNoTypeClasses 'readCountLines

9796inspect $ 'readCountLines `hasNoType` ''Step

9897inspect $ 'readCountLines `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

99−inspect $ 'readCountLines `hasNoType` ''MA.ReadUState -- 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.

103102readCountWords :: Handle -> IO Int

104103readCountWords =

105− S.length

104+ S.fold Fold.length

106105 . IUS.words FL.drain

107106 . SS.decodeLatin1

108− . S.unfold FH.read

107+ . S.unfold FH.reader

109108

110109#ifdef INSPECTION

111110inspect $ hasNoTypeClasses 'readCountWords

@@ -114,13 +113,13 @@ inspect $ hasNoTypeClasses 'readCountWords

114113

115114-- | Sum the bytes in a file.

116115readSumBytes :: Handle -> IO Word8

117−readSumBytes = S.sum . S.unfold FH.read

116+readSumBytes = S.fold Fold.sum . S.unfold FH.reader

118117

119118#ifdef INSPECTION

120119inspect $ hasNoTypeClasses 'readSumBytes

121120inspect $ 'readSumBytes `hasNoType` ''Step

122121inspect $ 'readSumBytes `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

123−inspect $ 'readSumBytes `hasNoType` ''MA.ReadUState -- 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

@@ -134,21 +133,21 @@ inspect $ 'readSumBytes `hasNoType` ''MA.ReadUState -- FH.read/A.read

134133-- fusion-plugin to propagate INLINE phase information such that this problem

135134-- does not occur.

136135readDrain :: Handle -> IO ()

137−readDrain inh = S.drain $ S.unfold FH.read inh

136+readDrain inh = S.fold Fold.drain $ S.unfold FH.reader inh

138137

139138-- XXX investigate why we need an INLINE in this case (GHC)

140139{-# INLINE readDecodeLatin1 #-}

141140readDecodeLatin1 :: Handle -> IO ()

142141readDecodeLatin1 inh =

143− S.drain

142+ S.fold Fold.drain

144143 $ SS.decodeLatin1

145− $ S.unfold FH.read inh

144+ $ S.unfold FH.reader inh

146145

147146readDecodeUtf8 :: Handle -> IO ()

148147readDecodeUtf8 inh =

149− S.drain

148+ S.fold Fold.drain

150149 $ SS.decodeUtf8

151− $ S.unfold FH.read inh

150+ $ S.unfold FH.reader inh

152151

153152#ifdef INSPECTION

154153inspect $ hasNoTypeClasses 'readDecodeUtf8

@@ -187,25 +186,25 @@ o_1_space_reduce_read env =

187186-------------------------------------------------------------------------------

188187

189188-- | Count the number of lines in a file.

190−toChunksConcatUnfoldCountLines :: Handle -> IO Int

191−toChunksConcatUnfoldCountLines inh =

192− S.length

189+getChunksConcatUnfoldCountLines :: Handle -> IO Int

190+getChunksConcatUnfoldCountLines inh =

191+ S.fold Fold.length

193192 $ IUS.lines FL.drain

194193 $ SS.decodeLatin1

195194 -- XXX replace with toBytes

196− $ S.unfoldMany A.read (IFH.toChunks inh)

195+ $ S.unfoldMany A.reader (IFH.readChunks inh)

197196

198197#ifdef INSPECTION

199−inspect $ hasNoTypeClasses 'toChunksConcatUnfoldCountLines

200−inspect $ 'toChunksConcatUnfoldCountLines `hasNoType` ''Step

201−inspect $ 'toChunksConcatUnfoldCountLines `hasNoType` ''D.ConcatMapUState

198+inspect $ hasNoTypeClasses 'getChunksConcatUnfoldCountLines

199+inspect $ 'getChunksConcatUnfoldCountLines `hasNoType` ''Step

200+inspect $ 'getChunksConcatUnfoldCountLines `hasNoType` ''D.ConcatMapUState

202201#endif

203202

204203o_1_space_reduce_toBytes :: BenchEnv -> [Benchmark]

205204o_1_space_reduce_toBytes env =

206205 [ bgroup "reduce/toBytes"

207206 [ mkBench "US.lines . SS.decodeLatin1" env $ \inh _ ->

208− toChunksConcatUnfoldCountLines inh

207+ getChunksConcatUnfoldCountLines inh

209208 ]

210209 ]

211210

@@ -214,46 +213,51 @@ o_1_space_reduce_toBytes env =

214213-------------------------------------------------------------------------------

215214

216215chunksOfSum :: Int -> Handle -> IO Int

217−chunksOfSum n inh = S.length $ S.chunksOf n FL.sum (S.unfold FH.read inh)

216+chunksOfSum n inh =

217+ S.fold Fold.length $ IP.groupsOf n FL.sum (S.unfold FH.reader inh)

218218

219219foldManyPostChunksOfSum :: Int -> Handle -> IO Int

220220foldManyPostChunksOfSum n inh =

221− S.length $ IP.foldManyPost (FL.take n FL.sum) (S.unfold FH.read inh)

221+ S.fold Fold.length

222+ $ IP.foldManyPost (FL.take n FL.sum) (S.unfold FH.reader inh)

222223

223224foldManyChunksOfSum :: Int -> Handle -> IO Int

224225foldManyChunksOfSum n inh =

225− S.length $ IP.foldMany (FL.take n FL.sum) (S.unfold FH.read inh)

226+ S.fold Fold.length

227+ $ IP.foldMany (FL.take n FL.sum) (S.unfold FH.reader inh)

226228

227229-- XXX investigate why we need an INLINE in this case (GHC)

228230-- Even though allocations remain the same in both cases inlining improves time

229231-- by 4x.

230232-- | Slice in chunks of size n and get the count of chunks.

231−{-# INLINE chunksOf #-}

232−chunksOf :: Int -> Handle -> IO Int

233−chunksOf n inh =

233+{-# INLINE groupsOf #-}

234+groupsOf :: Int -> Handle -> IO Int

235+groupsOf n inh =

234236 -- writeNUnsafe gives 2.5x boost here over writeN.

235− S.length $ S.chunksOf n (AT.writeNUnsafe n) (S.unfold FH.read inh)

237+ S.fold Fold.length

238+ $ IP.groupsOf n (A.writeNUnsafe n) (S.unfold FH.reader inh)

236239

237240#ifdef INSPECTION

238−inspect $ hasNoTypeClasses 'chunksOf

239−inspect $ 'chunksOf `hasNoType` ''Step

240−inspect $ 'chunksOf `hasNoType` ''FoldMany

241−inspect $ 'chunksOf `hasNoType` ''AT.ArrayUnsafe -- AT.writeNUnsafe

242−inspect $ 'chunksOf `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

243−inspect $ 'chunksOf `hasNoType` ''MA.ReadUState -- FH.read/A.read

241+inspect $ hasNoTypeClasses 'groupsOf

242+inspect $ 'groupsOf `hasNoType` ''Step

243+inspect $ 'groupsOf `hasNoType` ''FoldMany

244+inspect $ 'groupsOf `hasNoType` ''MutArray.ArrayUnsafe -- AT.writeNUnsafe

245+ -- FH.read/A.read

246+inspect $ 'groupsOf `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

244247#endif

245248

246−{-# INLINE arraysOf #-}

247−arraysOf :: Int -> Handle -> IO Int

248−arraysOf n inh = S.length $ IP.arraysOf n (S.unfold FH.read inh)

249+{-# INLINE chunksOf #-}

250+chunksOf :: Int -> Handle -> IO Int

251+chunksOf n inh =

252+ S.fold Fold.length $ Stream.chunksOf n (S.unfold FH.reader inh)

249253

250254o_1_space_reduce_read_grouped :: BenchEnv -> [Benchmark]

251255o_1_space_reduce_read_grouped env =

252256 [ bgroup "reduce/read/chunks"

253− [ mkBench ("S.chunksOf " ++ show (bigSize env) ++ " FL.sum") env $

257+ [ mkBench ("S.groupsOf " ++ show (bigSize env) ++ " FL.sum") env $

254258 \inh _ ->

255259 chunksOfSum (bigSize env) inh

256− , mkBench "S.chunksOf 1 FL.sum" env $ \inh _ ->

260+ , mkBench "S.groupsOf 1 FL.sum" env $ \inh _ ->

257261 chunksOfSum 1 inh

258262

259263 -- XXX investigate why we need inline/noinline in these cases (GHC)

@@ -276,20 +280,20 @@ o_1_space_reduce_read_grouped env =

276280 $ \inh _ -> inline foldManyChunksOfSum 1 inh

277281

278282 -- folding chunks to arrays

283+ , mkBenchSmall "S.groupsOf 1" env $ \inh _ ->

284+ groupsOf 1 inh

285+ , mkBench "S.groupsOf 10" env $ \inh _ ->

286+ groupsOf 10 inh

287+ , mkBench "S.groupsOf 1000" env $ \inh _ ->

288+ groupsOf 1000 inh

289+

290+ -- chunksOf may use a different impl than groupsOf

279291 , mkBenchSmall "S.chunksOf 1" env $ \inh _ ->

280292 chunksOf 1 inh

281293 , mkBench "S.chunksOf 10" env $ \inh _ ->

282294 chunksOf 10 inh

283295 , mkBench "S.chunksOf 1000" env $ \inh _ ->

284296 chunksOf 1000 inh

285−

286− -- arraysOf may use a different impl than chunksOf

287− , mkBenchSmall "S.arraysOf 1" env $ \inh _ ->

288− arraysOf 1 inh

289− , mkBench "S.arraysOf 10" env $ \inh _ ->

290− arraysOf 10 inh

291− , mkBench "S.arraysOf 1000" env $ \inh _ ->

292− arraysOf 1000 inh

293297 ]

294298 ]

295299

benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+48−51

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Streamly.Benchmark.FileSystem.Handle

@@ -24,25 +26,23 @@ where

2426

2527import System.IO (Handle)

2628import Prelude hiding (last, length)

27−import Streamly.Internal.Data.Array.Foreign.Type (defaultChunkSize)

29+import Streamly.Internal.System.IO (defaultChunkSize)

2830

2931import qualified Streamly.FileSystem.Handle as FH

3032import qualified Streamly.Internal.Data.Unfold as IUF

3133import qualified Streamly.Internal.FileSystem.Handle as IFH

32−import qualified Streamly.Data.Array.Foreign as A

33−import qualified Streamly.Prelude as S

34+import qualified Streamly.Data.Array as A

35+import qualified Streamly.Data.Stream.Prelude as S

3436

35−import Gauge hiding (env)

37+import Test.Tasty.Bench hiding (env)

3638import Streamly.Benchmark.Common.Handle

3739

3840#ifdef INSPECTION

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

41+import Streamly.Internal.Data.Stream (Step(..))

4042

41−import qualified Streamly.Internal.Data.Stream.StreamD.Type as D

43+import qualified Streamly.Internal.Data.Stream as D

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

43−import qualified Streamly.Internal.Data.Array.Stream.Mut.Foreign as MAS

44−import qualified Streamly.Internal.Data.Array.Foreign.Type as AT

45−import qualified Streamly.Internal.Data.Array.Foreign.Mut.Type as MA

45+import qualified Streamly.Internal.Data.MutArray as MutArray

4646

4747import Test.Inspection

4848#endif

@@ -53,7 +53,7 @@ import Test.Inspection

5353

5454-- | Copy file

5555copyChunks :: Handle -> Handle -> IO ()

56−copyChunks inh outh = S.fold (IFH.writeChunks outh) $ IFH.toChunks inh

56+copyChunks inh outh = S.fold (IFH.writeChunks outh) $ IFH.readChunks inh

5757

5858#ifdef INSPECTION

5959inspect $ hasNoTypeClasses 'copyChunks

@@ -62,7 +62,7 @@ inspect $ 'copyChunks `hasNoType` ''Step

6262

6363o_1_space_copy_chunked :: BenchEnv -> [Benchmark]

6464o_1_space_copy_chunked env =

65− [ bgroup "copy/toChunks"

65+ [ bgroup "copy/getChunks"

6666 [ mkBench "toNull" env $ \inH _ ->

6767 copyChunks inH (nullH env)

6868 , mkBench "raw" env $ \inH outH ->

@@ -76,14 +76,14 @@ o_1_space_copy_chunked env =

7676

7777-- | Copy file

7878copyStream :: Handle -> Handle -> IO ()

79−copyStream inh outh = S.fold (FH.write outh) (S.unfold FH.read inh)

79+copyStream inh outh = S.fold (FH.write outh) (S.unfold FH.reader inh)

8080

8181#ifdef INSPECTION

8282inspect $ hasNoTypeClasses 'copyStream

8383inspect $ 'copyStream `hasNoType` ''Step -- S.unfold

8484inspect $ 'copyStream `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

85−inspect $ 'copyStream `hasNoType` ''MA.ReadUState -- FH.read/A.read

86−inspect $ 'copyStream `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe

85+inspect $ 'copyStream `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe

86+ -- FH.read/A.read

8787inspect $ 'copyStream `hasNoType` ''Strict.Tuple3' -- FH.write/chunksOf

8888#endif

8989

@@ -103,28 +103,28 @@ o_1_space_copy_read env =

103103

104104-- | Send the file contents to /dev/null

105105readFromBytesNull :: Handle -> Handle -> IO ()

106−readFromBytesNull inh devNull = IFH.fromBytes devNull $ S.unfold FH.read inh

106+readFromBytesNull inh devNull = IFH.putBytes devNull $ S.unfold FH.reader inh

107107

108108#ifdef INSPECTION

109109inspect $ hasNoTypeClasses 'readFromBytesNull

110110inspect $ 'readFromBytesNull `hasNoType` ''Step

111−inspect $ 'readFromBytesNull `hasNoType` ''MAS.SpliceState

112−inspect $ 'readFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.arraysOf

111+inspect $ 'readFromBytesNull `hasNoType` ''MutArray.SpliceState

112+inspect $ 'readFromBytesNull `hasNoType` ''MutArray.ArrayUnsafe -- FH.fromBytes/S.chunksOf

113113inspect $ 'readFromBytesNull `hasNoType` ''D.FoldMany

114114#endif

115115

116116-- | Send the file contents ('defaultChunkSize') to /dev/null

117−readWithBufferOfFromBytesNull :: Handle -> Handle -> IO ()

118−readWithBufferOfFromBytesNull inh devNull =

119− IFH.fromBytes devNull

120− $ S.unfold FH.readWithBufferOf (defaultChunkSize, inh)

117+readWithFromBytesNull :: Handle -> Handle -> IO ()

118+readWithFromBytesNull inh devNull =

119+ IFH.putBytes devNull

120+ $ S.unfold FH.readerWith (defaultChunkSize, inh)

121121

122122#ifdef INSPECTION

123−inspect $ hasNoTypeClasses 'readWithBufferOfFromBytesNull

124−inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''Step

125−inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''MAS.SpliceState

126−inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.arraysOf

127−inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''D.FoldMany

123+inspect $ hasNoTypeClasses 'readWithFromBytesNull

124+inspect $ 'readWithFromBytesNull `hasNoType` ''Step

125+inspect $ 'readWithFromBytesNull `hasNoType` ''MutArray.SpliceState

126+inspect $ 'readWithFromBytesNull `hasNoType` ''MutArray.ArrayUnsafe -- FH.fromBytes/S.chunksOf

127+inspect $ 'readWithFromBytesNull `hasNoType` ''D.FoldMany

128128#endif

129129

130130-- | Send the chunk content ('defaultChunkSize') to /dev/null

@@ -135,63 +135,60 @@ _readChunks inh devNull = IUF.fold fld unf inh

135135 where

136136

137137 fld = FH.write devNull

138− unf = IUF.many FH.readChunks A.read

138+ unf = IUF.many A.reader FH.chunkReader

139139

140140-- | Send the chunk content to /dev/null

141−-- Implicitly benchmarked via 'readWithBufferOfFromBytesNull'

142−_readChunksWithBufferOf :: Handle -> Handle -> IO ()

143−_readChunksWithBufferOf inh devNull = IUF.fold fld unf (defaultChunkSize, inh)

141+-- Implicitly benchmarked via 'readWithFromBytesNull'

142+_readChunksWith :: Handle -> Handle -> IO ()

143+_readChunksWith inh devNull = IUF.fold fld unf (defaultChunkSize, inh)

144144

145145 where

146146

147147 fld = FH.write devNull

148− unf = IUF.many FH.readChunksWithBufferOf A.read

149−

148+ unf = IUF.many A.reader FH.chunkReaderWith

150149

151150o_1_space_copy_fromBytes :: BenchEnv -> [Benchmark]

152151o_1_space_copy_fromBytes env =

153− [ bgroup "copy/fromBytes"

152+ [ bgroup "copy/putBytes"

154153 [ mkBench "rawToNull" env $ \inh _ ->

155154 readFromBytesNull inh (nullH env)

156− , mkBench "FH.readWithBufferOf" env $ \inh _ ->

157− readWithBufferOfFromBytesNull inh (nullH env)

155+ , mkBench "FH.readWith" env $ \inh _ ->

156+ readWithFromBytesNull inh (nullH env)

158157 ]

159158 ]

160159

161160-- | Send the file contents ('defaultChunkSize') to /dev/null

162−{-# NOINLINE writeReadWithBufferOf #-}

163−writeReadWithBufferOf :: Handle -> Handle -> IO ()

164−writeReadWithBufferOf inh devNull = IUF.fold fld unf (defaultChunkSize, inh)

161+writeReadWith :: Handle -> Handle -> IO ()

162+writeReadWith inh devNull = IUF.fold fld unf (defaultChunkSize, inh)

165163

166164 where

167165

168− fld = FH.writeWithBufferOf defaultChunkSize devNull

169− unf = FH.readWithBufferOf

166+ fld = FH.writeWith defaultChunkSize devNull

167+ unf = FH.readerWith

170168

171169#ifdef INSPECTION

172−inspect $ hasNoTypeClasses 'writeReadWithBufferOf

173−inspect $ 'writeReadWithBufferOf `hasNoType` ''Step

174−inspect $ 'writeReadWithBufferOf `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

175−inspect $ 'writeReadWithBufferOf `hasNoType` ''MA.ReadUState -- FH.read/A.read

176−inspect $ 'writeReadWithBufferOf `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe

170+inspect $ hasNoTypeClasses 'writeReadWith

171+inspect $ 'writeReadWith `hasNoType` ''Step

172+inspect $ 'writeReadWith `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

173+inspect $ 'writeReadWith `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe

174+ -- FH.read/A.read

177175#endif

178176

179177-- | Send the file contents ('AT.defaultChunkSize') to /dev/null

180−{-# NOINLINE writeRead #-}

181178writeRead :: Handle -> Handle -> IO ()

182179writeRead inh devNull = IUF.fold fld unf inh

183180

184181 where

185182

186183 fld = FH.write devNull

187− unf = FH.read

184+ unf = FH.reader

188185

189186#ifdef INSPECTION

190187inspect $ hasNoTypeClasses 'writeRead

191188inspect $ 'writeRead `hasNoType` ''Step

192189inspect $ 'writeRead `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

193−inspect $ 'writeRead `hasNoType` ''MA.ReadUState -- FH.read/A.read

194−inspect $ 'writeRead `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe

190+inspect $ 'writeRead `hasNoType` ''MutArray.ArrayUnsafe -- FH.write/writeNUnsafe

191+ -- FH.read/A.read

195192#endif

196193

197194o_1_space_copy :: BenchEnv -> [Benchmark]

@@ -199,8 +196,8 @@ o_1_space_copy env =

199196 [ bgroup "copy"

200197 [ mkBench "FH.write . FH.read" env $ \inh _ ->

201198 writeRead inh (nullH env)

202− , mkBench "FH.writeWithBufferOf . FH.readWithBufferOf" env $ \inh _ ->

203− writeReadWithBufferOf inh (nullH env)

199+ , mkBench "FH.writeWith . FH.readWith" env $ \inh _ ->

200+ writeReadWith inh (nullH env)

204201 ]

205202 ]

206203

benchmark/Streamly/Benchmark/Prelude/Adaptive.hs+19−7

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -8,7 +10,7 @@

810import Control.Concurrent (threadDelay)

911import Control.Monad (when)

1012import Control.Monad.IO.Class (liftIO)

11−import Gauge

13+import Test.Tasty.Bench

1214import Streamly.Prelude as S

1315import System.Random (randomRIO)

1416

@@ -19,6 +21,9 @@ import System.Random (randomRIO)

1921-- Also, the worker dispatch depends on the worker dispatch latency which is

2022-- set to fixed 200 us. We need to keep that in mind when designing tests.

2123

24+moduleName :: String

25+moduleName = "Prelude.Adaptive"

26+

2227value :: Int

2328value = 1000

2429

@@ -31,11 +36,14 @@ source range = S.replicateM value $ do

3136

3237{-# INLINE run #-}

3338run :: IsStream t => (Int, Int) -> (Int, Int) -> (t IO Int -> SerialT IO Int) -> IO ()

34−run srange crange t = S.drain $ do

35− n <- t $ source srange

36− d <- liftIO (randomRIO crange)

37− when (d /= 0) $ liftIO $ threadDelay d

38− return n

39+run srange crange t = S.drain $ S.mapM action (t $ source srange)

40+

41+ where

42+

43+ action x = liftIO $ do

44+ d <- randomRIO crange

45+ when (d /= 0) $ threadDelay d

46+ return x

3947

4048low, medium, high :: Int

4149low = 10

@@ -78,7 +86,11 @@ randomVar = run (low,high) (low,high)

7886

7987main :: IO ()

8088main =

81− defaultMain

89+ defaultMain [bgroup moduleName allBenchmarks]

90+

91+ where

92+

93+ allBenchmarks =

8294 [

8395 bgroup "serialConstantSlowConsumer"

8496 [ bench "serially" $ nfIO $ alwaysConstSlowSerial fromSerial

benchmark/Streamly/Benchmark/Prelude/Ahead.hs+4−4

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -13,7 +15,7 @@ import qualified Streamly.Prelude as S

1315import Streamly.Benchmark.Common

1416import Streamly.Benchmark.Prelude

1517

16−import Gauge

18+import Test.Tasty.Bench

1719

1820moduleName :: String

1921moduleName = "Prelude.Ahead"

@@ -117,9 +119,7 @@ o_n_space_outerProduct value =

117119-------------------------------------------------------------------------------

118120

119121main :: IO ()

120−main = do

121− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

122− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

122+main = runWithCLIOpts defaultStreamSize allBenchmarks

123123

124124 where

125125

benchmark/Streamly/Benchmark/Prelude/Async.hs+9−8

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -9,12 +11,12 @@ import Prelude hiding (mapM)

911

1012import Streamly.Prelude (fromAsync, async, maxBuffer, maxThreads, fromSerial)

1113import qualified Streamly.Prelude as S

12−import qualified Streamly.Internal.Data.Stream.StreamK.Type as Internal

14+import qualified Streamly.Internal.Data.Stream.IsStream.Transform as Transform

1315

1416import Streamly.Benchmark.Common

1517import Streamly.Benchmark.Prelude

1618

17−import Gauge

19+import Test.Tasty.Bench

1820

1921moduleName :: String

2022moduleName = "Prelude.Async"

@@ -48,7 +50,7 @@ foldrSShared :: Int -> Int -> IO ()

4850foldrSShared count n =

4951 S.drain

5052 $ fromAsync

51− $ Internal.foldrSShared (\x xs -> S.consM (return x) xs) S.nil

53+ $ Transform.foldrSShared (\x xs -> S.consM (return x) xs) S.nil

5254 $ fromSerial

5355 $ sourceUnfoldrM count n

5456

@@ -122,9 +124,9 @@ o_1_space_concatFoldable value =

122124 (sourceFoldMapWithStream value)

123125 , benchIOSrc fromAsync "foldMapWithM (<>) (List)"

124126 (sourceFoldMapWithM value)

125− , benchIOSrc fromSerial "S.concatFoldableWith (<>) (List)"

127+ , benchIOSrc fromAsync "S.concatFoldableWith (<>) (List)"

126128 (concatFoldableWith value)

127− , benchIOSrc fromSerial "S.concatForFoldableWith (<>) (List)"

129+ , benchIOSrc fromAsync "S.concatForFoldableWith (<>) (List)"

128130 (concatForFoldableWith value)

129131 , benchIOSrc fromAsync "foldMapM (List)" (sourceFoldMapM value)

130132 ]

@@ -183,9 +185,8 @@ o_n_space_outerProduct value =

183185-------------------------------------------------------------------------------

184186

185187main :: IO ()

186−main = do

187− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

188− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

188+main = runWithCLIOpts defaultStreamSize allBenchmarks

189+

189190

190191 where

191192

benchmark/Streamly/Benchmark/Prelude/Concurrent.hs+7−1

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

2+{-# LANGUAGE CPP #-}

13{-# LANGUAGE RankNTypes #-}

24-- |

35-- Module : Main

@@ -13,7 +15,7 @@ import Streamly.Prelude

1315 , fromWAsync, parallel, fromParallel

1416 )

1517

16−import Gauge

18+import Test.Tasty.Bench

1719import qualified Streamly.Prelude as S

1820

1921-------------------------------------------------------------------------------

@@ -77,6 +79,7 @@ concatGroup buflen threads usec n =

7779

7880main :: IO ()

7981main =

82+#ifdef MIN_VERSION_gauge

8083 defaultMainWith (defaultConfig

8184 { timeLimit = Just 0

8285 , minSamples = Just 1

@@ -84,6 +87,9 @@ main =

8487 , includeFirstIter = True

8588 , quickMode = True

8689 })

90+#else

91+ defaultMain

92+#endif

8793

8894 [ -- bgroup "append/buf-1-threads-10k-0sec" (appendGroup 1 10000 0)

8995 -- , bgroup "append/buf-100-threads-100k-0sec" (appendGroup 100 100000 0)

benchmark/Streamly/Benchmark/Prelude/Merge.hsnew file+298

@@ -0,0 +1,298 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

3+-- |

4+-- Module : Main

6+--

7+-- License : BSD3

8+-- Maintainer : streamly@composewell.com

10+{-# LANGUAGE BangPatterns #-}

11+{-# LANGUAGE CPP #-}

12+{-# LANGUAGE FlexibleContexts #-}

13+{-# LANGUAGE ScopedTypeVariables #-}

14+{-# LANGUAGE RankNTypes #-}

15+

16+#ifdef __HADDOCK_VERSION__

17+#undef INSPECTION

18+#endif

19+

20+#ifdef INSPECTION

21+{-# LANGUAGE TemplateHaskell #-}

22+{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

23+#endif

24+

25+import Streamly.Internal.Data.Stream.IsStream (SerialT)

26+import qualified Data.List as List

27+import qualified Streamly.Internal.Data.Stream.IsStream as Stream

28+-- import qualified Streamly.Internal.Data.Unfold as Unfold

29+

30+import Streamly.Benchmark.Common

31+import Streamly.Benchmark.Prelude

32+

33+import Test.Tasty.Bench

34+

35+#ifdef INSPECTION

36+import GHC.Types (SPEC(..))

37+import Test.Inspection

38+

39+import qualified Streamly.Internal.Data.Stream as D

40+#endif

41+

42+moduleName :: String

43+moduleName = "Prelude.Merge"

44+

45+-------------------------------------------------------------------------------

46+-- Merging

47+-------------------------------------------------------------------------------

48+

49+{-# INLINE mergeWith #-}

50+mergeWith ::

51+ ( (Int -> Int -> Ordering)

52+ -> SerialT IO Int

53+ -> SerialT IO Int

54+ -> SerialT IO Int

55+ )

56+ -> (Int -> Int -> Ordering)

57+ -> Int -> Int -> IO ()

58+mergeWith g cmp count n =

59+ Stream.drain

60+ $ g

61+ cmp

62+ (sourceUnfoldrM count n)

63+ (sourceUnfoldrM count (n + 1))

64+

65+{-# INLINE mergeWithM #-}

66+mergeWithM ::

67+ ( (Int -> Int -> IO Ordering)

68+ -> SerialT IO Int

69+ -> SerialT IO Int

70+ -> SerialT IO Int

71+ )

72+ -> (Int -> Int -> Ordering)

73+ -> Int -> Int -> IO ()

74+mergeWithM g cmp count n =

75+ Stream.drain

76+ $ g

77+ (\a b -> return $ cmp a b)

78+ (sourceUnfoldrM count n)

79+ (sourceUnfoldrM count (n + 1))

80+

81+{-# INLINE mergeBy #-}

82+mergeBy :: (Int -> Int -> Ordering) -> Int -> Int -> IO ()

83+mergeBy = mergeWith Stream.mergeBy

84+

85+{-# INLINE mergeByM #-}

86+mergeByM :: (Int -> Int -> Ordering) -> Int -> Int -> IO ()

87+mergeByM = mergeWithM Stream.mergeByM

88+

89+{-# INLINE mergeByMFused #-}

90+mergeByMFused :: (Int -> Int -> Ordering) -> Int -> Int -> IO ()

91+mergeByMFused = mergeWithM Stream.mergeByMFused

92+

93+#ifdef INSPECTION

94+inspect $ hasNoTypeClasses 'mergeBy

95+inspect $ 'mergeBy `hasNoType` ''SPEC

96+inspect $ 'mergeBy `hasNoType` ''D.Step

97+

98+inspect $ hasNoTypeClasses 'mergeByM

99+inspect $ 'mergeByM `hasNoType` ''SPEC

100+inspect $ 'mergeByM `hasNoType` ''D.Step

101+

102+{-# INLINE _mergeByMFusedCheck #-}

103+_mergeByMFusedCheck :: IO ()

104+_mergeByMFusedCheck = mergeWithM Stream.mergeByMFused compare 0 0

105+

106+inspect $ hasNoTypeClasses '_mergeByMFusedCheck

107+inspect $ '_mergeByMFusedCheck `hasNoType` ''SPEC

108+inspect $ '_mergeByMFusedCheck `hasNoType` ''D.Step

109+#endif

110+

111+{-# INLINE concatPairsWithMergeBy #-}

112+concatPairsWithMergeBy :: (Int -> Int -> Ordering) -> Int -> Int -> Int -> IO ()

113+concatPairsWithMergeBy cmp = concatPairsWith (Stream.mergeBy cmp)

114+

115+{-# INLINE concatPairsWithMergeByFused #-}

116+concatPairsWithMergeByFused ::

117+ (Int -> Int -> Ordering) -> Int -> Int -> Int -> IO ()

118+concatPairsWithMergeByFused cmp =

119+ concatPairsWith (Stream.mergeByMFused (\x y -> return $ cmp x y))

120+

121+-------------------------------------------------------------------------------

122+-- Interleaving

123+-------------------------------------------------------------------------------

124+

125+o_1_space_joining :: Int -> [Benchmark]

126+o_1_space_joining value =

127+ [ bgroup "joining (2 of n/2)"

128+ [ benchIOSrc1

129+ "mergeBy compare"

130+ (mergeBy compare (value `div` 2))

131+ , benchIOSrc1

132+ "mergeByM compare"

133+ (mergeByM compare (value `div` 2))

134+ , benchIOSrc1

135+ "mergeByMFused compare"

136+ (mergeByMFused compare (value `div` 2))

137+

138+ , benchIOSrc1

139+ "mergeBy (flip compare)"

140+ (mergeBy (flip compare) (value `div` 2))

141+ , benchIOSrc1

142+ "mergeByM (flip compare)"

143+ (mergeByM (flip compare) (value `div` 2))

144+ , benchIOSrc1

145+ "mergeByMFused (flip compare)"

146+ (mergeByMFused (flip compare) (value `div` 2))

147+

148+ , benchIOSrc1

149+ "concatPairsWithMergeBy compare"

150+ (concatPairsWithMergeBy compare 2 (value `div` 2))

151+ , benchIOSrc1

152+ "concatPairsWithMergeBy (flip compare)"

153+ (concatPairsWithMergeBy (flip compare) 2 (value `div` 2))

154+

155+ , benchIOSrc1

156+ "concatPairsWithMergeByFused compare"

157+ (concatPairsWithMergeByFused compare 2 (value `div` 2))

158+ , benchIOSrc1

159+ "concatPairsWithMergeByFused (flip compare)"

160+ (concatPairsWithMergeByFused (flip compare) 2 (value `div` 2))

161+ ]

162+ ]

163+

164+-------------------------------------------------------------------------------

165+-- Concat

166+-------------------------------------------------------------------------------

167+

168+{-

169+{-# INLINE sourceUnfoldrMUF #-}

170+-- (count, value)

171+sourceUnfoldrMUF :: Monad m => Int -> UF.Unfold m (Int, Int) Int

172+sourceUnfoldrMUF count = UF.unfoldrM step

173+ where

174+ step (cnt, start) =

175+ return $

176+ if cnt > start + count

177+ then Nothing

178+ else Just (cnt, (cnt + 1, start))

179+

180+{-# INLINE unfoldManyMergeBy #-}

181+unfoldManyMergeBy :: Int -> Int -> Int -> IO ()

182+unfoldManyMergeBy outer inner n =

183+ S.drain $ (Internal.unfoldManyMergeBy compare)

184+ -- (UF.lmap return (UF.replicateM inner))

185+ (UF.lmap (\x -> (x,x)) (sourceUnfoldrMUF inner))

186+ (sourceUnfoldrM outer n)

187+

188+#ifdef INSPECTION

189+inspect $ hasNoTypeClasses 'unfoldManyMergeBy

190+-- inspect $ 'unfoldManyMergeBy `hasNoType` ''SPEC

191+-- inspect $ 'unfoldManyMergeBy `hasNoType`

192+-- ''D.ConcatUnfoldMergeState

193+#endif

194+-}

195+

196+{-# INLINE sortBy #-}

197+sortBy :: (Int -> Int -> Ordering) -> SerialT IO Int -> IO ()

198+sortBy cmp = Stream.drain . Stream.sortBy cmp

199+

200+{-

201+-- For fair comparison with concatPairs, removed sorted segmentation

202+{-# INLINE listSortBy #-}

203+listSortBy :: (a -> a -> Ordering) -> [a] -> [a]

204+listSortBy cmp = mergeAll . sequences

205+ where

206+ sequences = fmap (: [])

207+

208+ mergeAll [x] = x

209+ mergeAll xs = mergeAll (mergePairs xs)

210+

211+ mergePairs (a:b:xs) = let !x = merge a b

212+ in x : mergePairs xs

213+ mergePairs xs = xs

214+

215+ merge as@(a:as') bs@(b:bs')

216+ | a `cmp` b == GT = b:merge as bs'

217+ | otherwise = a:merge as' bs

218+ merge [] bs = bs

219+ merge as [] = as

220+-}

221+

222+o_n_heap_concat :: Int -> [Benchmark]

223+o_n_heap_concat value =

224+ [ bgroup "concatPairsWith"

225+ [ benchIOSrc1

226+ "concatPairsWithMergeBy compare (n of 1)"

227+ (concatPairsWithMergeBy compare value 1)

228+ , benchIOSrc1

229+ "concatPairsWithMergeBy compare (sqrtVal of sqrtVal)"

230+ (concatPairsWithMergeBy compare sqrtVal sqrtVal)

231+

232+ , benchIOSrc1

233+ "concatPairsWithMergeBy (flip compare) (n of 1)"

234+ (concatPairsWithMergeBy (flip compare) value 1)

235+ , benchIOSrc1

236+ "concatPairsWithMergeBy (flip compare) (sqrtVal of sqrtVal)"

237+ (concatPairsWithMergeBy (flip compare) sqrtVal sqrtVal)

238+

239+ , benchIOSrc1

240+ "concatPairsWithMergeByFused compare (n of 1)"

241+ (concatPairsWithMergeByFused compare value 1)

242+ , benchIOSrc1

243+ "concatPairsWithMergeByFused compare (sqrtVal of sqrtVal)"

244+ (concatPairsWithMergeByFused compare sqrtVal sqrtVal)

245+ ]

246+ -- TODO: change sourceUnfoldrM to generate alternating bigger and lower

247+ -- numbers to simulate a random input for a worst case sort benchmark. We

248+ -- can use 0 and value as two ints in the state and alternate each in the

249+ -- output streams, incrementing the lower number of decrementing the higher

250+ -- number.

251+ , bgroup "sorting"

252+ [ benchIOSink value "sortBy compare" (sortBy compare)

253+ , benchIOSink value "sortBy (flip compare)" (sortBy (flip compare))

254+ , benchIOSink value "sortBy compare randomized"

255+ (sortBy compare . Stream.map (\x -> if even x then x + 2 else x))

256+ {-

257+ , bench "sortByLists compare"

258+ $ nf (\x -> listSortBy compare [1..x]) value

259+ , bench "sortByLists (flip compare)"

260+ $ nf (\x -> listSortBy (flip compare) [1..x]) value

261+ , bench "sortByLists compare randomized"

262+ $ nf (\x -> listSortBy compare

263+ (map (\n -> if even n then n + 2 else n) [1..x])

264+ )

265+ value

266+ -}

267+ , bench "sortByLists compare"

268+ $ nf (\x -> List.sortBy compare [1..x]) value

269+ , bench "sortByLists (flip compare)"

270+ $ nf (\x -> List.sortBy (flip compare) [1..x]) value

271+ , bench "sortByLists compare randomized"

272+ $ nf (\x -> List.sortBy compare

273+ (map (\n -> if even n then n + 2 else n) [1..x])

274+ )

275+ value

276+ ]

277+ ]

278+

279+ where

280+

281+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

282+

283+-------------------------------------------------------------------------------

284+-- Main

285+-------------------------------------------------------------------------------

286+

287+-- In addition to gauge options, the number of elements in the stream can be

288+-- passed using the --stream-size option.

289+--

290+main :: IO ()

291+main = runWithCLIOpts defaultStreamSize allBenchmarks

292+

293+ where

294+

295+ allBenchmarks size =

296+ [ bgroup (o_1_space_prefix moduleName) (o_1_space_joining size)

297+ , bgroup (o_n_heap_prefix moduleName) (o_n_heap_concat size)

298+ ]

benchmark/Streamly/Benchmark/Prelude/Parallel.hs+5−6

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -15,13 +17,12 @@ import Streamly.Prelude

1517

1618import qualified Streamly.Prelude as S

1719import qualified Streamly.Internal.Data.Fold as FL

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

1920import qualified Streamly.Internal.Data.Stream.IsStream as Internal

2021

2122import Streamly.Benchmark.Common

2223import Streamly.Benchmark.Prelude

2324

24−import Gauge

25+import Test.Tasty.Bench

2526

2627moduleName :: String

2728moduleName = "Prelude.Parallel"

@@ -72,7 +73,7 @@ parAppSum src = (S.sum S.|$. src) >>= \x -> seq x (return ())

7273

7374{-# INLINE tapAsyncS #-}

7475tapAsyncS :: S.MonadAsync m => Int -> SerialT m Int -> m ()

75−tapAsyncS n = composeN n $ Par.tapAsync S.sum

76+tapAsyncS n = composeN n $ Internal.tapAsyncK S.sum

7677

7778{-# INLINE tapAsync #-}

7879tapAsync :: S.MonadAsync m => Int -> SerialT m Int -> m ()

@@ -219,9 +220,7 @@ o_n_space_outerProduct value =

219220-------------------------------------------------------------------------------

220221

221222main :: IO ()

222−main = do

223− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

224− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

223+main = runWithCLIOpts defaultStreamSize allBenchmarks

225224

226225 where

227226

benchmark/Streamly/Benchmark/Prelude/Rate.hs+10−12

@@ -1,3 +1,4 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

12{-# LANGUAGE FlexibleContexts #-}

34-- |

@@ -13,7 +14,7 @@ import qualified Streamly.Prelude as S

1314import Streamly.Benchmark.Common

1415import Streamly.Benchmark.Prelude

1516

16−import Gauge

17+import Test.Tasty.Bench

1718

1819moduleName :: String

1920moduleName = "Prelude.Rate"

@@ -87,12 +88,12 @@ o_1_space_async value =

8788o_1_space_ahead :: Int -> [Benchmark]

8889o_1_space_ahead value =

8990 [ bgroup

90− "aheadly"

91− [ benchIOSrc fromAhead "avgRate/1M" $ avgRate value 1000000

92− , benchIOSrc fromAhead "minRate/1M" $ minRate value 1000000

93− , benchIOSrc fromAhead "maxRate/1M" $ maxRate value 1000000

94− , benchIOSrc fromAsync "constRate/1M" $ constRate value 1000000

95− ]

91+ "aheadly"

92+ [ benchIOSrc fromAhead "avgRate/1M" $ avgRate value 1000000

93+ , benchIOSrc fromAhead "minRate/1M" $ minRate value 1000000

94+ , benchIOSrc fromAhead "maxRate/1M" $ maxRate value 1000000

95+ , benchIOSrc fromAsync "constRate/1M" $ constRate value 1000000

96+ ]

9697 ]

9798

9899-------------------------------------------------------------------------------

@@ -100,13 +101,10 @@ o_1_space_ahead value =

100101-------------------------------------------------------------------------------

101102

102103main :: IO ()

103−main = do

104− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

105− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

104+main = runWithCLIOpts defaultStreamSize allBenchmarks

106105

107106 where

108107

109108 allBenchmarks value =

110109 [ bgroup (o_1_space_prefix moduleName)

111− $ concat [o_1_space_async value, o_1_space_ahead value]

112− ]

110+ $ concat [o_1_space_async value, o_1_space_ahead value]]

benchmark/Streamly/Benchmark/Prelude/Serial.hsdeleted−54

@@ -1,54 +0,0 @@

1−-- |

2−-- Module : Serial

4−-- License : BSD-3-Clause

5−-- Maintainer : streamly@composewell.com

6−

7−{-# LANGUAGE CPP #-}

8−{-# LANGUAGE FlexibleContexts #-}

9−{-# LANGUAGE ScopedTypeVariables #-}

10−{-# LANGUAGE RankNTypes #-}

11−

12−module Main (main) where

13−

14−import Streamly.Benchmark.Common.Handle (mkHandleBenchEnv)

15−

16−import qualified Serial.Elimination as Elimination

17−import qualified Serial.Exceptions as Exceptions

18−import qualified Serial.Generation as Generation

19−import qualified Serial.Nested as Nested

20−import qualified Serial.Split as Split

21−import qualified Serial.Transformation1 as Transformation1

22−import qualified Serial.Transformation2 as Transformation2

23−import qualified Serial.Transformation3 as Transformation3

24−

25−import Gauge hiding (env)

26−import Streamly.Benchmark.Common

27−

28−moduleName :: String

29−moduleName = "Prelude.Serial"

30−

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

32−-- Main

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

34−

35−-- In addition to gauge options, the number of elements in the stream can be

36−-- passed using the --stream-size option.

37−--

38−main :: IO ()

39−main = do

40− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

41− env <- mkHandleBenchEnv

42− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value env)

43− where

44−

45− allBenchmarks size env = Prelude.concat

46− [ Generation.benchmarks moduleName size

47− , Elimination.benchmarks moduleName size

48− , Exceptions.benchmarks moduleName env

49− , Split.benchmarks moduleName env

50− , Transformation1.benchmarks moduleName size

51− , Transformation2.benchmarks moduleName size

52− , Transformation3.benchmarks moduleName size

53− , Nested.benchmarks moduleName size

54− ]

benchmark/Streamly/Benchmark/Prelude/Serial/Exceptions.hsdeleted−217

@@ -1,217 +0,0 @@

1−-- |

2−-- Module : Streamly.Benchmark.Prelude.Serial.Exceptions

4−-- License : BSD-3-Clause

5−-- Maintainer : streamly@composewell.com

6−-- Stability : experimental

7−-- Portability : GHC

8−

9−{-# LANGUAGE CPP #-}

10−{-# LANGUAGE ScopedTypeVariables #-}

11−

12−#ifdef __HADDOCK_VERSION__

13−#undef INSPECTION

14−#endif

15−

16−#ifdef INSPECTION

17−{-# LANGUAGE TemplateHaskell #-}

18−{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

19−#endif

20−

21−module Serial.Exceptions (benchmarks) where

22−

23−import Control.Exception (SomeException)

24−import System.IO (Handle, hClose, hPutChar)

25−

26−import qualified Streamly.FileSystem.Handle as FH

27−import qualified Streamly.Internal.Data.Unfold as IUF

28−import qualified Streamly.Internal.FileSystem.Handle as IFH

29−import qualified Streamly.Internal.Data.Stream.IsStream as IP

30−import qualified Streamly.Prelude as S

31−

32−import Gauge hiding (env)

33−import Prelude hiding (last, length)

34−import Streamly.Benchmark.Common

35−import Streamly.Benchmark.Common.Handle

36−

37−#ifdef INSPECTION

38−import Test.Inspection

39−#endif

40−

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

42−-- stream exceptions

43−-------------------------------------------------------------------------------

44−

45−-- | Send the file contents to /dev/null with exception handling

46−readWriteOnExceptionStream :: Handle -> Handle -> IO ()

47−readWriteOnExceptionStream inh devNull =

48− let readEx = S.onException (hClose inh) (S.unfold FH.read inh)

49− in S.fold (FH.write devNull) $ readEx

50−

51−-- | Send the file contents to /dev/null with exception handling

52−readWriteHandleExceptionStream :: Handle -> Handle -> IO ()

53−readWriteHandleExceptionStream inh devNull =

54− let handler (_e :: SomeException) = S.yieldM (hClose inh >> return 10)

55− readEx = S.handle handler (S.unfold FH.read inh)

56− in S.fold (FH.write devNull) $ readEx

57−

58−-- | Send the file contents to /dev/null with exception handling

59−readWriteFinally_Stream :: Handle -> Handle -> IO ()

60−readWriteFinally_Stream inh devNull =

61− let readEx = IP.finally_ (hClose inh) (S.unfold FH.read inh)

62− in S.fold (FH.write devNull) readEx

63−

64−readWriteFinallyStream :: Handle -> Handle -> IO ()

65−readWriteFinallyStream inh devNull =

66− let readEx = S.finally (hClose inh) (S.unfold FH.read inh)

67− in S.fold (FH.write devNull) readEx

68−

69−-- | Send the file contents to /dev/null with exception handling

70−fromToBytesBracket_Stream :: Handle -> Handle -> IO ()

71−fromToBytesBracket_Stream inh devNull =

72− let readEx = IP.bracket_ (return ()) (\_ -> hClose inh)

73− (\_ -> IFH.toBytes inh)

74− in IFH.fromBytes devNull $ readEx

75−

76−#ifdef INSPECTION

77−inspect $ hasNoTypeClasses 'fromToBytesBracket_Stream

78−-- inspect $ 'fromToBytesBracketStream `hasNoType` ''Step

79−#endif

80−

81−fromToBytesBracketStream :: Handle -> Handle -> IO ()

82−fromToBytesBracketStream inh devNull =

83− let readEx = S.bracket (return ()) (\_ -> hClose inh)

84− (\_ -> IFH.toBytes inh)

85− in IFH.fromBytes devNull $ readEx

86−

87−readWriteBeforeAfterStream :: Handle -> Handle -> IO ()

88−readWriteBeforeAfterStream inh devNull =

89− let readEx =

90− IP.after (hClose inh)

91− $ IP.before (hPutChar devNull 'A') (S.unfold FH.read inh)

92− in S.fold (FH.write devNull) readEx

93−

94−readWriteAfterStream :: Handle -> Handle -> IO ()

95−readWriteAfterStream inh devNull =

96− let readEx = IP.after (hClose inh) (S.unfold FH.read inh)

97− in S.fold (FH.write devNull) readEx

98−

99−readWriteAfter_Stream :: Handle -> Handle -> IO ()

100−readWriteAfter_Stream inh devNull =

101− let readEx = IP.after_ (hClose inh) (S.unfold FH.read inh)

102− in S.fold (FH.write devNull) readEx

103−

104−o_1_space_copy_stream_exceptions :: BenchEnv -> [Benchmark]

105−o_1_space_copy_stream_exceptions env =

106− [ bgroup "exceptions"

107− [ mkBenchSmall "S.onException" env $ \inh _ ->

108− readWriteOnExceptionStream inh (nullH env)

109− , mkBenchSmall "S.handle" env $ \inh _ ->

110− readWriteHandleExceptionStream inh (nullH env)

111− , mkBenchSmall "S.finally_" env $ \inh _ ->

112− readWriteFinally_Stream inh (nullH env)

113− , mkBenchSmall "S.finally" env $ \inh _ ->

114− readWriteFinallyStream inh (nullH env)

115− , mkBenchSmall "S.after . S.before" env $ \inh _ ->

116− readWriteBeforeAfterStream inh (nullH env)

117− , mkBenchSmall "S.after" env $ \inh _ ->

118− readWriteAfterStream inh (nullH env)

119− , mkBenchSmall "S.after_" env $ \inh _ ->

120− readWriteAfter_Stream inh (nullH env)

121− ]

122− , bgroup "exceptions/fromToBytes"

123− [ mkBenchSmall "S.bracket_" env $ \inh _ ->

124− fromToBytesBracket_Stream inh (nullH env)

125− , mkBenchSmall "S.bracket" env $ \inh _ ->

126− fromToBytesBracketStream inh (nullH env)

127− ]

128− ]

129−

130− -------------------------------------------------------------------------------

131−-- Exceptions readChunks

132−-------------------------------------------------------------------------------

133−

134−-- | Send the file contents to /dev/null with exception handling

135−readChunksOnException :: Handle -> Handle -> IO ()

136−readChunksOnException inh devNull =

137− let readEx = IUF.onException (\_ -> hClose inh) FH.readChunks

138− in IUF.fold (IFH.writeChunks devNull) readEx inh

139−

140−#ifdef INSPECTION

141−inspect $ hasNoTypeClasses 'readChunksOnException

142−-- inspect $ 'readChunksOnException `hasNoType` ''Step

143−#endif

144−

145−-- | Send the file contents to /dev/null with exception handling

146−readChunksBracket_ :: Handle -> Handle -> IO ()

147−readChunksBracket_ inh devNull =

148− let readEx = IUF.bracket_ return (\_ -> hClose inh) FH.readChunks

149− in IUF.fold (IFH.writeChunks devNull) readEx inh

150−

151−#ifdef INSPECTION

152−inspect $ hasNoTypeClasses 'readChunksBracket_

153−-- inspect $ 'readChunksBracket `hasNoType` ''Step

154−#endif

155−

156−readChunksBracket :: Handle -> Handle -> IO ()

157−readChunksBracket inh devNull =

158− let readEx = IUF.bracket return (\_ -> hClose inh) FH.readChunks

159− in IUF.fold (IFH.writeChunks devNull) readEx inh

160−

161−o_1_space_copy_exceptions_readChunks :: BenchEnv -> [Benchmark]

162−o_1_space_copy_exceptions_readChunks env =

163− [ bgroup "exceptions/readChunks"

164− [ mkBench "UF.onException" env $ \inH _ ->

165− readChunksOnException inH (nullH env)

166− , mkBench "UF.bracket_" env $ \inH _ ->

167− readChunksBracket_ inH (nullH env)

168− , mkBench "UF.bracket" env $ \inH _ ->

169− readChunksBracket inH (nullH env)

170− ]

171− ]

172−

173−-------------------------------------------------------------------------------

174−-- Exceptions toChunks

175−-------------------------------------------------------------------------------

176−

177−-- | Send the file contents to /dev/null with exception handling

178−toChunksBracket_ :: Handle -> Handle -> IO ()

179−toChunksBracket_ inh devNull =

180− let readEx = IP.bracket_

181− (return ())

182− (\_ -> hClose inh)

183− (\_ -> IFH.toChunks inh)

184− in S.fold (IFH.writeChunks devNull) $ readEx

185−

186−#ifdef INSPECTION

187−inspect $ hasNoTypeClasses 'toChunksBracket_

188−-- inspect $ 'toChunksBracket `hasNoType` ''Step

189−#endif

190−

191−toChunksBracket :: Handle -> Handle -> IO ()

192−toChunksBracket inh devNull =

193− let readEx = S.bracket

194− (return ())

195− (\_ -> hClose inh)

196− (\_ -> IFH.toChunks inh)

197− in S.fold (IFH.writeChunks devNull) $ readEx

198−

199−o_1_space_copy_exceptions_toChunks :: BenchEnv -> [Benchmark]

200−o_1_space_copy_exceptions_toChunks env =

201− [ bgroup "exceptions/toChunks"

202− [ mkBench "S.bracket_" env $ \inH _ ->

203− toChunksBracket_ inH (nullH env)

204− , mkBench "S.bracket" env $ \inH _ ->

205− toChunksBracket inH (nullH env)

206− ]

207− ]

208−

209−

210−benchmarks :: String -> BenchEnv -> [Benchmark]

211−benchmarks moduleName env =

212− [ bgroup (o_1_space_prefix moduleName) $ concat

213− [ o_1_space_copy_exceptions_readChunks env

214− , o_1_space_copy_exceptions_toChunks env

215− , o_1_space_copy_stream_exceptions env

216− ]

217− ]

benchmark/Streamly/Benchmark/Prelude/Serial/Generation.hsdeleted−179

@@ -1,179 +0,0 @@

1−-- |

2−-- Module : Serial.Generation

4−-- License : BSD-3-Clause

5−-- Maintainer : streamly@composewell.com

6−

7−{-# LANGUAGE CPP #-}

8−{-# LANGUAGE FlexibleContexts #-}

9−{-# LANGUAGE ScopedTypeVariables #-}

10−{-# LANGUAGE RankNTypes #-}

11−

12−module Serial.Generation (benchmarks) where

13−

14−import Data.Functor.Identity (Identity)

15−

16−import qualified Prelude

17−import qualified GHC.Exts as GHC

18−

19−import qualified Streamly.Prelude as S

20−

21−import Gauge

22−import Streamly.Prelude (SerialT, fromSerial, MonadAsync)

23−import Streamly.Benchmark.Common

24−import Streamly.Benchmark.Prelude

25−import Prelude hiding (repeat, replicate, iterate)

26−

27−-------------------------------------------------------------------------------

28−-- Generation

29−-------------------------------------------------------------------------------

30−

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

32−-- fromList

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

34−

35−{-# INLINE sourceIsList #-}

36−sourceIsList :: Int -> Int -> SerialT Identity Int

37−sourceIsList value n = GHC.fromList [n..n+value]

38−

39−{-# INLINE sourceIsString #-}

40−sourceIsString :: Int -> Int -> SerialT Identity Char

41−sourceIsString value n = GHC.fromString (Prelude.replicate (n + value) 'a')

42−

43−{-# INLINE readInstance #-}

44−readInstance :: String -> SerialT Identity Int

45−readInstance str =

46− let r = reads str

47− in case r of

48− [(x,"")] -> x

49− _ -> error "readInstance: no parse"

50−

51−-- For comparisons

52−{-# INLINE readInstanceList #-}

53−readInstanceList :: String -> [Int]

54−readInstanceList str =

55− let r = reads str

56− in case r of

57− [(x,"")] -> x

58− _ -> error "readInstance: no parse"

59−

60−{-# INLINE repeat #-}

61−repeat :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

62−repeat count = S.take count . S.repeat

63−

64−{-# INLINE repeatM #-}

65−repeatM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

66−repeatM count = S.take count . S.repeatM . return

67−

68−{-# INLINE replicate #-}

69−replicate :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

70−replicate = S.replicate

71−

72−{-# INLINE replicateM #-}

73−replicateM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

74−replicateM count = S.replicateM count . return

75−

76−{-# INLINE enumerateFrom #-}

77−enumerateFrom :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

78−enumerateFrom count = S.take count . S.enumerateFrom

79−

80−{-# INLINE enumerateFromTo #-}

81−enumerateFromTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

82−enumerateFromTo = sourceIntFromTo

83−

84−{-# INLINE enumerateFromThen #-}

85−enumerateFromThen :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

86−enumerateFromThen count inp = S.take count $ S.enumerateFromThen inp (inp + 1)

87−

88−{-# INLINE enumerateFromThenTo #-}

89−enumerateFromThenTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

90−enumerateFromThenTo = sourceIntFromThenTo

91−

92−-- n ~ 1

93−{-# INLINE enumerate #-}

94−enumerate :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

95−enumerate count n = S.take (count + n) S.enumerate

96−

97−-- n ~ 1

98−{-# INLINE enumerateTo #-}

99−enumerateTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

100−enumerateTo count n = S.enumerateTo (minBound + count + n)

101−

102−{-# INLINE iterate #-}

103−iterate :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

104−iterate count = S.take count . S.iterate (+1)

105−

106−{-# INLINE iterateM #-}

107−iterateM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

108−iterateM count = S.take count . S.iterateM (return . (+1)) . return

109−

110−{-# INLINE fromIndices #-}

111−fromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

112−fromIndices value n = S.take value $ S.fromIndices (+ n)

113−

114−{-# INLINE fromIndicesM #-}

115−fromIndicesM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

116−fromIndicesM value n = S.take value $ S.fromIndicesM (return <$> (+ n))

117−

118−o_1_space_generation :: Int -> [Benchmark]

119−o_1_space_generation value =

120− [ bgroup "generation"

121− [ benchIOSrc fromSerial "unfoldr" (sourceUnfoldr value)

122− , benchIOSrc fromSerial "unfoldrM" (sourceUnfoldrM value)

123− , benchIOSrc fromSerial "repeat" (repeat value)

124− , benchIOSrc fromSerial "repeatM" (repeatM value)

125− , benchIOSrc fromSerial "replicate" (replicate value)

126− , benchIOSrc fromSerial "replicateM" (replicateM value)

127− , benchIOSrc fromSerial "iterate" (iterate value)

128− , benchIOSrc fromSerial "iterateM" (iterateM value)

129− , benchIOSrc fromSerial "fromIndices" (fromIndices value)

130− , benchIOSrc fromSerial "fromIndicesM" (fromIndicesM value)

131− , benchIOSrc fromSerial "intFromTo" (sourceIntFromTo value)

132− , benchIOSrc fromSerial "intFromThenTo" (sourceIntFromThenTo value)

133− , benchIOSrc fromSerial "integerFromStep" (sourceIntegerFromStep value)

134− , benchIOSrc fromSerial "fracFromThenTo" (sourceFracFromThenTo value)

135− , benchIOSrc fromSerial "fracFromTo" (sourceFracFromTo value)

136− , benchIOSrc fromSerial "fromList" (sourceFromList value)

137− , benchPureSrc "IsList.fromList" (sourceIsList value)

138− , benchPureSrc "IsString.fromString" (sourceIsString value)

139− , benchIOSrc fromSerial "fromListM" (sourceFromListM value)

140− , benchIOSrc fromSerial "enumerateFrom" (enumerateFrom value)

141− , benchIOSrc fromSerial "enumerateFromTo" (enumerateFromTo value)

142− , benchIOSrc fromSerial "enumerateFromThen" (enumerateFromThen value)

143− , benchIOSrc fromSerial "enumerateFromThenTo" (enumerateFromThenTo value)

144− , benchIOSrc fromSerial "enumerate" (enumerate value)

145− , benchIOSrc fromSerial "enumerateTo" (enumerateTo value)

146−

147− -- These essentially test cons and consM

148− , benchIOSrc fromSerial "fromFoldable" (sourceFromFoldable value)

149− , benchIOSrc fromSerial "fromFoldableM" (sourceFromFoldableM value)

150−

151− , benchIOSrc fromSerial "absTimes" $ absTimes value

152− ]

153− ]

154−

155−o_n_heap_generation :: Int -> [Benchmark]

156−o_n_heap_generation value =

157− [ bgroup "buffered"

158− -- Buffers the output of show/read.

159− -- XXX can the outputs be streaming? Can we have special read/show

160− -- style type classes, readM/showM supporting streaming effects?

161− [ bench "readsPrec pure streams" $

162− nf readInstance (mkString value)

163− , bench "readsPrec Haskell lists" $

164− nf readInstanceList (mkListString value)

165− ]

166− ]

167−

168−-------------------------------------------------------------------------------

169−-- Main

170−-------------------------------------------------------------------------------

171−

172−-- In addition to gauge options, the number of elements in the stream can be

173−-- passed using the --stream-size option.

174−--

175−benchmarks :: String -> Int -> [Benchmark]

176−benchmarks moduleName size =

177− [ bgroup (o_1_space_prefix moduleName) (o_1_space_generation size)

178− , bgroup (o_n_heap_prefix moduleName) (o_n_heap_generation size)

179− ]

benchmark/Streamly/Benchmark/Prelude/Serial/Transformation2.hsdeleted−449

@@ -1,449 +0,0 @@

1−-- |

2−-- Module : Serial.Transformation2

4−-- License : BSD-3-Clause

5−-- Maintainer : streamly@composewell.com

6−

7−{-# LANGUAGE CPP #-}

8−{-# LANGUAGE FlexibleContexts #-}

9−{-# LANGUAGE ScopedTypeVariables #-}

10−{-# LANGUAGE DeriveAnyClass #-}

11−{-# LANGUAGE DeriveGeneric #-}

12−{-# LANGUAGE RankNTypes #-}

13−{-# LANGUAGE TupleSections #-}

14−

15−module Serial.Transformation2 (benchmarks) where

16−

17−import Control.DeepSeq (NFData(..))

18−import Control.Monad (when)

19−import Control.Monad.IO.Class (MonadIO(..))

20−import Data.Monoid (Sum(..))

21−import GHC.Generics (Generic)

22−

23−import qualified Data.List as List

24−import qualified Streamly.Internal.Data.Fold as FL

25−import qualified Streamly.Internal.Data.Stream.IsStream as Internal

26−import qualified Streamly.Prelude as S

27−

28−import Gauge

29−import Streamly.Prelude (SerialT, fromSerial)

30−import Streamly.Benchmark.Common

31−import Streamly.Benchmark.Prelude

32−import Prelude hiding (reverse, tail)

33−

34−-------------------------------------------------------------------------------

35−-- Iteration/looping utilities

36−-------------------------------------------------------------------------------

37−

38−{-# INLINE iterateN #-}

39−iterateN :: (Int -> a -> a) -> a -> Int -> a

40−iterateN g initial count = f count initial

41−

42− where

43−

44− f (0 :: Int) x = x

45− f i x = f (i - 1) (g i x)

46−

47−-- Iterate a transformation over a singleton stream

48−{-# INLINE iterateSingleton #-}

49−iterateSingleton :: S.MonadAsync m

50− => (Int -> SerialT m Int -> SerialT m Int)

51− -> Int

52− -> Int

53− -> SerialT m Int

54−iterateSingleton g count n = iterateN g (return n) count

55−

56−-- XXX need to check why this is slower than the explicit recursion above, even

57−-- if the above code is written in a foldr like head recursive way. We also

58−-- need to try this with foldlM' once #150 is fixed.

59−-- However, it is perhaps best to keep the iteration benchmarks independent of

60−-- foldrM and any related fusion issues.

61−{-# INLINE _iterateSingleton #-}

62−_iterateSingleton ::

63− S.MonadAsync m

64− => (Int -> SerialT m Int -> SerialT m Int)

65− -> Int

66− -> Int

67− -> SerialT m Int

68−_iterateSingleton g value n = S.foldrM g (return n) $ sourceIntFromTo value n

69−

70−-- Apply transformation g count times on a stream of length len

71−{-# INLINE iterateSource #-}

72−iterateSource ::

73− S.MonadAsync m

74− => (SerialT m Int -> SerialT m Int)

75− -> Int

76− -> Int

77− -> Int

78− -> SerialT m Int

79−iterateSource g count len n = f count (sourceUnfoldrM len n)

80−

81− where

82−

83− f (0 :: Int) stream = stream

84− f i stream = f (i - 1) (g stream)

85−

86−-------------------------------------------------------------------------------

87−-- Functor

88−-------------------------------------------------------------------------------

89−

90−o_n_space_functor :: Int -> [Benchmark]

91−o_n_space_functor value =

92− [ bgroup "Functor"

93− [ benchIO "(+) (n times) (baseline)" $ \i0 ->

94− iterateN (\i acc -> acc >>= \n -> return $ i + n) (return i0) value

95− , benchIOSrc fromSerial "(<$) (n times)" $

96− iterateSingleton (<$) value

97− , benchIOSrc fromSerial "fmap (n times)" $

98− iterateSingleton (fmap . (+)) value

99− {-

100− , benchIOSrc fromSerial "_(<$) (n times)" $

101− _iterateSingleton (<$) value

102− , benchIOSrc fromSerial "_fmap (n times)" $

103− _iterateSingleton (fmap . (+)) value

104− -}

105− ]

106− ]

107−

108−-------------------------------------------------------------------------------

109−-- Grouping transformations

110−-------------------------------------------------------------------------------

111−

112−{-# INLINE groups #-}

113−groups :: MonadIO m => SerialT m Int -> m ()

114−groups = S.drain . S.groups FL.drain

115−

116−-- XXX Change this test when the order of comparison is later changed

117−{-# INLINE groupsByGT #-}

118−groupsByGT :: MonadIO m => SerialT m Int -> m ()

119−groupsByGT = S.drain . S.groupsBy (>) FL.drain

120−

121−{-# INLINE groupsByEq #-}

122−groupsByEq :: MonadIO m => SerialT m Int -> m ()

123−groupsByEq = S.drain . S.groupsBy (==) FL.drain

124−

125−-- XXX Change this test when the order of comparison is later changed

126−{-# INLINE groupsByRollingLT #-}

127−groupsByRollingLT :: MonadIO m => SerialT m Int -> m ()

128−groupsByRollingLT =

129− S.drain . S.groupsByRolling (<) FL.drain

130−

131−{-# INLINE groupsByRollingEq #-}

132−groupsByRollingEq :: MonadIO m => SerialT m Int -> m ()

133−groupsByRollingEq =

134− S.drain . S.groupsByRolling (==) FL.drain

135−

136−{-# INLINE foldMany #-}

137−foldMany :: Monad m => SerialT m Int -> m ()

138−foldMany =

139− S.drain

140− . S.map getSum

141− . Internal.foldMany (FL.take 2 FL.mconcat)

142− . S.map Sum

143−

144−{-# INLINE foldIterateM #-}

145−foldIterateM :: Monad m => SerialT m Int -> m ()

146−foldIterateM =

147− S.drain

148− . S.map getSum

149− . Internal.foldIterateM (return . FL.take 2 . FL.sconcat) (Sum 0)

150− . S.map Sum

151−

152−o_1_space_grouping :: Int -> [Benchmark]

153−o_1_space_grouping value =

154− -- Buffering operations using heap proportional to group/window sizes.

155− [ bgroup "grouping"

156− [ benchIOSink value "groups" groups

157− , benchIOSink value "groupsByGT" groupsByGT

158− , benchIOSink value "groupsByEq" groupsByEq

159− , benchIOSink value "groupsByRollingLT" groupsByRollingLT

160− , benchIOSink value "groupsByRollingEq" groupsByRollingEq

161− , benchIOSink value "foldMany" foldMany

162− , benchIOSink value "foldIterateM" foldIterateM

163− ]

164− ]

165−

166−-------------------------------------------------------------------------------

167−-- Size conserving transformations (reordering, buffering, etc.)

168−-------------------------------------------------------------------------------

169−

170−{-# INLINE reverse #-}

171−reverse :: MonadIO m => Int -> SerialT m Int -> m ()

172−reverse n = composeN n S.reverse

173−

174−{-# INLINE reverse' #-}

175−reverse' :: MonadIO m => Int -> SerialT m Int -> m ()

176−reverse' n = composeN n Internal.reverse'

177−

178−{-# INLINE sortBy #-}

179−sortBy :: MonadIO m => Int -> SerialT m Int -> m ()

180−sortBy n = composeN n (Internal.sortBy compare)

181−

182−o_n_heap_buffering :: Int -> [Benchmark]

183−o_n_heap_buffering value =

184− [ bgroup "buffered"

185− [

186− -- Reversing/sorting a stream

187− benchIOSink value "reverse" (reverse 1)

188− , benchIOSink value "reverse'" (reverse' 1)

189− , benchIOSink value "sortBy" (sortBy 1)

190− , bench "sort Lists" $ nf (\x -> List.sort [1..x]) value

191−

192− , benchIOSink value "mkAsync" (mkAsync fromSerial)

193− ]

194− ]

195−

196−-------------------------------------------------------------------------------

197−-- Grouping/Splitting

198−-------------------------------------------------------------------------------

199−

200−{-# INLINE classifySessionsOf #-}

201−classifySessionsOf :: (S.MonadAsync m) => SerialT m Int -> m ()

202−classifySessionsOf =

203− S.drain

204− . Internal.classifySessionsOf (const (return False)) 3 FL.drain

205− . Internal.timestamped

206− . S.concatMap (\x -> S.map (x,) (S.enumerateFromTo 1 (10 :: Int)))

207−

208−o_n_space_grouping :: Int -> [Benchmark]

209−o_n_space_grouping value =

210− -- Buffering operations using heap proportional to group/window sizes.

211− [ bgroup "grouping"

212− [ benchIOSink (value `div` 10) "classifySessionsOf" classifySessionsOf

213− ]

214− ]

215−

216−-------------------------------------------------------------------------------

217−-- Mixed Transformation

218−-------------------------------------------------------------------------------

219−

220−{-# INLINE scanMap #-}

221−scanMap :: MonadIO m => Int -> SerialT m Int -> m ()

222−scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0

223−

224−{-# INLINE dropMap #-}

225−dropMap :: MonadIO m => Int -> SerialT m Int -> m ()

226−dropMap n = composeN n $ S.map (subtract 1) . S.drop 1

227−

228−{-# INLINE dropScan #-}

229−dropScan :: MonadIO m => Int -> SerialT m Int -> m ()

230−dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1

231−

232−{-# INLINE takeDrop #-}

233−takeDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

234−takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)

235−

236−{-# INLINE takeScan #-}

237−takeScan :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

238−takeScan value n = composeN n $ S.scanl' (+) 0 . S.take (value + 1)

239−

240−{-# INLINE takeMap #-}

241−takeMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

242−takeMap value n = composeN n $ S.map (subtract 1) . S.take (value + 1)

243−

244−{-# INLINE filterDrop #-}

245−filterDrop :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

246−filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))

247−

248−{-# INLINE filterTake #-}

249−filterTake :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

250−filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))

251−

252−{-# INLINE filterScan #-}

253−filterScan :: MonadIO m => Int -> SerialT m Int -> m ()

254−filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)

255−

256−{-# INLINE filterScanl1 #-}

257−filterScanl1 :: MonadIO m => Int -> SerialT m Int -> m ()

258−filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)

259−

260−{-# INLINE filterMap #-}

261−filterMap :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

262−filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))

263−

264−-------------------------------------------------------------------------------

265−-- Scan and fold

266−-------------------------------------------------------------------------------

267−

268−data Pair a b =

269− Pair !a !b

270− deriving (Generic, NFData)

271−

272−{-# INLINE sumProductFold #-}

273−sumProductFold :: Monad m => SerialT m Int -> m (Int, Int)

274−sumProductFold = S.foldl' (\(s, p) x -> (s + x, p * x)) (0, 1)

275−

276−{-# INLINE sumProductScan #-}

277−sumProductScan :: Monad m => SerialT m Int -> m (Pair Int Int)

278−sumProductScan =

279− S.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p * x)) (Pair 0 1) .

280− S.scanl' (\(s, _) x -> (s + x, x)) (0, 0)

281−

282−{-# INLINE foldl'ReduceMap #-}

283−foldl'ReduceMap :: Monad m => SerialT m Int -> m Int

284−foldl'ReduceMap = fmap (+ 1) . S.foldl' (+) 0

285−

286−o_1_space_transformations_mixed :: Int -> [Benchmark]

287−o_1_space_transformations_mixed value =

288− -- scanl-map and foldl-map are equivalent to the scan and fold in the foldl

289− -- library. If scan/fold followed by a map is efficient enough we may not

290− -- need monolithic implementations of these.

291− [ bgroup "mixed"

292− [ benchIOSink value "scanl-map" (scanMap 1)

293− , benchIOSink value "foldl-map" foldl'ReduceMap

294− , benchIOSink value "sum-product-fold" sumProductFold

295− , benchIOSink value "sum-product-scan" sumProductScan

296− ]

297− ]

298−

299−o_1_space_transformations_mixedX4 :: Int -> [Benchmark]

300−o_1_space_transformations_mixedX4 value =

301− [ bgroup "mixedX4"

302− [ benchIOSink value "scan-map" (scanMap 4)

303− , benchIOSink value "drop-map" (dropMap 4)

304− , benchIOSink value "drop-scan" (dropScan 4)

305− , benchIOSink value "take-drop" (takeDrop value 4)

306− , benchIOSink value "take-scan" (takeScan value 4)

307− , benchIOSink value "take-map" (takeMap value 4)

308− , benchIOSink value "filter-drop" (filterDrop value 4)

309− , benchIOSink value "filter-take" (filterTake value 4)

310− , benchIOSink value "filter-scan" (filterScan 4)

311− , benchIOSink value "filter-scanl1" (filterScanl1 4)

312− , benchIOSink value "filter-map" (filterMap value 4)

313− ]

314− ]

315−

316−-------------------------------------------------------------------------------

317−-- Iterating a transformation over and over again

318−-------------------------------------------------------------------------------

319−

320−-- this is quadratic

321−{-# INLINE iterateScan #-}

322−iterateScan :: S.MonadAsync m => Int -> Int -> Int -> SerialT m Int

323−iterateScan = iterateSource (S.scanl' (+) 0)

324−

325−-- this is quadratic

326−{-# INLINE iterateScanl1 #-}

327−iterateScanl1 :: S.MonadAsync m => Int -> Int -> Int -> SerialT m Int

328−iterateScanl1 = iterateSource (S.scanl1' (+))

329−

330−{-# INLINE iterateMapM #-}

331−iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> SerialT m Int

332−iterateMapM = iterateSource (S.mapM return)

333−

334−{-# INLINE iterateFilterEven #-}

335−iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> SerialT m Int

336−iterateFilterEven = iterateSource (S.filter even)

337−

338−{-# INLINE iterateTakeAll #-}

339−iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> SerialT m Int

340−iterateTakeAll value = iterateSource (S.take (value + 1))

341−

342−{-# INLINE iterateDropOne #-}

343−iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> SerialT m Int

344−iterateDropOne = iterateSource (S.drop 1)

345−

346−{-# INLINE iterateDropWhileFalse #-}

347−iterateDropWhileFalse :: S.MonadAsync m

348− => Int -> Int -> Int -> Int -> SerialT m Int

349−iterateDropWhileFalse value = iterateSource (S.dropWhile (> (value + 1)))

350−

351−{-# INLINE iterateDropWhileTrue #-}

352−iterateDropWhileTrue :: S.MonadAsync m

353− => Int -> Int -> Int -> Int -> SerialT m Int

354−iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1)))

355−

356−{-# INLINE tail #-}

357−tail :: Monad m => SerialT m a -> m ()

358−tail s = S.tail s >>= mapM_ tail

359−

360−{-# INLINE nullHeadTail #-}

361−nullHeadTail :: Monad m => SerialT m Int -> m ()

362−nullHeadTail s = do

363− r <- S.null s

364− when (not r) $ do

365− _ <- S.head s

366− S.tail s >>= mapM_ nullHeadTail

367−

368−-- Head recursive operations.

369−o_n_stack_iterated :: Int -> [Benchmark]

370−o_n_stack_iterated value = by10 `seq` by100 `seq`

371− [ bgroup "iterated"

372− [ benchIOSrc fromSerial "mapM (n/10 x 10)" $ iterateMapM by10 10

373− , benchIOSrc fromSerial "scanl' (quadratic) (n/100 x 100)" $

374− iterateScan by100 100

375− , benchIOSrc fromSerial "scanl1' (n/10 x 10)" $ iterateScanl1 by10 10

376− , benchIOSrc fromSerial "filterEven (n/10 x 10)" $

377− iterateFilterEven by10 10

378− , benchIOSrc fromSerial "takeAll (n/10 x 10)" $

379− iterateTakeAll value by10 10

380− , benchIOSrc fromSerial "dropOne (n/10 x 10)" $ iterateDropOne by10 10

381− , benchIOSrc fromSerial "dropWhileFalse (n/10 x 10)" $

382− iterateDropWhileFalse value by10 10

383− , benchIOSrc fromSerial "dropWhileTrue (n/10 x 10)" $

384− iterateDropWhileTrue value by10 10

385− , benchIOSink value "tail" tail

386− , benchIOSink value "nullHeadTail" nullHeadTail

387− ]

388− ]

389−

390− where

391−

392− by10 = value `div` 10

393− by100 = value `div` 100

394−

395−-------------------------------------------------------------------------------

396−-- Pipes

397−-------------------------------------------------------------------------------

398−

399−o_1_space_pipes :: Int -> [Benchmark]

400−o_1_space_pipes value =

401− [ bgroup "pipes"

402− [ benchIOSink value "mapM" (transformMapM fromSerial 1)

403− , benchIOSink value "compose" (transformComposeMapM fromSerial 1)

404− , benchIOSink value "tee" (transformTeeMapM fromSerial 1)

405−#ifdef DEVBUILD

406− -- XXX this take 1 GB memory to compile

407− , benchIOSink value "zip" (transformZipMapM fromSerial 1)

408−#endif

409− ]

410− ]

411−

412−o_1_space_pipesX4 :: Int -> [Benchmark]

413−o_1_space_pipesX4 value =

414− [ bgroup "pipesX4"

415− [ benchIOSink value "mapM" (transformMapM fromSerial 4)

416− , benchIOSink value "compose" (transformComposeMapM fromSerial 4)

417− , benchIOSink value "tee" (transformTeeMapM fromSerial 4)

418−#ifdef DEVBUILD

419− -- XXX this take 1 GB memory to compile

420− , benchIOSink value "zip" (transformZipMapM fromSerial 4)

421−#endif

422− ]

423− ]

424−

425−-------------------------------------------------------------------------------

426−-- Main

427−-------------------------------------------------------------------------------

428−

429−-- In addition to gauge options, the number of elements in the stream can be

430−-- passed using the --stream-size option.

431−--

432−benchmarks :: String -> Int -> [Benchmark]

433−benchmarks moduleName size =

434− [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat

435− [ o_1_space_grouping size

436− , o_1_space_transformations_mixed size

437− , o_1_space_transformations_mixedX4 size

438−

439− -- pipes

440− , o_1_space_pipes size

441− , o_1_space_pipesX4 size

442− ]

443− , bgroup (o_n_stack_prefix moduleName) (o_n_stack_iterated size)

444− , bgroup (o_n_heap_prefix moduleName) $ Prelude.concat

445− [ o_n_space_grouping size

446− , o_n_space_functor size

447− , o_n_heap_buffering size

448− ]

449− ]

benchmark/Streamly/Benchmark/Prelude/Serial/Transformation3.hsdeleted−122

@@ -1,122 +0,0 @@

1−-- |

2−-- Module : Serial.Transformation3

4−-- License : BSD-3-Clause

5−-- Maintainer : streamly@composewell.com

6−

7−{-# LANGUAGE CPP #-}

8−{-# LANGUAGE FlexibleContexts #-}

9−{-# LANGUAGE ScopedTypeVariables #-}

10−{-# LANGUAGE RankNTypes #-}

11−

12−module Serial.Transformation3 (benchmarks) where

13−

14−import Control.Monad.State.Strict (StateT, get, put, MonadState)

15−import qualified Control.Monad.State.Strict as State

16−import Control.Monad.Trans.Class (lift)

17−

18−import qualified Streamly.Prelude as S

19−import qualified Streamly.Internal.Data.Stream.IsStream as Internal

20−

21−import Gauge

22−import Streamly.Prelude (SerialT, fromSerial)

23−import Streamly.Benchmark.Common

24−import Streamly.Benchmark.Prelude

25−import Prelude hiding (reverse, tail)

26−

27−-------------------------------------------------------------------------------

28−-- Monad transformation (hoisting etc.)

29−-------------------------------------------------------------------------------

30−

31−{-# INLINE sourceUnfoldrState #-}

32−sourceUnfoldrState :: (S.IsStream t, S.MonadAsync m)

33− => Int -> Int -> t (StateT Int m) Int

34−sourceUnfoldrState value n = S.unfoldrM step n

35− where

36− step cnt =

37− if cnt > n + value

38− then return Nothing

39− else do

40− s <- get

41− put (s + 1)

42− return (Just (s, cnt + 1))

43−

44−{-# INLINE evalStateT #-}

45−evalStateT :: S.MonadAsync m => Int -> Int -> SerialT m Int

46−evalStateT value n =

47− Internal.evalStateT (return 0) (sourceUnfoldrState value n)

48−

49−{-# INLINE withState #-}

50−withState :: S.MonadAsync m => Int -> Int -> SerialT m Int

51−withState value n =

52− Internal.evalStateT

53− (return (0 :: Int)) (Internal.liftInner (sourceUnfoldrM value n))

54−

55−o_1_space_hoisting :: Int -> [Benchmark]

56−o_1_space_hoisting value =

57− [ bgroup "hoisting"

58− [ benchIOSrc fromSerial "evalState" (evalStateT value)

59− , benchIOSrc fromSerial "withState" (withState value)

60− ]

61− ]

62−

63−{-# INLINE iterateStateIO #-}

64−iterateStateIO ::

65− (S.MonadAsync m)

66− => Int

67− -> StateT Int m Int

68−iterateStateIO n = do

69− x <- get

70− if x > n

71− then do

72− put (x - 1)

73− iterateStateIO n

74− else return x

75−

76−{-# INLINE iterateStateT #-}

77−iterateStateT :: Int -> SerialT (StateT Int IO) Int

78−iterateStateT n = do

79− x <- lift get

80− if x > n

81− then do

82− lift $ put (x - 1)

83− iterateStateT n

84− else return x

85−

86−{-# INLINE iterateState #-}

87−iterateState ::

88− (S.MonadAsync m, MonadState Int m)

89− => Int

90− -> SerialT m Int

91−iterateState n = do

92− x <- get

93− if x > n

94− then do

95− put (x - 1)

96− iterateState n

97− else return x

98−

99−o_n_heap_transformer :: Int -> [Benchmark]

100−o_n_heap_transformer value =

101− [ bgroup "transformer"

102− [ benchIO "StateT Int IO (n times) (baseline)" $ \n ->

103− State.evalStateT (iterateStateIO n) value

104− , benchIO "SerialT (StateT Int IO) (n times)" $ \n ->

105− State.evalStateT (S.drain (iterateStateT n)) value

106− , benchIO "MonadState Int m => SerialT m Int" $ \n ->

107− State.evalStateT (S.drain (iterateState n)) value

108− ]

109− ]

110−

111−-------------------------------------------------------------------------------

112−-- Main

113−-------------------------------------------------------------------------------

114−

115−-- In addition to gauge options, the number of elements in the stream can be

116−-- passed using the --stream-size option.

117−--

118−benchmarks :: String -> Int -> [Benchmark]

119−benchmarks moduleName size =

120− [ bgroup (o_1_space_prefix moduleName) (o_1_space_hoisting size)

121− , bgroup (o_n_heap_prefix moduleName) (o_n_heap_transformer size)

122− ]

benchmark/Streamly/Benchmark/Prelude/WAsync.hs+4−4

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -13,7 +15,7 @@ import qualified Streamly.Prelude as S

1315import Streamly.Benchmark.Common

1416import Streamly.Benchmark.Prelude

1517

16−import Gauge

18+import Test.Tasty.Bench

1719

1820moduleName :: String

1921moduleName = "Prelude.WAsync"

@@ -167,9 +169,7 @@ o_n_space_outerProduct value =

167169-------------------------------------------------------------------------------

168170

169171main :: IO ()

170−main = do

171− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

172− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

172+main = runWithCLIOpts defaultStreamSize allBenchmarks

173173

174174 where

175175

benchmark/Streamly/Benchmark/Prelude/WSerial.hs+216−66

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -27,13 +29,13 @@ import qualified Streamly.Internal.Data.Unfold as UF

2729import Streamly.Benchmark.Common

2830import Streamly.Benchmark.Prelude

2931

30−import Gauge

32+import Test.Tasty.Bench

3133

3234#ifdef INSPECTION

3335import GHC.Types (SPEC(..))

3436import Test.Inspection

3537

36−import qualified Streamly.Internal.Data.Stream.StreamD as D

38+import qualified Streamly.Internal.Data.Stream as D

3739#endif

3840

3941moduleName :: String

@@ -88,18 +90,54 @@ inspect $ 'roundRobin2 `hasNoType` ''SPEC

8890inspect $ 'roundRobin2 `hasNoType` ''D.InterleaveState

8991#endif

9092

91−o_1_space_joining :: Int -> [Benchmark]

92−o_1_space_joining value =

93− [ bgroup "joining"

94− [ benchIOSrc1 "wSerial (2,x/2)" (wSerial2 value)

95− , benchIOSrc1 "interleave (2,x/2)" (interleave2 value)

96− , benchIOSrc1 "roundRobin (2,x/2)" (roundRobin2 value)

97− ]

98− ]

93+{-# INLINE sourceUnfoldrMUF #-}

94+-- (count, value)

95+sourceUnfoldrMUF :: Monad m => Int -> UF.Unfold m (Int, Int) Int

96+sourceUnfoldrMUF count = UF.unfoldrM step

97+ where

98+ step (cnt, start) =

99+ return $

100+ if cnt > start + count

101+ then Nothing

102+ else Just (cnt, (cnt + 1, start))

103+

104+{-# INLINE unfoldManyInterleave #-}

105+unfoldManyInterleave :: Int -> Int -> Int -> IO ()

106+unfoldManyInterleave outer inner n =

107+ S.drain $ Internal.unfoldManyInterleave

108+ -- (UF.lmap return (UF.replicateM inner))

109+ (UF.lmap (\x -> (x,x)) (sourceUnfoldrMUF inner))

110+ (sourceUnfoldrM outer n)

99111

100−-------------------------------------------------------------------------------

101−-- Concat

102−-------------------------------------------------------------------------------

112+#ifdef INSPECTION

113+inspect $ hasNoTypeClasses 'unfoldManyInterleave

114+-- inspect $ 'unfoldManyInterleave `hasNoType` ''SPEC

115+-- inspect $ 'unfoldManyInterleave `hasNoType`

116+-- ''D.ConcatUnfoldInterleaveState

117+#endif

118+

119+{-# INLINE unfoldManyRoundRobin #-}

120+unfoldManyRoundRobin :: Int -> Int -> Int -> IO ()

121+unfoldManyRoundRobin outer inner n =

122+ S.drain $ Internal.unfoldManyRoundRobin

123+ -- (UF.lmap return (UF.replicateM inner))

124+ (UF.lmap (\x -> (x,x)) (sourceUnfoldrMUF inner))

125+ (sourceUnfoldrM outer n)

126+

127+#ifdef INSPECTION

128+inspect $ hasNoTypeClasses 'unfoldManyRoundRobin

129+-- inspect $ 'unfoldManyRoundRobin `hasNoType` ''SPEC

130+-- inspect $ 'unfoldManyRoundRobin `hasNoType`

131+-- ''D.ConcatUnfoldInterleaveState

132+#endif

133+

134+{-# INLINE concatPairsWithWSerial #-}

135+concatPairsWithWSerial :: Int -> Int -> Int -> IO ()

136+concatPairsWithWSerial = concatPairsWith Internal.wSerial

137+

138+{-# INLINE concatPairsWithRoundrobin #-}

139+concatPairsWithRoundrobin :: Int -> Int -> Int -> IO ()

140+concatPairsWithRoundrobin = concatPairsWith Internal.roundrobin

103141

104142{-# INLINE concatMapWithWSerial #-}

105143concatMapWithWSerial :: Int -> Int -> Int -> IO ()

@@ -110,86 +148,198 @@ inspect $ hasNoTypeClasses 'concatMapWithWSerial

110148inspect $ 'concatMapWithWSerial `hasNoType` ''SPEC

111149#endif

112150

151+o_1_space_joining :: Int -> [Benchmark]

152+o_1_space_joining value =

153+ [ bgroup "joining (2 of n/2)"

154+ [ benchIOSrc1 "wSerial" (wSerial2 value)

155+ , benchIOSrc1 "interleave" (interleave2 value)

156+ , benchIOSrc1 "roundRobin" (roundRobin2 value)

157+ , benchIOSrc1

158+ "concatMapWithWSerial"

159+ (concatMapWithWSerial 2 (value `div` 2))

160+ , benchIOSrc1

161+ "concatMapWithInterleave"

162+ (concatStreamsWith Internal.interleave 2 (value `div` 2))

163+ , benchIOSrc1

164+ "concatMapWithRoundrobin"

165+ (concatStreamsWith Internal.roundrobin 2 (value `div` 2))

166+ , benchIOSrc1

167+ "unfoldManyInterleave"

168+ (unfoldManyInterleave 2 (value `div` 2))

169+ , benchIOSrc1

170+ "concatPairsWithWSerial"

171+ (concatPairsWithWSerial 2 (value `div` 2))

172+ , benchIOSrc1

173+ "concatPairsWithRoundrobin"

174+ (concatPairsWithRoundrobin 2 (value `div` 2))

175+ ]

176+ ]

177+

178+-------------------------------------------------------------------------------

179+-- Concat

180+-------------------------------------------------------------------------------

181+

113182o_1_space_concat :: Int -> [Benchmark]

114183o_1_space_concat value =

115− [ bgroup "concat"

184+ [ bgroup "concatMapWith"

116185 [ benchIOSrc1

117− "concatMapWithWSerial (2,x/2)"

118− (concatMapWithWSerial 2 (value `div` 2))

186+ "concatMapWithWSerial (n of 1)"

187+ (concatStreamsWith wSerial value 1)

119188 , benchIOSrc1

120− "concatMapWithWSerial (x/2,2)"

121− (concatMapWithWSerial (value `div` 2) 2)

189+ "concatMapWithWSerial (sqrtVal of sqrtVal)"

190+ (concatStreamsWith wSerial sqrtVal sqrtVal)

122191 ]

123192 ]

124193

125−{-# INLINE unfoldManyInterleaveRepl4xN #-}

126−unfoldManyInterleaveRepl4xN :: Int -> Int -> IO ()

127−unfoldManyInterleaveRepl4xN value n =

128− S.drain $ Internal.unfoldManyInterleave

129− (UF.lmap return (UF.replicateM 4))

130− (sourceUnfoldrM (value `div` 4) n)

194+ where

131195

132−#ifdef INSPECTION

133−inspect $ hasNoTypeClasses 'unfoldManyInterleaveRepl4xN

134−-- inspect $ 'unfoldManyInterleaveRepl4xN `hasNoType` ''SPEC

135−-- inspect $ 'unfoldManyInterleaveRepl4xN `hasNoType`

136−-- ''D.ConcatUnfoldInterleaveState

137−#endif

196+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

138197

139−{-# INLINE unfoldManyRoundRobinRepl4xN #-}

140−unfoldManyRoundRobinRepl4xN :: Int -> Int -> IO ()

141−unfoldManyRoundRobinRepl4xN value n =

142− S.drain $ Internal.unfoldManyRoundRobin

143− (UF.lmap return (UF.replicateM 4))

144− (sourceUnfoldrM (value `div` 4) n)

198+o_n_space_concat :: Int -> [Benchmark]

199+o_n_space_concat value =

200+ [ bgroup "concatMapWith"

201+ [

202+ -- concatMapWith using StreamD versions of interleave operations are

203+ -- all quadratic, we just measure the sqrtVal benchmark for comparison.

204+ benchIOSrc1

205+ "concatMapWithInterleave (sqrtVal of 1)"

206+ (concatStreamsWith Internal.interleave sqrtVal 1)

207+ , benchIOSrc1

208+ "concatMapWithInterleave (sqrtVal of sqrtVal)"

209+ (concatStreamsWith Internal.interleave sqrtVal sqrtVal)

210+ , benchIOSrc1

211+ "concatMapWithRoundrobin (sqrtVal of sqrtVal)"

212+ (concatStreamsWith Internal.roundrobin sqrtVal sqrtVal)

213+ ]

214+ ]

145215

146−#ifdef INSPECTION

147−inspect $ hasNoTypeClasses 'unfoldManyRoundRobinRepl4xN

148−-- inspect $ 'unfoldManyRoundRobinRepl4xN `hasNoType` ''SPEC

149−-- inspect $ 'unfoldManyRoundRobinRepl4xN `hasNoType`

150−-- ''D.ConcatUnfoldInterleaveState

151−#endif

216+ where

217+

218+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

219+

220+{-# INLINE concatPairsWithInterleave #-}

221+concatPairsWithInterleave :: Int -> Int -> Int -> IO ()

222+concatPairsWithInterleave = concatPairsWith Internal.interleave

223+

224+{-# INLINE concatPairsWithInterleaveSuffix #-}

225+concatPairsWithInterleaveSuffix :: Int -> Int -> Int -> IO ()

226+concatPairsWithInterleaveSuffix = concatPairsWith Internal.interleaveSuffix

227+

228+{-# INLINE concatPairsWithInterleaveInfix #-}

229+concatPairsWithInterleaveInfix :: Int -> Int -> Int -> IO ()

230+concatPairsWithInterleaveInfix = concatPairsWith Internal.interleaveInfix

231+

232+{-# INLINE concatPairsWithInterleaveMin #-}

233+concatPairsWithInterleaveMin :: Int -> Int -> Int -> IO ()

234+concatPairsWithInterleaveMin = concatPairsWith Internal.interleaveMin

152235

153236o_n_heap_concat :: Int -> [Benchmark]

154237o_n_heap_concat value =

155− [ bgroup "concat"

238+ [ bgroup "concatPairsWith"

156239 [

157− -- interleave x/4 streams of 4 elements each. Needs to buffer

158− -- proportional to x/4. This is different from WSerial because

159− -- WSerial expands slowly because of binary interleave behavior and

160− -- this expands immediately because of Nary interleave behavior.

161240 benchIOSrc1

162− "unfoldManyInterleaveRepl (x/4,4)"

163− (unfoldManyInterleaveRepl4xN value)

241+ "unfoldManyInterleave (n of 1)"

242+ (unfoldManyInterleave value 1)

243+ , benchIOSrc1

244+ "unfoldManyInterleave (sqrtVal of sqrtVal)"

245+ (unfoldManyInterleave sqrtVal sqrtVal)

246+

247+ , benchIOSrc1

248+ "unfoldManyRoundRobin (n of 1)"

249+ (unfoldManyRoundRobin value 1)

250+ , benchIOSrc1

251+ "unfoldManyRoundRobin (sqrtVal of sqrtVal)"

252+ (unfoldManyRoundRobin sqrtVal sqrtVal)

253+

254+ , benchIOSrc1

255+ "concatPairsWithWSerial (n of 1)"

256+ (concatPairsWithWSerial value 1)

257+ , benchIOSrc1

258+ "concatPairsWithWSerial (sqrtVal of sqrtVal)"

259+ (concatPairsWithWSerial sqrtVal sqrtVal)

260+

261+ , benchIOSrc1

262+ "concatPairsWithInterleave (n of 1)"

263+ (concatPairsWithInterleave value 1)

264+ , benchIOSrc1

265+ "concatPairsWithInterleave (sqrtVal of sqrtVal)"

266+ (concatPairsWithInterleave sqrtVal sqrtVal)

267+

268+ , benchIOSrc1

269+ "concatPairsWithInterleaveSuffix (n of 1)"

270+ (concatPairsWithInterleaveSuffix value 1)

271+ , benchIOSrc1

272+ "concatPairsWithInterleaveSuffix (sqrtVal of sqrtVal)"

273+ (concatPairsWithInterleaveSuffix sqrtVal sqrtVal)

274+

275+ , benchIOSrc1

276+ "concatPairsWithInterleaveInfix (n of 1)"

277+ (concatPairsWithInterleaveInfix value 1)

164278 , benchIOSrc1

165− "unfoldManyRoundRobinRepl (x/4,4)"

166− (unfoldManyRoundRobinRepl4xN value)

279+ "concatPairsWithInterleaveInfix (sqrtVal of sqrtVal)"

280+ (concatPairsWithInterleaveInfix sqrtVal sqrtVal)

281+

282+ , benchIOSrc1

283+ "concatPairsWithInterleaveMin (n of 1)"

284+ (concatPairsWithInterleaveMin value 1)

285+ , benchIOSrc1

286+ "concatPairsWithInterleaveMin (sqrtVal of sqrtVal)"

287+ (concatPairsWithInterleaveMin sqrtVal sqrtVal)

288+

289+ , benchIOSrc1

290+ "concatPairsWithRoundrobin (n of 1)"

291+ (concatPairsWithRoundrobin value 1)

292+ , benchIOSrc1

293+ "concatPairsWithRoundrobin (sqrtVal of sqrtVal)"

294+ (concatPairsWithRoundrobin sqrtVal sqrtVal)

167295 ]

168296 ]

169297

298+ where

299+

300+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

301+

170302-------------------------------------------------------------------------------

171303-- Monad

172304-------------------------------------------------------------------------------

173305

174306o_1_space_outerProduct :: Int -> [Benchmark]

175307o_1_space_outerProduct value =

176− [ bgroup "monad-outer-product"

177− [ benchIO "toNullAp" $ toNullAp value fromWSerial

178− , benchIO "toNullM" $ toNullM value fromWSerial

179− , benchIO "toNullM3" $ toNullM3 value fromWSerial

180− , benchIO "filterAllOutM" $ filterAllOutM value fromWSerial

181− , benchIO "filterAllInM" $ filterAllInM value fromWSerial

182− , benchIO "filterSome" $ filterSome value fromWSerial

183− , benchIO "breakAfterSome" $ breakAfterSome value fromWSerial

308+ [ bgroup "outer-product"

309+ [ benchIO

310+ "drain applicative (+) (sqrtVal of sqrtVal)"

311+ (toNullAp value fromWSerial)

312+ , benchIO

313+ "drain monad (+) (sqrtVal of sqrtVal)"

314+ (toNullM value fromWSerial)

315+ , benchIO

316+ "drain monad (+) (cbrtVal of cbrtVal of cbrtVal)"

317+ (toNullM3 value fromWSerial)

318+ , benchIO

319+ "filterAllOut monad (+) (sqrtVal of sqrtVal)"

320+ (filterAllOutM value fromWSerial)

321+ , benchIO

322+ "filterAllIn monad (+) (sqrtVal of sqrtVal)"

323+ (filterAllInM value fromWSerial)

324+ , benchIO

325+ "filterSome monad (+) (sqrtVal of sqrtVal)"

326+ (filterSome value fromWSerial)

327+ , benchIO

328+ "breakAfterSome monad (+) (sqrtVal of sqrtVal)"

329+ (breakAfterSome value fromWSerial)

184330 ]

185331 ]

186332

187333o_n_space_outerProduct :: Int -> [Benchmark]

188334o_n_space_outerProduct value =

189335 [ bgroup

190− "monad-outer-product"

191− [ benchIO "toList" $ toListM value fromWSerial

192− , benchIO "toListSome" $ toListSome value fromWSerial

336+ "outer-product"

337+ [ benchIO

338+ "toList monad (+) (sqrtVal of sqrtVal)"

339+ (toListM value fromWSerial)

340+ , benchIO

341+ "toListSome monad (+) (sqrtVal of sqrtVal)"

342+ (toListSome value fromWSerial)

193343 ]

194344 ]

195345

@@ -201,9 +351,8 @@ o_n_space_outerProduct value =

201351-- passed using the --stream-size option.

202352--

203353main :: IO ()

204−main = do

205− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

206− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

354+main = runWithCLIOpts defaultStreamSize allBenchmarks

355+

207356

208357 where

209358

@@ -215,5 +364,6 @@ main = do

215364 , o_1_space_outerProduct size

216365 ]

217366 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_concat size)

218− , bgroup (o_n_space_prefix moduleName) (o_n_space_outerProduct size)

367+ , bgroup (o_n_space_prefix moduleName) $

368+ o_n_space_outerProduct size ++ o_n_space_concat size

219369 ]

benchmark/Streamly/Benchmark/Prelude/ZipAsync.hs+18−4

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -13,7 +15,7 @@ import qualified Streamly.Prelude as S

1315import Streamly.Benchmark.Common

1416import Streamly.Benchmark.Prelude

1517

16−import Gauge

18+import Test.Tasty.Bench

1719

1820moduleName :: String

1921moduleName = "Prelude.ZipAsync"

@@ -41,6 +43,12 @@ zipAsyncAp count n =

4143 S.fromZipAsync $

4244 (,) <$> sourceUnfoldrM count n <*> sourceUnfoldrM count (n + 1)

4345

46+fromZipAsyncTraverse :: String -> Int -> Benchmark

47+fromZipAsyncTraverse name count =

48+ bench name

49+ $ nfIO

50+ $ S.drain $ S.fromZipAsync $ traverse S.fromPure [0 :: Int .. count]

51+

4452o_1_space_joining :: Int -> [Benchmark]

4553o_1_space_joining value =

4654 [ bgroup "joining"

@@ -53,6 +61,13 @@ o_1_space_joining value =

5361 ]

5462 ]

5563

64+o_n_heap_joining :: Int -> [Benchmark]

65+o_n_heap_joining value =

66+ [ bgroup "joining"

67+ [ fromZipAsyncTraverse "ZipAsync Applicative (x/100)" (value `div` 100)

68+ ]

69+ ]

70+

5671-------------------------------------------------------------------------------

5772-- Monad outer product

5873-------------------------------------------------------------------------------

@@ -69,9 +84,7 @@ o_1_space_outerProduct value =

6984-------------------------------------------------------------------------------

7085

7186main :: IO ()

72−main = do

73− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

74− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

87+main = runWithCLIOpts defaultStreamSize allBenchmarks

7588

7689 where

7790

@@ -80,4 +93,5 @@ main = do

8093 [ o_1_space_joining size

8194 , o_1_space_outerProduct size

8295 ]

96+ , bgroup (o_n_heap_prefix moduleName) $ o_n_heap_joining size

8397 ]

benchmark/Streamly/Benchmark/Prelude/ZipSerial.hs+53−7

@@ -1,3 +1,5 @@

1+{-# OPTIONS_GHC -Wno-deprecations #-}

13-- |

24-- Module : Main

@@ -27,13 +29,13 @@ import qualified Streamly.Prelude as S

2729import Streamly.Benchmark.Common

2830import Streamly.Benchmark.Prelude hiding (sourceUnfoldrM)

2931

30−import Gauge

32+import Test.Tasty.Bench

3133

3234#ifdef INSPECTION

3335import GHC.Types (SPEC(..))

3436import Test.Inspection

3537

36−import qualified Streamly.Internal.Data.Stream.StreamD as D

38+import qualified Streamly.Internal.Data.Stream as D

3739#endif

3840

3941moduleName :: String

@@ -84,11 +86,26 @@ inspect $ 'zipWithM `hasNoType` ''SPEC

8486inspect $ 'zipWithM `hasNoType` ''D.Step

8587#endif

8688

89+{-

90+{-# INLINE concatMapWithZip #-}

91+concatMapWithZip :: Int -> Int -> Int -> IO ()

92+concatMapWithZip = concatStreamsWith (S.zipWith (+))

93+-}

94+

95+{-# INLINE concatPairsWithZip #-}

96+concatPairsWithZip :: Int -> Int -> Int -> IO ()

97+concatPairsWithZip = concatPairsWith (S.zipWith (+))

98+

8799o_1_space_joining :: Int -> [Benchmark]

88100o_1_space_joining value =

89101 [ bgroup "joining"

90− [ benchIOSrc1 "zip (2,x/2)" (zipWith (value `div` 2))

91− , benchIOSrc1 "zipM (2,x/2)" (zipWithM (value `div` 2))

102+ [ benchIOSrc1 "zip (2 of n/2)" (zipWith (value `div` 2))

103+ , benchIOSrc1 "zipM (2 of n/2)" (zipWithM (value `div` 2))

104+ {-

105+ -- Not correct because of nil stream at end issue.

106+ , benchIOSrc1 "concatMapWithZip (+) (2 of n/2)"

107+ (concatMapWithZip 2 (value `div` 2))

108+ -}

92109 ]

93110 ]

94111

@@ -103,11 +120,39 @@ o_1_space_mapping value =

103120 ]

104121 ]

105122

123+-------------------------------------------------------------------------------

124+-- Concat

125+-------------------------------------------------------------------------------

126+

127+o_n_heap_concat :: Int -> [Benchmark]

128+o_n_heap_concat value =

129+ [ bgroup "concatPairsWith"

130+ [ {- -- This fails with stack overflow.

131+ benchIOSrc1 "concatMapWithZip (n of 1)"

132+ (concatMapWithZip value 1)

133+ -- Not correct because of nil stream at end issue.

134+ , benchIOSrc1 "concatMapWithZip (sqrtVal of sqrtVal)"

135+ (concatMapWithZip sqrtVal sqrtVal)

136+ -}

137+ benchIOSrc1 "concatPairsWithZip (n of 1)"

138+ (concatPairsWithZip value 1)

139+ , benchIOSrc1 "concatPairsWithZip (sqrtVal of sqrtVal)"

140+ (concatPairsWithZip sqrtVal sqrtVal)

141+ , benchIOSrc1 "concatPairsWithZip (+) (2 of n/2)"

142+ (concatPairsWithZip 2 (value `div` 2))

143+ ]

144+ ]

145+

146+ where

147+

148+ sqrtVal = round $ sqrt (fromIntegral value :: Double)

149+

106150-------------------------------------------------------------------------------

107151-- Monad outer product

108152-------------------------------------------------------------------------------

109153

110154{-

155+-- Not correct because of nil stream at end issue.

111156o_1_space_outerProduct :: Int -> [Benchmark]

112157o_1_space_outerProduct value =

113158 [ bgroup "monad-outer-product"

@@ -125,9 +170,7 @@ o_1_space_outerProduct value =

125170-- passed using the --stream-size option.

126171--

127172main :: IO ()

128−main = do

129− (value, cfg, benches) <- parseCLIOpts defaultStreamSize

130− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)

173+main = runWithCLIOpts defaultStreamSize allBenchmarks

131174

132175 where

133176

@@ -138,4 +181,7 @@ main = do

138181 -- XXX need to fix, timing in ns

139182 -- , o_1_space_outerProduct size

140183 ]

184+ , bgroup (o_n_heap_prefix moduleName) $ concat

185+ [ o_n_heap_concat size

186+ ]

141187 ]

benchmark/Streamly/Benchmark/Unicode/Char.hsnew file+90

@@ -0,0 +1,90 @@

1+{-# OPTIONS_GHC -Wno-deprecations -Wno-orphans #-}

3+--

4+-- Module : Streamly.Unicode.Char

6+-- License : BSD-3-Clause

7+-- Maintainer : streamly@composewell.com

8+-- Stability : experimental

9+-- Portability : GHC

10+

11+--------------------------------------------------------------------------------

12+-- Imports

13+--------------------------------------------------------------------------------

14+

15+import Control.DeepSeq (NFData(..))

16+import Streamly.Internal.Data.Array (Array)

17+import System.FilePath (dropExtensions, takeFileName)

18+import System.FilePath.Posix ((</>))

19+import Test.Tasty.Bench (Benchmark, bench, bgroup, defaultMain, env, nfIO)

20+import Streamly.Internal.Unicode.Char

21+ ( NormalizationMode(NFC, NFD, NFKC, NFKD)

22+ , normalize

23+ )

24+import Streamly.Benchmark.Common (o_1_space_prefix)

25+

26+import qualified Streamly.Internal.Data.Array as Array

27+import qualified Streamly.Internal.Data.Stream as IsStream

28+import qualified System.Directory as Dir

29+

30+--------------------------------------------------------------------------------

31+-- Utilities

32+--------------------------------------------------------------------------------

33+

34+moduleName :: String

35+moduleName = "Unicode.Char"

36+

37+dataDir :: FilePath

38+dataDir = "benchmark/Streamly/Benchmark/Unicode/data"

39+

40+-- Truncate or expand all datasets to this size to provide a normalized

41+-- measurement view across all datasets and to reduce the effect of noise

42+-- because of the datasets being too small.

43+dataSetSize :: Int

44+dataSetSize = 1000000

45+

46+-- Unboxed arrays are fully evaluated.

47+instance NFData (Array a) where

48+ {-# INLINE rnf #-}

49+ rnf _ = ()

50+

51+makeBench ::

52+ (String, Array Char -> IO ()) -> (String, IO (Array Char)) -> Benchmark

53+makeBench (implName, func) (dataName, setup) =

54+ env setup (bench (implName ++ "/" ++ dataName) . nfIO . func)

55+

56+strInput :: FilePath -> (String, IO String)

57+strInput file = (dataName file, fmap (take dataSetSize . cycle) (readFile file))

58+

59+ where

60+

61+ dataName = dropExtensions . takeFileName

62+

63+arrInput :: FilePath -> (String, IO (Array Char))

64+arrInput file = second (fmap Array.fromList) (strInput file)

65+

66+ where

67+

68+ second f (a, b) = (a, f b)

69+

70+--------------------------------------------------------------------------------

71+-- Benchmarks

72+--------------------------------------------------------------------------------

73+

74+benchFunctions :: [(String, Array Char -> IO ())]

75+benchFunctions =

76+ [ ("NFD", IsStream.drain . normalize NFD . Array.read)

77+ , ("NFKD", IsStream.drain . normalize NFKD . Array.read)

78+ , ("NFC", IsStream.drain . normalize NFC . Array.read)

79+ , ("NFKC", IsStream.drain . normalize NFKC . Array.read)

80+ ]

81+

82+main :: IO ()

83+main = do

84+ cdir <- Dir.getCurrentDirectory

85+ dataFiles <- fmap (dataDir </>) <$> Dir.listDirectory (cdir </> dataDir)

86+ defaultMain

87+ [ bgroup

88+ (o_1_space_prefix moduleName)

89+ (makeBench <$> benchFunctions <*> map arrInput dataFiles)

90+ ]

benchmark/Streamly/Benchmark/Unicode/Parser.hsnew file+107

@@ -0,0 +1,107 @@

1+-- |

2+-- Module : Streamly.Benchmark.Data.Parser

4+--

5+-- License : BSD-3-Clause

6+-- Maintainer : streamly@composewell.com

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+149−104

@@ -1,4 +1,6 @@

1−-- |

1+{-# OPTIONS_GHC -Wno-deprecations #-}

3+--

24-- Module : Streamly.Unicode.Stream

46-- License : BSD-3-Clause

@@ -9,6 +11,11 @@

911{-# LANGUAGE CPP #-}

1012{-# LANGUAGE ScopedTypeVariables #-}

1113

14+#undef FUSION_CHECK

15+#ifdef FUSION_CHECK

16+{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}

17+#endif

18+

1219#ifdef __HADDOCK_VERSION__

1320#undef INSPECTION

1421#endif

@@ -18,31 +25,30 @@

1825{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}

1926#endif

2027

28+import Streamly.Data.Stream (Stream)

29+import Streamly.Data.Fold (Fold)

2130import Prelude hiding (last, length)

2231import System.IO (Handle)

2332

24−import qualified Streamly.Data.Fold as FL

25−import qualified Streamly.Unicode.Stream as SS

26−import qualified Streamly.FileSystem.Handle as FH

27−import qualified Streamly.Internal.Data.Unfold as IUF

28−import qualified Streamly.Internal.Unicode.Stream as IUS

29−import qualified Streamly.Internal.FileSystem.Handle as IFH

30−import qualified Streamly.Internal.Unicode.Array.Char as IUA

31−import qualified Streamly.Internal.Data.Stream.IsStream as IP

32−import qualified Streamly.Data.Array.Foreign as A

33−import qualified Streamly.Prelude as S

34−

35−import Gauge hiding (env)

33+import qualified Streamly.Data.Array as Array

34+import qualified Streamly.Data.Fold as Fold

35+import qualified Streamly.Internal.Data.Stream as Stream

36+import qualified Streamly.Internal.Data.Unfold as Unfold

37+import qualified Streamly.Internal.FileSystem.Handle as Handle

38+import qualified Streamly.Internal.Unicode.Array as UnicodeArr

39+import qualified Streamly.Internal.Unicode.Stream as Unicode

40+

41+import Test.Tasty.Bench hiding (env)

3642import Streamly.Benchmark.Common

3743import Streamly.Benchmark.Common.Handle

3844

3945#ifdef INSPECTION

40−import Foreign.Storable (Storable)

41−import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))

42−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

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

44−import qualified Streamly.Internal.Data.Array.Foreign.Type as AT

45−import qualified Streamly.Internal.Data.Array.Foreign.Mut.Type as MA

4652

4753import Test.Inspection

4854#endif

@@ -54,10 +60,10 @@ moduleName = "Unicode.Stream"

5460{-# NOINLINE copyCodecUtf8ArraysLenient #-}

5561copyCodecUtf8ArraysLenient :: Handle -> Handle -> IO ()

5662copyCodecUtf8ArraysLenient inh outh =

57− S.fold (FH.write outh)

58− $ SS.encodeUtf8'

59− $ IUS.decodeUtf8Arrays

60− $ IFH.toChunks inh

63+ Stream.fold (Handle.write outh)

64+ $ Unicode.encodeUtf8'

65+ $ Unicode.decodeUtf8Chunks

66+ $ Handle.readChunks inh

6167

6268#ifdef INSPECTION

6369inspect $ hasNoTypeClasses 'copyCodecUtf8ArraysLenient

@@ -68,7 +74,7 @@ o_1_space_decode_encode_chunked :: BenchEnv -> [Benchmark]

6874o_1_space_decode_encode_chunked env =

6975 [ bgroup "decode-encode/toChunks"

7076 [

71− mkBenchSmall "decodeEncodeUtf8Lenient" env $ \inH outH ->

77+ mkBenchSmall "encodeUtf8' . decodeUtf8Arrays" env $ \inH outH ->

7278 copyCodecUtf8ArraysLenient inH outH

7379 ]

7480 ]

@@ -77,63 +83,69 @@ o_1_space_decode_encode_chunked env =

7783-- copy with group/ungroup transformations

7884-------------------------------------------------------------------------------

7985

86+{-# INLINE splitOnSuffix #-}

87+splitOnSuffix

88+ :: (Monad m)

89+ => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b

90+splitOnSuffix predicate f = Stream.foldMany (Fold.takeEndBy_ predicate f)

91+

8092{-# NOINLINE linesUnlinesCopy #-}

8193linesUnlinesCopy :: Handle -> Handle -> IO ()

8294linesUnlinesCopy inh outh =

83− S.fold (FH.write outh)

84− $ SS.encodeLatin1'

85− $ IUS.unlines IUF.fromList

86− $ S.splitOnSuffix (== '\n') FL.toList

87− $ SS.decodeLatin1

88− $ S.unfold FH.read inh

95+ Stream.fold (Handle.write outh)

96+ $ Unicode.encodeLatin1'

97+ $ Unicode.unlines Unfold.fromList

98+ $ splitOnSuffix (== '\n') Fold.toList

99+ $ Unicode.decodeLatin1

100+ $ Stream.unfold Handle.reader inh

89101

90102{-# NOINLINE linesUnlinesArrayWord8Copy #-}

91103linesUnlinesArrayWord8Copy :: Handle -> Handle -> IO ()

92104linesUnlinesArrayWord8Copy inh outh =

93− S.fold (FH.write outh)

94− $ IP.interposeSuffix 10 A.read

95− $ S.splitOnSuffix (== 10) A.write

96− $ S.unfold FH.read inh

105+ Stream.fold (Handle.write outh)

106+ $ Stream.interposeSuffix 10 Array.reader

107+ $ splitOnSuffix (== 10) Array.write

108+ $ Stream.unfold Handle.reader inh

97109

98110-- XXX splitSuffixOn requires -funfolding-use-threshold=150 for better fusion

99111-- | Lines and unlines

100112{-# NOINLINE linesUnlinesArrayCharCopy #-}

101113linesUnlinesArrayCharCopy :: Handle -> Handle -> IO ()

102114linesUnlinesArrayCharCopy inh outh =

103− S.fold (FH.write outh)

104− $ SS.encodeLatin1'

105− $ IUA.unlines

106− $ IUA.lines

107− $ SS.decodeLatin1

108− $ S.unfold FH.read inh

115+ Stream.fold (Handle.write outh)

116+ $ Unicode.encodeLatin1'

117+ $ UnicodeArr.unlines

118+ $ UnicodeArr.lines

119+ $ Unicode.decodeLatin1

120+ $ Stream.unfold Handle.reader inh

109121

110122#ifdef INSPECTION

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

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

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

113125#endif

114126

115−-- XXX to write this we need to be able to map decodeUtf8 on the A.read fold.

127+-- XXX to write this we need to be able to map decodeUtf8 on the Array.read fold.

116128-- For that we have to write decodeUtf8 as a Pipe.

117129{-

118130{-# INLINE linesUnlinesArrayUtf8Copy #-}

119131linesUnlinesArrayUtf8Copy :: Handle -> Handle -> IO ()

120132linesUnlinesArrayUtf8Copy inh outh =

121− S.fold (FH.write outh)

122− $ SS.encodeLatin1'

123− $ IP.intercalate (A.fromList [10]) (pipe SS.decodeUtf8P A.read)

124− $ S.splitOnSuffix (== '\n') (IFL.map SS.encodeUtf8' A.write)

125− $ SS.decodeLatin1

126− $ S.unfold FH.read inh

133+ Stream.fold (Handle.write outh)

134+ $ Unicode.encodeLatin1'

135+ $ Stream.intercalate (Array.fromList [10]) (pipe Unicode.decodeUtf8P Array.read)

136+ $ Stream.splitOnSuffix (== '\n') (IFold.map Unicode.encodeUtf8' Array.write)

137+ $ Unicode.decodeLatin1

138+ $ Stream.unfold Handle.read inh

127139-}

128140

129141-- | Word, unwords and copy

130142{-# NOINLINE wordsUnwordsCopyWord8 #-}

131143wordsUnwordsCopyWord8 :: Handle -> Handle -> IO ()

132144wordsUnwordsCopyWord8 inh outh =

133− S.fold (FH.write outh)

134− $ IP.interposeSuffix 32 IUF.fromList

135− $ S.wordsBy isSp FL.toList

136− $ S.unfold FH.read inh

145+ Stream.fold (Handle.write outh)

146+ $ Stream.interposeSuffix 32 Unfold.fromList

147+ $ Stream.wordsBy isSp Fold.toList

148+ $ Stream.unfold Handle.reader inh

137149

138150#ifdef INSPECTION

139151inspect $ hasNoTypeClasses 'wordsUnwordsCopyWord8

@@ -144,9 +156,9 @@ inspect $ hasNoTypeClasses 'wordsUnwordsCopyWord8

144156{-# NOINLINE wordsUnwordsCopy #-}

145157wordsUnwordsCopy :: Handle -> Handle -> IO ()

146158wordsUnwordsCopy inh outh =

147− S.fold (FH.write outh)

148− $ SS.encodeLatin1'

149− $ IUS.unwords IUF.fromList

159+ Stream.fold (Handle.write outh)

160+ $ Unicode.encodeLatin1'

161+ $ Unicode.unwords Unfold.fromList

150162 -- XXX This pipeline does not fuse with wordsBy but fuses with splitOn

151163 -- with -funfolding-use-threshold=300. With wordsBy it does not fuse

152164 -- even with high limits for inlining and spec-constr ghc options. With

@@ -154,10 +166,10 @@ wordsUnwordsCopy inh outh =

154166 -- is no evidence in the core that a join point involving Step

155167 -- constructors is not getting inlined. Not being able to fuse at all in

156168 -- this case could be an unknown issue, need more investigation.

157− $ S.wordsBy isSpace FL.toList

158− -- -- $ S.splitOn isSpace FL.toList

159− $ SS.decodeLatin1

160− $ S.unfold FH.read inh

169+ $ Stream.wordsBy isSpace Fold.toList

170+ -- -- $ Stream.splitOn isSpace Fold.toList

171+ $ Unicode.decodeLatin1

172+ $ Stream.unfold Handle.reader inh

161173

162174#ifdef INSPECTION

163175-- inspect $ hasNoTypeClasses 'wordsUnwordsCopy

@@ -167,28 +179,28 @@ wordsUnwordsCopy inh outh =

167179{-# NOINLINE wordsUnwordsCharArrayCopy #-}

168180wordsUnwordsCharArrayCopy :: Handle -> Handle -> IO ()

169181wordsUnwordsCharArrayCopy inh outh =

170− S.fold (FH.write outh)

171− $ SS.encodeLatin1'

172− $ IUA.unwords

173− $ IUA.words

174− $ SS.decodeLatin1

175− $ S.unfold FH.read inh

182+ Stream.fold (Handle.write outh)

183+ $ Unicode.encodeLatin1'

184+ $ UnicodeArr.unwords

185+ $ UnicodeArr.words

186+ $ Unicode.decodeLatin1

187+ $ Stream.unfold Handle.reader inh

176188

177189o_1_space_copy_read_group_ungroup :: BenchEnv -> [Benchmark]

178190o_1_space_copy_read_group_ungroup env =

179191 [ bgroup "ungroup-group"

180− [ mkBenchSmall "US.unlines . S.splitOnSuffix ([Word8])" env

192+ [ mkBenchSmall "unlines . splitOnSuffix ([Word8])" env

181193 $ \inh outh -> linesUnlinesCopy inh outh

182− , mkBenchSmall "S.interposeSuffix . S.splitOnSuffix(Array Word8)" env

194+ , mkBenchSmall "interposeSuffix . splitOnSuffix (Array Word8)" env

183195 $ \inh outh -> linesUnlinesArrayWord8Copy inh outh

184− , mkBenchSmall "UA.unlines . UA.lines (Array Char)" env

196+ , mkBenchSmall "UnicodeArr.unlines . UnicodeArr.lines (Array Char)" env

185197 $ \inh outh -> linesUnlinesArrayCharCopy inh outh

186198

187− , mkBenchSmall "S.interposeSuffix . S.wordsBy ([Word8])" env

199+ , mkBenchSmall "interposeSuffix . wordsBy ([Word8])" env

188200 $ \inh outh -> wordsUnwordsCopyWord8 inh outh

189− , mkBenchSmall "US.unwords . S.wordsBy ([Char])" env

201+ , mkBenchSmall "unwords . wordsBy ([Char])" env

190202 $ \inh outh -> wordsUnwordsCopy inh outh

191− , mkBenchSmall "UA.unwords . UA.words (Array Char)" env

203+ , mkBenchSmall "UnicodeArr.unwords . UnicodeArr.words (Array Char)" env

192204 $ \inh outh -> wordsUnwordsCharArrayCopy inh outh

193205 ]

194206 ]

@@ -201,55 +213,55 @@ o_1_space_copy_read_group_ungroup env =

201213{-# NOINLINE copyStreamLatin1' #-}

202214copyStreamLatin1' :: Handle -> Handle -> IO ()

203215copyStreamLatin1' inh outh =

204− S.fold (FH.write outh)

205− $ SS.encodeLatin1'

206− $ SS.decodeLatin1

207− $ S.unfold FH.read inh

216+ Stream.fold (Handle.write outh)

217+ $ Unicode.encodeLatin1'

218+ $ Unicode.decodeLatin1

219+ $ Stream.unfold Handle.reader inh

208220

209221#ifdef INSPECTION

210222inspect $ hasNoTypeClasses 'copyStreamLatin1'

211223inspect $ 'copyStreamLatin1' `hasNoType` ''Step

212−inspect $ 'copyStreamLatin1' `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

213−inspect $ 'copyStreamLatin1' `hasNoType` ''MA.ReadUState -- FH.read/A.read

224+inspect $ 'copyStreamLatin1' `hasNoType` ''Unfold.ConcatState -- Handle.read/UF.many

214225

215226inspect $ 'copyStreamLatin1' `hasNoType` ''Fold.Step

216−inspect $ 'copyStreamLatin1' `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe

217−inspect $ 'copyStreamLatin1' `hasNoType` ''Strict.Tuple3' -- FH.write/chunksOf

227+inspect $ 'copyStreamLatin1' `hasNoType` ''MutArray.ArrayUnsafe -- Handle.write/writeNUnsafe

228+ -- Handle.read/Array.read

229+inspect $ 'copyStreamLatin1' `hasNoType` ''Strict.Tuple3' -- Handle.write/chunksOf

218230#endif

219231

220232-- | Copy file (encodeLatin1)

221233{-# NOINLINE copyStreamLatin1 #-}

222234copyStreamLatin1 :: Handle -> Handle -> IO ()

223235copyStreamLatin1 inh outh =

224− S.fold (FH.write outh)

225− $ SS.encodeLatin1

226− $ SS.decodeLatin1

227− $ S.unfold FH.read inh

236+ Stream.fold (Handle.write outh)

237+ $ Unicode.encodeLatin1

238+ $ Unicode.decodeLatin1

239+ $ Stream.unfold Handle.reader inh

228240

229241#ifdef INSPECTION

230242inspect $ hasNoTypeClasses 'copyStreamLatin1

231243inspect $ 'copyStreamLatin1 `hasNoType` ''Step

232−inspect $ 'copyStreamLatin1 `hasNoType` ''IUF.ConcatState -- FH.read/UF.many

233−inspect $ 'copyStreamLatin1 `hasNoType` ''MA.ReadUState -- FH.read/A.read

244+inspect $ 'copyStreamLatin1 `hasNoType` ''Unfold.ConcatState -- Handle.read/UF.many

234245

235246inspect $ 'copyStreamLatin1 `hasNoType` ''Fold.ManyState

236247inspect $ 'copyStreamLatin1 `hasNoType` ''Fold.Step

237−inspect $ 'copyStreamLatin1 `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe

238−inspect $ 'copyStreamLatin1 `hasNoType` ''Strict.Tuple3' -- FH.write/chunksOf

248+inspect $ 'copyStreamLatin1 `hasNoType` ''MutArray.ArrayUnsafe -- Handle.write/writeNUnsafe

249+ -- Handle.read/Array.read

250+inspect $ 'copyStreamLatin1 `hasNoType` ''Strict.Tuple3' -- Handle.write/chunksOf

239251#endif

240252

241253-- | Copy file

242254_copyStreamUtf8' :: Handle -> Handle -> IO ()

243255_copyStreamUtf8' inh outh =

244− S.fold (FH.write outh)

245− $ SS.encodeUtf8'

246− $ SS.decodeUtf8'

247− $ S.unfold FH.read inh

256+ Stream.fold (Handle.write outh)

257+ $ Unicode.encodeUtf8'

258+ $ Unicode.decodeUtf8'

259+ $ Stream.unfold Handle.reader inh

248260

249261#ifdef INSPECTION

250262inspect $ hasNoTypeClasses '_copyStreamUtf8'

251263-- inspect $ '_copyStreamUtf8 `hasNoType` ''Step

252−-- inspect $ '_copyStreamUtf8 `hasNoType` ''AT.FlattenState

264+-- inspect $ '_copyStreamUtf8 `hasNoType` ''Array.FlattenState

253265-- inspect $ '_copyStreamUtf8 `hasNoType` ''D.ConcatMapUState

254266#endif

255267

@@ -257,48 +269,81 @@ inspect $ hasNoTypeClasses '_copyStreamUtf8'

257269{-# NOINLINE copyStreamUtf8 #-}

258270copyStreamUtf8 :: Handle -> Handle -> IO ()

259271copyStreamUtf8 inh outh =

260− S.fold (FH.write outh)

261− $ SS.encodeUtf8

262− $ SS.decodeUtf8

263− $ S.unfold FH.read inh

272+ Stream.fold (Handle.write outh)

273+ $ Unicode.encodeUtf8

274+ $ Unicode.decodeUtf8

275+ $ Stream.unfold Handle.reader inh

264276

265277#ifdef INSPECTION

266278inspect $ hasNoTypeClasses 'copyStreamUtf8

267279-- inspect $ 'copyStreamUtf8Lax `hasNoType` ''Step

268−-- inspect $ 'copyStreamUtf8Lax `hasNoType` ''AT.FlattenState

280+-- inspect $ 'copyStreamUtf8Lax `hasNoType` ''Array.FlattenState

269281-- inspect $ 'copyStreamUtf8Lax `hasNoType` ''D.ConcatMapUState

270282#endif

271283

284+{-# NOINLINE _copyStreamUtf8'Fold #-}

285+_copyStreamUtf8'Fold :: Handle -> Handle -> IO ()

286+_copyStreamUtf8'Fold inh outh =

287+ Stream.fold (Handle.write outh)

288+ $ Unicode.encodeUtf8

289+ $ Stream.catRights

290+ $ Stream.parseMany Unicode.writeCharUtf8'

291+ $ Stream.unfold Handle.reader inh

292+

293+{-# NOINLINE _copyStreamUtf8Parser #-}

294+_copyStreamUtf8Parser :: Handle -> Handle -> IO ()

295+_copyStreamUtf8Parser inh outh =

296+ Stream.fold (Handle.write outh)

297+ $ Unicode.encodeUtf8

298+ $ Stream.catRights $ Stream.parseMany

299+ (Unicode.parseCharUtf8With Unicode.TransliterateCodingFailure)

300+ $ Stream.unfold Handle.reader inh

301+

272302o_1_space_decode_encode_read :: BenchEnv -> [Benchmark]

273303o_1_space_decode_encode_read env =

274304 [ bgroup "decode-encode"

275305 [

276306 -- This needs an ascii file, as decode just errors out.

277− mkBench "SS.encodeLatin1' . SS.decodeLatin1" env $ \inh outh ->

307+ mkBench "encodeLatin1' . decodeLatin1" env $ \inh outh ->

278308 copyStreamLatin1' inh outh

279− , mkBench "SS.encodeLatin1 . SS.decodeLatin1" env $ \inh outh ->

309+ , mkBench "encodeLatin1 . decodeLatin1" env $ \inh outh ->

280310 copyStreamLatin1 inh outh

281−#ifdef DEVBUILD

282− , mkBench "copyUtf8" env $ \inh outh ->

311+#ifdef INCLUDE_STRICT_UTF8

312+ -- Requires valid unicode input

313+ , mkBench "encodeUtf8' . decodeUtf8'" env $ \inh outh ->

283314 _copyStreamUtf8' inh outh

315+ , mkBench "encodeUtf8' . foldMany writeCharUtf8'" env $ \inh outh ->

316+ _copyStreamUtf8'Fold inh outh

284317#endif

285− , mkBenchSmall "SS.encodeUtf8 . SS.decodeUtf8Lax" env $ \inh outh ->

318+ , mkBenchSmall "encodeUtf8 . parseMany parseCharUtf8" env

319+ $ \inh outh -> _copyStreamUtf8Parser inh outh

320+ , mkBenchSmall "encodeUtf8 . decodeUtf8" env $ \inh outh ->

286321 copyStreamUtf8 inh outh

287322 ]

288323 ]

289324

290325main :: IO ()

291326main = do

292− (_, cfg, benches) <- parseCLIOpts defaultStreamSize

327+#ifndef FUSION_CHECK

293328 env <- mkHandleBenchEnv

294− runMode (mode cfg) cfg benches (allBenchmarks env)

329+ defaultMain (allBenchmarks env)

295330

296331 where

297332

298333 allBenchmarks env =

299− [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat $

334+ [ bgroup (o_1_space_prefix moduleName) $ Prelude.concat

300335 [ o_1_space_copy_read_group_ungroup env

301336 , o_1_space_decode_encode_chunked env

302337 , o_1_space_decode_encode_read env

303338 ]

304339 ]

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.hsnew file+55

@@ -0,0 +1,55 @@

1+--

2+-- Module : Streamly.Unicode.Utf8

4+-- License : BSD-3-Clause

5+-- Maintainer : streamly@composewell.com

6+-- Stability : experimental

7+-- Portability : GHC

9+--------------------------------------------------------------------------------

10+-- Imports

11+--------------------------------------------------------------------------------

12+

13+import Data.Char (chr)

14+import Streamly.Internal.Unicode.Utf8 (Utf8)

15+

16+import Test.Tasty.Bench hiding (env)

17+import Streamly.Benchmark.Common

18+

19+import qualified Streamly.Internal.Unicode.Utf8 as Utf8

20+

21+--------------------------------------------------------------------------------

22+-- Utilities

23+--------------------------------------------------------------------------------

24+

25+moduleName :: String

26+moduleName = "Unicode.Stream"

27+

28+--------------------------------------------------------------------------------

29+-- Benchmarks

30+--------------------------------------------------------------------------------

31+

32+{-# INLINE pack #-}

33+pack :: Int -> Utf8

34+pack i = Utf8.pack $ chr <$> [1 .. i]

35+

36+{-# INLINE packUnpack #-}

37+packUnpack :: Int -> String

38+packUnpack = Utf8.unpack . pack

39+

40+--------------------------------------------------------------------------------

41+-- Main function

42+--------------------------------------------------------------------------------

43+

44+main :: IO ()

45+main = runWithCLIOpts defaultStreamSize allBenchmarks

46+

47+ where

48+

49+ allBenchmarks value =

50+ [ bgroup

51+ moduleName

52+ [ bench "pack" $ whnf pack value

53+ , bench "pack + unpack" $ whnf packUnpack value

54+ ]

55+ ]

benchmark/Streamly/Benchmark/Unicode/data/AllChars.txtnew file+216

@@ -0,0 +1,216 @@

1+This page contains characters from each of the Unicode character blocks.

3+Basic Latin

4+! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~

5+Latin-1 Supplement

6+ ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ

7+Latin Extended-A

8+Ā ā Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď Đ đ Ē ē Ĕ ĕ Ė ė Ę ę Ě ě Ĝ ĝ Ğ ğ Ġ ġ Ģ ģ Ĥ ĥ Ħ ħ Ĩ ĩ Ī ī Ĭ ĭ Į į İ ı Ĳ ĳ Ĵ ĵ Ķ ķ ĸ Ĺ ĺ Ļ ļ Ľ ľ Ŀ ŀ Ł ł Ń ń Ņ ņ Ň ň ŉ Ŋ ŋ Ō ō Ŏ ŏ Ő ő Œ œ Ŕ ŕ Ŗ ŗ Ř ř Ś ś Ŝ ŝ Ş ş Š š Ţ ţ Ť ť Ŧ ŧ Ũ ũ Ū ū Ŭ ŭ Ů ů Ű ű Ų ų Ŵ ŵ Ŷ ŷ Ÿ Ź ź Ż ż Ž ž ſ

9+Latin Extended-B

10+ƀ Ɓ Ƃ ƃ Ƅ ƅ Ɔ Ƈ ƈ Ɖ Ɗ Ƌ ƌ ƍ Ǝ Ə Ɛ Ƒ ƒ Ɠ Ɣ ƕ Ɩ Ɨ Ƙ ƙ ƚ ƛ Ɯ Ɲ ƞ Ɵ Ơ ơ Ƣ ƣ Ƥ ƥ Ʀ Ƨ ƨ Ʃ ƪ ƫ Ƭ ƭ Ʈ Ư ư Ʊ Ʋ Ƴ ƴ Ƶ ƶ Ʒ Ƹ ƹ ƺ ƻ Ƽ ƽ ƾ ƿ ǀ ǁ ǂ ǃ Ǆ ǅ ǆ Ǉ ǈ ǉ Ǌ ǋ ǌ Ǎ ǎ Ǐ ǐ Ǒ ǒ Ǔ ǔ Ǖ ǖ Ǘ ǘ Ǚ ǚ Ǜ ǜ ǝ Ǟ ǟ Ǡ ǡ Ǣ ǣ Ǥ ǥ Ǧ ǧ Ǩ ǩ Ǫ ǫ Ǭ ǭ Ǯ ǯ ǰ Ǳ ǲ ǳ Ǵ ǵ Ƕ Ƿ Ǹ ǹ Ǻ ǻ Ǽ ǽ Ǿ ǿ ...

11+IPA Extensions

12+ɐ ɑ ɒ ɓ ɔ ɕ ɖ ɗ ɘ ə ɚ ɛ ɜ ɝ ɞ ɟ ɠ ɡ ɢ ɣ ɤ ɥ ɦ ɧ ɨ ɩ ɪ ɫ ɬ ɭ ɮ ɯ ɰ ɱ ɲ ɳ ɴ ɵ ɶ ɷ ɸ ɹ ɺ ɻ ɼ ɽ ɾ ɿ ʀ ʁ ʂ ʃ ʄ ʅ ʆ ʇ ʈ ʉ ʊ ʋ ʌ ʍ ʎ ʏ ʐ ʑ ʒ ʓ ʔ ʕ ʖ ʗ ʘ ʙ ʚ ʛ ʜ ʝ ʞ ʟ ʠ ʡ ʢ ʣ ʤ ʥ ʦ ʧ ʨ ʩ ʪ ʫ ʬ ʭ

13+Spacing Modifier Letters

14+ʰ ʱ ʲ ʳ ʴ ʵ ʶ ʷ ʸ ʹ ʺ ʻ ʼ ʽ ʾ ʿ ˀ ˁ ˂ ˃ ˄ ˅ ˆ ˇ ˈ ˉ ˊ ˋ ˌ ˍ ˎ ˏ ː ˑ ˒ ˓ ˔ ˕ ˖ ˗ ˘ ˙ ˚ ˛ ˜ ˝ ˞ ˟ ˠ ˡ ˢ ˣ ˤ ˥ ˦ ˧ ˨ ˩ ˪ ˫ ˬ ˭ ˮ

15+Combining Diacritical Marks

16+̀ ́ ̂ ̃ ̄ ̅ ̆ ̇ ̈ ̉ ̊ ̋ ̌ ̍ ̎ ̏ ̐ ̑ ̒ ̓ ̔ ̕ ̖ ̗ ̘ ̙ ̚ ̛ ̜ ̝ ̞ ̟ ̠ ̡ ̢ ̣ ̤ ̥ ̦ ̧ ̨ ̩ ̪ ̫ ̬ ̭ ̮ ̯ ̰ ̱ ̲ ̳ ̴ ̵ ̶ ̷ ̸ ̹ ̺ ̻ ̼ ̽ ̾ ̿ ̀ ́ ͂ ̓ ̈́ ͅ ͆ ͇ ͈ ͉ ͊ ͋ ͌ ͍ ͎ ͏ ͠ ͡ ͢ ͣ ͤ ͥ ͦ ͧ ͨ ͩ ͪ ͫ ͬ ͭ ͮ ͯ

17+Greek and Coptic

18+ʹ ͵ ͺ ; ΄ ΅ Ά · Έ Ή Ί Ό Ύ Ώ ΐ Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω Ϊ Ϋ ά έ ή ί ΰ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω ϊ ϋ ό ύ ώ ϐ ϑ ϒ ϓ ϔ ϕ ϖ ϗ Ϙ ϙ Ϛ ϛ Ϝ ϝ Ϟ ϟ Ϡ ϡ Ϣ ϣ Ϥ ϥ Ϧ ϧ Ϩ ϩ Ϫ ϫ Ϭ ϭ Ϯ ϯ ϰ ϱ ϲ ϳ ϴ ϵ ϶

19+Cyrillic

20+Ѐ Ё Ђ Ѓ Є Ѕ І Ї Ј Љ Њ Ћ Ќ Ѝ Ў Џ А Б В Г Д Е Ж З И Й К Л М Н О П Р С Т У Ф Х Ц Ч Ш Щ Ъ Ы Ь Э Ю Я а б в г д е ж з и й к л м н о п р с т у ф х ц ч ш щ ъ ы ь э ю я ѐ ё ђ ѓ є ѕ і ї ј љ њ ћ ќ ѝ ў џ Ѡ ѡ Ѣ ѣ Ѥ ѥ Ѧ ѧ Ѩ ѩ Ѫ ѫ Ѭ ѭ Ѯ ѯ Ѱ ѱ Ѳ ѳ Ѵ ѵ Ѷ ѷ Ѹ ѹ Ѻ ѻ Ѽ ѽ Ѿ ѿ ...

21+Cyrillic Supplementary

22+Ԁ ԁ Ԃ ԃ Ԅ ԅ Ԇ ԇ Ԉ ԉ Ԋ ԋ Ԍ ԍ Ԏ ԏ

23+Armenian

24+Ա Բ Գ Դ Ե Զ Է Ը Թ Ժ Ի Լ Խ Ծ Կ Հ Ձ Ղ Ճ Մ Յ Ն Շ Ո Չ Պ Ջ Ռ Ս Վ Տ Ր Ց Ւ Փ Ք Օ Ֆ ՙ ՚ ՛ ՜ ՝ ՞ ՟ ա բ գ դ ե զ է ը թ ժ ի լ խ ծ կ հ ձ ղ ճ մ յ ն շ ո չ պ ջ ռ ս վ տ ր ց ւ փ ք օ ֆ և ։ ֊

25+Hebrew

26+֑ ֒ ֓ ֔ ֕ ֖ ֗ ֘ ֙ ֚ ֛ ֜ ֝ ֞ ֟ ֠ ֡ ֣ ֤ ֥ ֦ ֧ ֨ ֩ ֪ ֫ ֬ ֭ ֮ ֯ ְ ֱ ֲ ֳ ִ ֵ ֶ ַ ָ ֹ ֻ ּ ֽ ־ ֿ ׀ ׁ ׂ ׃ ׄ א ב ג ד ה ו ז ח ט י ך כ ל ם מ ן נ ס ע ף פ ץ צ ק ר ש ת װ ױ ײ ׳ ״

27+Arabic

28+، ؛ ؟ ء آ أ ؤ إ ئ ا ب ة ت ث ج ح خ د ذ ر ز س ش ص ض ط ظ ع غ ـ ف ق ك ل م ن ه و ى ي ً ٌ ٍ َ ُ ِ ّ ْ ٓ ٔ ٕ ٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩ ٪ ٫ ٬ ٭ ٮ ٯ ٰ ٱ ٲ ٳ ٴ ٵ ٶ ٷ ٸ ٹ ٺ ٻ ټ ٽ پ ٿ ڀ ځ ڂ ڃ ڄ څ چ ڇ ڈ ډ ڊ ڋ ڌ ڍ ڎ ڏ ڐ ڑ ڒ ړ ڔ ڕ ږ ڗ ژ ڙ ښ ڛ ڜ ڝ ڞ ڟ ڠ ڡ ڢ ڣ ڤ ڥ ڦ ڧ ڨ ک ڪ ګ ڬ ...

29+Syriac

30+܀ ܁ ܂ ܃ ܄ ܅ ܆ ܇ ܈ ܉ ܊ ܋ ܌ ܍ ܏ ܐ ܑ ܒ ܓ ܔ ܕ ܖ ܗ ܘ ܙ ܚ ܛ ܜ ܝ ܞ ܟ ܠ ܡ ܢ ܣ ܤ ܥ ܦ ܧ ܨ ܩ ܪ ܫ ܬ ܰ ܱ ܲ ܳ ܴ ܵ ܶ ܷ ܸ ܹ ܺ ܻ ܼ ܽ ܾ ܿ ݀ ݁ ݂ ݃ ݄ ݅ ݆ ݇ ݈ ݉ ݊

31+Thaana

32+ހ ށ ނ ރ ބ ޅ ކ އ ވ މ ފ ދ ތ ލ ގ ޏ ސ ޑ ޒ ޓ ޔ ޕ ޖ ޗ ޘ ޙ ޚ ޛ ޜ ޝ ޞ ޟ ޠ ޡ ޢ ޣ ޤ ޥ ަ ާ ި ީ ު ޫ ެ ޭ ޮ ޯ ް ޱ

33+Devanagari

34+ँ ं ः अ आ इ ई उ ऊ ऋ ऌ ऍ ऎ ए ऐ ऑ ऒ ओ औ क ख ग घ ङ च छ ज झ ञ ट ठ ड ढ ण त थ द ध न ऩ प फ ब भ म य र ऱ ल ळ ऴ व श ष स ह ़ ऽ ा ि ी ु ू ृ ॄ ॅ ॆ े ै ॉ ॊ ो ौ ् ॐ ॑ ॒ ॓ ॔ क़ ख़ ग़ ज़ ड़ ढ़ फ़ य़ ॠ ॡ ॢ ॣ । ॥ ० १ २ ३ ४ ५ ६ ७ ८ ९ ॰

35+Bengali

36+ঁ ং ঃ অ আ ই ঈ উ ঊ ঋ ঌ এ ঐ ও ঔ ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য র ল শ ষ স হ ় া ি ী ু ূ ৃ ৄ ে ৈ ো ৌ ্ ৗ ড় ঢ় য় ৠ ৡ ৢ ৣ ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯ ৰ ৱ ৲ ৳ ৴ ৵ ৶ ৷ ৸ ৹ ৺

37+Gurmukhi

38+ਂ ਅ ਆ ਇ ਈ ਉ ਊ ਏ ਐ ਓ ਔ ਕ ਖ ਗ ਘ ਙ ਚ ਛ ਜ ਝ ਞ ਟ ਠ ਡ ਢ ਣ ਤ ਥ ਦ ਧ ਨ ਪ ਫ ਬ ਭ ਮ ਯ ਰ ਲ ਲ਼ ਵ ਸ਼ ਸ ਹ ਼ ਾ ਿ ੀ ੁ ੂ ੇ ੈ ੋ ੌ ੍ ਖ਼ ਗ਼ ਜ਼ ੜ ਫ਼ ੦ ੧ ੨ ੩ ੪ ੫ ੬ ੭ ੮ ੯ ੰ ੱ ੲ ੳ ੴ

39+Gujarati

40+ઁ ં ઃ અ આ ઇ ઈ ઉ ઊ ઋ ઍ એ ઐ ઑ ઓ ઔ ક ખ ગ ઘ ઙ ચ છ જ ઝ ઞ ટ ઠ ડ ઢ ણ ત થ દ ધ ન પ ફ બ ભ મ ય ર લ ળ વ શ ષ સ હ ઼ ઽ ા િ ી ુ ૂ ૃ ૄ ૅ ે ૈ ૉ ો ૌ ્ ૐ ૠ ૦ ૧ ૨ ૩ ૪ ૫ ૬ ૭ ૮ ૯

41+Oriya

42+ଁ ଂ ଃ ଅ ଆ ଇ ଈ ଉ ଊ ଋ ଌ ଏ ଐ ଓ ଔ କ ଖ ଗ ଘ ଙ ଚ ଛ ଜ ଝ ଞ ଟ ଠ ଡ ଢ ଣ ତ ଥ ଦ ଧ ନ ପ ଫ ବ ଭ ମ ଯ ର ଲ ଳ ଶ ଷ ସ ହ ଼ ଽ ା ି ୀ ୁ ୂ ୃ େ ୈ ୋ ୌ ୍ ୖ ୗ ଡ଼ ଢ଼ ୟ ୠ ୡ ୦ ୧ ୨ ୩ ୪ ୫ ୬ ୭ ୮ ୯ ୰

43+Tamil

44+ஂ ஃ அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ க ங ச ஜ ஞ ட ண த ந ன ப ம ய ர ற ல ள ழ வ ஷ ஸ ஹ ா ி ீ ு ூ ெ ே ை ொ ோ ௌ ் ௗ ௧ ௨ ௩ ௪ ௫ ௬ ௭ ௮ ௯ ௰ ௱ ௲

45+Telugu

46+ఁ ం ః అ ఆ ఇ ఈ ఉ ఊ ఋ ఌ ఎ ఏ ఐ ఒ ఓ ఔ క ఖ గ ఘ ఙ చ ఛ జ ఝ ఞ ట ఠ డ ఢ ణ త థ ద ధ న ప ఫ బ భ మ య ర ఱ ల ళ వ శ ష స హ ా ి ీ ు ూ ృ ౄ ె ే ై ొ ో ౌ ్ ౕ ౖ ౠ ౡ ౦ ౧ ౨ ౩ ౪ ౫ ౬ ౭ ౮ ౯

47+Kannada

48+ಂ ಃ ಅ ಆ ಇ ಈ ಉ ಊ ಋ ಌ ಎ ಏ ಐ ಒ ಓ ಔ ಕ ಖ ಗ ಘ ಙ ಚ ಛ ಜ ಝ ಞ ಟ ಠ ಡ ಢ ಣ ತ ಥ ದ ಧ ನ ಪ ಫ ಬ ಭ ಮ ಯ ರ ಱ ಲ ಳ ವ ಶ ಷ ಸ ಹ ಾ ಿ ೀ ು ೂ ೃ ೄ ೆ ೇ ೈ ೊ ೋ ೌ ್ ೕ ೖ ೞ ೠ ೡ ೦ ೧ ೨ ೩ ೪ ೫ ೬ ೭ ೮ ೯

49+Malayalam

50+ം ഃ അ ആ ഇ ഈ ഉ ഊ ഋ ഌ എ ഏ ഐ ഒ ഓ ഔ ക ഖ ഗ ഘ ങ ച ഛ ജ ഝ ഞ ട ഠ ഡ ഢ ണ ത ഥ ദ ധ ന പ ഫ ബ ഭ മ യ ര റ ല ള ഴ വ ശ ഷ സ ഹ ാ ി ീ ു ൂ ൃ െ േ ൈ ൊ ോ ൌ ് ൗ ൠ ൡ ൦ ൧ ൨ ൩ ൪ ൫ ൬ ൭ ൮ ൯

51+Sinhala

52+ං ඃ අ ආ ඇ ඈ ඉ ඊ උ ඌ ඍ ඎ ඏ ඐ එ ඒ ඓ ඔ ඕ ඖ ක ඛ ග ඝ ඞ ඟ ච ඡ ජ ඣ ඤ ඥ ඦ ට ඨ ඩ ඪ ණ ඬ ත ථ ද ධ න ඳ ප ඵ බ භ ම ඹ ය ර ල ව ශ ෂ ස හ ළ ෆ ් ා ැ ෑ ි ී ු ූ ෘ ෙ ේ ෛ ො ෝ ෞ ෟ ෲ ෳ ෴

53+Thai

54+ก ข ฃ ค ฅ ฆ ง จ ฉ ช ซ ฌ ญ ฎ ฏ ฐ ฑ ฒ ณ ด ต ถ ท ธ น บ ป ผ ฝ พ ฟ ภ ม ย ร ฤ ล ฦ ว ศ ษ ส ห ฬ อ ฮ ฯ ะ ั า ำ ิ ี ึ ื ุ ู ฺ ฿ เ แ โ ใ ไ ๅ ๆ ็ ่ ้ ๊ ๋ ์ ํ ๎ ๏ ๐ ๑ ๒ ๓ ๔ ๕ ๖ ๗ ๘ ๙ ๚ ๛

55+Lao

56+ກ ຂ ຄ ງ ຈ ຊ ຍ ດ ຕ ຖ ທ ນ ບ ປ ຜ ຝ ພ ຟ ມ ຢ ຣ ລ ວ ສ ຫ ອ ຮ ຯ ະ ັ າ ຳ ິ ີ ຶ ື ຸ ູ ົ ຼ ຽ ເ ແ ໂ ໃ ໄ ໆ ່ ້ ໊ ໋ ໌ ໍ ໐ ໑ ໒ ໓ ໔ ໕ ໖ ໗ ໘ ໙ ໜ ໝ

57+Tibetan

58+ༀ ༁ ༂ ༃ ༄ ༅ ༆ ༇ ༈ ༉ ༊ ་ ༌ ། ༎ ༏ ༐ ༑ ༒ ༓ ༔ ༕ ༖ ༗ ༘ ༙ ༚ ༛ ༜ ༝ ༞ ༟ ༠ ༡ ༢ ༣ ༤ ༥ ༦ ༧ ༨ ༩ ༪ ༫ ༬ ༭ ༮ ༯ ༰ ༱ ༲ ༳ ༴ ༵ ༶ ༷ ༸ ༹ ༺ ༻ ༼ ༽ ༾ ༿ ཀ ཁ ག གྷ ང ཅ ཆ ཇ ཉ ཊ ཋ ཌ ཌྷ ཎ ཏ ཐ ད དྷ ན པ ཕ བ བྷ མ ཙ ཚ ཛ ཛྷ ཝ ཞ ཟ འ ཡ ར ལ ཤ ཥ ས ཧ ཨ ཀྵ ཪ ཱ ི ཱི ུ ཱུ ྲྀ ཷ ླྀ ཹ ེ ཻ ོ ཽ ཾ ཿ ྀ ཱྀ ྂ ྃ ྄ ྅ ྆ ...

59+Myanmar

60+က ခ ဂ ဃ င စ ဆ ဇ ဈ ဉ ည ဋ ဌ ဍ ဎ ဏ တ ထ ဒ ဓ န ပ ဖ ဗ ဘ မ ယ ရ လ ဝ သ ဟ ဠ အ ဣ ဤ ဥ ဦ ဧ ဩ ဪ ာ ိ ီ ု ူ ေ ဲ ံ ့ း ္ ၀ ၁ ၂ ၃ ၄ ၅ ၆ ၇ ၈ ၉ ၊ ။ ၌ ၍ ၎ ၏ ၐ ၑ ၒ ၓ ၔ ၕ ၖ ၗ ၘ ၙ

61+Georgian

62+Ⴀ Ⴁ Ⴂ Ⴃ Ⴄ Ⴅ Ⴆ Ⴇ Ⴈ Ⴉ Ⴊ Ⴋ Ⴌ Ⴍ Ⴎ Ⴏ Ⴐ Ⴑ Ⴒ Ⴓ Ⴔ Ⴕ Ⴖ Ⴗ Ⴘ Ⴙ Ⴚ Ⴛ Ⴜ Ⴝ Ⴞ Ⴟ Ⴠ Ⴡ Ⴢ Ⴣ Ⴤ Ⴥ ა ბ გ დ ე ვ ზ თ ი კ ლ მ ნ ო პ ჟ რ ს ტ უ ფ ქ ღ ყ შ ჩ ც ძ წ ჭ ხ ჯ ჰ ჱ ჲ ჳ ჴ ჵ ჶ ჷ ჸ ჻

63+Hangul Jamo

64+ᄀ ᄁ ᄂ ᄃ ᄄ ᄅ ᄆ ᄇ ᄈ ᄉ ᄊ ᄋ ᄌ ᄍ ᄎ ᄏ ᄐ ᄑ ᄒ ᄓ ᄔ ᄕ ᄖ ᄗ ᄘ ᄙ ᄚ ᄛ ᄜ ᄝ ᄞ ᄟ ᄠ ᄡ ᄢ ᄣ ᄤ ᄥ ᄦ ᄧ ᄨ ᄩ ᄪ ᄫ ᄬ ᄭ ᄮ ᄯ ᄰ ᄱ ᄲ ᄳ ᄴ ᄵ ᄶ ᄷ ᄸ ᄹ ᄺ ᄻ ᄼ ᄽ ᄾ ᄿ ᅀ ᅁ ᅂ ᅃ ᅄ ᅅ ᅆ ᅇ ᅈ ᅉ ᅊ ᅋ ᅌ ᅍ ᅎ ᅏ ᅐ ᅑ ᅒ ᅓ ᅔ ᅕ ᅖ ᅗ ᅘ ᅙ ᅟ ᅠ ᅡ ᅢ ᅣ ᅤ ᅥ ᅦ ᅧ ᅨ ᅩ ᅪ ᅫ ᅬ ᅭ ᅮ ᅯ ᅰ ᅱ ᅲ ᅳ ᅴ ᅵ ᅶ ᅷ ᅸ ᅹ ᅺ ᅻ ᅼ ᅽ ᅾ ᅿ ᆀ ᆁ ᆂ ᆃ ᆄ ...

65+Ethiopic

66+ሀ ሁ ሂ ሃ ሄ ህ ሆ ለ ሉ ሊ ላ ሌ ል ሎ ሏ ሐ ሑ ሒ ሓ ሔ ሕ ሖ ሗ መ ሙ ሚ ማ ሜ ም ሞ ሟ ሠ ሡ ሢ ሣ ሤ ሥ ሦ ሧ ረ ሩ ሪ ራ ሬ ር ሮ ሯ ሰ ሱ ሲ ሳ ሴ ስ ሶ ሷ ሸ ሹ ሺ ሻ ሼ ሽ ሾ ሿ ቀ ቁ ቂ ቃ ቄ ቅ ቆ ቈ ቊ ቋ ቌ ቍ ቐ ቑ ቒ ቓ ቔ ቕ ቖ ቘ ቚ ቛ ቜ ቝ በ ቡ ቢ ባ ቤ ብ ቦ ቧ ቨ ቩ ቪ ቫ ቬ ቭ ቮ ቯ ተ ቱ ቲ ታ ቴ ት ቶ ቷ ቸ ቹ ቺ ቻ ቼ ች ቾ ቿ ኀ ኁ ኂ ኃ ኄ ኅ ኆ ኈ ኊ ...

67+Cherokee

68+Ꭰ Ꭱ Ꭲ Ꭳ Ꭴ Ꭵ Ꭶ Ꭷ Ꭸ Ꭹ Ꭺ Ꭻ Ꭼ Ꭽ Ꭾ Ꭿ Ꮀ Ꮁ Ꮂ Ꮃ Ꮄ Ꮅ Ꮆ Ꮇ Ꮈ Ꮉ Ꮊ Ꮋ Ꮌ Ꮍ Ꮎ Ꮏ Ꮐ Ꮑ Ꮒ Ꮓ Ꮔ Ꮕ Ꮖ Ꮗ Ꮘ Ꮙ Ꮚ Ꮛ Ꮜ Ꮝ Ꮞ Ꮟ Ꮠ Ꮡ Ꮢ Ꮣ Ꮤ Ꮥ Ꮦ Ꮧ Ꮨ Ꮩ Ꮪ Ꮫ Ꮬ Ꮭ Ꮮ Ꮯ Ꮰ Ꮱ Ꮲ Ꮳ Ꮴ Ꮵ Ꮶ Ꮷ Ꮸ Ꮹ Ꮺ Ꮻ Ꮼ Ꮽ Ꮾ Ꮿ Ᏸ Ᏹ Ᏺ Ᏻ Ᏼ

69+Unified Canadian Aboriginal Syllabics

70+ᐁ ᐂ ᐃ ᐄ ᐅ ᐆ ᐇ ᐈ ᐉ ᐊ ᐋ ᐌ ᐍ ᐎ ᐏ ᐐ ᐑ ᐒ ᐓ ᐔ ᐕ ᐖ ᐗ ᐘ ᐙ ᐚ ᐛ ᐜ ᐝ ᐞ ᐟ ᐠ ᐡ ᐢ ᐣ ᐤ ᐥ ᐦ ᐧ ᐨ ᐩ ᐪ ᐫ ᐬ ᐭ ᐮ ᐯ ᐰ ᐱ ᐲ ᐳ ᐴ ᐵ ᐶ ᐷ ᐸ ᐹ ᐺ ᐻ ᐼ ᐽ ᐾ ᐿ ᑀ ᑁ ᑂ ᑃ ᑄ ᑅ ᑆ ᑇ ᑈ ᑉ ᑊ ᑋ ᑌ ᑍ ᑎ ᑏ ᑐ ᑑ ᑒ ᑓ ᑔ ᑕ ᑖ ᑗ ᑘ ᑙ ᑚ ᑛ ᑜ ᑝ ᑞ ᑟ ᑠ ᑡ ᑢ ᑣ ᑤ ᑥ ᑦ ᑧ ᑨ ᑩ ᑪ ᑫ ᑬ ᑭ ᑮ ᑯ ᑰ ᑱ ᑲ ᑳ ᑴ ᑵ ᑶ ᑷ ᑸ ᑹ ᑺ ᑻ ᑼ ᑽ ᑾ ᑿ ᒀ ...

71+Ogham

72+  ᚁ ᚂ ᚃ ᚄ ᚅ ᚆ ᚇ ᚈ ᚉ ᚊ ᚋ ᚌ ᚍ ᚎ ᚏ ᚐ ᚑ ᚒ ᚓ ᚔ ᚕ ᚖ ᚗ ᚘ ᚙ ᚚ ᚛ ᚜

73+Runic

74+ᚠ ᚡ ᚢ ᚣ ᚤ ᚥ ᚦ ᚧ ᚨ ᚩ ᚪ ᚫ ᚬ ᚭ ᚮ ᚯ ᚰ ᚱ ᚲ ᚳ ᚴ ᚵ ᚶ ᚷ ᚸ ᚹ ᚺ ᚻ ᚼ ᚽ ᚾ ᚿ ᛀ ᛁ ᛂ ᛃ ᛄ ᛅ ᛆ ᛇ ᛈ ᛉ ᛊ ᛋ ᛌ ᛍ ᛎ ᛏ ᛐ ᛑ ᛒ ᛓ ᛔ ᛕ ᛖ ᛗ ᛘ ᛙ ᛚ ᛛ ᛜ ᛝ ᛞ ᛟ ᛠ ᛡ ᛢ ᛣ ᛤ ᛥ ᛦ ᛧ ᛨ ᛩ ᛪ ᛫ ᛬ ᛭ ᛮ ᛯ ᛰ

75+Tagalog

76+ᜀ ᜁ ᜂ ᜃ ᜄ ᜅ ᜆ ᜇ ᜈ ᜉ ᜊ ᜋ ᜌ ᜎ ᜏ ᜐ ᜑ ᜒ ᜓ ᜔

77+Hanunoo

78+ᜠ ᜡ ᜢ ᜣ ᜤ ᜥ ᜦ ᜧ ᜨ ᜩ ᜪ ᜫ ᜬ ᜭ ᜮ ᜯ ᜰ ᜱ ᜲ ᜳ ᜴ ᜵ ᜶

79+Buhid

80+ᝀ ᝁ ᝂ ᝃ ᝄ ᝅ ᝆ ᝇ ᝈ ᝉ ᝊ ᝋ ᝌ ᝍ ᝎ ᝏ ᝐ ᝑ ᝒ ᝓ

81+Tagbanwa

82+ᝠ ᝡ ᝢ ᝣ ᝤ ᝥ ᝦ ᝧ ᝨ ᝩ ᝪ ᝫ ᝬ ᝮ ᝯ ᝰ ᝲ ᝳ

83+Khmer

84+ក ខ គ ឃ ង ច ឆ ជ ឈ ញ ដ ឋ ឌ ឍ ណ ត ថ ទ ធ ន ប ផ ព ភ ម យ រ ល វ ឝ ឞ ស ហ ឡ អ ឣ ឤ ឥ ឦ ឧ ឨ ឩ ឪ ឫ ឬ ឭ ឮ ឯ ឰ ឱ ឲ ឳ ឴ ឵ ា ិ ី ឹ ឺ ុ ូ ួ ើ ឿ ៀ េ ែ ៃ ោ ៅ ំ ះ ៈ ៉ ៊ ់ ៌ ៍ ៎ ៏ ័ ៑ ្ ៓ ។ ៕ ៖ ៗ ៘ ៙ ៚ ៛ ៜ ០ ១ ២ ៣ ៤ ៥ ៦ ៧ ៨ ៩

85+Mongolian

86+᠀ ᠁ ᠂ ᠃ ᠄ ᠅ ᠆ ᠇ ᠈ ᠉ ᠊ ᠋ ᠌ ᠍ ᠎ ᠐ ᠑ ᠒ ᠓ ᠔ ᠕ ᠖ ᠗ ᠘ ᠙ ᠠ ᠡ ᠢ ᠣ ᠤ ᠥ ᠦ ᠧ ᠨ ᠩ ᠪ ᠫ ᠬ ᠭ ᠮ ᠯ ᠰ ᠱ ᠲ ᠳ ᠴ ᠵ ᠶ ᠷ ᠸ ᠹ ᠺ ᠻ ᠼ ᠽ ᠾ ᠿ ᡀ ᡁ ᡂ ᡃ ᡄ ᡅ ᡆ ᡇ ᡈ ᡉ ᡊ ᡋ ᡌ ᡍ ᡎ ᡏ ᡐ ᡑ ᡒ ᡓ ᡔ ᡕ ᡖ ᡗ ᡘ ᡙ ᡚ ᡛ ᡜ ᡝ ᡞ ᡟ ᡠ ᡡ ᡢ ᡣ ᡤ ᡥ ᡦ ᡧ ᡨ ᡩ ᡪ ᡫ ᡬ ᡭ ᡮ ᡯ ᡰ ᡱ ᡲ ᡳ ᡴ ᡵ ᡶ ᡷ ᢀ ᢁ ᢂ ᢃ ᢄ ᢅ ᢆ ᢇ ᢈ ᢉ ᢊ ᢋ ᢌ ᢍ ᢎ ...

87+Latin Extended Additional

88+Ḁ ḁ Ḃ ḃ Ḅ ḅ Ḇ ḇ Ḉ ḉ Ḋ ḋ Ḍ ḍ Ḏ ḏ Ḑ ḑ Ḓ ḓ Ḕ ḕ Ḗ ḗ Ḙ ḙ Ḛ ḛ Ḝ ḝ Ḟ ḟ Ḡ ḡ Ḣ ḣ Ḥ ḥ Ḧ ḧ Ḩ ḩ Ḫ ḫ Ḭ ḭ Ḯ ḯ Ḱ ḱ Ḳ ḳ Ḵ ḵ Ḷ ḷ Ḹ ḹ Ḻ ḻ Ḽ ḽ Ḿ ḿ Ṁ ṁ Ṃ ṃ Ṅ ṅ Ṇ ṇ Ṉ ṉ Ṋ ṋ Ṍ ṍ Ṏ ṏ Ṑ ṑ Ṓ ṓ Ṕ ṕ Ṗ ṗ Ṙ ṙ Ṛ ṛ Ṝ ṝ Ṟ ṟ Ṡ ṡ Ṣ ṣ Ṥ ṥ Ṧ ṧ Ṩ ṩ Ṫ ṫ Ṭ ṭ Ṯ ṯ Ṱ ṱ Ṳ ṳ Ṵ ṵ Ṷ ṷ Ṹ ṹ Ṻ ṻ Ṽ ṽ Ṿ ṿ ...

89+Greek Extended

90+ἀ ἁ ἂ ἃ ἄ ἅ ἆ ἇ Ἀ Ἁ Ἂ Ἃ Ἄ Ἅ Ἆ Ἇ ἐ ἑ ἒ ἓ ἔ ἕ Ἐ Ἑ Ἒ Ἓ Ἔ Ἕ ἠ ἡ ἢ ἣ ἤ ἥ ἦ ἧ Ἠ Ἡ Ἢ Ἣ Ἤ Ἥ Ἦ Ἧ ἰ ἱ ἲ ἳ ἴ ἵ ἶ ἷ Ἰ Ἱ Ἲ Ἳ Ἴ Ἵ Ἶ Ἷ ὀ ὁ ὂ ὃ ὄ ὅ Ὀ Ὁ Ὂ Ὃ Ὄ Ὅ ὐ ὑ ὒ ὓ ὔ ὕ ὖ ὗ Ὑ Ὓ Ὕ Ὗ ὠ ὡ ὢ ὣ ὤ ὥ ὦ ὧ Ὠ Ὡ Ὢ Ὣ Ὤ Ὥ Ὦ Ὧ ὰ ά ὲ έ ὴ ή ὶ ί ὸ ό ὺ ύ ὼ ώ ᾀ ᾁ ᾂ ᾃ ᾄ ᾅ ᾆ ᾇ ᾈ ᾉ ᾊ ᾋ ᾌ ᾍ ...

91+General Punctuation

92+ ‌ ‍ <U+200E> <U+200F> ‐ ‑ ‒ – — ― ‖ ‗ ‘ ’ ‚ ‛ “ ” „ ‟ † ‡ • ‣ ․ ‥ … ‧     <U+202A> <U+202B> <U+202C> <U+202D> <U+202E>   ‰ ‱ ′ ″ ‴ ‵ ‶ ‷ ‸ ‹ › ※ ‼ ‽ ‾ ‿ ⁀ ⁁ ⁂ ⁃ ⁄ ⁅ ⁆ ⁇ ⁈ ⁉ ⁊ ⁋ ⁌ ⁍ ⁎ ⁏ ⁐ ⁑ ⁒ ⁗   ⁠ ⁡ ⁢ ⁣ ⁪ ⁫ ⁬ ⁭ ⁮ ⁯

93+Superscripts and Subscripts

94+⁰ ⁱ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹ ⁺ ⁻ ⁼ ⁽ ⁾ ⁿ ₀ ₁ ₂ ₃ ₄ ₅ ₆ ₇ ₈ ₉ ₊ ₋ ₌ ₍ ₎

95+Currency Symbols

96+₠ ₡ ₢ ₣ ₤ ₥ ₦ ₧ ₨ ₩ ₪ ₫ € ₭ ₮ ₯ ₰ ₱

97+Combining Diacritical Marks for Symbols

98+⃐ ⃑ ⃒ ⃓ ⃔ ⃕ ⃖ ⃗ ⃘ ⃙ ⃚ ⃛ ⃜ ⃝ ⃞ ⃟ ⃠ ⃡ ⃢ ⃣ ⃤ ⃥ ⃦ ⃧ ⃨ ⃩ ⃪

99+Letterlike Symbols

100+℀ ℁ ℂ ℃ ℄ ℅ ℆ ℇ ℈ ℉ ℊ ℋ ℌ ℍ ℎ ℏ ℐ ℑ ℒ ℓ ℔ ℕ № ℗ ℘ ℙ ℚ ℛ ℜ ℝ ℞ ℟ ℠ ℡ ™ ℣ ℤ ℥ Ω ℧ ℨ ℩ K Å ℬ ℭ ℮ ℯ ℰ ℱ Ⅎ ℳ ℴ ℵ ℶ ℷ ℸ ℹ ℺ ℽ ℾ ℿ ⅀ ⅁ ⅂ ⅃ ⅄ ⅅ ⅆ ⅇ ⅈ ⅉ ⅊ ⅋

101+Number Forms

102+⅓ ⅔ ⅕ ⅖ ⅗ ⅘ ⅙ ⅚ ⅛ ⅜ ⅝ ⅞ ⅟ Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ Ⅺ Ⅻ Ⅼ Ⅽ Ⅾ Ⅿ ⅰ ⅱ ⅲ ⅳ ⅴ ⅵ ⅶ ⅷ ⅸ ⅹ ⅺ ⅻ ⅼ ⅽ ⅾ ⅿ ↀ ↁ ↂ Ↄ

103+Arrows

104+← ↑ → ↓ ↔ ↕ ↖ ↗ ↘ ↙ ↚ ↛ ↜ ↝ ↞ ↟ ↠ ↡ ↢ ↣ ↤ ↥ ↦ ↧ ↨ ↩ ↪ ↫ ↬ ↭ ↮ ↯ ↰ ↱ ↲ ↳ ↴ ↵ ↶ ↷ ↸ ↹ ↺ ↻ ↼ ↽ ↾ ↿ ⇀ ⇁ ⇂ ⇃ ⇄ ⇅ ⇆ ⇇ ⇈ ⇉ ⇊ ⇋ ⇌ ⇍ ⇎ ⇏ ⇐ ⇑ ⇒ ⇓ ⇔ ⇕ ⇖ ⇗ ⇘ ⇙ ⇚ ⇛ ⇜ ⇝ ⇞ ⇟ ⇠ ⇡ ⇢ ⇣ ⇤ ⇥ ⇦ ⇧ ⇨ ⇩ ⇪ ⇫ ⇬ ⇭ ⇮ ⇯ ⇰ ⇱ ⇲ ⇳ ⇴ ⇵ ⇶ ⇷ ⇸ ⇹ ⇺ ⇻ ⇼ ⇽ ⇾ ⇿

105+Mathematical Operators

106+∀ ∁ ∂ ∃ ∄ ∅ ∆ ∇ ∈ ∉ ∊ ∋ ∌ ∍ ∎ ∏ ∐ ∑ − ∓ ∔ ∕ ∖ ∗ ∘ ∙ √ ∛ ∜ ∝ ∞ ∟ ∠ ∡ ∢ ∣ ∤ ∥ ∦ ∧ ∨ ∩ ∪ ∫ ∬ ∭ ∮ ∯ ∰ ∱ ∲ ∳ ∴ ∵ ∶ ∷ ∸ ∹ ∺ ∻ ∼ ∽ ∾ ∿ ≀ ≁ ≂ ≃ ≄ ≅ ≆ ≇ ≈ ≉ ≊ ≋ ≌ ≍ ≎ ≏ ≐ ≑ ≒ ≓ ≔ ≕ ≖ ≗ ≘ ≙ ≚ ≛ ≜ ≝ ≞ ≟ ≠ ≡ ≢ ≣ ≤ ≥ ≦ ≧ ≨ ≩ ≪ ≫ ≬ ≭ ≮ ≯ ≰ ≱ ≲ ≳ ≴ ≵ ≶ ≷ ≸ ≹ ≺ ≻ ≼ ≽ ≾ ≿ ...

107+Miscellaneous Technical

108+⌀ ⌁ ⌂ ⌃ ⌄ ⌅ ⌆ ⌇ ⌈ ⌉ ⌊ ⌋ ⌌ ⌍ ⌎ ⌏ ⌐ ⌑ ⌒ ⌓ ⌔ ⌕ ⌖ ⌗ ⌘ ⌙ ⌚ ⌛ ⌜ ⌝ ⌞ ⌟ ⌠ ⌡ ⌢ ⌣ ⌤ ⌥ ⌦ ⌧ ⌨ 〈 〉 ⌫ ⌬ ⌭ ⌮ ⌯ ⌰ ⌱ ⌲ ⌳ ⌴ ⌵ ⌶ ⌷ ⌸ ⌹ ⌺ ⌻ ⌼ ⌽ ⌾ ⌿ ⍀ ⍁ ⍂ ⍃ ⍄ ⍅ ⍆ ⍇ ⍈ ⍉ ⍊ ⍋ ⍌ ⍍ ⍎ ⍏ ⍐ ⍑ ⍒ ⍓ ⍔ ⍕ ⍖ ⍗ ⍘ ⍙ ⍚ ⍛ ⍜ ⍝ ⍞ ⍟ ⍠ ⍡ ⍢ ⍣ ⍤ ⍥ ⍦ ⍧ ⍨ ⍩ ⍪ ⍫ ⍬ ⍭ ⍮ ⍯ ⍰ ⍱ ⍲ ⍳ ⍴ ⍵ ⍶ ⍷ ⍸ ⍹ ⍺ ⍻ ⍼ ⍽ ⍾ ⍿ ...

109+Control Pictures

110+␀ ␁ ␂ ␃ ␄ ␅ ␆ ␇ ␈ ␉ ␊ ␋ ␌ ␍ ␎ ␏ ␐ ␑ ␒ ␓ ␔ ␕ ␖ ␗ ␘ ␙ ␚ ␛ ␜ ␝ ␞ ␟ ␠ ␡ ␢ ␣ ␤ ␥ ␦

111+Optical Character Recognition

112+⑀ ⑁ ⑂ ⑃ ⑄ ⑅ ⑆ ⑇ ⑈ ⑉ ⑊

113+Enclosed Alphanumerics

114+① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰ ⒱ ⒲ ⒳ ⒴ ⒵ Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ...

115+Box Drawing

116+─ ━ │ ┃ ┄ ┅ ┆ ┇ ┈ ┉ ┊ ┋ ┌ ┍ ┎ ┏ ┐ ┑ ┒ ┓ └ ┕ ┖ ┗ ┘ ┙ ┚ ┛ ├ ┝ ┞ ┟ ┠ ┡ ┢ ┣ ┤ ┥ ┦ ┧ ┨ ┩ ┪ ┫ ┬ ┭ ┮ ┯ ┰ ┱ ┲ ┳ ┴ ┵ ┶ ┷ ┸ ┹ ┺ ┻ ┼ ┽ ┾ ┿ ╀ ╁ ╂ ╃ ╄ ╅ ╆ ╇ ╈ ╉ ╊ ╋ ╌ ╍ ╎ ╏ ═ ║ ╒ ╓ ╔ ╕ ╖ ╗ ╘ ╙ ╚ ╛ ╜ ╝ ╞ ╟ ╠ ╡ ╢ ╣ ╤ ╥ ╦ ╧ ╨ ╩ ╪ ╫ ╬ ╭ ╮ ╯ ╰ ╱ ╲ ╳ ╴ ╵ ╶ ╷ ╸ ╹ ╺ ╻ ╼ ╽ ╾ ╿

117+Block Elements

118+▀ ▁ ▂ ▃ ▄ ▅ ▆ ▇ █ ▉ ▊ ▋ ▌ ▍ ▎ ▏ ▐ ░ ▒ ▓ ▔ ▕ ▖ ▗ ▘ ▙ ▚ ▛ ▜ ▝ ▞ ▟

119+Geometric Shapes

120+■ □ ▢ ▣ ▤ ▥ ▦ ▧ ▨ ▩ ▪ ▫ ▬ ▭ ▮ ▯ ▰ ▱ ▲ △ ▴ ▵ ▶ ▷ ▸ ▹ ► ▻ ▼ ▽ ▾ ▿ ◀ ◁ ◂ ◃ ◄ ◅ ◆ ◇ ◈ ◉ ◊ ○ ◌ ◍ ◎ ● ◐ ◑ ◒ ◓ ◔ ◕ ◖ ◗ ◘ ◙ ◚ ◛ ◜ ◝ ◞ ◟ ◠ ◡ ◢ ◣ ◤ ◥ ◦ ◧ ◨ ◩ ◪ ◫ ◬ ◭ ◮ ◯ ◰ ◱ ◲ ◳ ◴ ◵ ◶ ◷ ◸ ◹ ◺ ◻ ◼ ◽ ◾ ◿

121+Miscellaneous Symbols

122+☀ ☁ ☂ ☃ ☄ ★ ☆ ☇ ☈ ☉ ☊ ☋ ☌ ☍ ☎ ☏ ☐ ☑ ☒ ☓ ☖ ☗ ☙ ☚ ☛ ☜ ☝ ☞ ☟ ☠ ☡ ☢ ☣ ☤ ☥ ☦ ☧ ☨ ☩ ☪ ☫ ☬ ☭ ☮ ☯ ☰ ☱ ☲ ☳ ☴ ☵ ☶ ☷ ☸ ☹ ☺ ☻ ☼ ☽ ☾ ☿ ♀ ♁ ♂ ♃ ♄ ♅ ♆ ♇ ♈ ♉ ♊ ♋ ♌ ♍ ♎ ♏ ♐ ♑ ♒ ♓ ♔ ♕ ♖ ♗ ♘ ♙ ♚ ♛ ♜ ♝ ♞ ♟ ♠ ♡ ♢ ♣ ♤ ♥ ♦ ♧ ♨ ♩ ♪ ♫ ♬ ♭ ♮ ♯ ♰ ♱ ♲ ♳ ♴ ♵ ♶ ♷ ♸ ♹ ♺ ♻ ♼ ♽ ⚀ ⚁ ⚂ ⚃ ⚄ ...

123+Dingbats

124+✁ ✂ ✃ ✄ ✆ ✇ ✈ ✉ ✌ ✍ ✎ ✏ ✐ ✑ ✒ ✓ ✔ ✕ ✖ ✗ ✘ ✙ ✚ ✛ ✜ ✝ ✞ ✟ ✠ ✡ ✢ ✣ ✤ ✥ ✦ ✧ ✩ ✪ ✫ ✬ ✭ ✮ ✯ ✰ ✱ ✲ ✳ ✴ ✵ ✶ ✷ ✸ ✹ ✺ ✻ ✼ ✽ ✾ ✿ ❀ ❁ ❂ ❃ ❄ ❅ ❆ ❇ ❈ ❉ ❊ ❋ ❍ ❏ ❐ ❑ ❒ ❖ ❘ ❙ ❚ ❛ ❜ ❝ ❞ ❡ ❢ ❣ ❤ ❥ ❦ ❧ ❨ ❩ ❪ ❫ ❬ ❭ ❮ ❯ ❰ ❱ ❲ ❳ ❴ ❵ ❶ ❷ ❸ ❹ ❺ ❻ ❼ ❽ ❾ ❿ ➀ ➁ ➂ ➃ ➄ ➅ ➆ ➇ ➈ ➉ ➊ ➋ ➌ ...

125+Miscellaneous Mathematical Symbols-A

126+⟐ ⟑ ⟒ ⟓ ⟔ ⟕ ⟖ ⟗ ⟘ ⟙ ⟚ ⟛ ⟜ ⟝ ⟞ ⟟ ⟠ ⟡ ⟢ ⟣ ⟤ ⟥ ⟦ ⟧ ⟨ ⟩ ⟪ ⟫

127+Supplemental Arrows-A

128+⟰ ⟱ ⟲ ⟳ ⟴ ⟵ ⟶ ⟷ ⟸ ⟹ ⟺ ⟻ ⟼ ⟽ ⟾ ⟿

129+Braille Patterns

130+⠀ ⠁ ⠂ ⠃ ⠄ ⠅ ⠆ ⠇ ⠈ ⠉ ⠊ ⠋ ⠌ ⠍ ⠎ ⠏ ⠐ ⠑ ⠒ ⠓ ⠔ ⠕ ⠖ ⠗ ⠘ ⠙ ⠚ ⠛ ⠜ ⠝ ⠞ ⠟ ⠠ ⠡ ⠢ ⠣ ⠤ ⠥ ⠦ ⠧ ⠨ ⠩ ⠪ ⠫ ⠬ ⠭ ⠮ ⠯ ⠰ ⠱ ⠲ ⠳ ⠴ ⠵ ⠶ ⠷ ⠸ ⠹ ⠺ ⠻ ⠼ ⠽ ⠾ ⠿ ⡀ ⡁ ⡂ ⡃ ⡄ ⡅ ⡆ ⡇ ⡈ ⡉ ⡊ ⡋ ⡌ ⡍ ⡎ ⡏ ⡐ ⡑ ⡒ ⡓ ⡔ ⡕ ⡖ ⡗ ⡘ ⡙ ⡚ ⡛ ⡜ ⡝ ⡞ ⡟ ⡠ ⡡ ⡢ ⡣ ⡤ ⡥ ⡦ ⡧ ⡨ ⡩ ⡪ ⡫ ⡬ ⡭ ⡮ ⡯ ⡰ ⡱ ⡲ ⡳ ⡴ ⡵ ⡶ ⡷ ⡸ ⡹ ⡺ ⡻ ⡼ ⡽ ⡾ ⡿ ...

131+Supplemental Arrows-B

132+⤀ ⤁ ⤂ ⤃ ⤄ ⤅ ⤆ ⤇ ⤈ ⤉ ⤊ ⤋ ⤌ ⤍ ⤎ ⤏ ⤐ ⤑ ⤒ ⤓ ⤔ ⤕ ⤖ ⤗ ⤘ ⤙ ⤚ ⤛ ⤜ ⤝ ⤞ ⤟ ⤠ ⤡ ⤢ ⤣ ⤤ ⤥ ⤦ ⤧ ⤨ ⤩ ⤪ ⤫ ⤬ ⤭ ⤮ ⤯ ⤰ ⤱ ⤲ ⤳ ⤴ ⤵ ⤶ ⤷ ⤸ ⤹ ⤺ ⤻ ⤼ ⤽ ⤾ ⤿ ⥀ ⥁ ⥂ ⥃ ⥄ ⥅ ⥆ ⥇ ⥈ ⥉ ⥊ ⥋ ⥌ ⥍ ⥎ ⥏ ⥐ ⥑ ⥒ ⥓ ⥔ ⥕ ⥖ ⥗ ⥘ ⥙ ⥚ ⥛ ⥜ ⥝ ⥞ ⥟ ⥠ ⥡ ⥢ ⥣ ⥤ ⥥ ⥦ ⥧ ⥨ ⥩ ⥪ ⥫ ⥬ ⥭ ⥮ ⥯ ⥰ ⥱ ⥲ ⥳ ⥴ ⥵ ⥶ ⥷ ⥸ ⥹ ⥺ ⥻ ⥼ ⥽ ⥾ ⥿

133+Miscellaneous Mathematical Symbols-B

134+⦀ ⦁ ⦂ ⦃ ⦄ ⦅ ⦆ ⦇ ⦈ ⦉ ⦊ ⦋ ⦌ ⦍ ⦎ ⦏ ⦐ ⦑ ⦒ ⦓ ⦔ ⦕ ⦖ ⦗ ⦘ ⦙ ⦚ ⦛ ⦜ ⦝ ⦞ ⦟ ⦠ ⦡ ⦢ ⦣ ⦤ ⦥ ⦦ ⦧ ⦨ ⦩ ⦪ ⦫ ⦬ ⦭ ⦮ ⦯ ⦰ ⦱ ⦲ ⦳ ⦴ ⦵ ⦶ ⦷ ⦸ ⦹ ⦺ ⦻ ⦼ ⦽ ⦾ ⦿ ⧀ ⧁ ⧂ ⧃ ⧄ ⧅ ⧆ ⧇ ⧈ ⧉ ⧊ ⧋ ⧌ ⧍ ⧎ ⧏ ⧐ ⧑ ⧒ ⧓ ⧔ ⧕ ⧖ ⧗ ⧘ ⧙ ⧚ ⧛ ⧜ ⧝ ⧞ ⧟ ⧠ ⧡ ⧢ ⧣ ⧤ ⧥ ⧦ ⧧ ⧨ ⧩ ⧪ ⧫ ⧬ ⧭ ⧮ ⧯ ⧰ ⧱ ⧲ ⧳ ⧴ ⧵ ⧶ ⧷ ⧸ ⧹ ⧺ ⧻ ⧼ ⧽ ⧾ ⧿

135+Supplemental Mathematical Operators

136+⨀ ⨁ ⨂ ⨃ ⨄ ⨅ ⨆ ⨇ ⨈ ⨉ ⨊ ⨋ ⨌ ⨍ ⨎ ⨏ ⨐ ⨑ ⨒ ⨓ ⨔ ⨕ ⨖ ⨗ ⨘ ⨙ ⨚ ⨛ ⨜ ⨝ ⨞ ⨟ ⨠ ⨡ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨯ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨹ ⨺ ⨻ ⨼ ⨽ ⨾ ⨿ ⩀ ⩁ ⩂ ⩃ ⩄ ⩅ ⩆ ⩇ ⩈ ⩉ ⩊ ⩋ ⩌ ⩍ ⩎ ⩏ ⩐ ⩑ ⩒ ⩓ ⩔ ⩕ ⩖ ⩗ ⩘ ⩙ ⩚ ⩛ ⩜ ⩝ ⩞ ⩟ ⩠ ⩡ ⩢ ⩣ ⩤ ⩥ ⩦ ⩧ ⩨ ⩩ ⩪ ⩫ ⩬ ⩭ ⩮ ⩯ ⩰ ⩱ ⩲ ⩳ ⩴ ⩵ ⩶ ⩷ ⩸ ⩹ ⩺ ⩻ ⩼ ⩽ ⩾ ⩿ ...

137+CJK Radicals Supplement

138+⺀⺁⺂⺃⺄⺅⺆⺇⺈⺉⺊⺋⺌⺍⺎⺏⺐⺑⺒⺓⺔⺕⺖⺗⺘⺙⺛⺜⺝⺞⺟⺠⺡⺢⺣⺤⺥⺦⺧⺨⺩⺪⺫⺬⺭⺮⺯⺰⺱⺲⺳⺴⺵⺶⺷⺸⺹⺺⺻⺼⺽⺾⺿⻀⻁⻂⻃⻄⻅⻆⻇⻈⻉⻊⻋⻌⻍⻎⻏⻐⻑⻒⻓⻔⻕⻖⻗⻘⻙⻚⻛⻜⻝⻞⻟⻠⻡⻢⻣⻤⻥⻦⻧⻨⻩⻪⻫⻬⻭⻮⻯⻰⻱⻲⻳

139+Kangxi Radicals

140+⼀⼁⼂⼃⼄⼅⼆⼇⼈⼉⼊⼋⼌⼍⼎⼏⼐⼑⼒⼓⼔⼕⼖⼗⼘⼙⼚⼛⼜⼝⼞⼟⼠⼡⼢⼣⼤⼥⼦⼧⼨⼩⼪⼫⼬⼭⼮⼯⼰⼱⼲⼳⼴⼵⼶⼷⼸⼹⼺⼻⼼⼽⼾⼿⽀⽁⽂⽃⽄⽅⽆⽇⽈⽉⽊⽋⽌⽍⽎⽏⽐⽑⽒⽓⽔⽕⽖⽗⽘⽙⽚⽛⽜⽝⽞⽟⽠⽡⽢⽣⽤⽥⽦⽧⽨⽩⽪⽫⽬⽭⽮⽯⽰⽱⽲⽳⽴⽵⽶⽷⽸⽹⽺⽻⽼⽽⽾⽿ ...

141+Ideographic Description Characters

142+⿰ ⿱ ⿲ ⿳ ⿴ ⿵ ⿶ ⿷ ⿸ ⿹ ⿺ ⿻

143+CJK Symbols and Punctuation

144+　、。〃〄々〆〇〈〉《》「」『』【】〒〓〔〕〖〗〘〙〚〛〜〝〞〟〠〡〢〣〤〥〦〧〨〩〪〭〮〯〫〬〰〱〲〳〴〵〶〷〸〹〺〻〼〽〾〿

145+Hiragana

146+ぁあぃいぅうぇえぉおかがきぎくぐけげこごさざしじすずせぜそぞただちぢっつづてでとどなにぬねのはばぱひびぴふぶぷへべぺほぼぽまみむめもゃやゅゆょよらりるれろゎわゐゑをんゔゕゖ゙゚゛゜ゝゞゟ

147+Katakana

148+゠ァアィイゥウェエォオカガキギクグケゲコゴサザシジスズセゼソゾタダチヂッツヅテデトドナニヌネノハバパヒビピフブプヘベペホボポマミムメモャヤュユョヨラリルレロヮワヰヱヲンヴヵヶヷヸヹヺ・ーヽヾヿ

149+Bopomofo

150+ㄅㄆㄇㄈㄉㄊㄋㄌㄍㄎㄏㄐㄑㄒㄓㄔㄕㄖㄗㄘㄙㄚㄛㄜㄝㄞㄟㄠㄡㄢㄣㄤㄥㄦㄧㄨㄩㄪㄫㄬ

151+Hangul Compatibility Jamo

152+ㄱ ㄲ ㄳ ㄴ ㄵ ㄶ ㄷ ㄸ ㄹ ㄺ ㄻ ㄼ ㄽ ㄾ ㄿ ㅀ ㅁ ㅂ ㅃ ㅄ ㅅ ㅆ ㅇ ㅈ ㅉ ㅊ ㅋ ㅌ ㅍ ㅎ ㅏ ㅐ ㅑ ㅒ ㅓ ㅔ ㅕ ㅖ ㅗ ㅘ ㅙ ㅚ ㅛ ㅜ ㅝ ㅞ ㅟ ㅠ ㅡ ㅢ ㅣ ㅤ ㅥ ㅦ ㅧ ㅨ ㅩ ㅪ ㅫ ㅬ ㅭ ㅮ ㅯ ㅰ ㅱ ㅲ ㅳ ㅴ ㅵ ㅶ ㅷ ㅸ ㅹ ㅺ ㅻ ㅼ ㅽ ㅾ ㅿ ㆀ ㆁ ㆂ ㆃ ㆄ ㆅ ㆆ ㆇ ㆈ ㆉ ㆊ ㆋ ㆌ ㆍ ㆎ

153+Kanbun

154+㆐ ㆑ ㆒ ㆓ ㆔ ㆕ ㆖ ㆗ ㆘ ㆙ ㆚ ㆛ ㆜ ㆝ ㆞ ㆟

155+Bopomofo Extended

156+ㆠ ㆡ ㆢ ㆣ ㆤ ㆥ ㆦ ㆧ ㆨ ㆩ ㆪ ㆫ ㆬ ㆭ ㆮ ㆯ ㆰ ㆱ ㆲ ㆳ ㆴ ㆵ ㆶ ㆷ

157+Katakana Phonetic Extensions

158+ㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ

159+Enclosed CJK Letters and Months

160+㈀㈁㈂㈃㈄㈅㈆㈇㈈㈉㈊㈋㈌㈍㈎㈏㈐㈑㈒㈓㈔㈕㈖㈗㈘㈙㈚㈛㈜㈠㈡㈢㈣㈤㈥㈦㈧㈨㈩㈪㈫㈬㈭㈮㈯㈰㈱㈲㈳㈴㈵㈶㈷㈸㈹㈺㈻㈼㈽㈾㈿㉀㉁㉂㉃㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟㉠㉡㉢㉣㉤㉥㉦㉧㉨㉩㉪㉫㉬㉭㉮㉯㉰㉱㉲㉳㉴㉵㉶㉷㉸㉹㉺㉻㉿㊀㊁㊂㊃㊄㊅㊆㊇㊈㊉㊊㊋㊌㊍㊎㊏㊐㊑㊒ ...

161+CJK Compatibility

162+㌀㌁㌂㌃㌄㌅㌆㌇㌈㌉㌊㌋㌌㌍㌎㌏㌐㌑㌒㌓㌔㌕㌖㌗㌘㌙㌚㌛㌜㌝㌞㌟㌠㌡㌢㌣㌤㌥㌦㌧㌨㌩㌪㌫㌬㌭㌮㌯㌰㌱㌲㌳㌴㌵㌶㌷㌸㌹㌺㌻㌼㌽㌾㌿㍀㍁㍂㍃㍄㍅㍆㍇㍈㍉㍊㍋㍌㍍㍎㍏㍐㍑㍒㍓㍔㍕㍖㍗㍘㍙㍚㍛㍜㍝㍞㍟㍠㍡㍢㍣㍤㍥㍦㍧㍨㍩㍪㍫㍬㍭㍮㍯㍰㍱㍲㍳㍴㍵㍶㍻㍼㍽㍾㍿㎀㎁㎂㎃ ...

163+CJK Unified Ideographs Extension A

164+㐀㐁㐂㐃㐄㐅㐆㐇㐈㐉㐊㐋㐌㐍㐎㐏㐐㐑㐒㐓㐔㐕㐖㐗㐘㐙㐚㐛㐜㐝㐞㐟㐠㐡㐢㐣㐤㐥㐦㐧㐨㐩㐪㐫㐬㐭㐮㐯㐰㐱㐲㐳㐴㐵㐶㐷㐸㐹㐺㐻㐼㐽㐾㐿㑀㑁㑂㑃㑄㑅㑆㑇㑈㑉㑊㑋㑌㑍㑎㑏㑐㑑㑒㑓㑔㑕㑖㑗㑘㑙㑚㑛㑜㑝㑞㑟㑠㑡㑢㑣㑤㑥㑦㑧㑨㑩㑪㑫㑬㑭㑮㑯㑰㑱㑲㑳㑴㑵㑶㑷㑸㑹㑺㑻㑼㑽㑾㑿 ...

165+CJK Unified Ideographs

166+一丁丂七丄丅丆万丈三上下丌不与丏丐丑丒专且丕世丗丘丙业丛东丝丞丟丠両丢丣两严並丧丨丩个丫丬中丮丯丰丱串丳临丵丶丷丸丹为主丼丽举丿乀乁乂乃乄久乆乇么义乊之乌乍乎乏乐乑乒乓乔乕乖乗乘乙乚乛乜九乞也习乡乢乣乤乥书乧乨乩乪乫乬乭乮乯买乱乲乳乴乵乶乷乸乹乺乻乼乽乾乿 ...

167+Yi Syllables

168+ꀀ ꀁ ꀂ ꀃ ꀄ ꀅ ꀆ ꀇ ꀈ ꀉ ꀊ ꀋ ꀌ ꀍ ꀎ ꀏ ꀐ ꀑ ꀒ ꀓ ꀔ ꀕ ꀖ ꀗ ꀘ ꀙ ꀚ ꀛ ꀜ ꀝ ꀞ ꀟ ꀠ ꀡ ꀢ ꀣ ꀤ ꀥ ꀦ ꀧ ꀨ ꀩ ꀪ ꀫ ꀬ ꀭ ꀮ ꀯ ꀰ ꀱ ꀲ ꀳ ꀴ ꀵ ꀶ ꀷ ꀸ ꀹ ꀺ ꀻ ꀼ ꀽ ꀾ ꀿ ꁀ ꁁ ꁂ ꁃ ꁄ ꁅ ꁆ ꁇ ꁈ ꁉ ꁊ ꁋ ꁌ ꁍ ꁎ ꁏ ꁐ ꁑ ꁒ ꁓ ꁔ ꁕ ꁖ ꁗ ꁘ ꁙ ꁚ ꁛ ꁜ ꁝ ꁞ ꁟ ꁠ ꁡ ꁢ ꁣ ꁤ ꁥ ꁦ ꁧ ꁨ ꁩ ꁪ ꁫ ꁬ ꁭ ꁮ ꁯ ꁰ ꁱ ꁲ ꁳ ꁴ ꁵ ꁶ ꁷ ꁸ ꁹ ꁺ ꁻ ꁼ ꁽ ꁾ ꁿ ...

169+Yi Radicals

170+꒐ ꒑ ꒒ ꒓ ꒔ ꒕ ꒖ ꒗ ꒘ ꒙ ꒚ ꒛ ꒜ ꒝ ꒞ ꒟ ꒠ ꒡ ꒢ ꒣ ꒤ ꒥ ꒦ ꒧ ꒨ ꒩ ꒪ ꒫ ꒬ ꒭ ꒮ ꒯ ꒰ ꒱ ꒲ ꒳ ꒴ ꒵ ꒶ ꒷ ꒸ ꒹ ꒺ ꒻ ꒼ ꒽ ꒾ ꒿ ꓀ ꓁ ꓂ ꓃ ꓄ ꓅ ꓆

171+Hangul Syllables

172+가 각 갂 갃 간 갅 갆 갇 갈 갉 갊 갋 갌 갍 갎 갏 감 갑 값 갓 갔 강 갖 갗 갘 같 갚 갛 개 객 갞 갟 갠 갡 갢 갣 갤 갥 갦 갧 갨 갩 갪 갫 갬 갭 갮 갯 갰 갱 갲 갳 갴 갵 갶 갷 갸 갹 갺 갻 갼 갽 갾 갿 걀 걁 걂 걃 걄 걅 걆 걇 걈 걉 걊 걋 걌 걍 걎 걏 걐 걑 걒 걓 걔 걕 걖 걗 걘 걙 걚 걛 걜 걝 걞 걟 걠 걡 걢 걣 걤 걥 걦 걧 걨 걩 걪 걫 걬 걭 걮 걯 거 걱 걲 걳 건 걵 걶 걷 걸 걹 걺 걻 걼 걽 걾 걿 ...

173+Private Use Area

174+                                                                                                                                ...

175+CJK Compatibility Ideographs

176+豈更車賈滑串句龜龜契金喇奈懶癩羅蘿螺裸邏樂洛烙珞落酪駱亂卵欄爛蘭鸞嵐濫藍襤拉臘蠟廊朗浪狼郎來冷勞擄櫓爐盧老蘆虜路露魯鷺碌祿綠菉錄鹿論壟弄籠聾牢磊賂雷壘屢樓淚漏累縷陋勒肋凜凌稜綾菱陵讀拏樂諾丹寧怒率異北磻便復不泌數索參塞省葉說殺辰沈拾若掠略亮兩凉梁糧良諒量勵 ...

177+Alphabetic Presentation Forms

178+ﬀ ﬁ ﬂ ﬃ ﬄ ﬅ ﬆ ﬓ ﬔ ﬕ ﬖ ﬗ יִ ﬞ ײַ ﬠ ﬡ ﬢ ﬣ ﬤ ﬥ ﬦ ﬧ ﬨ ﬩ שׁ שׂ שּׁ שּׂ אַ אָ אּ בּ גּ דּ הּ וּ זּ טּ יּ ךּ כּ לּ מּ נּ סּ ףּ פּ צּ קּ רּ שּ תּ וֹ בֿ כֿ פֿ ﭏ

179+Arabic Presentation Forms-A

180+ﭐ ﭑ ﭒ ﭓ ﭔ ﭕ ﭖ ﭗ ﭘ ﭙ ﭚ ﭛ ﭜ ﭝ ﭞ ﭟ ﭠ ﭡ ﭢ ﭣ ﭤ ﭥ ﭦ ﭧ ﭨ ﭩ ﭪ ﭫ ﭬ ﭭ ﭮ ﭯ ﭰ ﭱ ﭲ ﭳ ﭴ ﭵ ﭶ ﭷ ﭸ ﭹ ﭺ ﭻ ﭼ ﭽ ﭾ ﭿ ﮀ ﮁ ﮂ ﮃ ﮄ ﮅ ﮆ ﮇ ﮈ ﮉ ﮊ ﮋ ﮌ ﮍ ﮎ ﮏ ﮐ ﮑ ﮒ ﮓ ﮔ ﮕ ﮖ ﮗ ﮘ ﮙ ﮚ ﮛ ﮜ ﮝ ﮞ ﮟ ﮠ ﮡ ﮢ ﮣ ﮤ ﮥ ﮦ ﮧ ﮨ ﮩ ﮪ ﮫ ﮬ ﮭ ﮮ ﮯ ﮰ ﮱ ﯓ ﯔ ﯕ ﯖ ﯗ ﯘ ﯙ ﯚ ﯛ ﯜ ﯝ ﯞ ﯟ ﯠ ﯡ ﯢ ﯣ ﯤ ﯥ ﯦ ﯧ ﯨ ﯩ ﯪ ﯫ ﯬ ﯭ ﯮ ﯯ ﯰ ...

181+Variation Selectors

182+︀ ︁ ︂ ︃ ︄ ︅ ︆ ︇ ︈ ︉ ︊ ︋ ︌ ︍ ︎ ️

183+Combining Half Marks

184+︠ ︡ ︢ ︣

185+CJK Compatibility Forms

186+︰︱︲︳︴︵︶︷︸︹︺︻︼︽︾︿﹀﹁﹂﹃﹄﹅﹆﹉﹊﹋﹌﹍﹎﹏

187+Small Form Variants

188+﹐ ﹑ ﹒ ﹔ ﹕ ﹖ ﹗ ﹘ ﹙ ﹚ ﹛ ﹜ ﹝ ﹞ ﹟ ﹠ ﹡ ﹢ ﹣ ﹤ ﹥ ﹦ ﹨ ﹩ ﹪ ﹫

189+Arabic Presentation Forms-B

190+ﹰ ﹱ ﹲ ﹳ ﹴ ﹶ ﹷ ﹸ ﹹ ﹺ ﹻ ﹼ ﹽ ﹾ ﹿ ﺀ ﺁ ﺂ ﺃ ﺄ ﺅ ﺆ ﺇ ﺈ ﺉ ﺊ ﺋ ﺌ ﺍ ﺎ ﺏ ﺐ ﺑ ﺒ ﺓ ﺔ ﺕ ﺖ ﺗ ﺘ ﺙ ﺚ ﺛ ﺜ ﺝ ﺞ ﺟ ﺠ ﺡ ﺢ ﺣ ﺤ ﺥ ﺦ ﺧ ﺨ ﺩ ﺪ ﺫ ﺬ ﺭ ﺮ ﺯ ﺰ ﺱ ﺲ ﺳ ﺴ ﺵ ﺶ ﺷ ﺸ ﺹ ﺺ ﺻ ﺼ ﺽ ﺾ ﺿ ﻀ ﻁ ﻂ ﻃ ﻄ ﻅ ﻆ ﻇ ﻈ ﻉ ﻊ ﻋ ﻌ ﻍ ﻎ ﻏ ﻐ ﻑ ﻒ ﻓ ﻔ ﻕ ﻖ ﻗ ﻘ ﻙ ﻚ ﻛ ﻜ ﻝ ﻞ ﻟ ﻠ ﻡ ﻢ ﻣ ﻤ ﻥ ﻦ ﻧ ﻨ ﻩ ﻪ ﻫ ﻬ ﻭ ﻮ ﻯ ﻰ ...

191+Halfwidth and Fullwidth Forms

192+！＂＃＄％＆＇（）＊＋，－．／０１２３４５６７８９：；＜＝＞？＠ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ［＼］＾＿｀ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ｛｜｝～｟｠｡｢｣､･ｦｧｨｩｪｫｬｭｮｯｰｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀ ...

193+Specials

194+￹ ￺ ￻ �

195+Old Italic

196+𐌀 𐌁 𐌂 𐌃 𐌄 𐌅 𐌆 𐌇 𐌈 𐌉 𐌊 𐌋 𐌌 𐌍 𐌎 𐌏 𐌐 𐌑 𐌒 𐌓 𐌔 𐌕 𐌖 𐌗 𐌘 𐌙 𐌚 𐌛 𐌜 𐌝 𐌞 𐌠 𐌡 𐌢 𐌣

197+Gothic

198+𐌰 𐌱 𐌲 𐌳 𐌴 𐌵 𐌶 𐌷 𐌸 𐌹 𐌺 𐌻 𐌼 𐌽 𐌾 𐌿 𐍀 𐍁 𐍂 𐍃 𐍄 𐍅 𐍆 𐍇 𐍈 𐍉 𐍊

199+Deseret

200+𐐀 𐐁 𐐂 𐐃 𐐄 𐐅 𐐆 𐐇 𐐈 𐐉 𐐊 𐐋 𐐌 𐐍 𐐎 𐐏 𐐐 𐐑 𐐒 𐐓 𐐔 𐐕 𐐖 𐐗 𐐘 𐐙 𐐚 𐐛 𐐜 𐐝 𐐞 𐐟 𐐠 𐐡 𐐢 𐐣 𐐤 𐐥 𐐨 𐐩 𐐪 𐐫 𐐬 𐐭 𐐮 𐐯 𐐰 𐐱 𐐲 𐐳 𐐴 𐐵 𐐶 𐐷 𐐸 𐐹 𐐺 𐐻 𐐼 𐐽 𐐾 𐐿 𐑀 𐑁 𐑂 𐑃 𐑄 𐑅 𐑆 𐑇 𐑈 𐑉 𐑊 𐑋 𐑌 𐑍

201+Byzantine Musical Symbols

202+𝀀 𝀁 𝀂 𝀃 𝀄 𝀅 𝀆 𝀇 𝀈 𝀉 𝀊 𝀋 𝀌 𝀍 𝀎 𝀏 𝀐 𝀑 𝀒 𝀓 𝀔 𝀕 𝀖 𝀗 𝀘 𝀙 𝀚 𝀛 𝀜 𝀝 𝀞 𝀟 𝀠 𝀡 𝀢 𝀣 𝀤 𝀥 𝀦 𝀧 𝀨 𝀩 𝀪 𝀫 𝀬 𝀭 𝀮 𝀯 𝀰 𝀱 𝀲 𝀳 𝀴 𝀵 𝀶 𝀷 𝀸 𝀹 𝀺 𝀻 𝀼 𝀽 𝀾 𝀿 𝁀 𝁁 𝁂 𝁃 𝁄 𝁅 𝁆 𝁇 𝁈 𝁉 𝁊 𝁋 𝁌 𝁍 𝁎 𝁏 𝁐 𝁑 𝁒 𝁓 𝁔 𝁕 𝁖 𝁗 𝁘 𝁙 𝁚 𝁛 𝁜 𝁝 𝁞 𝁟 𝁠 𝁡 𝁢 𝁣 𝁤 𝁥 𝁦 𝁧 𝁨 𝁩 𝁪 𝁫 𝁬 𝁭 𝁮 𝁯 𝁰 𝁱 𝁲 𝁳 𝁴 𝁵 𝁶 𝁷 𝁸 𝁹 𝁺 𝁻 𝁼 𝁽 𝁾 𝁿 ...

203+Musical Symbols

204+𝄀 𝄁 𝄂 𝄃 𝄄 𝄅 𝄆 𝄇 𝄈 𝄉 𝄊 𝄋 𝄌 𝄍 𝄎 𝄏 𝄐 𝄑 𝄒 𝄓 𝄔 𝄕 𝄖 𝄗 𝄘 𝄙 𝄚 𝄛 𝄜 𝄝 𝄞 𝄟 𝄠 𝄡 𝄢 𝄣 𝄤 𝄥 𝄦 𝄪 𝄫 𝄬 𝄭 𝄮 𝄯 𝄰 𝄱 𝄲 𝄳 𝄴 𝄵 𝄶 𝄷 𝄸 𝄹 𝄺 𝄻 𝄼 𝄽 𝄾 𝄿 𝅀 𝅁 𝅂 𝅃 𝅄 𝅅 𝅆 𝅇 𝅈 𝅉 𝅊 𝅋 𝅌 𝅍 𝅎 𝅏 𝅐 𝅑 𝅒 𝅓 𝅔 𝅕 𝅖 𝅗 𝅘 𝅙 𝅚 𝅛 𝅜 𝅝 𝅗𝅥 𝅘𝅥 𝅘𝅥𝅮 𝅘𝅥𝅯 𝅘𝅥𝅰 𝅘𝅥𝅱 𝅘𝅥𝅲 𝅥 𝅦 𝅧 𝅨 𝅩 𝅪 𝅫 𝅬 𝅭 𝅮 𝅯 𝅰 𝅱 𝅲 𝅳 𝅴 𝅵 𝅶 𝅷 𝅸 𝅹 𝅺 𝅻 𝅼 𝅽 𝅾 𝅿 𝆀 𝆁 𝆂 ...

205+Mathematical Alphanumeric Symbols

206+𝐀 𝐁 𝐂 𝐃 𝐄 𝐅 𝐆 𝐇 𝐈 𝐉 𝐊 𝐋 𝐌 𝐍 𝐎 𝐏 𝐐 𝐑 𝐒 𝐓 𝐔 𝐕 𝐖 𝐗 𝐘 𝐙 𝐚 𝐛 𝐜 𝐝 𝐞 𝐟 𝐠 𝐡 𝐢 𝐣 𝐤 𝐥 𝐦 𝐧 𝐨 𝐩 𝐪 𝐫 𝐬 𝐭 𝐮 𝐯 𝐰 𝐱 𝐲 𝐳 𝐴 𝐵 𝐶 𝐷 𝐸 𝐹 𝐺 𝐻 𝐼 𝐽 𝐾 𝐿 𝑀 𝑁 𝑂 𝑃 𝑄 𝑅 𝑆 𝑇 𝑈 𝑉 𝑊 𝑋 𝑌 𝑍 𝑎 𝑏 𝑐 𝑑 𝑒 𝑓 𝑔 𝑖 𝑗 𝑘 𝑙 𝑚 𝑛 𝑜 𝑝 𝑞 𝑟 𝑠 𝑡 𝑢 𝑣 𝑤 𝑥 𝑦 𝑧 𝑨 𝑩 𝑪 𝑫 𝑬 𝑭 𝑮 𝑯 𝑰 𝑱 𝑲 𝑳 𝑴 𝑵 𝑶 𝑷 𝑸 𝑹 𝑺 𝑻 𝑼 𝑽 𝑾 𝑿 𝒀 ...

207+CJK Unified Ideographs Extension B

208+𠀀𠀁𠀂𠀃𠀄𠀅𠀆𠀇𠀈𠀉𠀊𠀋𠀌𠀍𠀎𠀏𠀐𠀑𠀒𠀓𠀔𠀕𠀖𠀗𠀘𠀙𠀚𠀛𠀜𠀝𠀞𠀟𠀠𠀡𠀢𠀣𠀤𠀥𠀦𠀧𠀨𠀩𠀪𠀫𠀬𠀭𠀮𠀯𠀰𠀱𠀲𠀳𠀴𠀵𠀶𠀷𠀸𠀹𠀺𠀻𠀼𠀽𠀾𠀿𠁀𠁁𠁂𠁃𠁄𠁅𠁆𠁇𠁈𠁉𠁊𠁋𠁌𠁍𠁎𠁏𠁐𠁑𠁒𠁓𠁔𠁕𠁖𠁗𠁘𠁙𠁚𠁛𠁜𠁝𠁞𠁟𠁠𠁡𠁢𠁣𠁤𠁥𠁦𠁧𠁨𠁩𠁪𠁫𠁬𠁭𠁮𠁯𠁰𠁱𠁲𠁳𠁴𠁵𠁶𠁷𠁸𠁹𠁺𠁻𠁼𠁽𠁾𠁿 ...

209+CJK Compatibility Ideographs Supplement

210+丽丸乁𠄢你侮侻倂偺備僧像㒞𠘺免兔兤具𠔜㒹內再𠕋冗冤仌冬况𩇟凵刃㓟刻剆割剷㔕勇勉勤勺包匆北卉卑博即卽卿卿卿𠨬灰及叟𠭣叫叱吆咞吸呈周咢哶唐啓啣善善喙喫喳嗂圖嘆圗噑噴切壮城埴堍型堲報墬𡓤売壷夆多夢奢𡚨𡛪姬娛娧姘婦㛮㛼嬈嬾嬾𡧈寃寘寧寳𡬘寿将当尢㞁屠屮峀岍𡷤嵃𡷦嵮嵫 ...

211+Tags

212+󠀁 󠀠 󠀡 󠀢 󠀣 󠀤 󠀥 󠀦 󠀧 󠀨 󠀩 󠀪 󠀫 󠀬 󠀭 󠀮 󠀯 󠀰 󠀱 󠀲 󠀳 󠀴 󠀵 󠀶 󠀷 󠀸 󠀹 󠀺 󠀻 󠀼 󠀽 󠀾 󠀿 󠁀 󠁁 󠁂 󠁃 󠁄 󠁅 󠁆 󠁇 󠁈 󠁉 󠁊 󠁋 󠁌 󠁍 󠁎 󠁏 󠁐 󠁑 󠁒 󠁓 󠁔 󠁕 󠁖 󠁗 󠁘 󠁙 󠁚 󠁛 󠁜 󠁝 󠁞 󠁟 󠁠 󠁡 󠁢 󠁣 󠁤 󠁥 󠁦 󠁧 󠁨 󠁩 󠁪 󠁫 󠁬 󠁭 󠁮 󠁯 󠁰 󠁱 󠁲 󠁳 󠁴 󠁵 󠁶 󠁷 󠁸 󠁹 󠁺 󠁻 󠁼 󠁽 󠁾 󠁿

213+Supplementary Private Use Area-A

214+󰀀 󰀁 󰀂 󰀃 󰀄 󰀅 󰀆 󰀇 󰀈 󰀉 󰀊 󰀋 󰀌 󰀍 󰀎 󰀏 󰀐 󰀑 󰀒 󰀓 󰀔 󰀕 󰀖 󰀗 󰀘 󰀙 󰀚 󰀛 󰀜 󰀝 󰀞 󰀟 󰀠 󰀡 󰀢 󰀣 󰀤 󰀥 󰀦 󰀧 󰀨 󰀩 󰀪 󰀫 󰀬 󰀭 󰀮 󰀯 󰀰 󰀱 󰀲 󰀳 󰀴 󰀵 󰀶 󰀷 󰀸 󰀹 󰀺 󰀻 󰀼 󰀽 󰀾 󰀿 󰁀 󰁁 󰁂 󰁃 󰁄 󰁅 󰁆 󰁇 󰁈 󰁉 󰁊 󰁋 󰁌 󰁍 󰁎 󰁏 󰁐 󰁑 󰁒 󰁓 󰁔 󰁕 󰁖 󰁗 󰁘 󰁙 󰁚 󰁛 󰁜 󰁝 󰁞 󰁟 󰁠 󰁡 󰁢 󰁣 󰁤 󰁥 󰁦 󰁧 󰁨 󰁩 󰁪 󰁫 󰁬 󰁭 󰁮 󰁯 󰁰 󰁱 󰁲 󰁳 󰁴 󰁵 󰁶 󰁷 󰁸 󰁹 󰁺 󰁻 󰁼 󰁽 󰁾 󰁿 ...

215+Supplementary Private Use Area-B

216+􀀀 􀀁 􀀂 􀀃 􀀄 􀀅 􀀆 􀀇 􀀈 􀀉 􀀊 􀀋 􀀌 􀀍 􀀎 􀀏 􀀐 􀀑 􀀒 􀀓 􀀔 􀀕 􀀖 􀀗 􀀘 􀀙 􀀚 􀀛 􀀜 􀀝 􀀞 􀀟 􀀠 􀀡 􀀢 􀀣 􀀤 􀀥 􀀦 􀀧 􀀨 􀀩 􀀪 􀀫 􀀬 􀀭 􀀮 􀀯 􀀰 􀀱 􀀲 􀀳 􀀴 􀀵 􀀶 􀀷 􀀸 􀀹 􀀺 􀀻 􀀼 􀀽 􀀾 􀀿 􀁀 􀁁 􀁂 􀁃 􀁄 􀁅 􀁆 􀁇 􀁈 􀁉 􀁊 􀁋 􀁌 􀁍 􀁎 􀁏 􀁐 􀁑 􀁒 􀁓 􀁔 􀁕 􀁖 􀁗 􀁘 􀁙 􀁚 􀁛 􀁜 􀁝 􀁞 􀁟 􀁠 􀁡 􀁢 􀁣 􀁤 􀁥 􀁦 􀁧 􀁨 􀁩 􀁪 􀁫 􀁬 􀁭 􀁮 􀁯 􀁰 􀁱 􀁲 􀁳 􀁴 􀁵 􀁶 􀁷 􀁸 􀁹 􀁺 􀁻 􀁼 􀁽 􀁾 􀁿 ...

benchmark/Streamly/Benchmark/Unicode/data/Deutsch.txtnew file+153

@@ -0,0 +1,153 @@

1+Der FC Bayern München (offiziell: Fußball-Club Bayern, München eingetragener Verein)[1] ist ein Sportverein aus München. Die seit 2002eine eigene Aktiengesellschaft ausgegliederte Profifußballabteilung ist deutscher Rekordmeister, Rekordsieger im DFB-Pokal, Ligapokal sowie Supercup und belegtder Ewigen Tabelle der Bundesliga den ersten Platz. Damit ist Bayern München im Profifußball der erfolgreichste deutsche Fußballverein.

2+Auf europäischer Ebene gehört der FC Bayern mit sechs Europapokalsiegen, davon vierder Champions League bzw. dem Europapokal der Landesmeister, zu den fünf erfolgreichsten Vereinen. Neben Juventus Turin und Ajax Amsterdam ist er einer der Vereine, die sowohl den Europapokal der Landesmeister, bzw. Champions League, den UEFA-Pokal, als auch den Europapokal der Pokalsieger gewinnen konnten. Zweimal gewann der FC Bayern München zudem den Weltpokal.

3+Auch wirtschaftlich gehört der Verein zu den weltweit erfolgreichsten: Nach der Saison 2009/10 belegten die Bayern Rang vierder Rangliste der umsatzstärksten Klubs und im April 2011 den gleichen Rangder Liste der wertvollsten Vereine des Forbes Magazine.[2] Mit 171.345 Vereinsmitgliedern (Stand: 18. November 2011) ist der FC Bayern einer der mitgliederstärksten Sportvereine weltweit. Innerhalb der letzten zwölf Monate stieg die Zahl um über 11.000 Mitglieder. Der Verein hat 2952 offizielle Fanclubs (Vorjahr: 2764) mit insgesamt 204.235 registrierten Mitgliedern. Dies ist ein Anstieg von über 12.000 Mitgliedern.[3][4]

4+Seit 1965 spielt der FC Bayern ununterbrochender Bundesliga, lediglich die ersten zwei Jahre nach Einführung der Bundesliga war die Mannschaft zweitklassig. Die zweite Mannschaft des FC Bayern spielt zurzeitder viertklassigen Regionalliga Süd. Sie gewannder Saison 2003/04 den Meistertitelder damals noch drittklassigen Regionalliga Süd.

5+Zum FC Bayern gehören zudem weitere Abteilungen, die auch einige Erfolge aufweisen können. So wurden die derzeitder Frauen-Bundesliga spielenden Fußballfrauen 1976 Deutscher Meister. Weitere Erfolge feierten die Basketballer mit zwei Meisterschaften und einem Pokalsieg, die Schachabteilung mit neun Deutschen Meisterschaften und einem Europapokalsieg sowie die Turner mit vier Deutschen Meisterschaften.

7+Am 27. Februar 1900 fand im Gasthaus „Bäckerhöfl“ eine Sitzung der Fußballabteilung des MTV München statt. Es war kurz zuvor zu einem Streit über die weitere Entwicklung der Fußballabteilung gekommen, da eine Generalversammlung des MTV dem Beitritt des Vereins zum süddeutschen Fußballverband eine Absage erteilt hatte. Um 21:30 Uhr verließen elf Männer, Nägele, Schmid, Karl, Wamsler, Ringler, Focke, Francke, Friedrich, Zöpfel, Pollack und John das Lokal und fanden sich im Restaurant „Gisela“Schwabing ein, um noch am selben Abend den FC Bayern München zu gründen.[5] Den Vorsitz führte Franz John, der auch der erste Vorsitzendeder Geschichte der Bayern werden sollte. Als Vereinsfarben wählte man Blau-Weiß, der Mitgliedsbeitrag wurde auf eine Mark festgesetzt.

8+Als erster Trainingsplatz diente der stadteigene, heute noch existierende Schyrenplatz. Der erste Gegner war im März 1900 der 1. Münchner FC 1896, der FC Bayern gewann das Spiel mit 5:2. Schnell stießen weitere Spieler zum Verein, so unter anderem drei Spieler der Fußballabteilung des TV München 1860. Im Frühjahr 1900 überließen die Geschäftsleute Wamsler dem FC Bayern ein Grundstück an der Clemensstraße als Spielstätte. Das erste Spiel einer langen und traditionsreichen Derbygeschichte zwischen dem FC Bayern und den „Sechzigern“ fand im Jahr 1902 statt. Der FC Bayern gewann das Spiel mit 3:0. Um den Spielbetrieb auszuweiten, beschloss der Verein 1906 den Übertritt zum Münchner Sport-Club, behielt aber eine gewisse Eigenständigkeit bei, was sichder Bezeichnung „F.A. Bayern im Münchner SC“ (F.A. = Fußballabteilung) ausdrückte. Infolge der Fusion trat Bayern nunweißen Hemden und roten Hosen an, diese Farben lösten damit das Blau-Weiß aus der Gründungszeit ab, die Bezeichnung Die Roten war geboren. Auf lokaler Ebene entwickelten sich die „Bayern“ zur unangefochtenen Nummer Eins im Fußball, im Wettbewerb auf süddeutscher Ebene waren sie hingegen weniger erfolgreich. Zu sehr dominierten zu dieser Zeit noch die Mannschaften, die bereitsden 1890er Jahren entlang des Oberrheins zwischen Freiburg und Frankfurt entstanden waren und sich weiterentwickelt hatten, das Fußballgeschehen.

9+1907 mussten die Bayern die Sportanlage an der Karl-Theodor-Straße aufgeben und zum Sportplatz an der Leopoldstraße umziehen. Eingeweiht wurde damit auch die erste Tribüne auf einem FußballplatzMünchen. Im Eröffnungsspiel gab es ein 8:1 gegen Wacker München. Bereits 1908 hatte der FC Bayern mehr als 300 Mitglieder, acht Mannschaften und mehr als 100 Jugendspieler. Dies hatte eine Satzungsänderung zur Folge, wodurch Verwaltungsarbeit und der Sportbereich getrennt wurden. Die Spieler hatten dadurch mehr Zeit sich auf den Sport zu konzentrieren. 1910 konnten sie das erste Mal an der Endrunde zur Süddeutschen Meisterschaft teilnehmen. Am Ende belegte der FCB den 2. Platz hinter dem Karlsruher FV. Im selben Jahr stellten die Bayern mit Max Gablonsky ihren ersten Nationalspieler.

10+Während des Ersten Weltkrieges kam der Sport zeitweise zum Erliegen und im Verein und dessen Umfeld gab es ein ständiges Auf und Ab. Erst von der Spielzeit 1919/20 an warSüddeutschland wieder ein regelmäßiger Ligabetrieb gewährleistet. Im Oktober 1919 traten die Bayern aus dem Münchner SC aus und fusionierten mit dem Turnverein Jahn zum TuSpV Bayern. William Townley wurde erneut als Trainer verpflichtet, womit man die Tradition der englischen Trainer im Verein fortsetzte. Bereitsden Vorkriegsjahren hatten die Bayern mit Coach Taylor, Hoer und Charles Griffith drei Engländer als Trainer, von denen letzterer der erste hauptberufliche Bayerntrainer war.

11+Im Frühjahr 1924 trennte man sich im Zuge der reinlichen Scheidung wieder vom TuSpV Bayern und trat fortan nur noch als eigenständiger Verein unter dem Namen „FC Bayern München“ auf. Mit dem Schotten Jim McPherson setzten die Bayern erneut auf einen britischen Trainer. 1926 spielten die Bayern um die Süddeutsche Meisterschaft. Die härtesten Konkurrenten kamen damals mit dem 1. FC Nürnberg und der SpVgg. Fürth, die damals als beste Mannschaft Deutschlands galt, aus Bayern. Das Rückspiel gegen Fürth im Grünwalder Stadion wurde live im Radio übertragen und nach einem dramatischen Spiel gewann der FCB mit 4:3. Die Bayern waren zum ersten Male Süddeutscher Meister, scheiterten dann aber schon im Achtelfinale um die deutsche MeisterschaftLeipzig gegen den SV Fortuna Leipzig 02 mit 0:2. Bereits 1928 gelang mit dem ungarischen Trainer Leo Weisz der Gewinn der zweiten Süddeutschen Meisterschaft. Erneut qualifizierte man sich damit zur Endrunde um die Deutsche Meisterschaft und über Siege gegen den FC Wacker Halle und die SpVgg Sülz 07 erreichte der FC Bayern das Halbfinale und feierte damit den bis dahin größten Erfolg der Vereinsgeschichte. Im Duisburger Wedaustadion unterlagen die Bayern dem Hamburger SV jedoch deutlich mit 2:8.

12+Nach drei gescheiterten Anläufen zum Gewinn der Deutschen Meisterschaftden Jahren 1926, 1928 und 1929 hatte man 1932 mehr Erfolg. Der Trainerwechsel von Kálmán Konrád zu Richard Dombi 1930 erwies sich somit im Nachhinein als gute Entscheidung. Das Finale um die Süddeutsche Meisterschaft verlor der FC Bayern gegen die Eintracht aus Frankfurt und ging als Süddeutscher Vizemeisterdie Endrunde um die Deutsche Meisterschaft. Der Reihe nach traf man auf Minerva 1893 Berlin und den Polizei SV Chemnitz, ehe man im Halbfinale dem Erzrivalen aus Franken, dem 1. FC Nürnberg, gegenüberstand. Das Spiel fandMannheim statt und die Bayern besiegten den bis dahin fünfmaligen Deutschen Meister mit 2:0. Die Tore erzielten Oskar Rohr und Hans Welker. Im Finale am 12. Juni 1932, dasNürnberg ausgetragen wurde, traf man erneut auf die Frankfurter Eintracht, gegen die man schon im Finale um die Süddeutsche Meisterschaft unterlegen war. Tausende Bayern-Fans machten sich auf den Weg, darunter auch etwa 400 Arbeitslose mit dem Fahrrad. Im Nachhinein übernahm der Verein die Kosten für diese Fans für Übernachtung und Eintrittskarten. Am Tage des Endspiels herrschten 30 Grad im Schatten und 55.000 Zuschauer sahen das Spiel im Stadion.der 35. Minute nahm der Frankfurter Hennes Straub auf der Torlinie die Hand zu Hilfe und es gab Elfmeter für den FC Bayern. „Ossi“ Rohr verwandelte sicher zum 1:0.der zweiten Hälfte drängten die Frankfurter auf den Ausgleich, dochder 75. Minute erzielte Franz Krumm das entscheidende 2:0 für Bayern. Nach dem Abpfiff hielt der FC Bayern München zum ersten Malder Vereinsgeschichte die Victoriader Hand. Zum ersten Mal wurde ein Verein aus München Deutscher Meister und die Mannschaft wurde begeistertder Landeshauptstadt empfangen. Die Siegesfeier fand im Münchener Löwenbräukeller statt, die Spieler wurden auf Pferdekutschen zur Feier gebracht.einer der Festreden hieß es, „was man schon im Vorjahr bei 1860 bestimmt gedacht, hat heuer FC Bayern fertig gebracht“.

13+

14+1933 konnte der Titel nicht verteidigt werden, nachdem der Verein beide Spiele gegen den TSV 1860 München um die Süddeutsche Meisterschaft verloren hatte. Nach der NS-Übernahme der Regierungsgewalt unter der Führung Adolf Hitlers musste Präsident Kurt Landauer auf Grund seiner jüdischen Abstammung auf politischen Druck hin im selben Jahr zurücktreten. Trainer Dombi, ebenfalls jüdischer Abstammung, wechselte kurz daraufdie Schweiz. Der FC Bayern war, im Gegensatz zum Stadtrivalen 1860 München, bei den neuen Machthabern wegen Landauer und Dombi als „Judenclub“ verpönt. Erst Anfang 1943 konnte mit Josef Sauter ein NSDAP-Mitglied als Präsident im Verein eingesetzt werden, die Unterstützung einzelner Spieler für Landauer bei einem Gastspielder Schweiz hatte weitere Repressalien zur Folge.[6]

15+Zudem verließ auch Oskar Rohr den Verein, um Profispieler bei den Grasshoppers Zürich zu werden. Neuer Trainer wurde Hans Tauchert, der aber nicht an die alten Erfolge anknüpfen konnte und bereits 1934 durch Ludwig Hofmann ersetzt wurde. Hofmann verstarb aber bereits kurze Zeit später an einer Halserkrankung und Richard Michalke übernahm das Amt des Trainers. Damit war die Talfahrt allerdings noch nicht beendet und so stand man im Jahre 1939 kurz vor dem ersten Abstiegder Geschichte des Vereins, konnte die Klasse jedoch gerade noch halten. Im Verlauf des Krieges wurden die Gauligen weiter regionalisiert, um die Wege für die Vereine für Auswärtsspiele möglichst kurz zu halten. Waren die Bayern anfangsder Gauliga Bayern, spielten sie anschließendder Gauliga Südbayern, die durch die Aufteilung der Gauliga Bayern entstand. Kurz vor Ende des Krieges spielte mander Gauliga München-Oberbayern. Im Jahre 1944 konnten Die Roten wieder eine Süddeutsche Meisterschaft gewinnen und qualifizierten sich so erneut für die Endrunde um die Deutsche Meisterschaft. Bereits im Achtelfinale verlor man jedoch nach Verlängerung gegen den VfR Mannheim. Am 13. Juli desselben Jahres wurden die Geschäftsstelle und ein Teil des Archivs bei Bombenangriffen zerstört. Im darauffolgenden Jahr qualifizierte man sich unter Spielertrainer Conny Heidkamp erneut für die Endrunde um die Deutsche Meisterschaft. Die Endrunde wurde im Jahr des Endes des Zweiten Weltkriegs jedoch nicht ausgetragen. Da das Stadion an der Grünwalder Straße bei Bombenangriffen 1943 zerstört und erst im August 1945 wieder freigegeben wurde, trug der FC Bayern seine Spielediesen Jahren im Dantestadion (1943–1944), auf dem Platz an der Schlierseestraße (1944–1945) und auf dem Sportplatz der Hypobank an der Grünwalder Straße (1945) aus.

16+

17+Nach Ende des Zweiten Weltkriegs wurden alle deutschen Sportvereine durch den Alliierten Kontrollrat aufgelöst und mussten zur Neugründung eine Lizenz beantragen. Spieler des FC Bayern fanden alsbald wieder zusammen, bestritten am 24. Juni 1945 gegen den FC Wacker München das erste Spiel nach Kriegsende und stiegen im November desselben Jahresden Spielbetrieb der Oberliga Süd ein. Der Neuanfang nach dem Krieg war schwierig, fast jährlich wechselten die Trainer und der sportliche Erfolg hielt sich zunächstGrenzen. Im Juni 1947 kehrte Kurt Landauer aus dem Exil zurück, wurde wenige Wochen später erneut zum 1. Vorsitzenden des Vereins gewählt. Seine vierte und letzte Amtszeit endete 1951.

18+Die Mitgliederzahlen des Vereines entwickelten sichden Nachkriegsjahren positiv. Bald zählte der FC Bayern erneut mehr als 1000 Mitglieder, auch die Jugendabteilungen erlebten regen Zulauf. 1949 erreichte man nochmals die Qualifikationsspiele zur Deutschen Meisterschaft über einen 3. Tabellenplatzder Oberliga.der Qualifikation traf man auf den FC St. Pauli, verlor aber im Wiederholungsspiel, das bereits am nächsten Tag ausgetragen wurde, mit 0:2. Danach begann eine längere sportliche Talfahrt des Vereins, die sogar im Abstieg gipfelte. 1954/55 stiegen die Bayern zum ersten und einzigen Maleihrer Geschichte aus der damaligen obersten Liga ab. Im Folgejahr gelang allerdings der sofortige Wiederaufstieg.

19+

20+Einer der wenigen sportlichen Höhepunkte der 40er und 50er Jahre war der Gewinn des DFB-Pokals. Im Jahr des Wiederaufstiegs wollten die Bayern ursprünglich gar nicht am DFB-Pokal teilnehmen. Man wollte schlicht Reisekosten sparen. Doch der neue Trainer Willibald Hahn forderte unbedingt eine Teilnahme und konnte sich am Ende gegen die Vereinsführung durchsetzen. Nachdem im Halbfinale der 1. FC Saarbrücken mit 3:1 bezwungen wurde, wartete im Finale die Fortuna aus Düsseldorf. Das Finale fand am 29. Dezember 1957 im Augsburger Rosenaustadion vor 42.000 Zuschauern statt, darunter rund 12.000 Bayernfans. Am Tage des Spiels gab es starke Schneefälle und der Boden war mit Schnee bedeckt. Dies schien den Bayern, die als Außenseiterdas Spiel gingen, sehr entgegenzukommen. Von Anfang an dominierte der FC Bayern das Geschehen und die Fortuna hatte es nur ihrem Torwart Albert Görtz zu verdanken, dass das Spiel lange Zeit 0:0 stand.der 78. Minute gelang es dem überragenden Rudi Jobst nach dreimaligem Anlauf den Ball im Netz unterzubringen. Nachdem man die restliche Spielzeit unbeschadet überstand, war mit dem Abpfiff der erste DFB-Pokalsiegder Geschichte des FC Bayern erreicht.

21+Spieldaten des Endspiels um den DFB-Pokal 1957

22+Nach dem überraschenden Pokalerfolg und dem ersten großen Titel seit 1932 trat wieder die Tristesse der Oberliga ein. Man erreichte nur Platz sieben und es gab neuerlich finanzielle Probleme. Letzteres konnte durch Roland Endler gelöst werden. Der Geschäftsmann aus Neuss, ein großer Fan der Bayern, wurde neuer Präsident und die Finanznöte hatten ein Ende.

23+Mit dem neuen Trainer Adolf Patek ging es 1958/59 zunächst wieder aufwärts. Mit Platz vier zum Ende der Saison erzielte man das beste Resultat seit zehn Jahren.der darauffolgenden Saison wurden dem FC Bayern wegen einer sogenannten „Überbezahlung“ der Spielerder Saison 57/58 vier Punkte abgezogen. Als ursprüngliches Strafmaß waren acht Punkte Abzug vorgesehen, doch ein Einspruch der Bayern brachte eine Strafmilderung. Der Punktabzug führte dennoch dazu, dass der Verein die Endrunde um die Deutsche Meisterschaft verpasste und am Ende nur auf Platz fünf landete. Einziger Höhepunktder Spielzeit 1960/61 war der Sieg im Derby gegen den TSV 1860 München. Nach einem zwischenzeitlichem 2:2 wurden die Löwen am Ende mit 6:2 aus dem Stadion gefegt. Nach einem nur enttäuschenden 8. Platz im Folgejahr musste Trainer Patek seinen Hut nehmen. Für ihn kam Helmut Schneider.

24+In der Saison 1962/63 trat der Verein zum ersten Maleinem renommierten internationalen Wettbewerb auf: Im Viertelfinale des Messestädte-Pokals schied man gegen Dinamo Zagreb aus. National ging es für die Bayern darum, sich für die kommende neue Bundesliga zu qualifizieren. Deshalb musste mehr als nur der 8. Platz der Vorsaison herauskommen. Zudem begann am 28. April 1962 eine neue Ära beim FC Bayern. Zunächst nur kommissarisch für ein Jahr übernahm Wilhelm Neudecker das Präsidentenamt des Vereins. Es sollten weit mehr als nur das eine werden. Der neue Präsident ließ nur die Neuverpflichtung eines gestandenen Spielers zu. Dieser war Herbert Erhardt. Ansonsten durfte Trainer Schneider nur junge Talente an die Isar holen. Einer von ihnen war ein gewisser Sepp Maier. Am 30. Dezember 1962 musste Stammtorhüter Kosar im Angriff aushelfen und Sepp Maier gab sein Debüt für den FC Bayern als gerade mal 18-Jähriger. Bayern beendete die Saison auf dem 3. Tabellenplatz hinter dem 1. FC Nürnberg und dem TSV 1860 München. Damit verpasste man nicht nur die Endrunde um die Deutsche Meisterschaft, man erhielt am 11. Mai 1963 auch die Absage vom DFB für die neue Bundesliga. Die fadenscheinige Begründung lautete: „Das Gremium war der Auffassung, dass […] es nicht ratsam erscheint, zwei Vereinen am gleichen Ort eine Lizenz für die Bundesliga zu erteilen.“ Somit musste der FC Bayern 1963/64der neu geschaffenen Regionalliga antreten. Helmut Schneiders Vertrag war eigentlich schon verlängert, dennoch musste er daraufhin den Verein verlassen.

25+Für ihn kam Zlatko Čajkovski. Das erklärte Saisonziel war das Erreichen der Aufstiegsrunde zur Bundesliga. Dieses Ziel konnte mit einem zweiten Platz am Ende der Saison auch erreicht werden. Am 6. Juni 1964 besiegte man im ersten Spiel der Aufstiegsrunde den FC St. Pauli mit 4:0. Es war das erste Pflichtspiel des damals erst 18 Jahre alten Franz Beckenbauer.[7][8]seinem ersten Spiel für die Bayern gelang ihm auch gleich sein erstes Tor. Beckenbauer hatte sich gegen einen Wechsel zum TSV 1860 München und für den FC Bayern entschieden, nachdem ereinem Spiel seines SC München von 1906 gegen den TSV 1860 von einem Gegenspieler geohrfeigt worden war. Dem FC Bayern fehlte am Ende nur ein Punkt zum Aufstieg und es hieß einen neuen Anlauf zu nehmen. Hatten bereitsden beiden Jahren zuvor Maier und Beckenbauer verpflichtet werden können, fehlte jetzt nur noch ein Baustein als Grundlage für die bald folgenden großen Jahre des FC Bayern München. Im Frühjahr 1964 hatte sich der Präsident des TSV 1860 MünchenNördlingen angesagt, um der Familie Müller einen Besuch abzustatten, um deren Sohn zum TSV zu lotsen. Da auch die Bayern Interesse an dem kleinen bulligen Stürmer hatten und davon Wind bekamen, erschienen sie eine Stunde früherNördlingen. Der TSV bot dem jungen Mann nur einen Amateurvertrag über ein Jahr, der FC Bayern einen Profivertrag. Der spätere „Bomber der Nation“, Gerd Müller, wechselte daher im Sommer zum FC Bayern. Čajkovski war gar nicht begeistert von der Verpflichtung des jungen, gedrungenen Stürmers und sagte: „Was soll isch mit dieses Junge, diese Figur, unmöglich.“ Später nannte er ihn liebevoll „kleines dickes Müller“.[9]

26+Gleichseinem ersten Spiel am 18. Oktober 1964 traf Müller zum 3:0 gegen den Freiburger FC. Zum Ende der Saison 1964/65 stand man mit einem Rekordtorverhältnis von 146:32 als Meister der Regionalliga Süd fest. Gerd Müller erzielte dabei26 Spielen 33 Tore und trugseiner ersten Saison maßgeblich zur Meisterschaft bei.der Aufstiegsrunde machte man gegen Tennis Borussia Berlin alles klar. Der Verein gewann mit 8:0Berlin und stieg damitdie Bundesliga auf.

27+Vor der ersten Bundesligasaison der Bayern schimpfte Čajkovski, dass er keine fertigen Spieler habe und zufrieden wäre, wenn man die Klasse halten würde. Doch die Mannschaft sollte ihn Lügen strafen. Die Bayern starteten gleich voll durch. Auch wenn man am ersten Spieltag im Derby gegen den TSV 1860 mit 0:1 als Verlierer vom Platz ging, so standen die Bayern am vierten Spieltag das erste Mal an der Tabellenspitze der Bundesliga. Zwar konnte diese nicht gehalten werden, aber das prestigeträchtige Rückspiel gegen den Lokalrivalen TSV 1860 konnte mit 3:0 gewonnen werden, und am Ende belegte man einen mehr als beachtlichen dritten Tabellenplatz. Es war das einzige Malder Geschichte der Bundesliga, dass beide Teams aus München am Ende einer Saison unter den ersten Drei standen. Platz dreider Liga war den Bayern allerdings längst nicht genug. Es gelang ihnen zum zweiten Malder Vereinsgeschichte den DFB-Pokal zu holen. Nach einem klasse Spiel gegen den Meidericher SV behielten die Bayern mit 4:2 die Oberhand und brachten den Pokal nach Hause. Sepp Maier sagte nach dem Spiel: „Hoaß war’s, gschwitzt hamma, und gwunna a no. Grad sche war’s!“ 1966 kamen damit sowohl der Meister der Bundesliga als auch der Pokalsieger aus München.

28+

29+In der nächsten Saison, 1966/67, blieb das Team nahezu unverändert. Einzig Franz „Bulle“ Roth kam aus Kaufbeuren hinzu, Georg Schwarzenbeck verstärkte das Team aus dem eigenen Nachwuchs. Nach dem Auftritt im inoffiziellen Messestädte-Pokal spielte der FC Bayern erstmalseinem von der UEFA veranstalteten internationalen Wettbewerb, dem Europapokal der Pokalsieger. Diese Saison des Pokalsiegerwettbewerbs wurde zum ersten großen Triumphzug der Bayern auf europäischer Bühne. Über Tatran Prešov, die Shamrock Rovers, Rapid Wien und Standard Lüttich erreichte der FC Bayern völlig überraschend das Finale, das fast zu einem Heimspiel mutierte, da esNürnberg stattfand. An gleicher Stelle hatten die Bayern schon 35 Jahre zuvor den ersten wichtigen Titel für den Verein gewinnen können.

30+Vor 71.000 Zuschauern erzielte Bulle Rothder Verlängerung (108. Minute) das 1:0 für die Münchner. Gegner im Finale waren die Glasgow Rangers, die zuvor im Achtelfinale den Titelverteidiger Borussia Dortmund aus dem Wettbewerb geworfen hatten. Roth, der Schütze zum einzigen Tor im Finale, hatte zwei Jahre zuvor nochder C-Klasse beim TSV Bertoldshofen gespielt und erzielte jetzt das entscheidende Tor zum ersten internationalen Titel des FC Bayern München. Nach Borussia Dortmund im Jahr zuvor gewann damit erneut ein deutscher Verein den Pokal der Pokalsieger.

31+Die reguläre Bundesliga-Saison schloss der FC Bayern zwar nur auf Platz sechs ab, jedoch konnte man den DFB-Pokal erfolgreich verteidigen. Auch dieses Finale fand nicht weit von München entfernt statt.Stuttgart sahen 68.000 Zuschauer den erneuten Pokaltriumph der Bayern. Mit 4:0, durch Tore von Müller (2), Ohlhauser und Brenninger (je 1), hatte der Hamburger SV mit Uwe Seeler keine Chance.

32+

33+Dies war der dritte Pokalerfolg innerhalb von zwölf Monaten. Franz Beckenbauer wurde das erste Malseiner noch jungen Karriere zum „Fußballer des Jahres“ gewählt. Die darauf folgende Saison 1967/68 war nicht das Jahr der Bayern. Im Halbfinale des Europapokals der Pokalsieger 1967/68 scheiterte man am späteren Sieger AC Mailand, im DFB-Pokal warf der damalige Regionalligist VfL Bochum den Titelverteidiger im Halbfinale aus dem Wettbewerb. Die Bundesliga schloss man nur als Fünfter ab. Viel wichtiger aber war wohl, dass man erstmalsder Geschichte der Bundesliga am Erzrivalen TSV 1860 vorbeizog und zwar sowohlder Tabelle als auchder Gunst der ZuschauerMünchen. War vorher der TSV der größere von beiden Münchner Vereinen, so hat der FC Bayern München ihn jetzt überholt. Und daran änderte sich bis heute nichts.

34+Tschik Čajkovski verließ 1968 nach fünf erfolgreichen Jahren den Verein Richtung Hannover 96. Für ihn kam Branko Zebec. Mit ihm kamen auch Gustl Starek und Peter Pumm. Beide sollten sichZukunft als tragende Säulen seines Konzepts, das auf eine starke Defensive setzte, erweisen. Sein Rezept ging auf und die Bayern gewannen zum ersten Malder Vereinsgeschichte das Double aus Meisterschaft und Pokal. Gleichzeitig gelang zum ersten Mal seit 1937 wieder einem Verein das Double (damals dem FC Schalke 04). Eben jenen FC Schalke bezwang man im Pokalendspiel mit 2:1. Vor dem Spiel nahm Gerd Müller die Ehrung für den „Fußballer des Jahres“ entgegen und Branko Zebec holteseinem ersten Jahr als Trainer gleich Meisterschaft und Pokal.

35+

36+Am 13. März 1970 löste Udo Lattek den bisherigen Trainer Zebec ab. Mit der Amtsübernahme Latteks begann für den FC Bayern eine neue, noch erfolgreichere Ära. Unter Lattek brachte der FC Bayern die Saison 1969/70 als Zweiter zu Ende. Gerd Müller wurde zum dritten Male Torschützenkönig der Bundesliga mit der Rekordtorzahl von 38 Toreneiner Saison. Zudem wurde er Torschützenkönig bei der Fußball-WM 1970Mexiko.diesem Sommer beendete der langjährige Kapitän Werner Olk seine aktive Karriere. Meister wurde Borussia Mönchengladbach vor den Bayern. Die Rivalität zwischen diesen beiden Vereinen sollte kennzeichnend für die 70er Jahre werden. Beide holtendieser Zeit insgesamt acht Mal die deutsche Meisterschaft. Auchder Folgesaison blieb den Münchnern erneut nur der zweite Platz hinter der Fohlen-Elf aus Gladbach. Belächelte man anfangs die Verpflichtung Latteks, so wurden die Kritiker doch schon früh eines Besseren belehrt. Udo Lattek war bis dahin ohne große Trainererfahrung, dochseiner ersten vollen Saison als Cheftrainer gewann sein Team den DFB-Pokal und wurde erneut Vizemeister. Vor dem Pokalfinale bekam Gerd Müller wiederum eine Auszeichnung als Torschützenkönig, diesmal jedoch sogar als bester Torschütze Europas. Im Finale gegen den 1. FC Köln lagen die Bayern schon nach 13 Minuten mit 0:1 zurück ehe Beckenbauerder 53. Minute ausgleichen konnte. Dem für Franz Roth eingewechselten Edgar Schneider gelang dannder 118. Minute das Siegtor. Die Bayern hatten damit bereits zum fünften Mal das Pokalfinale erreicht und den DFB-Pokal gewonnen. Noch kein Einziges der Finals ging verloren. Es sollte aber der vorerst letzte Pokaltriumph der Bayern für eine ganze Dekade sein. Nach Olkder Vorsaison verließen nun mit Ohlhauser und Starek zwei weitere Leistungsträger den Verein.

37+Spieldaten des Endspiels um den DFB-Pokal 1971

38+Vor Beginn der neuen Spielzeit verpflichtete der Verein zwei neue Spieler, die später noch die Zukunft des FC Bayern maßgebend bestimmen sollten: Uli Hoeneß und Paul Breitner. Beide waren damals gerade 18 Jahre alt. Die Saison 1971/72 wurde für den Verein zum Jahr der Rekorde. Vom ersten Spieltag an blieb man 14 SpieleFolge ohne Niederlage. Am Ende wurde man mit 55 Punkten und 101 erzielten Toren Meister. 40 Tore davon erzielte allein Gerd Müller. Zudem wurde Borussia Dortmund mit 11:1 vom Platz gefegt. Dies alles war noch nie dagewesender noch jungen Geschichte der Bundesliga. Einige der Rekorde haben bis heute Bestand. Am 28. Juni 1972 bestritt der FC Bayern München sein erstes Heimspiel im Olympiastadion. Es war gleichzeitig das letzte Spiel der Saison.einem „Endspiel“ um die Meisterschaft wurde der Tabellenzweite Schalke 04 mit 5:1 geschlagen. Bayern war somit erneut Meister. Die Münchner machten auchder nächsten Saison da weiter, wo sieder Vorsaison aufgehört hatten. Vom ersten bis zum letzten Spieltag hieß der Tabellenführer FC Bayern München und wurde mit elf Punkten Vorsprung Meister vor dem 1. FC Köln. Nun war der FCB bereit für höhere AufgabenEuropa. 1974 verteidigte man zum zweiten Mal hintereinander die Meisterschaft, Gerd Müller wurde zum dritten MalFolge Torschützenkönig der Bundesliga und der FC Bayern München bestieg nun zum ersten Mal „Europas Thron“.

39+In der ersten Runde des Europapokals der Landesmeister kamen die Bayern dabei erst durch ein Elfmeterschießen im Rückspiel beim schwedischen Meister Åtvidabergs FF eine Runde weiter. Danach kam es zum deutsch-deutschen Duell zwischen dem FC Bayern München und Dynamo Dresden. Zur Halbzeit führte Dynamo mit 3:2München, doch die Münchner konnten das Spiel noch drehen und mit 4:3 gewinnen. Somit hatte Dresden eine gute Ausgangssituation für das Rückspiel. Doch die Roten gingen bereits nach zwölf Minuten durch zwei Tore von Hoeneß mit 2:0Führung. Kurz nach der Halbzeitpause gelang den Sachsen allerdingsder 52. Minute der Ausgleich und vier Minuten später sogar der Führungstreffer zum 3:2. Gerd Müller glich jedochder 56. Minute zum 3:3-Endstand aus. Die nächsten beiden Runden überstand man relativ leicht gegen ZSKA Sofia und Újpest Budapest und stand im Finale Atlético Madrid gegenüber. Es war kein herausragendes Spiel und die Konsequenz war ein 0:0 nach 90 Minuten. Sechs Minuten vor Ende der Verlängerung gelang Luis Aragonés das 1:0 für Madrid durch einen Freistoß. Der Schiedsrichter hatte die Pfeife schon im Mund, als Georg „Katsche“ Schwarzenbeck den Ball von Beckenbauer zugespielt bekam. Er sah keine Anspielstation im Mittelfeld, Beckenbauer rief nur „Schieß einfach!“ und so hielt er aus 30 Metern einfach aufs Tor: 1:1der 119. Minute. Schwarzenbeck ging mit diesem Tordie Geschichte des Fußballs ein.

40+Das 1:1 bedeutete nach damaligen Regeln ein Wiederholungsspiel, das nur zwei Tage später an gleicher Stelle stattfinden sollte.diesem Spiel behielten die Münchner klar die Oberhand und schlugen Atlético mit 4:0. Zum ersten Mal gewann eine deutsche Mannschaft den Pokal der Landesmeister.

41+

42+1974 verließ Paul Breitner den FC BayernRichtung Real Madrid und es kamen zwei neue Spieler, Klaus Wunder vom MSV Duisburg und ein erst 18-jähriger Stürmer namens Karl-Heinz Rummenigge aus Lippstadt. Rummenigge und Breitner sollten Jahre später als Breitnigge für Furore sorgen. Zunächst aber schied man als beste Mannschaft Europas gegen den MSV Duisburg bereitsder dritten Hauptrunde des DFB-Pokals aus.der Liga erreichte man nur den zehnten Tabellenplatz. Da esder Liga nicht lief, kam es zur Winterpause zu einem Krisengespräch zwischen Lattek und Präsident Neudecker. Lattek schilderte das Gespräch später so: „Herr Neudecker, wir müssen etwas ändern.“ worauf Neudecker mit „Sie haben recht. Sie sind gefeuert.“ antwortete. Neuer Trainer wurde Dettmar Cramer.

43+Mit Cramer konnte zwar auch nicht die Bundesligasaison gerettet werden, aber passend zum 75- jährigen Vereinsjubiläum gewann der FC Bayern erneut den Pokal der Landesmeister. Über den 1. FC Magdeburg, Ararat Eriwan und den AS Saint-Étienne konnte erneut das Finale erreicht werden. Auf den 1. FC Magdeburg hätte man bereits ein paar Tage früher im Europäischen Supercup treffen können, da Magdeburg den Pokal der Pokalsieger 1974 im Mai gegen den AC Mailand gewonnen hatte. Für den Supercup konnte man sich jedoch auf keinen Termin einigen, so dass das Aufeinandertreffen im Pokal der Landesmeister zusätzlich zum Supercup-Ersatz geriet. Ebenso wie im Jahr zuvor gegen Dynamo Dresden tat man sich auch gegen die Magdeburger schwer, kam aber letzten Endes doch eine Runde weiter.Paris, wo das Finale stattfand, setzten sich die Münchner klar mit 2:0 gegen Leeds United durch.

44+Spieldaten des Endspiels um den Pokal der Landesmeister 1975

45+1975/76 lief es zunächst auch unter Cramer nicht besserder Bundesliga. Zur Winterpause belegte man nur Platz zehn. Die Spiele um den UEFA Super Cup gegen Dynamo Kiew verlor man ebenfalls. Doch nach der Winterpause lief es besser und der Verein belegte am Ende den dritten Tabellenplatz. Im DFB-Pokal kamen die Bayern bisHalbfinale, wo man am Hamburger SV scheiterte. Nach Jeunesse Esch, Malmö FF und Benfica Lissabon standen die Bayern im Halbfinale des Pokals der Landesmeister Real Madrid gegenüber. Das Rückspiel im Olympiastadion war restlos ausverkauft, wollte man doch auch Paul Breitner und Günter NetzerDiensten von Real sehen. Nach einem 1:1 im Hinspiel gewann man mit zwei Toren von Gerd Müller 2:0 und zog zum dritten MalFolge ins Finale ein. Dort trafen die Münchner auf den AS Saint-Étienne. Franz Roth zeichnete sich schon wie im Vorjahr als Torschütze im Finale aus, diesmal jedoch gleich als Goldtorschütze: Sein 1:0der 57. Minute war das Einzigeder gesamten Partie und zum dritten Mal war der FC Bayern Gewinner des Landesmeisterpokals. Dieses war zuvor nur den Königlichen aus Madrid (fünf MalFolge) und Ajax Amsterdam von 1971 bis 1973 gelungen.

46+Nach den Jahren der internationalen Triumphe befand sich die Mannschaft im Umbruch. Einer der letzten großen Höhepunkte war der Gewinn des Weltpokals. Als erste deutsche Mannschaft holte man den Pokal gegen Cruzeiro Belo Horizonte, während man den Supercup erneut verlor, diesmal gegen den RSC Anderlecht. Franz Beckenbauer wurde zum Fußballer Europas gewählt und verließ zum Ende der Saison den FC BayernRichtung Cosmos New York.der Liga wurde man nur Zwölfter und erlebte eine der bittersten Heimpleiten der Geschichte, als man mit 0:7 gegen den FC Schalke 04 verlor. 65 Gegentoreeiner Spielzeit bedeuten den absoluten Negativrekord für die Münchner.

47+Im Dezember 1977 machte der Verein ein Tauschgeschäft mit Eintracht Frankfurt. Cramer wechselte im Tausch für Trainer Gyula Lóránt an den Main. Bayern wurde nur Tabellenzwölfter, die schlechteste Platzierung der Bundesligageschichte des FC Bayern. Zum Ende der Saison kam Paul Breitner zurück. Für 1,75 Millionen Mark wechselte er von Eintracht Braunschweig zurück an die Isar. Gyula Lóránt wurde bereits im Dezember 1978 beurlaubt und sein bisheriger Co-Trainer Pál Csernai übernahm das Amt des Trainers. Als Nachfolger war Max Merkel im Gespräch, doch die Mannschaft sprach sich gegen ihn aus. Gerd Müller folgte Franz Beckenbauer 1979die USA, Uli Hoeneß wechselte nach Nürnberg und der langjährige Präsident Neudecker trat nach 17 Jahren Amtszeit ab; neuer Präsident wurde Hoffmann. Einziger Lichtblickden unruhigen Zeiten war das neugeschaffene Duo Rummenigge und Breitner, auch Breitnigge genannt. Alleine 26 der erzielten 69 Tore gingen auf das Konto der beiden. Im April 1979 kehrte Uli Hoeneß zum FC Bayern zurück und wurde, obwohl gerade erst 27 Jahre alt, Manager des Vereins.

48+

49+Im Juli 1979 erreichte den Verein die nächste Hiobsbotschaft. Sepp Maier verletzte sich nach einem Autounfall so schwer, dass die Katze von Anzing, wie er auch genannt wurde, seine Karriere frühzeitig beenden musste. Mit 35 Jahren hatte er 473 Bundesligaspiele bestritten, alle für den FC Bayern, davon 442 Spiele in Folge. Maiers Nachfolger wurde Walter Junghans. Auch der letzte Große der 70er-Ära musste seine Karriere frühzeitig beenden. Katsche Schwarzenbeck bestritt am 18. August 1979 sein letztes Bundesligaspiel gegen den FC Schalke 04. Er zog sich eine Achillessehnenverletzung zu, die ihn zwang, seine Karriere zu beenden. Schwarzenbeck bestritt 416 Bundesligaspiele für die Bayern, in denen er 16 Tore erzielte. Andere rückten dafür ins Rampenlicht beim FC Bayern. Klaus Augenthaler, inzwischen Stammspieler, Dieter Hoeneß, der vom VfB Stuttgart an die Isar kam und natürlich Karl-Heinz Rummenigge. Letzterer wurde 1979 zum Fußballer Europas gewählt.

50+Im DFB-Pokal schied man blamablerweise gegen die SpVgg Bayreuth schon in der dritten Hauptrunde aus. Als Vierter des Vorjahres in der Bundesliga startete man im UEFA-Pokal, erreichte dort das Halbfinale und unterlag dort abermals im deutsch-deutschen Duell der Eintracht aus Frankfurt trotz eines 2:0 im Hinspiel. Bereits im Jahr zuvor war man im Achtelfinale des UEFA-Pokals gegen Eintracht Frankfurt ausgeschieden. In der Rückrunde der Bundesliga lieferten sich die Bayern ein Kopf-an-Kopf-Rennen mit dem HSV. Erst am letzten Spieltag kam es zur Entscheidung über die Meisterschaft. Bayern München gewann zu Hause im Olympiastadion mit 2:1 durch Tore von Breitner und Rummenigge. Seit dem Gewinn des Weltpokals 1976 konnte nun der erste Titel für die Bayern und zugleich die erste Meisterschaft seit sechs Jahren gefeiert werden. Der Umbruch, eingeleitet 1977/78, war abgeschlossen und die Bayern fanden in die Erfolgsspur zurück.

51+1980/81 konnte der FC Bayern München erstmals wieder seinen Meistertitel verteidigen, wobei das Duo Breitnigge insgesamt 46 Tore erzielte. Im Pokal der Landesmeister gelangte man bis ins Halbfinale und eliminierte dabei u. a. Ajax Amsterdam. Auch im Halbfinale verlor man kein Spiel gegen den FC Liverpool, musste aber wegen der Auswärtstorregel nach dem 1:1 im Rückspiel in München die Segel streichen. Die Reds aus Liverpool holten im Finale ihren dritten Pokal der Landesmeister. In der dritten Hauptrunde des DFB-Pokals war erneut Endstation. Diesmal war es der 1. FC Kaiserslautern, der die Bayern früh stoppte.

52+Doch im folgenden Jahr holte der Verein elf Jahre nach dem letzten Sieg zum sechsten Mal den Pokal an die Isar. Das Finale im Frankfurter Waldstadion war eines der außergewöhnlichsten in der Geschichte dieses Wettbewerbs, denn Dieter Hoeneß spielte es trotz einer Kopfverletzung, die er sich im Spiel zuzog, mit Kopfverband zu Ende. Die Bayern lagen zur Halbzeit bereits mit 0:2 gegen den Erzrivalen aus Franken, dem 1. FC Nürnberg, zurück. Nach einem Kopfballduell mit Alois Reinhardt zog sich Hoeneß die schwere Kopfverletzung zu, die zunächst nur notdürftig verbunden wurde. In der Halbzeitpause redete sein Bruder Uli ihm zu, er solle die Zähne zusammenbeißen, denn man würde ihn brauchen. Daraufhin ließ Dieter Hoeneß die Wunde ohne Narkose nähen und erschien zur zweiten Halbzeit wieder auf dem Rasen. Der FC Bayern drehte das Spiel noch und Dieter Hoeneß gelang dabei sogar in der 89. Minute das entscheidende Tor zum 4:2 per Kopf. Auch im Europapokal war man wieder erfolgreicher und gelangte ins Finale des Pokals der Landesmeister, unterlag dort jedoch Aston Villa mit 0:1 trotz einer klaren Dominanz im Spielverlauf. In der Meisterschaft machten der HSV und der 1. FC Köln den Titel unter sich aus. Es blieb nur der 3. Platz für die Münchner, nachdem man am Bökelberg gegen Gladbach mit 0:3 unterlag.

53+Spieldaten des Endspiels um den DFB-Pokal 1982 und des Endspiels um den Europapokal der Landesmeister 1982

54+Im Juli 1983 kehrte Udo Lattek als Trainer nach München zurück. Pal Csernai wurde drei Spieltage vor Ablauf der Saison 1982/83 wegen Erfolglosigkeit entlassen. Der FC Bayern konnte diesmal keinen Titel holen und kam auch in kein Finale. So scheiterte man im Pokal der Pokalsieger an der Mannschaft von Alex Ferguson, dem FC Aberdeen, der später auch den Titel holte. In der Bundesliga belegte man nur Platz vier. Zum Saisonende beendete mit Paul Breitner erneut einer der Großen seine Karriere. Mit Jean-Marie Pfaff wurde jedoch auch schon ein neuer Publikumsliebling verpflichtet. Am 33. Spieltag gegen Schalke gab Michael Rummenigge, der Bruder von Karl-Heinz, seinen Einstand bei den Bayern. Unter Lattek folgten nun erneut sehr erfolgreiche Jahre. Die Mannschaft erreichte unter seiner Leitung dreimal hintereinander das Pokalfinale und musste sich nur 1985 Bayer Uerdingen geschlagen geben. Das Finale 1984 gegen Borussia Mönchengladbach musste im Elfmeterschießen entschieden werden. Ausgerechnet Lothar Matthäus, der zur folgenden Spielzeit an die Isar wechselte, verschoss den ersten Elfmeter für Gladbach.

55+Spieldaten des Endspiels um den DFB-Pokal 1984; Spieldaten des Endspiels um den DFB-Pokal 1985 und Spieldaten des Endspiels um den DFB-Pokal 1986

56+Erreichten die Bayern 1985 noch das Halbfinale des Europapokals der Pokalsieger, standen sie 1987 wieder im Finale des Pokals der Landesmeister. Dort traf man in Wien auf den FC Porto, der als Außenseiter in die Partie ging. Bis zur 78. Minute führten die Bayern mit 1:0 durch ein Tor von Ludwig Kögl, ehe Rabah Madjer durch ein sensationelles Hackentricktor der Ausgleich gelang. Nur zwei Minuten später folgte das 2:1 des FC Porto und der FC Bayern verpasste erneut die Chance auf den Gewinn des Europapokals der Landesmeister. Die Meisterschaft konnte man in den Jahren 1985 bis 1987 drei Mal in Folge gewinnen. Mit dem Gewinn der Meisterschaft 1986 löste man den 1. FC Nürnberg als Rekordmeister Deutschlands ab, wobei den Bayern in der Saison 1984/85 das seltene Kunststück gelang, vom ersten bis zum letzten Spieltag Tabellenführer der Bundesliga zu sein. Udo Lattek nahm zum Ende der Saison 1986/87 seinen Hut und verabschiedete sich zum letzten Male von den Bayern. In seinen zwei Amtszeiten als Trainer des FC Bayern München gewann er insgesamt sechs Meisterschaften, dreimal den DFB-Pokal und einmal den Landesmeisterpokal.

57+Spieldaten des Endspiels um den Europapokal der Landesmeister 1987

58+Auf Udo Lattek folgte Jupp Heynckes als Trainer bei den Bayern. In seiner ersten Saison als verantwortlicher Trainer sprang am Ende Platz zwei hinter Werder Bremen heraus. Es folgte erneut ein Umbruch in der Mannschaft, wobei fünf Nationalspieler den Verein verließen. Matthäus und Brehme gingen zu Inter Mailand und Jean-Marie Pfaff verließ den Verein in Richtung Lierse SK. Immerhin 156 Bundesligaspiele hatte Pfaff für die Bayern absolviert. Nachfolger von Pfaff wurde der damals 25-jährige Raimond Aumann. Neu verpflichtet wurden dafür u. a. Stefan Reuter, Olaf Thon und Roland Grahammer. So klappte es dann für Heynckes mit der Meisterschaft im zweiten Anlauf und Roland Wohlfarth wurde mit 17 Treffern Torschützenkönig der Bundesliga. Im DFB-Pokal war man dagegen nicht so erfolgreich und schied bereits in der dritten Runde gegen den Karlsruher SC aus. Im UEFA-Pokal erreichte man immerhin das Halbfinale. Dort scheiterten die Münchner am späteren Pokalsieger SSC Neapel mit dem damaligen Weltstar Diego Armando Maradona. In besserer Erinnerung aus jener Europapokalsaison 1988/89 dürfte jedoch das Achtelfinalrückspiel bei Inter Mailand sein. Nach einem 0:2 im Hinspiel schafften die Bayern das „Wunder von Mailand“ und gewannen das Rückspiel mit 3:1. Ebenfalls legendär war der Auftritt von Trainer Christoph Daum zusammen mit Bayern-Trainer Heynckes im ZDF-Sportstudio. Dabei kam es zum Eklat, als Daum meinte, dass eine Wetterkarte interessanter sei als ein Gespräch mit Heynckes und sich hinterher noch an seine Stirn tippte. Die Person Daum sollte den FC Bayern noch lange begleiten.

59+

60+Für die Saison 1989/90, die ähnlich verlief wie die vorherige Saison, kamen sieben neue Spieler hinzu. Der Meistertitel wurde erfolgreich verteidigt, im DFB-Pokal schied der FC Bayern im Achtelfinale beim VfB Stuttgart aus und im Europapokal der Landesmeister wurde das Halbfinale erreicht, wo man am AC Mailand scheiterte. Das „Tor des Jahrzehnts“ gelang Klaus Augenthaler als er im Pokalspiel bei Eintracht Frankfurt aus 48,90 Metern das entscheidende 1:0 erzielte. Mit Augenthaler, Kohler, Pflügler, Reuter, Thon und Aumann fuhren gleich sechs Bayernspieler zur WM 1990 und kamen als Weltmeister zurück.

61+Die 90er Jahre begannen für die Bayern wie die 80er Jahre endeten. Mit dem Halbfinale im Pokal der Landesmeister erreichte der Verein zum dritten Mal in Folge die Runde der letzten Vier in einem Europapokalwettbewerb. Dies gelang zuletzt fast zehn Jahre zuvor, von 1980 bis 1982. Nach dem SSC Neapel und dem AC Mailand in den Jahren zuvor war diesmal Roter Stern Belgrad Endstation. Dabei schied die Mannschaft knapp und unglücklich aus. Bis zur 90. Minute des Rückspiels führte man mit 2:1 und wäre somit in der Verlängerung gewesen. Doch einen Flatterball von Klaus Augenthaler auf das eigene Tor vermochte Raimond Aumann nicht festzuhalten und mit einem 2:2 zog Roter Stern ins Finale ein. Im DFB-Pokal setzte es ein peinliches 0:1 in der ersten Runde bei den Amateuren vom FV 09 Weinheim, in der Liga wurde man Vizemeister hinter dem 1. FC Kaiserslautern.

62+Zur neuen Saison wechselten Kohler und Reuter zu Juventus Turin. Allein für Kohler erhielten die Bayern rund 15 Millionen Mark an Ablöse,[10] doch die Ablöse konnte den Verlust von Kohler nicht wettmachen. Thomas Berthold wurde vom AS Rom verpflichtet, konnte ihn aber nicht ersetzen. Klaus Augenthaler hatte zudem seine Karriere beendet, in der er 404 Bundesligaspiele für den FC Bayern absolvierte und siebenmal Meister und dreimal Pokalsieger wurde.[11] Raimond Aumann und Brian Laudrup erlitten beide einen Kreuzbandriss. Die Mannschaft bestand nur noch aus einem Gerippe. Für Aumann und den ebenfalls ausgefallenen Ersatztorwart Sven Scheuer wurde kurzfristig Toni Schumacher verpflichtet, der in acht Bundesligaspielen vor der Winterpause 91/92 für die etatmäßige Nummer 1 das Bayerntor hütete.

63+Nach dem Zweitrundenaus im Pokal gegen den FC Homburg und einer 1:4-Heimniederlage gegen die Stuttgarter Kickers war der Druck der Öffentlichkeit so groß, dass der Verein Jupp Heynckes am 8. Oktober 1991 entließ. Laut Raimond Aumann hatten die Spieler Tränen in den Augen, als sich Heynckes von ihnen verabschiedete.[12] Uli Hoeneß, der mit Jupp Heynckes befreundet ist und die Entscheidung der Entlassung mitgetragen hatte, sagte Jahre später mehrmals, dass es seine größte Fehlentscheidung gewesen sei.[13]

64+Betrachtet man die vier Jahre unter Heynckes mit zwei Vizemeisterschaften, zwei Meisterschaften und dem dreimaligen Erreichen des Halbfinals im Europapokal, kann man sicher von einer erfolgreichen Trainerära sprechen. Der öffentliche Druck, der letzten Endes zur Entlassung Jupp Heynckes führte, deutete bereits damals auf die gestiegenen Ansprüche des Vereins, der Fans und der Medien in München hin. Eine Dekade später sollten Trainer trotz zweier Doubles entlassen werden.

65+Nachfolger von Heynckes wurde Søren Lerby, der von 1983 bis 1986 89 Spiele für den FC Bayern absolviert hatte. Doch auch Lerby vermochte das Ruder nicht herumzureißen und so setzte es im Europapokal sogar eine der deftigsten Niederlagen in der Vereinsgeschichte. In der 2. Runde des UEFA-Pokals wurden die Bayern von B 1903 Kopenhagen mit 6:2 deklassiert. Am Ende belegten die Bayern nur Platz zehn in der Bundesliga und qualifizierten sich das erste Mal seit 1979 nicht für einen internationalen Wettbewerb. Im März 1992 wurde Erich Ribbeck als neuer Trainer und Nachfolger von Lerby verpflichtet. Zudem investierte der Verein im Sommer insgesamt 23,5 Millionen Mark in neue Spieler, für damalige Verhältnisse eine unglaubliche Summe. Allerdings verließen Stefan Effenberg und Brian Laudrup den Verein für 17 Millionen gemeinsam zum AC Florenz. Lothar Matthäus kehrte im Gegenzug nach vier Jahren in Italien an die Isar zurück. Dazu kamen Spieler wie Thomas Helmer, Mehmet Scholl und Jorginho. 32 Spieltage blieb der FC Bayern auf Platz eins der Tabelle und wurde am Ende doch nur Zweiter hinter Werder Bremen.

66+1994 holten die Münchner endlich den 13. Meistertitel. Zuvor war in der Winterpause Trainer Ribbeck entlassen worden und der damalige Vizepräsident Franz Beckenbauer übernahm zum ersten Mal den Trainerposten bei seinen Bayern.

67+Zur neuen Spielzeit 1994/1995 wurde Giovanni Trapattoni als Trainer verpflichtet, der jedoch nur ein Jahr an der Isar blieb. Die Sprachprobleme waren zu groß. Als neuer Torhüter stieß Oliver Kahn zu den Bayern, der später zu einer Ikone in München werden sollte. Im Herbst 1994 löste Franz Beckenbauer den seit 1985 amtierenden Fritz Scherer als Präsidenten des Gesamtvereins ab. In der Meisterschaft wurde der FC Bayern nur Sechster, doch konnte unter dem „Mister“ Trapattoni immerhin das Halbfinale des zwischenzeitlich in UEFA Champions League umbenannten Landesmeisterpokals erreicht werden, wo man gegen den späteren Gewinner Ajax Amsterdam allerdings chancenlos war. Wie schon 1990 leistete man sich im DFB-Pokal einen blamablen Ausrutscher in Runde eins. Diesmal hieß der Gegner Vestenbergsgreuth, gegen den man in Nürnberg mit 0:1 unterlag. Durch den Pokalsieg von Borussia Mönchengladbach gelangte der FC Bayern trotz des sechsten Tabellenplatzes doch noch ins internationale Geschäft und konnte in der Folgesaison am UEFA-Pokal teilnehmen. Franz Beckenbauer bezeichnete darauf hin den Wettbewerb als „Cup der Verlierer“.

68+Mit Otto Rehhagel kam in der Folgesaison ein renommierter Trainer an die Isar, der zuvor 14 Jahre lang den SV Werder Bremen trainiert hatte. Doch trotz Platz zwei in der Liga und des Einzugs ins Endspiel des UEFA-Pokals musste Rehhagel am 27. April 1996 seinen Posten räumen. Franz Beckenbauer nahm erneut Platz auf der Bank, doch es blieb in der Bundesliga beim zweiten Platz hinter Borussia Dortmund. Er gewann jedoch die beiden UEFA-Pokal-Endspiele gegen Girondins Bordeaux. Beckenbauer hatte damit den Europapokal der Pokalsieger, den Pokal der Landesmeister, den Weltpokal, die Europa- und die Weltmeisterschaft als Spieler und die WM und den UEFA-Pokal als Trainer gewonnen. Einzig den europäischen Supercup gewann er nie. Jürgen Klinsmann, der vor der Saison von den Tottenham Hotspurs nach München gewechselt war, stellte in dieser UEFA-Pokal-Saison mit 15 Turniertreffern einen neuen Rekord auf.[14]

69+

70+Zur neuen Saison kehrte Giovanni Trapattoni an die Isar zurück und wurde mit dem FC Bayern Deutscher Meister der Saison 96/97. Es war sein erster Titel außerhalb Italiens. 1998 holte er mit den Bayern den DFB-Pokal gegen den MSV Duisburg. Der DFB-Pokalsieg 1998 war zugleich der erste Pokalsieg des Vereins seit nunmehr zwölf Jahren. Nach diesem Erfolg verließ der Italiener die Münchner zum zweiten Mal. Unvergessen blieb dabei seine bekannte Wutrede nach einem 0:1 gegen Schalke am 10. März 1998 in einer Pressekonferenz.

71+Spieldaten des DFB-Pokal Endspiels 1998

72+1998 kam der Meistermacher der Dortmunder Borussia, Ottmar Hitzfeld, als Trapattoni-Nachfolger nach München. Mit Hitzfeld kehrte auch Stefan Effenberg an die Isar zurück, der bereits von 1990 bis 1992 für den FC Bayern gespielt hatte. Er wurde in den nächsten Jahren zu Hitzfelds verlängertem Arm in der Mannschaft. Unter dem neuen Trainer wurde man auf Anhieb Meister. Dabei hatte man am Ende 15 Punkte Vorsprung auf den Vizemeister Bayer Leverkusen und das Triple schien möglich.

73+Die Meisterschaft bereits gesichert, stand man am 26. Mai 1999 im Champions-League-Finale in Barcelona der Mannschaft von Manchester United gegenüber, gegen die man in der Gruppenphase zweimal Unentschieden gespielt hatte. Bereits in der 6. Minute gingen die Bayern durch ein Tor von Mario Basler mit 1:0 in Führung. Der FC Bayern war auch im weiteren Verlauf des Spiels überlegen und hätte sowohl durch Mehmet Scholl als auch Carsten Jancker die Führung weiter ausbauen können. Beide trafen jedoch nur den Torpfosten beziehungsweise die Latte. In der 80. Minute ließ sich Lothar Matthäus, bis dahin einer der besten Spieler auf dem Platz, auf eigenen Wunsch auswechseln. Die Mannschaft hielt bis zur Nachspielzeit das 1:0, jedoch gelang es Manchester durch Tore von Sheringham und Solskjær das Spiel innerhalb von zwei Minuten noch in der Nachspielzeit zu drehen. Dieses Champions-League-Finale ging als eines der denkwürdigsten in die Geschichte ein und noch heute wird über die Auswechslung von Matthäus kontrovers diskutiert.

74+Zweieinhalb Wochen später war Matthäus erneut die tragische Figur, als es im DFB-Pokal-Endspiel gegen Werder Bremen nach Verlängerung 1:1 stand und das Elfmeterschießen entscheiden musste. Den letzten Elfmeter schoss Matthäus, doch Werder-Torwart Rost hielt und somit ging dieses Elfmeterschießen mit 4:5 verloren. Es war das erste Mal, dass der FC Bayern gleich zwei Endspiele in einer Saison verlor. Dies sollte sich in der Saison 2011/12 jedoch in zeitlich umgekehrter Reihenfolge wiederholen.

75+Spieldaten des DFB-Pokal-Endspiels 1999 und Spieldaten des Champions-League-Endspiels 1999

76+Wie fast jedes Jahr gab es auch zur Saison 1999/2000 Neuzugänge und Veränderungen beim FC Bayern. So kamen der damals 17-jährige Roque Santa Cruz, Patrik Andersson und Paulo Sérgio neu zum Verein, Thomas Helmer, Ali Daei und später Mario Basler verließen ihn. Die Saison verlief durchaus erfolgreich. Bayern wurde zum 16. Mal Meister, gewann zum 10. Mal den DFB-Pokal (in einer Neuauflage des letztjährigen Endspiels wurde Werder Bremen mit 3:0 besiegt) und erreichte das Halbfinale der Champions League, wo man gegen Real Madrid ausschied, gegen die man in der Gruppenphase noch zweimal gewinnen konnte. Zudem feierte der Verein im Frühjahr 2000 sein 100-jähriges Vereinsjubiläum. Zu diesem Anlass wurde ein Einladungsturnier mit Real Madrid, Manchester United und Galatasaray Istanbul ausgetragen, das der FC Bayern gewinnen konnte.

77+Die Entscheidung in der Meisterschaft fiel erst am letzten Spieltag. Seit dem 30. Spieltag der Saison hatte Bayer 04 Leverkusen die Tabelle der Bundesliga angeführt. Nach dem 33. Spieltag betrug der Vorsprung drei Punkte. Ein Unentschieden bei der SpVgg Unterhaching hätte der Elf um Trainer Christoph Daum für den ersten Titelgewinn selbst bei einem Sieg der Bayern gegen Werder Bremen gereicht. Doch es kam anders. Bayern erledigte seine Aufgabe zu Hause und gewann mit 3:1. Gleichzeitig gelang es nur wenige Kilometer entfernt den Leverkusenern nicht, den einen Punkt unter Dach und Fach zu bringen. Leverkusen verlor mit 0:2 beim Aufsteiger aus dem Vorort Münchens – Michael Ballack schoss dabei ein Eigentor zum 0:1 – und die Meisterschaft ging an den FC Bayern.

78+

79+In der Saison 2000/01 gelang es dem FC Bayern, den Titel in der Bundesliga zu verteidigen; im DFB-Pokal scheiterte man bereits in der zweiten Runde im Elfmeterschießen beim 1. FC Magdeburg. Dafür gelang es 25 Jahre nach dem letzten Sieg im Europapokal der Landesmeister und zwei Jahre nach dem dramatischen Endspiel in Barcelona, diesen Pokal zum vierten Mal zu gewinnen.

80+Als Initialzündung für diesen Erfolg gilt das vorletzte Spiel der zweiten Gruppenphase bei Olympique Lyon. Der FC Bayern hatte nach einer schwachen Leistung mit 0:3 verloren, was Präsident Franz Beckenbauer beim Mitternachtsbankett zu einer berühmt gewordenen Wutrede („Uwe-Seeler-Traditionsmannschaft“) veranlasste. Die Rede zeigte Wirkung, die folgenden fünf Champions-League-Spiele (gegen Arsenal London, Manchester United und Real Madrid) wurden allesamt gewonnen und so stand man schließlich im Finale der Champions League, das man im Mailänder San Siro mit 5:4 im Elfmeterschießen gegen den FC Valencia gewann. Der Held der Partie war wieder einmal Torhüter Oliver Kahn, der drei Elfmeter parierte. Kahn hatte zuvor im Laufe der Saison schon häufig geglänzt, besonders im Halbfinalhinspiel gegen Real Madrid im Santiago Bernabéu.

81+Einige Tage zuvor war es in der Bundesliga zum Duell um die Meisterschaft gekommen. Bis zum 33. Spieltag war der FC Schalke 04 Tabellenführer. Dann verloren die Knappen ihr Spiel beim VfB Stuttgart durch ein Tor in der 90. Minute mit 0:1. Nur wenige Sekunden später erzielte Alexander Zickler den 2:1-Siegtreffer für den FC Bayern gegen den 1. FC Kaiserslautern. Schalke musste am 34. Spieltag gegen Unterhaching unbedingt gewinnen und auf eine Niederlage der Münchner im Hamburg hoffen, um doch noch Meister zu werden. Der FC Schalke gewann sein Spiel mit 5:3. Zeitgleich blieb die Partie in Hamburg lange torlos, doch in der 90. Minute ging der HSV durch einen Kopfball von Sergej Barbarez mit 1:0 in Führung.

82+Nach Gelsenkirchen, wo Schalkes Spiel bereits abgepfiffen war, drang die Nachricht, dass das Spiel in Hamburg aus sei und Bayern verloren habe, jedoch wurden im Parkstadion plötzlich Live-Bilder aus Hamburg auf der Anzeigetafel gezeigt. Dort war zu sehen, wie es für die von Oliver Kahn nach vorne gepeitschten Bayern in der dritten Minute der Nachspielzeit einen indirekten Freistoß im HSV-Strafraum gab, da der Torwart des HSV, Mathias Schober, einen Rückpass mit den Händen aufgenommen hatte. Stefan Effenberg nahm sich des Freistoßes an, legte den Ball auf Patrik Andersson vor und dieser schoss den Ball durch die Mauer ins Tor zum 1:1-Endstand. Somit wurde Bayern in der wohl dramatischsten Entscheidung der Bundesligageschichte erneut Meister; Torschütze Andersson verließ Bayern nach Ende der Saison zum FC Barcelona.

83+Die Saison 2001/02 verlief zunächst weniger erfolgreich. Schon die ersten Entscheidungen konnte der FC Bayern nicht für sich entscheiden. Man verlor im Ligapokal und im europäischen Supercup in Monaco mit 2:3 gegen den FC Liverpool. Am 27. November 2001 wurde in Tokio mit einem 1:0 nach Verlängerung gegen die Boca Juniors zum zweiten Mal nach 1976 der Weltpokal gewonnen. Schütze des Siegtores war Samuel Kuffour. Dies sollte jedoch der einzige Titel der Saison bleiben. In der Bundesliga erreichte man hinter Borussia Dortmund und Bayer Leverkusen nur Platz drei, in der Champions League war im Viertelfinale gegen Real Madrid und im DFB-Pokal im Halbfinale bei Schalke 04 Schluss.

84+

85+Für Stefan Effenberg, der die Bayern am Ende der letzten Saison verlassen hatte, wurde Michael Ballack verpflichtet, der in der abgelaufenen Saison mit Leverkusen jeweils den zweiten Platz in der Bundesliga, im DFB-Pokal und in der Champions League erreichte. Zudem wechselte dessen Mannschaftskollege Zé Roberto zu den Bayern. Ein weiterer Neuzugang war Sebastian Deisler, der allerdings nach einer Verletzung gleich zu Beginn für lange Zeit ausfiel.

86+In der Champions-League-Saison 2002/03 konnten die Bayern aus sechs Spielen nur zwei Punkte durch die beiden Unentschieden gegen den RC Lens erringen. Gegen AC Mailand und Deportivo La Coruña setzte es je zwei Niederlagen. Besonders ein Spieler erwies sich dabei für Deportivo als sicherer Schütze und bezwang Oliver Kahn in zwei Spielen vier Mal: Roy Makaay. Im Sommer 2003 wechselte dieser dann für die damalige Rekordsumme von 18,7 Millionen Euro zum FC Bayern München.

87+Die Saison verlief national jedoch erfolgreich und in der Bundesliga erreichte Bayern am Ende einen Vorsprung von 16 Punkten auf den zweitplatzierten VfB Stuttgart. Zudem gelang erneut der Sieg im DFB-Pokal. Mit 3:1 besiegte man im Finale den 1. FC Kaiserslautern und erreichte so erneut das Double. In der Saison gab Bastian Schweinsteiger seinen Einstand bei den Profis des FC Bayern beim Champions-League-Heimspiel gegen den RC Lens.

88+Im Frühjahr 2003 kam mit der Kirch-Affäre der wohl größte Skandal der Vereinsgeschichte ans Licht.

89+Spieldaten des Endspiels um den DFB-Pokal 2003

90+Saison 2003/04 [Bearbeiten]

91+Vor der Saison 2003/04 wechselte Martín Demichelis von River Plate Buenos Aires zum FC Bayern. In dieser Saison waren die Münchner gegen den blendend aufspielenden, späteren Meister Werder Bremen mit einem starken Ailton jedoch nicht in der Lage, den Titel zu verteidigen. So blieb am Ende als Zweiter immer noch die direkte Qualifikation zur Champions League im darauf folgenden Jahr. 2003/04 reichte es dort nur zum Achtelfinale, in dem man wie zwei Jahre zuvor gegen Real Madrid ausschied. Im DFB-Pokal war im Viertelfinale bei Alemannia Aachen Endstation. Zum Ende der Saison löste der FC Bayern den Vertrag mit Trainer Hitzfeld, der noch bis Mitte 2005 datiert war, vorzeitig auf.

92+Saison 2004/05 [Bearbeiten]

93+Für Hitzfeld kam in der Folgesaison Felix Magath vom VfB Stuttgart. Mit ihm kam der an die Schwaben ausgeliehene Philipp Lahm zurück an die Säbener Straße. Zudem gelang es den Bayern, Lúcio von Bayer Leverkusen für die neue Saison zu verpflichten.

94+Der neue Trainer hatte auf Anhieb Erfolg mit den Bayern. So gelang es 2004/05 erneut, das Double zu holen. In der Bundesliga zog man zum Ende der zweiten Saisonhälfte einsam seine Kreise und hatte zum Schluss 77 Punkte auf dem Konto und 14 Punkte Vorsprung auf den Tabellenzweiten, den FC Schalke 04, der die Bayern in der Bundesligasaison zweimal schlagen konnte. Dabei hatte Schalke nach dem 25. Spieltag und dem 1:0-Heimsieg noch einen Drei-Punkte-Vorsprung vor den Münchnern, konnte diesen jedoch nicht behaupten und verlor in der Folgezeit 17 Punkte in neun Spielen auf die Bayern. Beide Mannschaften standen sich auch im Finale des DFB-Pokals gegenüber, das die Münchner etwas glücklich aber verdient mit 2:1 für sich entscheiden konnten. In der Champions League mussten die Bayern im Viertelfinale gegen den FC Chelsea die Segel streichen. Zum Ende der Saison bestritt man das letzte Bundesligaspiel im Olympiastadion. Die Begegnung wurde 6:3 gegen den 1. FC Nürnberg gewonnen und so endete die Ära in diesem Stadion mit der deutschen Meisterschaft, wie sie schon 1971/72 begonnen hatte.

95+Spieldaten des Endspiels um den DFB-Pokal 2005

96+Saison 2005/06 [Bearbeiten]

97+Mit der neuen Saison zogen die Bayern in die neu gebaute Allianz Arena um. Und diese wurde so erfolgreich fortgesetzt, wie die Vorsaison endete. In seiner zweiten Saison beim FC Bayern schaffte Magath dabei ein Novum. Unter ihm gelang es dem FC Bayern, als erste deutsche Mannschaft im Fußball der Männer das Double zu verteidigen. Dabei setzte man sich in der Bundesliga am Ende vor Werder Bremen und dem HSV durch. Im Endspiel um den DFB-Pokal bezwang man Eintracht Frankfurt mit 1:0 durch ein Tor von Claudio Pizarro. In der Champions League war im Achtelfinale Schluss. Dabei war man nach einem 1:1 im Hinspiel gegen den AC Mailand im Rückspiel in Italien chancenlos und verlor mit 1:4. Ende der Saison lief der Vertrag von Michael Ballack aus. Bayern machte ihm ein Angebot über 36 Millionen Euro für einen neuen vier Jahre laufenden Vertrag, doch nach langer Überlegung lehnte der Nationalspieler ab und wechselte ablösefrei zum FC Chelsea. Nach der Saison beendete Bixente Lizarazu seine Karriere beim FC Bayern.

98+Spieldaten des Endspiels um den DFB-Pokal 2006

99+Saison 2006/07 [Bearbeiten]

100+Für die Saison 2006/07 wurde kein neuer Spielmacher geholt. Allerdings konnten Lukas Podolski und Mark van Bommel verpflichtet werden. Die dritte Saison beim FC Bayern verlief für Magath dann weniger erfolgreich. Wie drei Jahre zuvor scheiterte man dieses Mal schon im Pokal-Achtelfinale an Alemannia Aachen. Einer der Torschützen für Aachen war Jan Schlaudraff, der im folgenden Sommer zu den Bayern wechseln sollte. Zudem drohte man in der Bundesliga, nur auf Platz vier liegend, die Qualifikation zur Champions League zu verpassen. Deshalb reagierte man beim FC Bayern und holte einen alten Bekannten als Trainer zurück. Am 31. Januar 2007 wurde Felix Magath nach zwei Double-Gewinnen in Folge durch seinen Vorgänger Ottmar Hitzfeld ersetzt. Doch auch er konnte die Qualifikation zur Champions League nicht erreichen und man blieb auf dem vierten Platz, der schlechtesten Platzierung der Bayern der letzten zwölf Jahre. In der Champions League selbst war erneut gegen den AC Mailand Endstation, diesmal im Viertelfinale. Man hatte sich zwar mit einem 2:2 in Mailand eine gute Ausgangsposition für das Rückspiel im eigenen Stadion erarbeitet, verlor dann aber mit 0:2. Durch dieses Ausscheiden und Platz vier in der Liga war man für die nächste Saison erstmals seit der Saison 1996/97 nicht für die Champions League qualifiziert und musste mit dem UEFA-Pokal vorliebnehmen. Nach dieser Saison beendete Mehmet Scholl seine lange Karriere beim FC Bayern. Zuvor hatte Sebastian Deisler im Januar sein Karriereende bekanntgegeben.

101+Saison 2007/08 [Bearbeiten]

102+Um eine Saison wie die des Vorjahres nicht erneut zu erleben, investierten die Bayern in der Vorbereitung zur neuen Saison eine Rekordsumme von rund 70 Millionen Euro. Dabei wurden alleine 25 Millionen Euro für Franck Ribéry von Olympique Marseille und 12,5 Millionen Euro für Luca Toni vom AC Florenz ausgegeben. Als dann neben der schon bekannten Verpflichtung von Jan Schlaudraff mit Miroslav Klose auch noch ein dritter neuer Stürmer eingekauft wurde, erbat Roy Makaay seine Freigabe und wechselte zu Feyenoord Rotterdam. Zudem wechselte Hasan Salihamidžić zu Juventus Turin. Vereinseigengewächs Owen Hargreaves, der schon lange Ambitionen für die Premier League geäußert hatte, wechselte für eine Ablösesumme von 25 Millionen Euro zu Manchester United. Neben den oben genannten Spielern wechselte auch Hamit Altıntop von Schalke 04 zu den Bayern.

103+Die hohen Investitionen lohnten sich und Bayern gelang in dieser Saison der fünfte Double-Gewinn in einem Jahrzehnt und der siebte Double-Gewinn überhaupt. Dabei wurde den Zuschauern auch spielerisch ein erfrischender Fußball geboten, bei dem vor allem Ribéry seine ausgezeichnete Technik unter Beweis stellte. Die Saison selbst verlief recht einseitig. Mit einem Start-Ziel-Sieg erreichte der FC Bayern am Ende einen Vorsprung von zehn Punkten auf Werder Bremen. Im DFB-Pokalfinale wurde Borussia Dortmund mit 2:1 nach Verlängerung besiegt. Im UEFA-Pokal schaffte man es bis ins Halbfinale und musste sich dort nach einem 1:1 im Hinspiel in München dem späteren Gewinner Zenit Sankt Petersburg mit 0:4 in St. Petersburg geschlagen geben.

104+Neben der herben Halbfinalpleite blieb dabei besonders das Viertelfinalrückspiel in Getafe in Erinnerung. Nach einem 1:1 im Hinspiel in München musste man beim FC Getafe antreten. Nachdem es lange 1:0 für die Gastgeber stand, konnte Ribéry den Rückstand in der 89. Minute ausgleichen. Dadurch kam es zur Verlängerung. Dort stand es schnell 3:1 für Getafe. Erst in der 115. Minute kamen die Bayern durch Luca Toni zum Anschlusstreffer und in der letzten Minute der Verlängerung schaffte es wiederum Toni den Ausgleich zu erzielen. Somit war man aufgrund der mehr geschossenen Auswärtstore im Halbfinale.

105+In der Winterpause der Saison kündigte Ottmar Hitzfeld bereits an, seinen zum Saisonende auslaufenden Vertrag bei Bayern nicht zu verlängern. Um ihn zu ersetzen, wurde für die neue Saison der ehemalige Spieler Jürgen Klinsmann als neuer Trainer verpflichtet.

106+Mit dem Rekord von acht gewonnenen Meisterschaften und sechs gewonnenen DFB-Pokalen verließ Oliver Kahn den FC Bayern. Kahn gelang es in seiner letzten Saison, den Rekord von Oliver Reck (22 Gegentore in 34 Spielen aus der Saison 1987/88) mit 21 Gegentoren in 34 Spielen zu unterbieten. Nach der Saison wurde er zum Ehrenspielführer des FC Bayern München ernannt.

107+Spieldaten des Endspiels um den DFB-Pokal 2008

108+Saison 2008/09 [Bearbeiten]

109+Zu Beginn der Saison 2008/09 stand Michael Rensing als die neue Nummer 1 im Tor der Bayern, verlor seinen Platz jedoch im April 2009 an Hans Jörg Butt. Zudem wechselten Tim Borowski und der italienische Weltmeister Massimo Oddo zum Rekordmeister. Nach anfänglichen Schwierigkeiten in der Bundesliga gelang es, sich bis zur Winterpause an den Spitzenreiter, den Aufsteiger TSG 1899 Hoffenheim, heranzuarbeiten und punktgleich mit der TSG überwinterte man auf Platz zwei. Nachdem man die Leistungen in der zweiten Hälfte der Saison nicht stabilisieren konnte, musste Jürgen Klinsmann fünf Spieltage vor Schluss seinen Platz räumen und wurde durch Jupp Heynckes als Cheftrainer und dessen Co-Trainer Hermann Gerland ersetzt.[15] Unter dem neuen Trainer konnte sich die Mannschaft mit vier Siegen und einem Unentschieden hinter dem neuen Meister VfL Wolfsburg den zweiten Platz und somit die direkte Qualifikation für die Champions League der Folgesaison sichern. Im DFB-Pokal war man zuvor schon im Viertelfinale gegen Bayer Leverkusen ausgeschieden. In der Champions League konnte man sich im Achtelfinal-Hinspiel bei Sporting Lissabon mit 5:0 durchsetzen und zog nach einem 7:1 im Rückspiel in das Viertelfinale ein; das Gesamtergebnis von 12:1 gegen Sporting bedeutete Champions-League-Rekord. Im Viertelfinale erlebte man jedoch vier Tage nach einem 1:5 in der Bundesliga beim VfL Wolfsburg das von vielen Fans[16] und Medien befürchtete Hinspiel-Debakel beim FC Barcelona: Nach einer 4:0-Pausenführung im Camp Nou schalteten die zuvor schon kaum geforderten Katalanen noch etwas zurück, führten eine ersatzgeschwächte (ohne Lahm, Lucio, van Buyten und Klose) und katastrophal spielende Bayern-Mannschaft aber weiter vor, ohne ihre großen Chancen in weitere Tore umzumünzen. Nach einem 1:1 im von beiden Mannschaften, besonders aber von Barcelona, nicht mit letztem Einsatz geführtem Rückspiel war die Europapokalsaison für den FC Bayern beendet.

110+Kurz nach der Winterpause gab Willy Sagnol auf Grund andauernder Beschwerden im Knie sein Karriereende bekannt. Bis März 2009 hatte der von Los Angeles Galaxy ausgeliehene US-Amerikaner Landon Donovan ein etwas glückloses Gastspiel in München.

111+Den Verein verließen zum Saisonende Lukas Podolski zum 1. FC Köln, Zé Roberto zum HSV und Lúcio zu Inter Mailand. Der vom AC Mailand ausgeliehene Massimo Oddo wurde nicht übernommen.

112+Saison 2009/10 [Bearbeiten]

113+Am 1. Juli 2009 übernahm Louis van Gaal, der in der Vorsaison den AZ Alkmaar zur Niederländischen Fußballmeisterschaft führte, den Posten als Chef-Trainer des FC Bayern.

114+Zugänge zur Saison 2009/10 waren Anatolij Tymoschtschuk von Zenit St. Petersburg, Alexander Baumjohann von Borussia Mönchengladbach, Ivica Olić vom Hamburger SV, Edson Braafheid von Twente Enschede.[17], Danijel Pranjić vom SC Heerenveen[18] und Mario Gómez vom VfB Stuttgart. Letzterer ist mit einer Ablösesumme von 30 Millionen Euro der teuerste Transfer der Bundesligageschichte.[19] Zudem kehrte Andreas Görlitz, der an den Karlsruher SC ausgeliehen war, zum FC Bayern zurück. Daneben rückten aus der zweiten Mannschaft Thomas Müller und Holger Badstuber in den Profikader auf. Am 28. August 2009 wurde schließlich der holländische Nationalspieler Arjen Robben von Real Madrid verpflichtet.[20]

115+Am Beginn der Saison versuchte van Gaal nochmals, Michael Rensing als Stammtorwart zu installieren. Allerdings konnte dieser abermals nicht überzeugen, so dass er am fünften Spieltag seinen Stammplatz wieder an Hans Jörg Butt abtreten musste. Das erste Saison-Drittel verlief wenig erfolgreich für den FC Bayern. In der Bundesliga rutschte man zwischenzeitlich bis auf Rang 14 ab und auch das Weiterkommen in der Champions League war gefährdet. Im letzten Spiel der Champions-League-Gruppenphase besiegten die Bayern schließlich am 8. Dezember 2009 Juventus Turin auswärts mit 4:1, wodurch sie doch noch die Endrunde der Champions League erreichen konnten. Daneben gelang es dem FC Bayern in der Bundesliga, bis Mitte Februar 2010 neun Spiele hintereinander zu gewinnen und damit den Rückstand auf den Spitzenreiter Bayer Leverkusen, der zwischenzeitlich acht Punkte betragen hatte, auszugleichen. Am 24. Spieltag übernahmen die Bayern schließlich die Tabellenführung in der Bundesliga, die sie bis Saisonende nur noch einmal abgaben. Am letzten Spieltag wurde durch einen 3:1-Sieg bei Hertha BSC die 22. Deutsche Meisterschaft perfekt gemacht. Zudem gewann man das Finale des DFB-Pokals gegen Werder Bremen mit 4:0 und konnte somit den 15. Pokalsieg, gleichzeitig das achte Double, verbuchen.

116+Spieldaten des Endspiels um den DFB-Pokal 2010

117+Mit dem Einzug ins Finale der Champions League eröffnete sich die Chance für die Bayern, als erste deutsche Mannschaft das Triple aus Meisterschaft, nationalem sowie internationalem Pokal zu gewinnen. Allerdings verlor man am 22. Mai 2010 im Estadio Santiago Bernabéu in Madrid gegen Inter Mailand mit 0:2 und verpasste damit den historischen Triumph.

118+

119+Zu Beginn der Saison 2010/2011 konnte der Verein mit einem 2:0 gegen Schalke 04 den von der DFL wieder eingeführten Supercup gewinnen. In der Champions League erreichten die Münchner das Achtelfinale, wo sie gegen Inter Mailand nach einem 1:0-Auswärtssieg durch eine 2:3-Heimniederlage ausschieden. Im DFB-Pokal schieden sie im Halbfinale nach einer 0:1-Heimniederlage gegen Schalke aus.

120+Am 7. März 2011 wurde vom FC Bayern bekanntgegeben, dass der Vertrag mit Trainer Louis van Gaal am Saisonende zum 30. Juni 2011 vorzeitig und einvernehmlich aufgelöst werden wird. Grund hierfür war laut Pressemitteilung die unterschiedliche Auffassung über die strategische Ausrichtung des Klubs. Nachfolger wurde Jupp Heynckes, der einen Zweijahresvertrag erhielt.[21] Am 10. April 2011 gab der Verein aufgrund der weiteren sportlichen Talfahrt die sofortige Beurlaubung Louis van Gaals bekannt und ernannte den bisherigen Co-Trainer Andries Jonker zum Cheftrainer bis zum Saisonende.[22]

121+Nach 5 Spielen und 13 von 15 möglichen Punkten unter Jonker schloss die Mannschaft die Saison 2010/2011 als Dritter ab und sicherte sich damit die Teilnahme an der Qualifikation zur Champions League.

122+In der Bundesligasaison 2011/12 musste man sich erneut Borussia Dortmund geschlagen geben, schaffte mit dem zweiten Platz aber die direkte Champions-League-Qualifikation. Zudem wurde das Pokalfinale am 12. Mai 2012 in Berlin erreicht, in dem man mit 2:5 wieder Borussia Dortmund unterlegen war.

123+In der Champions League-Qualifikation besiegte man den FC Zürich mit 2:0 und 1:0 und erreichte somit die Gruppenphase. In den Duellen gegen den FC Villarreal, Manchester City und die SSC Neapel gelang es den Roten, bereits nach dem fünften Spieltag als Gruppensieger festzustehen.[23] Über den FC Basel, Olympique Marseille und Real Madrid zog man in das Finale der Champions League ein und verlor am 19. Mai 2012 gegen Chelsea London im eigenen Stadion nach Verlängerung (1:1) im Elfmeterschießen 3:4.

124+Mit dem jeweils zweiten Platz in Champions League, Meisterschaft und DFB-Pokal ging 2012 als ein Annus horribilis verpasster Chancen in die Vereinsgeschichte ein.

125+Die erste Mannschaft spielt seit 1965 in der Bundesliga. Der FC Bayern München ist der erfolgreichste deutsche Fußball-Club und deutscher Rekordmeister. Für 21 Meisterschaften seit Einführung der Bundesliga 1963 darf er vier Meistersterne auf dem Trikot tragen. Der FC Bayern ist der erste Verein, dem es gelang, das Double zu verteidigen. Der FC Bayern München ist neben Borussia Dortmund, Borussia Mönchengladbach und dem Hamburger SV der vierte Verein, der seinen Titel in der Fußball-Bundesliga verteidigen konnte. Mit 592 Spieltagen als Tabellenführer belegt der Verein den 1. Platz in der ewigen Liste der Tabellenführer. Neben Ajax Amsterdam und Juventus Turin gelang es dem FC Bayern, alle Europapokale sowie den Weltpokal zu gewinnen. Neben Bayern München gelang es bisher nur Real Madrid und Ajax Amsterdam, den Europapokal der Landesmeister dreimal in Folge zu gewinnen. Deswegen erlaubt es die UEFA unter anderem dem FC Bayern, ein Logo mit dem Champions-League-Pokal zu tragen, in dem zusätzlich die Anzahl aller gewonnenen Europapokale der Landesmeister (4) eingetragen ist. Unter den Vereinspokalen fehlt einzig der europäische Supercup, der bisher noch von keiner deutschen Mannschaft gewonnen wurde.

126+

127+Die zweite Mannschaft (bis 2005: FC Bayern München Amateure, seitdem offiziell: FC Bayern München II) ist ebenfalls eine Profimannschaft und spielt seit 2011 in der viertklassigen Regionalliga Süd. Von 1973 bis 2011 spielte die Mannschaft stets drittklassig. Betreut wird das Team derzeit von Andries Jonker als Trainer sowie Gerd Müller und Rainer Ulrich als Co-Trainern, Torwarttrainer ist Walter Junghans.

128+1983 und 1987 erreichten die Bayern-Amateure jeweils das Endspiel um die Deutsche Amateurmeisterschaft. Bei der Einführung der Regionalligen als dritthöchste Spielklasse 1994 war man direkt für die Regionalliga Süd qualifiziert und spielte in dieser Liga bis 2008, als durch einen achten Platz die Qualifikation für die neugegründete 3. Liga gelang, deren Premierensaison man 2008/09 als Fünfter beendete. In der Saison 2003/04 gewannen die Bayern-Amateure mit Spielern wie Zvjezdan Misimović, Piotr Trochowski und Paolo Guerrero die Meisterschaft in der Regionalliga Süd. Für den DFB-Pokal waren die Bayern-Amateure mehrmals qualifiziert, erreichten in der Saison 1993/94 das Achtelfinale sowie 1994/95 und 2004/05 sogar das Viertelfinale, wobei u. a. die Bundesligisten Werder Bremen, VfB Stuttgart, 1. FC Köln und Borussia Mönchengladbach besiegt wurden.

129+Immer wieder schafften Spieler der zweiten Mannschaft den Sprung in den Kader der Profimannschaft und wurden später Stammspieler, so u. a. Markus Babbel, Philipp Lahm, Owen Hargreaves, Bastian Schweinsteiger oder in jüngerer Zeit Holger Badstuber und Thomas Müller.

130+In den Anfangsjahren des Vereins wechselten die Spielstätten recht häufig. Das erste Spiel der Vereinsgeschichte fand auf dem städtischen Spielplatz an der Schyrenstraße statt. Der 1. Münchner FC wurde damals mit 5:2 bezwungen. 1901 bis 1907 spielte man dann in Schwabing an der Clemensstraße, um dann an die Leopoldstraße zu wechseln. Da immer mehr Zuschauer zu den Heimspielen des Vereins kamen, wechselte man ab 1920 erneut den Platz, ohne für eine längere Zeit eine feste Heimstätte zu haben. Für 47 Jahre fanden die „Roten“ dann ab 1925 im Grünwalder Stadion ihr festes Zuhause, wobei man bis zum Ende des Zweiten Weltkriegs Untermieter des TSV 1860 München war. Der TSV musste später aus finanziellen Gründen das Stadion an die Stadt München verkaufen. Bayerns Zuschauerrekord im Grünwalder Stadion beläuft sich auf mehr als 50.000 während der Saison 1961/62 gegen den 1. FC Nürnberg. Mit Beginn der Bundesliga waren dann nur noch 44.000 Zuschauer zugelassen.

131+

132+Nach Fertigstellung des Olympiastadions München für die Olympischen Sommerspiele 1972 zogen die Bayern dorthin um. Das erste Spiel der Bayern fand am letzten Spieltag der Saison 1971/72 statt. FC Schalke 04 hieß der Gegner und wurde vor 79.000 Zuschauern mit 5:1 geschlagen. Nach dem Spiel feierte der Verein seine erste von vielen Deutschen Meisterschaften im Olympiastadion. Durch eine Reduzierung der Stehplätze und kleinere Anpassungen im Stadion sank die offizielle Stadionkapazität schrittweise auf 69.200 Zuschauer bei nationalen Spielen und 59.000 bei internationalen Spielen. Aus Komfortgründen gab der Verein rund 6.000 Plätze, die keine gute Sicht auf das Spielfeld boten, nicht für den Verkauf frei und ließ zu Bundesliga-Spielen nur 63.000 Zuschauer ins Stadion. Ab 1995, ein Jahr nach dem Wiederaufstieg des TSV 1860 München in die Bundesliga trug auch der Stadtrivale seine Heimspiele im Olympiastadion aus, wobei die Löwen bei Spitzenspielen die zulässige Höchstgrenze von 69.200 Zuschauern nutzten.

133+Das Olympiastadion wurde mit der Zeit immer stärker als nicht mehr zeitgemäß für Fußballspiele auf Spitzenniveau kritisiert. Es gab keine VIP-Logen, das Stadion war nur zu einer Seite hin überdacht und in der weiten und offenen Anlage wollte keine rechte „Fußball-Stimmung“ aufkommen. Auch die vorhandene Tartanbahn und die dadurch bedingte große Entfernung zwischen Zuschauern und Spielgeschehen war Fans und Verantwortlichen ein Dorn im Auge. Zudem kam es bisweilen zu Terminkonflikten, wenn andere Veranstaltungen, wie z.B. Leichtathletikwettbewerbe oder Rockkonzerte im Stadion stattfinden sollten. Viele derartige Veranstaltungen wurden wegen der Beschwerden des FC Bayern als Hauptnutzer, (und mit ca. 5 Millionen DM jährlich größten Mietzahlers) an andere Orte verlegt. Prominentestes „Opfer“ war die alljährliche Rockveranstaltung Rock im Park, die schließlich von München nach Nürnberg verlegt wurde. Der Verein machte sich daher schon länger Gedanken über ein eigenes Stadion in München. Doch über Jahre hinweg fand man keinen geeigneten Platz und auch die Stadt als Eigentümerin der olympischen Spielstätte sträubte sich gegen derartige Pläne, da die Mietzahlungen des FC Bayern eine lukrative Einnahmequelle darstellten, die man nicht verlieren wollte. Als sich Deutschland für die Fußball-Weltmeisterschaft 2006 bewarb, kam das Thema Stadion erneut auf den Tisch, denn mit dem veralteten Olympiastadion wäre München als Spielort für das Turnier undenkbar gewesen. Da es hieß, dass es nirgendwo einen geeigneten Platz für einen Neubau in München geben würde, dachte man zunächst darüber nach, das Olympiastadion aufwendig zu renovieren und grundlegend umzubauen. Auch ein Abriss und Neubau unter dem denkmalgeschützten Zeltdach wurde durchgespielt. All diese Pläne scheiterten letzten Endes aber am Veto des Architekten Günter Behnisch. Um die örtliche Politik unter Zugzwang zu setzen, spekulierte der Verein daraufhin eine Zeitlang öffentlich darüber, das neue Stadion außerhalb der Stadtgrenzen, beispielsweise in Garching oder Poing zu errichten, womit der Stadt München etliches an Steuereinnahmen und Prestige verlorengegangen wäre.

134+

135+Wollte München also WM-Spielort werden, musste eine Lösung gefunden werden. Verschiedene Standorte wurden auf ihre Tauglichkeit hin geprüft und man einigte sich letzten Endes auf Fröttmaning am nördlichen Ende der Stadt als Standort für die neue Allianz Arena. Nach zähem Ringen wurde in der Kompromisslösung festgezurrt, dass der FC Bayern und 1860 München die neue Arena gemeinsam errichten und nutzen sollten, wobei jegliche Nutzung außerhalb von Fußball ausgeschlossen wurde, um dem Olympiastadion eine gewisse Grundauslastung bei Veranstaltungen zu sichern. Auch dieser Kompromiss wurde von der Öffentlichkeit kontrovers aufgenommen, sodass es sogar zu einer Volksabstimmung über den Stadionneubau kam, die mit etwa 2/3 der Stimmen zu Gunsten des Neubaus ausfiel. Die beiden Vereine trugen die Kosten für den Stadionbau, während die Stadt München und das Land Bayern für die Kosten der Infrastruktur aufkommen sollten. Zu Beginn waren die FC Bayern München AG und die TSV München von 1860 GmbH & Co. KGaA zu je 50 % an der Stadiongesellschaft, der die Arena gehört und sie betreibt, beteiligt. Beide Vereine müssen zur Nutzung der Arena entsprechende Mietentgelte entrichten, woraus die Stadion GmbH wiederum den Kredit, der den Bau finanzierte, bedient. Als die Löwen jedoch erneut in finanzielle Nöte gerieten, verkauften sie ihren 50-Prozent-Anteil an den Mitgesellschafter. Auch eine zunächst ausgehandelte Rückkaufoption wurde inzwischen an die Bayern verkauft. Somit steht das Stadion unter der alleinigen Kontrolle des FC Bayern München.

136+Baulich ist das Stadion in drei Ränge unterteilt. Dabei besteht die Haupttribüne mit den Ein- und Ausgängen größtenteils aus VIP-Plätzen und sogenannten Business-Seats. Die Fankurven des FC Bayern befinden sich jeweils hinter den Toren. Die Sitzschalen des Stadions sind in Grau, da wohl weder Rot noch Blau dem einen oder anderen der beiden Vereine zuzumuten gewesen wäre. Dies hat allerdings den Nachteil, dass das Stadion auf Grund des vielen Graus recht kühl wirkt. Während der Heimspiele des FCB leuchtet das Stadion außen in Rot. Mehrfarbige Beleuchtungen sind zwar möglich, wurden aber nachträglich polizeilich untersagt, da die Farbwechsel zu erhöhten Unfallzahlen auf der nahen Autobahn A9 geführt hatten.

137+Das Stadion fasste anfangs 66.000 Zuschauer. Durch eine Neuanordnung der Sitzreihen und den Umbau einiger überbreiter Business-Seats zu normalen Sitzplätzen wurde die Kapazität wenige Monate später auf 69.001 Zuschauer erhöht. Prinzipiell ist eine weitere Aufstockung bis auf über 80.000 Plätze ohne tiefgreifende Baumaßnahmen möglich, der Verein verzichtet aber darauf, vor allem aus Komfortgründen für die Zuschauer.

138+

139+Das Trainingsgelände des FC Bayern befindet sich in München-Giesing an der Säbener Straße 51. Es gilt als eines der modernsten Trainingsgelände in Europa. Vielfach wird behauptet, das Gelände befände sich im Stadtteil Harlaching, der jedoch wenige Meter weiter südlich beginnt.

140+Bereits seit 1949 nutzen die Bayern das Gelände an der Säbener Straße, der ehemaligen Bezirkssportanlage Harlaching. 1970 begann der Bau der neuen Geschäftsstelle und des Trainingsgeländes unter Präsident Neudecker. Am 17. Mai 1971 war die Anlage bezugsfertig. Zum ersten Mal in der Geschichte des Vereins waren Geschäftsstelle und Trainingsgelände vereint. Bereits 1979 wurde das Gelände erweitert, worauf Ende der 80er Jahre ein weiterer Ausbau folgte, um neue Gebäude für den Amateur- und Profibereich zu schaffen. Im Jahr 2000 gab es einen Brand im Profitrakt, wobei ein erheblicher Schaden an den Umkleidekabinen, in der medizinischen Abteilung und in der Sauna entstand. 2008 wurde ein neues Servicezentrum fertiggestellt mit einem neuen Fan-Shop auf einer 250 m² großen Fläche, zudem entstand eine Tiefgarage. Das neue Gebäude ist 95 Meter lang, 16 Meter breit und ca. 10 Meter hoch. Die Tiefgarage fasst 270 Stellplätze. Direkt neben dem neuen Gebäude entstand ein neuer Rasenplatz mit mehreren Sitzreihen auf einer Seite, auf dem in der Saison 2008/09 die Heimspiele der B-Jugend-Mannschaften ausgetragen wurden. Zudem wurde ein neuer Kunstrasenplatz mit zwei Kleinfeldern für die E- und F-Jugend angelegt. Des Weiteren wurde das alte Klubrestaurant in eine Kantine für die Vereinsangestellten umgewandelt. Waren früher alle Trainingseinheiten öffentlich, hat sich in jüngerer Zeit der allgemeine Trend durchgesetzt, meist nur noch einmal wöchentlich ein öffentliches Training stattfinden zu lassen. Insgesamt gibt es auf dem Gelände fünf Rasenplätze, zwei Kunstrasenplätze und einen Beachvolleyballplatz.

141+Nur durch einen Parkplatz und einen Fußweg vom Bayern-Gelände getrennt befindet sich das neue Sportgelände der Sportfreunde München. Durch die Erweiterungsmaßnahmen des FC Bayern musste das alte Gelände der Sportfreunde weichen und wurde um einige Meter nach Süden versetzt. Ein Stück weiter westlich, getrennt durch ein Wohnviertel, befindet sich an der Grünwalder Straße das Trainingsgelände des Erzrivalen TSV 1860 München.

142+Der FC Bayern München gliedert sich in die FC Bayern München AG und den FC Bayern München e. V. Auf einer außerordentlichen Mitgliederversammlung des Vereins am 14. Februar 2002 wurde die Ausgliederung der Fußballprofiabteilung in die FC Bayern München AG beschlossen. Vorstandsvorsitzender der AG ist Karl-Heinz Rummenigge, während Uli Hoeneß Präsident des FC Bayern München e. V. und Aufsichtsratsvorsitzender der AG ist. Zum e. V. gehören folgende Sportabteilungen: Fußball (Männer: Fußball-Bundesliga, Regionalliga Süd; Frauen: Fußball-Bundesliga der Frauen), Basketball (Männer: Basketball-Bundesliga), Handball, Schach (Männer: Bundesliga, Frauen: 2. Bundesliga), Sportkegeln, Tischtennis und Turnen.

143+

144+Die Beziehung zwischen dem FC Bayern München und dem Sportartikelhersteller Adidas kann als recht außergewöhnlich bezeichnet werden. Seit 1965 ist Adidas ununterbrochen Ausrüster des Vereins. Von 2002 bis 2010 hielt Adidas einen 10-Prozent-Anteil an der FC Bayern München AG, der für 77 Millionen Euro erworben wurde.[27] Zwischen März 2010 und Juni 2011 erwarb jedoch die Audi AG in drei Schritten Aktien im Wert von 90 Mio. Euro. Dies war verbunden mit einer Kapitalerhöhung von 2,5 Mio. auf 27,5 Mio. Euro.[28] Nach dieser Kapitalerhöhung halten der FC Bayern München e. V. 81,82 Prozent sowie Adidas und Audi je 9,09 Prozent der Aktien an der AG.

145+Mit Herbert Hainer stellt Adidas den stellvertretenden Aufsichtsratsvorsitzenden der AG.[29] Bis 2007 durfte auch kein Spieler des FC Bayern eine andere Schuhmarke tragen als Adidas, selbst wenn der Spieler einen Vertrag mit einem anderen Ausrüster als Adidas hatte. Erst mit dem Wechsel von Miroslav Klose zu Bayern München änderte sich dies.

146+

147+Kein anderer Verein Deutschlands hat so viele registrierte Anhänger wie der Rekordmeister. 2952 Fanklubs mit 204.235 Fanklub-Mitgliedern sind beim FC Bayern offiziell registriert (Stand: 18. November 2011).[32] In ganz Deutschland, aber auch weltweit gibt es organisierte Bayern-Fans. Zu den bekanntesten offiziellen Fanclubs gehören die „Red Munichs 89“, die „Red Sharks“ und die „Die 13 Höslwanger“. In den 1970er Jahren gab es mit der „Südkurve 73 und den „Red Angels zwei führende Gruppen beim FC Bayern. 1986 entstand in München die erste reine Hooligangruppe, die so genannte „Service Crew Munich (SCM). Mitte der 1990er Jahre entwickelte sich dann die Ultra-Bewegung. Als erste Gruppe sind hier die „Munichmaniacs 1996 zu erwähnen. Seit 2002 gibt es eine übergreifende Ultra-Gruppe, die Schickeria München. Diese ist aber kein offizieller Fanclub. Als Dachorganisation für Fans und Fanclubs gibt es den Club Nr. 12 mit aktuell über 1400 Mitgliedern.[33] Früher gab es ein Fanheim auf einem alten Bahngelände im Stadtteil Laim, das aber einem Wohngebiet weichen musste. Was die Zahl der nicht organisierten Fans und Anhänger weltweit anbelangt, gehört der FC Bayern München auch international zu den größten Vereinen. Fanbeauftragter ist mit Andreas Brück ein langjähriger Fan aus der Südkurve.

148+Jahrelang kämpften die Bayern-Fans und Fanclubs um ein neues, reines Fußballstadion, allein schon wegen der zu erwartenden besseren Stimmung. Tatsächlich zeigte sich jedoch nach dem Einzug in die Allianz Arena, dass die Stimmung im Stadion teilweise schlechter ist als im alten Olympiastadion mit Laufbahn und führte in der Vergangenheit zu sehr kontroversen Diskussionen zwischen Vereinsführung und aktiven Fans. Dies mag zum einen an dem so genannten Operettenpublikum liegen, zum anderen aber auch an der Aufteilung und Bauweise der Allianz Arena. So wurden die Fans aus der Südkurve des Olympiastadions im neuen Stadion auf Süd- und Nordkurve aufgeteilt. Im Unterrang der Südkurve befinden sich weniger Stehplätze als in der Südkurve des Olympiastadions, so gibt es zu Bundesligaspielen dort lediglich 6800 Stehplätze.

149+Zu den Heimspielen der zweiten Mannschaft im Stadion an der Grünwalder Straße finden sich auf der Gegengeraden meist zwischen 50 und 300 aktive Fans ein. Das Stadion wird von ihnen als „Hermann-Gerland-Kampfbahn“ bezeichnet, ein Zeichen der Anerkennung der Arbeit von Hermann Gerland als langjährigem Trainer der Mannschaft. Die seit 2005 vom DFB praktizierte Sprachregelung mit dem Namenszusatz „II“ statt „Amateure“ wird von den Fans nicht akzeptiert.

150+

151+Das aktuelle offizielle Vereinslied ist „Stern des Südens“, komponiert von Willy Astor und gesungen von Claus Lessmann, dem Leadsänger der Hardrockband Bonfire. Davor war jahrelang das Lied „Forever Number One“ die Hymne des Vereins. Das Lied „Stern des Südens“ befindet sich auf der CD „Heimspiel“ der FC Bayern Fans United und wurde auch als Single veröffentlicht. Die beiden offiziellen Lieder wurden jedoch von der Fanszene wenig akzeptiert, inoffizielle Hymne ist das Lied „Mir san die Bayern“.

152+Bekannt ist ebenfalls der alte Schlager von Franz Beckenbauer „Gute Freunde kann niemand trennen“. Angestimmt werden nahezu alle Lieder im Unterrang der Südkurve und hier sowohl von der Schickeria München[34] als auch von einem Trompeter und einer Reihe älterer Fans. Auch in der Nordkurve befinden sich aktive Fans, während sich die Zuschauer in den Sitzplatzbereichen meist passiv verhalten.

153+Überregional haben sich über die Jahre hinweg mehrere Rivalitäten herausgebildet. Meistens entstand so eine Rivalität mit einem Verein, mit dem die Bayern über einen gewissen Zeitraum hinweg um die Meisterschaft rangen. So waren dies Borussia Mönchengladbach in den 1970ern und Borussia Dortmund in den 1990er Jahren. Zudem gibt es noch die Rivalität zum 1. FC Kaiserslautern und die Nord-Süd-Gipfel gegen den Hamburger SV und Werder Bremen.

benchmark/Streamly/Benchmark/Unicode/data/Devanagari.txtnew file+699

@@ -0,0 +1,699 @@

1+मधुशाला

2+मृदु भावों के अंगूरों की आज बना लाया हाला,

3+प्रियतम, अपने ही हाथों से आज पिलाऊँगा प्याला,

4+पहले भोग लगा लूँ तेरा फिर प्रसाद जग पाएगा,

5+सबसे पहले तेरा स्वागत करती मेरी मधुशाला।।१।

7+प्यास तुझे तो, विश्व तपाकर पूर्ण निकालूँगा हाला,

8+एक पाँव से साकी बनकर नाचूँगा लेकर प्याला,

9+जीवन की मधुता तो तेरे ऊपर कब का वार चुका,

10+आज निछावर कर दूँगा मैं तुझ पर जग की मधुशाला।।२।

11+

12+प्रियतम, तू मेरी हाला है, मैं तेरा प्यासा प्याला,

13+अपने को मुझमें भरकर तू बनता है पीनेवाला,

14+मैं तुझको छक छलका करता, मस्त मुझे पी तू होता,

15+एक दूसरे की हम दोनों आज परस्पर मधुशाला।।३।

16+

17+भावुकता अंगूर लता से खींच कल्पना की हाला,

18+कवि साकी बनकर आया है भरकर कविता का प्याला,

19+कभी न कण-भर खाली होगा लाख पिएँ, दो लाख पिएँ!

20+पाठकगण हैं पीनेवाले, पुस्तक मेरी मधुशाला।।४।

21+

22+मधुर भावनाओं की सुमधुर नित्य बनाता हूँ हाला,

23+भरता हूँ इस मधु से अपने अंतर का प्यासा प्याला,

24+उठा कल्पना के हाथों से स्वयं उसे पी जाता हूँ,

25+अपने ही में हूँ मैं साकी, पीनेवाला, मधुशाला।।५।

26+

27+मदिरालय जाने को घर से चलता है पीनेवला,

28+'किस पथ से जाऊँ?' असमंजस में है वह भोलाभाला,

29+अलग-अलग पथ बतलाते सब पर मैं यह बतलाता हूँ -

30+'राह पकड़ तू एक चला चल, पा जाएगा मधुशाला।'। ६।

31+

32+चलने ही चलने में कितना जीवन, हाय, बिता डाला!

33+'दूर अभी है', पर, कहता है हर पथ बतलानेवाला,

34+हिम्मत है न बढूँ आगे को साहस है न फिरुँ पीछे,

35+किंकर्तव्यविमूढ़ मुझे कर दूर खड़ी है मधुशाला।।७।

36+

37+मुख से तू अविरत कहता जा मधु, मदिरा, मादक हाला,

38+हाथों में अनुभव करता जा एक ललित कल्पित प्याला,

39+ध्यान किए जा मन में सुमधुर सुखकर, सुंदर साकी का,

40+और बढ़ा चल, पथिक, न तुझको दूर लगेगी मधुशाला।।८।

41+

42+मदिरा पीने की अभिलाषा ही बन जाए जब हाला,

43+अधरों की आतुरता में ही जब आभासित हो प्याला,

44+बने ध्यान ही करते-करते जब साकी साकार, सखे,

45+रहे न हाला, प्याला, साकी, तुझे मिलेगी मधुशाला।।९।

46+

47+सुन, कलकल़ , छलछल़ मधुघट से गिरती प्यालों में हाला,

48+सुन, रूनझुन रूनझुन चल वितरण करती मधु साकीबाला,

49+बस आ पहुंचे, दुर नहीं कुछ, चार कदम अब चलना है,

50+चहक रहे, सुन, पीनेवाले, महक रही, ले, मधुशाला।।१०।

51+

52+जलतरंग बजता, जब चुंबन करता प्याले को प्याला,

53+वीणा झंकृत होती, चलती जब रूनझुन साकीबाला,

54+डाँट डपट मधुविक्रेता की ध्वनित पखावज करती है,

55+मधुरव से मधु की मादकता और बढ़ाती मधुशाला।।११।

56+

57+मेंहदी रंजित मृदुल हथेली पर माणिक मधु का प्याला,

58+अंगूरी अवगुंठन डाले स्वर्ण वर्ण साकीबाला,

59+पाग बैंजनी, जामा नीला डाट डटे पीनेवाले,

60+इन्द्रधनुष से होड़ लगाती आज रंगीली मधुशाला।।१२।

61+

62+हाथों में आने से पहले नाज़ दिखाएगा प्याला,

63+अधरों पर आने से पहले अदा दिखाएगी हाला,

64+बहुतेरे इनकार करेगा साकी आने से पहले,

65+पथिक, न घबरा जाना, पहले मान करेगी मधुशाला।।१३।

66+

67+लाल सुरा की धार लपट सी कह न इसे देना ज्वाला,

68+फेनिल मदिरा है, मत इसको कह देना उर का छाला,

69+दर्द नशा है इस मदिरा का विगत स्मृतियाँ साकी हैं,

70+पीड़ा में आनंद जिसे हो, आए मेरी मधुशाला।।१४।

71+

72+जगती की शीतल हाला सी पथिक, नहीं मेरी हाला,

73+जगती के ठंडे प्याले सा पथिक, नहीं मेरा प्याला,

74+ज्वाल सुरा जलते प्याले में दग्ध हृदय की कविता है,

75+जलने से भयभीत न जो हो, आए मेरी मधुशाला।।१५।

76+

77+बहती हाला देखी, देखो लपट उठाती अब हाला,

78+देखो प्याला अब छूते ही होंठ जला देनेवाला,

79+'होंठ नहीं, सब देह दहे, पर पीने को दो बूंद मिले'

80+ऐसे मधु के दीवानों को आज बुलाती मधुशाला।।१६।

81+

82+धर्मग्रन्थ सब जला चुकी है, जिसके अंतर की ज्वाला,

83+मंदिर, मसजिद, गिरिजे, सब को तोड़ चुका जो मतवाला,

84+पंडित, मोमिन, पादिरयों के फंदों को जो काट चुका,

85+कर सकती है आज उसी का स्वागत मेरी मधुशाला।।१७।

86+

87+लालायित अधरों से जिसने, हाय, नहीं चूमी हाला,

88+हर्ष-विकंपित कर से जिसने, हा, न छुआ मधु का प्याला,

89+हाथ पकड़ लज्जित साकी को पास नहीं जिसने खींचा,

90+व्यर्थ सुखा डाली जीवन की उसने मधुमय मधुशाला।।१८।

91+

92+बने पुजारी प्रेमी साकी, गंगाजल पावन हाला,

93+रहे फेरता अविरत गति से मधु के प्यालों की माला'

94+'और लिये जा, और पीये जा', इसी मंत्र का जाप करे'

95+मैं शिव की प्रतिमा बन बैठूं, मंदिर हो यह मधुशाला।।१९।

96+

97+बजी न मंदिर में घड़ियाली, चढ़ी न प्रतिमा पर माला,

98+बैठा अपने भवन मुअज्ज़िन देकर मस्जिद में ताला,

99+लुटे ख़जाने नरपितयों के गिरीं गढ़ों की दीवारें,

100+रहें मुबारक पीनेवाले, खुली रहे यह मधुशाला।।२०।

101+

102+बड़े बड़े परिवार मिटें यों, एक न हो रोनेवाला,

103+हो जाएँ सुनसान महल वे, जहाँ थिरकतीं सुरबाला,

104+राज्य उलट जाएँ, भूपों की भाग्य सुलक्ष्मी सो जाए,

105+जमे रहेंगे पीनेवाले, जगा करेगी मधुशाला।।२१।

106+

107+सब मिट जाएँ, बना रहेगा सुन्दर साकी, यम काला,

108+सूखें सब रस, बने रहेंगे, किन्तु, हलाहल औ' हाला,

109+धूमधाम औ' चहल पहल के स्थान सभी सुनसान बनें,

110+जगा करेगा अविरत मरघट, जगा करेगी मधुशाला।।२२।

111+

112+भुरा सदा कहलायेगा जग में बाँका, मदचंचल प्याला,

113+छैल छबीला, रसिया साकी, अलबेला पीनेवाला,

114+पटे कहाँ से, मधु औ' जग की जोड़ी ठीक नहीं,

115+जग जर्जर प्रतिदन, प्रतिक्षण, पर नित्य नवेली मधुशाला।।२३।

116+

117+बिना पिये जो मधुशाला को बुरा कहे, वह मतवाला,

118+पी लेने पर तो उसके मुह पर पड़ जाएगा ताला,

119+दास द्रोहियों दोनों में है जीत सुरा की, प्याले की,

120+विश्वविजयिनी बनकर जग में आई मेरी मधुशाला।।२४।

121+

122+हरा भरा रहता मदिरालय, जग पर पड़ जाए पाला,

123+वहाँ मुहर्रम का तम छाए, यहाँ होलिका की ज्वाला,

124+स्वर्ग लोक से सीधी उतरी वसुधा पर, दुख क्या जाने,

125+पढ़े मर्सिया दुनिया सारी, ईद मनाती मधुशाला।।२५।

126+

127+एक बरस में, एक बार ही जगती होली की ज्वाला,

128+एक बार ही लगती बाज़ी, जलती दीपों की माला,

129+दुनियावालों, किन्तु, किसी दिन आ मदिरालय में देखो,

130+दिन को होली, रात दिवाली, रोज़ मनाती मधुशाला।।२६।

131+

132+नहीं जानता कौन, मनुज आया बनकर पीनेवाला,

133+कौन अपिरिचत उस साकी से, जिसने दूध पिला पाला,

134+जीवन पाकर मानव पीकर मस्त रहे, इस कारण ही,

135+जग में आकर सबसे पहले पाई उसने मधुशाला।।२७।

136+

137+बनी रहें अंगूर लताएँ जिनसे मिलती है हाला,

138+बनी रहे वह मिटटी जिससे बनता है मधु का प्याला,

139+बनी रहे वह मदिर पिपासा तृप्त न जो होना जाने,

140+बनें रहें ये पीने वाले, बनी रहे यह मधुशाला।।२८।

141+

142+सकुशल समझो मुझको, सकुशल रहती यदि साकीबाला,

143+मंगल और अमंगल समझे मस्ती में क्या मतवाला,

144+मित्रों, मेरी क्षेम न पूछो आकर, पर मधुशाला की,

145+कहा करो 'जय राम' न मिलकर, कहा करो 'जय मधुशाला'।।२९।

146+

147+सूर्य बने मधु का विक्रेता, सिंधु बने घट, जल, हाला,

148+बादल बन-बन आए साकी, भूमि बने मधु का प्याला,

149+झड़ी लगाकर बरसे मदिरा रिमझिम, रिमझिम, रिमझिम कर,

150+बेलि, विटप, तृण बन मैं पीऊँ, वर्षा ऋतु हो मधुशाला।।३०।

151+

152+तारक मणियों से सज्जित नभ बन जाए मधु का प्याला,

153+सीधा करके भर दी जाए उसमें सागरजल हाला,

154+मत्त समीरण साकी बनकर अधरों पर छलका जाए,

155+फैले हों जो सागर तट से विश्व बने यह मधुशाला।।३१।

156+

157+अधरों पर हो कोई भी रस जिहवा पर लगती हाला,

158+भाजन हो कोई हाथों में लगता रक्खा है प्याला,

159+हर सूरत साकी की सूरत में परिवर्तित हो जाती,

160+आँखों के आगे हो कुछ भी, आँखों में है मधुशाला।।३२।

161+

162+पौधे आज बने हैं साकी ले ले फूलों का प्याला,

163+भरी हुई है जिसके अंदर पिरमल-मधु-सुरिभत हाला,

164+माँग माँगकर भ्रमरों के दल रस की मदिरा पीते हैं,

165+झूम झपक मद-झंपित होते, उपवन क्या है मधुशाला!।३३।

166+

167+प्रति रसाल तरू साकी सा है, प्रति मंजरिका है प्याला,

168+छलक रही है जिसके बाहर मादक सौरभ की हाला,

169+छक जिसको मतवाली कोयल कूक रही डाली डाली

170+हर मधुऋतु में अमराई में जग उठती है मधुशाला।।३४।

171+

172+मंद झकोरों के प्यालों में मधुऋतु सौरभ की हाला

173+भर भरकर है अनिल पिलाता बनकर मधु-मद-मतवाला,

174+हरे हरे नव पल्लव, तरूगण, नूतन डालें, वल्लरियाँ,

175+छक छक, झुक झुक झूम रही हैं, मधुबन में है मधुशाला।।३५।

176+

177+साकी बन आती है प्रातः जब अरुणा ऊषा बाला,

178+तारक-मणि-मंडित चादर दे मोल धरा लेती हाला,

179+अगणित कर-किरणों से जिसको पी, खग पागल हो गाते,

180+प्रति प्रभात में पूर्ण प्रकृति में मुखिरत होती मधुशाला।।३६।

181+

182+उतर नशा जब उसका जाता, आती है संध्या बाला,

183+बड़ी पुरानी, बड़ी नशीली नित्य ढला जाती हाला,

184+जीवन के संताप शोक सब इसको पीकर मिट जाते

185+सुरा-सुप्त होते मद-लोभी जागृत रहती मधुशाला।।३७।

186+

187+अंधकार है मधुविक्रेता, सुन्दर साकी शशिबाला

188+किरण किरण में जो छलकाती जाम जुम्हाई का हाला,

189+पीकर जिसको चेतनता खो लेने लगते हैं झपकी

190+तारकदल से पीनेवाले, रात नहीं है, मधुशाला।।३८।

191+

192+किसी ओर मैं आँखें फेरूँ, दिखलाई देती हाला

193+किसी ओर मैं आँखें फेरूँ, दिखलाई देता प्याला,

194+किसी ओर मैं देखूं, मुझको दिखलाई देता साकी

195+किसी ओर देखूं, दिखलाई पड़ती मुझको मधुशाला।।३९।

196+

197+साकी बन मुरली आई साथ लिए कर में प्याला,

198+जिनमें वह छलकाती लाई अधर-सुधा-रस की हाला,

199+योगिराज कर संगत उसकी नटवर नागर कहलाए,

200+देखो कैसों-कैसों को है नाच नचाती मधुशाला।।४०।

201+

202+वादक बन मधु का विक्रेता लाया सुर-सुमधुर-हाला,

203+रागिनियाँ बन साकी आई भरकर तारों का प्याला,

204+विक्रेता के संकेतों पर दौड़ लयों, आलापों में,

205+पान कराती श्रोतागण को, झंकृत वीणा मधुशाला।।४१।

206+

207+चित्रकार बन साकी आता लेकर तूली का प्याला,

208+जिसमें भरकर पान कराता वह बहु रस-रंगी हाला,

209+मन के चित्र जिसे पी-पीकर रंग-बिरंगे हो जाते,

210+चित्रपटी पर नाच रही है एक मनोहर मधुशाला।।४२।

211+

212+घन श्यामल अंगूर लता से खिंच खिंच यह आती हाला,

213+अरूण-कमल-कोमल कलियों की प्याली, फूलों का प्याला,

214+लोल हिलोरें साकी बन बन माणिक मधु से भर जातीं,

215+हंस मत्त होते पी पीकर मानसरोवर मधुशाला।।४३।

216+

217+हिम श्रेणी अंगूर लता-सी फैली, हिम जल है हाला,

218+चंचल नदियाँ साकी बनकर, भरकर लहरों का प्याला,

219+कोमल कूर-करों में अपने छलकाती निशिदिन चलतीं,

220+पीकर खेत खड़े लहराते, भारत पावन मधुशाला।।४४।

221+

222+धीर सुतों के हृदय रक्त की आज बना रक्तिम हाला,

223+वीर सुतों के वर शीशों का हाथों में लेकर प्याला,

224+अति उदार दानी साकी है आज बनी भारतमाता,

225+स्वतंत्रता है तृषित कालिका बलिवेदी है मधुशाला।।४५।

226+

227+दुतकारा मस्जिद ने मुझको कहकर है पीनेवाला,

228+ठुकराया ठाकुरद्वारे ने देख हथेली पर प्याला,

229+कहाँ ठिकाना मिलता जग में भला अभागे काफिर को?

230+शरणस्थल बनकर न मुझे यदि अपना लेती मधुशाला।।४६।

231+

232+पथिक बना मैं घूम रहा हूँ, सभी जगह मिलती हाला,

233+सभी जगह मिल जाता साकी, सभी जगह मिलता प्याला,

234+मुझे ठहरने का, हे मित्रों, कष्ट नहीं कुछ भी होता,

235+मिले न मंदिर, मिले न मस्जिद, मिल जाती है मधुशाला।।४७।

236+

237+सजें न मस्जिद और नमाज़ी कहता है अल्लाताला,

238+सजधजकर, पर, साकी आता, बन ठनकर, पीनेवाला,

239+शेख, कहाँ तुलना हो सकती मस्जिद की मदिरालय से

240+चिर विधवा है मस्जिद तेरी, सदा सुहागिन मधुशाला।।४८।

241+

242+बजी नफ़ीरी और नमाज़ी भूल गया अल्लाताला,

243+गाज गिरी, पर ध्यान सुरा में मग्न रहा पीनेवाला,

244+शेख, बुरा मत मानो इसको, साफ़ कहूँ तो मस्जिद को

245+अभी युगों तक सिखलाएगी ध्यान लगाना मधुशाला!।४९।

246+

247+मुसलमान औ' हिन्दू है दो, एक, मगर, उनका प्याला,

248+एक, मगर, उनका मदिरालय, एक, मगर, उनकी हाला,

249+दोनों रहते एक न जब तक मस्जिद मन्दिर में जाते,

250+बैर बढ़ाते मस्जिद मन्दिर मेल कराती मधुशाला!।५०।

251+

252+कोई भी हो शेख नमाज़ी या पंडित जपता माला,

253+बैर भाव चाहे जितना हो मदिरा से रखनेवाला,

254+एक बार बस मधुशाला के आगे से होकर निकले,

255+देखूँ कैसे थाम न लेती दामन उसका मधुशाला!।५१।

256+

257+और रसों में स्वाद तभी तक, दूर जभी तक है हाला,

258+इतरा लें सब पात्र न जब तक, आगे आता है प्याला,

259+कर लें पूजा शेख, पुजारी तब तक मस्जिद मन्दिर में

260+घूँघट का पट खोल न जब तक झाँक रही है मधुशाला।।५२।

261+

262+आज करे परहेज़ जगत, पर, कल पीनी होगी हाला,

263+आज करे इन्कार जगत पर कल पीना होगा प्याला,

264+होने दो पैदा मद का महमूद जगत में कोई, फिर

265+जहाँ अभी हैं मन्दिर मस्जिद वहाँ बनेगी मधुशाला।।५३।

266+

267+यज्ञ अग्नि सी धधक रही है मधु की भटठी की ज्वाला,

268+ऋषि सा ध्यान लगा बैठा है हर मदिरा पीने वाला,

269+मुनि कन्याओं सी मधुघट ले फिरतीं साकीबालाएँ,

270+किसी तपोवन से क्या कम है मेरी पावन मधुशाला।।५४।

271+

272+सोम सुरा पुरखे पीते थे, हम कहते उसको हाला,

273+द्रोणकलश जिसको कहते थे, आज वही मधुघट आला,

274+वेदिवहित यह रस्म न छोड़ो वेदों के ठेकेदारों,

275+युग युग से है पुजती आई नई नहीं है मधुशाला।।५५।

276+

277+वही वारूणी जो थी सागर मथकर निकली अब हाला,

278+रंभा की संतान जगत में कहलाती 'साकीबाला',

279+देव अदेव जिसे ले आए, संत महंत मिटा देंगे!

280+किसमें कितना दम खम, इसको खूब समझती मधुशाला।।५६।

281+

282+कभी न सुन पड़ता, 'इसने, हा, छू दी मेरी हाला',

283+कभी न कोई कहता, 'उसने जूठा कर डाला प्याला',

284+सभी जाति के लोग यहाँ पर साथ बैठकर पीते हैं,

285+सौ सुधारकों का करती है काम अकेले मधुशाला।।५७।

286+

287+श्रम, संकट, संताप, सभी तुम भूला करते पी हाला,

288+सबक बड़ा तुम सीख चुके यदि सीखा रहना मतवाला,

289+व्यर्थ बने जाते हो हिरजन, तुम तो मधुजन ही अच्छे,

290+ठुकराते हैं मंदिरवाले, पलक बिछाती मधुशाला।।५८।

291+

292+एक तरह से सबका स्वागत करती है साकीबाला,

293+अज्ञ विज्ञ में है क्या अंतर हो जाने पर मतवाला,

294+रंक राव में भेद हुआ है कभी नहीं मदिरालय में,

295+साम्यवाद की प्रथम प्रचारक है यह मेरी मधुशाला।।५९।

296+

297+बार बार मैंने आगे बढ़ आज नहीं माँगी हाला,

298+समझ न लेना इससे मुझको साधारण पीने वाला,

299+हो तो लेने दो ऐ साकी दूर प्रथम संकोचों को,

300+मेरे ही स्वर से फिर सारी गूँज उठेगी मधुशाला।।६०।

301+

302+कल? कल पर विश्वास किया कब करता है पीनेवाला

303+हो सकते कल कर जड़ जिनसे फिर फिर आज उठा प्याला,

304+आज हाथ में था, वह खोया, कल का कौन भरोसा है,

305+कल की हो न मुझे मधुशाला काल कुटिल की मधुशाला।।६१।

306+

307+आज मिला अवसर, तब फिर क्यों मैं न छकूँ जी-भर हाला

308+आज मिला मौका, तब फिर क्यों ढाल न लूँ जी-भर प्याला,

309+छेड़छाड़ अपने साकी से आज न क्यों जी-भर कर लूँ,

310+एक बार ही तो मिलनी है जीवन की यह मधुशाला।।६२।

311+

312+आज सजीव बना लो, प्रेयसी, अपने अधरों का प्याला,

313+भर लो, भर लो, भर लो इसमें, यौवन मधुरस की हाला,

314+और लगा मेरे होठों से भूल हटाना तुम जाओ,

315+अथक बनू मैं पीनेवाला, खुले प्रणय की मधुशाला।।६३।

316+

317+सुमुखी तुम्हारा, सुन्दर मुख ही, मुझको कन्चन का प्याला

318+छलक रही है जिसमें माणिक रूप मधुर मादक हाला,

319+मैं ही साकी बनता, मैं ही पीने वाला बनता हूँ

320+जहाँ कहीं मिल बैठे हम तुम़ वहीं गयी हो मधुशाला।।६४।

321+

322+दो दिन ही मधु मुझे पिलाकर ऊब उठी साकीबाला,

323+भरकर अब खिसका देती है वह मेरे आगे प्याला,

324+नाज़, अदा, अंदाजों से अब, हाय पिलाना दूर हुआ,

325+अब तो कर देती है केवल फ़र्ज़ - अदाई मधुशाला।।६५।

326+

327+छोटे-से जीवन में कितना प्यार करुँ, पी लूँ हाला,

328+आने के ही साथ जगत में कहलाया 'जानेवाला',

329+स्वागत के ही साथ विदा की होती देखी तैयारी,

330+बंद लगी होने खुलते ही मेरी जीवन-मधुशाला।।६६।

331+

332+क्या पीना, निर्द्वन्द न जब तक ढाला प्यालों पर प्याला,

333+क्या जीना, निश्चिंत न जब तक साथ रहे साकीबाला,

334+खोने का भय, हाय, लगा है पाने के सुख के पीछे,

335+मिलने का आनंद न देती मिलकर के भी मधुशाला।।६७।

336+

337+मुझे पिलाने को लाए हो इतनी थोड़ी-सी हाला!

338+मुझे दिखाने को लाए हो एक यही छिछला प्याला!

339+इतनी पी जीने से अच्छा सागर की ले प्यास मरुँ,

340+सिंधु-तृषा दी किसने रचकर बिंदु-बराबर मधुशाला।।६८।

341+

342+क्या कहता है, रह न गई अब तेरे भाजन में हाला,

343+क्या कहता है, अब न चलेगी मादक प्यालों की माला,

344+थोड़ी पीकर प्यास बढ़ी तो शेष नहीं कुछ पीने को,

345+प्यास बुझाने को बुलवाकर प्यास बढ़ाती मधुशाला।।६९।

346+

347+लिखी भाग्य में जितनी बस उतनी ही पाएगा हाला,

348+लिखा भाग्य में जैसा बस वैसा ही पाएगा प्याला,

349+लाख पटक तू हाथ पाँव, पर इससे कब कुछ होने का,

350+लिखी भाग्य में जो तेरे बस वही मिलेगी मधुशाला।।७०।

351+

352+कर ले, कर ले कंजूसी तू मुझको देने में हाला,

353+दे ले, दे ले तू मुझको बस यह टूटा फूटा प्याला,

354+मैं तो सब्र इसी पर करता, तू पीछे पछताएगी,

355+जब न रहूँगा मैं, तब मेरी याद करेगी मधुशाला।।७१।

356+

357+ध्यान मान का, अपमानों का छोड़ दिया जब पी हाला,

358+गौरव भूला, आया कर में जब से मिट्टी का प्याला,

359+साकी की अंदाज़ भरी झिड़की में क्या अपमान धरा,

360+दुनिया भर की ठोकर खाकर पाई मैंने मधुशाला।।७२।

361+

362+क्षीण, क्षुद्र, क्षणभंगुर, दुर्बल मानव मिटटी का प्याला,

363+भरी हुई है जिसके अंदर कटु-मधु जीवन की हाला,

364+मृत्यु बनी है निर्दय साकी अपने शत-शत कर फैला,

365+काल प्रबल है पीनेवाला, संसृति है यह मधुशाला।।७३।

366+

367+प्याले सा गढ़ हमें किसी ने भर दी जीवन की हाला,

368+नशा न भाया, ढाला हमने ले लेकर मधु का प्याला,

369+जब जीवन का दर्द उभरता उसे दबाते प्याले से,

370+जगती के पहले साकी से जूझ रही है मधुशाला।।७४।

371+

372+अपने अंगूरों से तन में हमने भर ली है हाला,

373+क्या कहते हो, शेख, नरक में हमें तपाएगी ज्वाला,

374+तब तो मदिरा खूब खिंचेगी और पिएगा भी कोई,

375+हमें नमक की ज्वाला में भी दीख पड़ेगी मधुशाला।।७५।

376+

377+यम आएगा लेने जब, तब खूब चलूँगा पी हाला,

378+पीड़ा, संकट, कष्ट नरक के क्या समझेगा मतवाला,

379+क्रूर, कठोर, कुटिल, कुविचारी, अन्यायी यमराजों के

380+डंडों की जब मार पड़ेगी, आड़ करेगी मधुशाला।।७६।

381+

382+यदि इन अधरों से दो बातें प्रेम भरी करती हाला,

383+यदि इन खाली हाथों का जी पल भर बहलाता प्याला,

384+हानि बता, जग, तेरी क्या है, व्यर्थ मुझे बदनाम न कर,

385+मेरे टूटे दिल का है बस एक खिलौना मधुशाला।।७७।

386+

387+याद न आए दुखमय जीवन इससे पी लेता हाला,

388+जग चिंताओं से रहने को मुक्त, उठा लेता प्याला,

389+शौक, साध के और स्वाद के हेतु पिया जग करता है,

390+पर मै वह रोगी हूँ जिसकी एक दवा है मधुशाला।।७८।

391+

392+गिरती जाती है दिन प्रतिदन प्रणयनी प्राणों की हाला

393+भग्न हुआ जाता दिन प्रतिदन सुभगे मेरा तन प्याला,

394+रूठ रहा है मुझसे रूपसी, दिन दिन यौवन का साकी

395+सूख रही है दिन दिन सुन्दरी, मेरी जीवन मधुशाला।।७९।

396+

397+यम आयेगा साकी बनकर साथ लिए काली हाला,

398+पी न होश में फिर आएगा सुरा-विसुध यह मतवाला,

399+यह अंतिम बेहोशी, अंतिम साकी, अंतिम प्याला है,

400+पथिक, प्यार से पीना इसको फिर न मिलेगी मधुशाला।८०।

401+

402+ढलक रही है तन के घट से, संगिनी जब जीवन हाला

403+पत्र गरल का ले जब अंतिम साकी है आनेवाला,

404+हाथ स्पर्श भूले प्याले का, स्वाद सुरा जीव्हा भूले

405+कानो में तुम कहती रहना, मधु का प्याला मधुशाला।।८१।

406+

407+मेरे अधरों पर हो अंतिम वस्तु न तुलसीदल प्याला

408+मेरी जीव्हा पर हो अंतिम वस्तु न गंगाजल हाला,

409+मेरे शव के पीछे चलने वालों याद इसे रखना

410+राम नाम है सत्य न कहना, कहना सच्ची मधुशाला।।८२।

411+

412+मेरे शव पर वह रोये, हो जिसके आंसू में हाला

413+आह भरे वो, जो हो सुरिभत मदिरा पी कर मतवाला,

414+दे मुझको वो कान्धा जिनके पग मद डगमग होते हों

415+और जलूं उस ठौर जहां पर कभी रही हो मधुशाला।।८३।

416+

417+और चिता पर जाये उंढेला पात्र न घ्रित का, पर प्याला

418+कंठ बंधे अंगूर लता में मध्य न जल हो, पर हाला,

419+प्राण प्रिये यदि श्राध करो तुम मेरा तो ऐसे करना

420+पीने वालों को बुलवा कऱ खुलवा देना मधुशाला।।८४।

421+

422+नाम अगर कोई पूछे तो, कहना बस पीनेवाला

423+काम ढालना, और ढालना सबको मदिरा का प्याला,

424+जाति प्रिये, पूछे यदि कोई कह देना दीवानों की

425+धर्म बताना प्यालों की ले माला जपना मधुशाला।।८५।

426+

427+ज्ञात हुआ यम आने को है ले अपनी काली हाला,

428+पंडित अपनी पोथी भूला, साधू भूल गया माला,

429+और पुजारी भूला पूजा, ज्ञान सभी ज्ञानी भूला,

430+किन्तु न भूला मरकर के भी पीनेवाला मधुशाला।।८६।

431+

432+यम ले चलता है मुझको तो, चलने दे लेकर हाला,

433+चलने दे साकी को मेरे साथ लिए कर में प्याला,

434+स्वर्ग, नरक या जहाँ कहीं भी तेरा जी हो लेकर चल,

435+ठौर सभी हैं एक तरह के साथ रहे यदि मधुशाला।।८७।

436+

437+पाप अगर पीना, समदोषी तो तीनों - साकी बाला,

438+नित्य पिलानेवाला प्याला, पी जानेवाली हाला,

439+साथ इन्हें भी ले चल मेरे न्याय यही बतलाता है,

440+कैद जहाँ मैं हूँ, की जाए कैद वहीं पर मधुशाला।।८८।

441+

442+शांत सकी हो अब तक, साकी, पीकर किस उर की ज्वाला,

443+'और, और' की रटन लगाता जाता हर पीनेवाला,

444+कितनी इच्छाएँ हर जानेवाला छोड़ यहाँ जाता!

445+कितने अरमानों की बनकर कब्र खड़ी है मधुशाला।।८९।

446+

447+जो हाला मैं चाह रहा था, वह न मिली मुझको हाला,

448+जो प्याला मैं माँग रहा था, वह न मिला मुझको प्याला,

449+जिस साकी के पीछे मैं था दीवाना, न मिला साकी,

450+जिसके पीछे था मैं पागल, हा न मिली वह मधुशाला!।९०।

451+

452+देख रहा हूँ अपने आगे कब से माणिक-सी हाला,

453+देख रहा हूँ अपने आगे कब से कंचन का प्याला,

454+'बस अब पाया!'- कह-कह कब से दौड़ रहा इसके पीछे,

455+किंतु रही है दूर क्षितिज-सी मुझसे मेरी मधुशाला।।९१।

456+

457+कभी निराशा का तम घिरता, छिप जाता मधु का प्याला,

458+छिप जाती मदिरा की आभा, छिप जाती साकीबाला,

459+कभी उजाला आशा करके प्याला फिर चमका जाती,

460+आँख मिचौली खेल रही है मुझसे मेरी मधुशाला।।९२।

461+

462+'आ आगे' कहकर कर पीछे कर लेती साकीबाला,

463+होंठ लगाने को कहकर हर बार हटा लेती प्याला,

464+नहीं मुझे मालूम कहाँ तक यह मुझको ले जाएगी,

465+बढ़ा बढ़ाकर मुझको आगे, पीछे हटती मधुशाला।।९३।

466+

467+हाथों में आने-आने में, हाय, फिसल जाता प्याला,

468+अधरों पर आने-आने में हाय, ढुलक जाती हाला,

469+दुनियावालो, आकर मेरी किस्मत की ख़ूबी देखो,

470+रह-रह जाती है बस मुझको मिलते-मिलते मधुशाला।।९४।

471+

472+प्राप्य नही है तो, हो जाती लुप्त नहीं फिर क्यों हाला,

473+प्राप्य नही है तो, हो जाता लुप्त नहीं फिर क्यों प्याला,

474+दूर न इतनी हिम्मत हारुँ, पास न इतनी पा जाऊँ,

475+व्यर्थ मुझे दौड़ाती मरु में मृगजल बनकर मधुशाला।।९५।

476+

477+मिले न, पर, ललचा ललचा क्यों आकुल करती है हाला,

478+मिले न, पर, तरसा तरसाकर क्यों तड़पाता है प्याला,

479+हाय, नियति की विषम लेखनी मस्तक पर यह खोद गई

480+'दूर रहेगी मधु की धारा, पास रहेगी मधुशाला!'।९६।

481+

482+मदिरालय में कब से बैठा, पी न सका अब तक हाला,

483+यत्न सहित भरता हूँ, कोई किंतु उलट देता प्याला,

484+मानव-बल के आगे निर्बल भाग्य, सुना विद्यालय में,

485+'भाग्य प्रबल, मानव निर्बल' का पाठ पढ़ाती मधुशाला।।९७।

486+

487+किस्मत में था खाली खप्पर, खोज रहा था मैं प्याला,

488+ढूँढ़ रहा था मैं मृगनयनी, किस्मत में थी मृगछाला,

489+किसने अपना भाग्य समझने में मुझसा धोखा खाया,

490+किस्मत में था अवघट मरघट, ढूँढ़ रहा था मधुशाला।।९८।

491+

492+उस प्याले से प्यार मुझे जो दूर हथेली से प्याला,

493+उस हाला से चाव मुझे जो दूर अधर से है हाला,

494+प्यार नहीं पा जाने में है, पाने के अरमानों में!

495+पा जाता तब, हाय, न इतनी प्यारी लगती मधुशाला।।९९।

496+

497+साकी के पास है तनिक सी श्री, सुख, संपित की हाला,

498+सब जग है पीने को आतुर ले ले किस्मत का प्याला,

499+रेल ठेल कुछ आगे बढ़ते, बहुतेरे दबकर मरते,

500+जीवन का संघर्ष नहीं है, भीड़ भरी है मधुशाला।।१००।

501+

502+साकी, जब है पास तुम्हारे इतनी थोड़ी सी हाला,

503+क्यों पीने की अभिलषा से, करते सबको मतवाला,

504+हम पिस पिसकर मरते हैं, तुम छिप छिपकर मुसकाते हो,

505+हाय, हमारी पीड़ा से है क्रीड़ा करती मधुशाला।।१०१।

506+

507+साकी, मर खपकर यदि कोई आगे कर पाया प्याला,

508+पी पाया केवल दो बूंदों से न अधिक तेरी हाला,

509+जीवन भर का, हाय, पिरश्रम लूट लिया दो बूंदों ने,

510+भोले मानव को ठगने के हेतु बनी है मधुशाला।।१०२।

511+

512+जिसने मुझको प्यासा रक्खा बनी रहे वह भी हाला,

513+जिसने जीवन भर दौड़ाया बना रहे वह भी प्याला,

514+मतवालों की जिह्वा से हैं कभी निकलते शाप नहीं,

515+दुखी बनाया जिसने मुझको सुखी रहे वह मधुशाला!।१०३।

516+

517+नहीं चाहता, आगे बढ़कर छीनूँ औरों की हाला,

518+नहीं चाहता, धक्के देकर, छीनूँ औरों का प्याला,

519+साकी, मेरी ओर न देखो मुझको तनिक मलाल नहीं,

520+इतना ही क्या कम आँखों से देख रहा हूँ मधुशाला।।१०४।

521+

522+मद, मदिरा, मधु, हाला सुन-सुन कर ही जब हूँ मतवाला,

523+क्या गति होगी अधरों के जब नीचे आएगा प्याला,

524+साकी, मेरे पास न आना मैं पागल हो जाऊँगा,

525+प्यासा ही मैं मस्त, मुबारक हो तुमको ही मधुशाला।।१०५।

526+

527+क्या मुझको आवश्यकता है साकी से माँगूँ हाला,

528+क्या मुझको आवश्यकता है साकी से चाहूँ प्याला,

529+पीकर मदिरा मस्त हुआ तो प्यार किया क्या मदिरा से!

530+मैं तो पागल हो उठता हूँ सुन लेता यदि मधुशाला।।१०६।

531+

532+देने को जो मुझे कहा था दे न सकी मुझको हाला,

533+देने को जो मुझे कहा था दे न सका मुझको प्याला,

534+समझ मनुज की दुर्बलता मैं कहा नहीं कुछ भी करता,

535+किन्तु स्वयं ही देख मुझे अब शरमा जाती मधुशाला।।१०७।

536+

537+एक समय संतुष्ट बहुत था पा मैं थोड़ी-सी हाला,

538+भोला-सा था मेरा साकी, छोटा-सा मेरा प्याला,

539+छोटे-से इस जग की मेरे स्वर्ग बलाएँ लेता था,

540+विस्तृत जग में, हाय, गई खो मेरी नन्ही मधुशाला!।१०८।

541+

542+बहुतेरे मदिरालय देखे, बहुतेरी देखी हाला,

543+भाँति भाँति का आया मेरे हाथों में मधु का प्याला,

544+एक एक से बढ़कर, सुन्दर साकी ने सत्कार किया,

545+जँची न आँखों में, पर, कोई पहली जैसी मधुशाला।।१०९।

546+

547+एक समय छलका करती थी मेरे अधरों पर हाला,

548+एक समय झूमा करता था मेरे हाथों पर प्याला,

549+एक समय पीनेवाले, साकी आलिंगन करते थे,

550+आज बनी हूँ निर्जन मरघट, एक समय थी मधुशाला।।११०।

551+

552+जला हृदय की भट्टी खींची मैंने आँसू की हाला,

553+छलछल छलका करता इससे पल पल पलकों का प्याला,

554+आँखें आज बनी हैं साकी, गाल गुलाबी पी होते,

555+कहो न विरही मुझको, मैं हूँ चलती फिरती मधुशाला!।१११।

556+

557+कितनी जल्दी रंग बदलती है अपना चंचल हाला,

558+कितनी जल्दी घिसने लगता हाथों में आकर प्याला,

559+कितनी जल्दी साकी का आकर्षण घटने लगता है,

560+प्रात नहीं थी वैसी, जैसी रात लगी थी मधुशाला।।११२।

561+

562+बूँद बूँद के हेतु कभी तुझको तरसाएगी हाला,

563+कभी हाथ से छिन जाएगा तेरा यह मादक प्याला,

564+पीनेवाले, साकी की मीठी बातों में मत आना,

565+मेरे भी गुण यों ही गाती एक दिवस थी मधुशाला।।११३।

566+

567+छोड़ा मैंने पथ मतों को तब कहलाया मतवाला,

568+चली सुरा मेरा पग धोने तोड़ा जब मैंने प्याला,

569+अब मानी मधुशाला मेरे पीछे पीछे फिरती है,

570+क्या कारण? अब छोड़ दिया है मैंने जाना मधुशाला।।११४।

571+

572+यह न समझना, पिया हलाहल मैंने, जब न मिली हाला,

573+तब मैंने खप्पर अपनाया ले सकता था जब प्याला,

574+जले हृदय को और जलाना सूझा, मैंने मरघट को

575+अपनाया जब इन चरणों में लोट रही थी मधुशाला।।११५।

576+

577+कितनी आई और गई पी इस मदिरालय में हाला,

578+टूट चुकी अब तक कितने ही मादक प्यालों की माला,

579+कितने साकी अपना अपना काम खतम कर दूर गए,

580+कितने पीनेवाले आए, किन्तु वही है मधुशाला।।११६।

581+

582+कितने होठों को रक्खेगी याद भला मादक हाला,

583+कितने हाथों को रक्खेगा याद भला पागल प्याला,

584+कितनी शक्लों को रक्खेगा याद भला भोला साकी,

585+कितने पीनेवालों में है एक अकेली मधुशाला।।११७।

586+

587+दर दर घूम रहा था जब मैं चिल्लाता - हाला! हाला!

588+मुझे न मिलता था मदिरालय, मुझे न मिलता था प्याला,

589+मिलन हुआ, पर नहीं मिलनसुख लिखा हुआ था किस्मत में,

590+मैं अब जमकर बैठ गया हूँ, घूम रही है मधुशाला।।११८।

591+

592+मैं मदिरालय के अंदर हूँ, मेरे हाथों में प्याला,

593+प्याले में मदिरालय बिंबित करनेवाली है हाला,

594+इस उधेड़-बुन में ही मेरा सारा जीवन बीत गया -

595+मैं मधुशाला के अंदर या मेरे अंदर मधुशाला!।११९।

596+

597+किसे नहीं पीने से नाता, किसे नहीं भाता प्याला,

598+इस जगती के मदिरालय में तरह-तरह की है हाला,

599+अपनी-अपनी इच्छा के अनुसार सभी पी मदमाते,

600+एक सभी का मादक साकी, एक सभी की मधुशाला।।१२०।

601+

602+वह हाला, कर शांत सके जो मेरे अंतर की ज्वाला,

603+जिसमें मैं बिंबित-प्रतिबिंबित प्रतिपल, वह मेरा प्याला,

604+मधुशाला वह नहीं जहाँ पर मदिरा बेची जाती है,

605+भेंट जहाँ मस्ती की मिलती मेरी तो वह मधुशाला।।१२१।

606+

607+मतवालापन हाला से ले मैंने तज दी है हाला,

608+पागलपन लेकर प्याले से, मैंने त्याग दिया प्याला,

609+साकी से मिल, साकी में मिल अपनापन मैं भूल गया,

610+मिल मधुशाला की मधुता में भूल गया मैं मधुशाला।।१२२।

611+

612+मदिरालय के द्वार ठोंकता किस्मत का छूंछा प्याला,

613+गहरी, ठंडी सांसें भर भर कहता था हर मतवाला,

614+कितनी थोड़ी सी यौवन की हाला, हा, मैं पी पाया!

615+बंद हो गई कितनी जल्दी मेरी जीवन मधुशाला।।१२३।

616+

617+कहाँ गया वह स्वर्गिक साकी, कहाँ गयी सुरिभत हाला,

618+कहाँ गया स्वपिनल मदिरालय, कहाँ गया स्वर्णिम प्याला!

619+पीनेवालों ने मदिरा का मूल्य, हाय, कब पहचाना?

620+फूट चुका जब मधु का प्याला, टूट चुकी जब मधुशाला।।१२४।

621+

622+अपने युग में सबको अनुपम ज्ञात हुई अपनी हाला,

623+अपने युग में सबको अदभुत ज्ञात हुआ अपना प्याला,

624+फिर भी वृद्धों से जब पूछा एक यही उत्तर पाया -

625+अब न रहे वे पीनेवाले, अब न रही वह मधुशाला!।१२५।

626+

627+'मय' को करके शुद्ध दिया अब नाम गया उसको, 'हाला'

628+'मीना' को 'मधुपात्र' दिया 'सागर' को नाम गया 'प्याला',

629+क्यों न मौलवी चौंकें, बिचकें तिलक-त्रिपुंडी पंडित जी

630+'मय-महिफल' अब अपना ली है मैंने करके 'मधुशाला'।।१२६।

631+

632+कितने मर्म जता जाती है बार-बार आकर हाला,

633+कितने भेद बता जाता है बार-बार आकर प्याला,

634+कितने अर्थों को संकेतों से बतला जाता साकी,

635+फिर भी पीनेवालों को है एक पहेली मधुशाला।।१२७।

636+

637+जितनी दिल की गहराई हो उतना गहरा है प्याला,

638+जितनी मन की मादकता हो उतनी मादक है हाला,

639+जितनी उर की भावुकता हो उतना सुन्दर साकी है,

640+जितना ही जो रिसक, उसे है उतनी रसमय मधुशाला।।१२८।

641+

642+जिन अधरों को छुए, बना दे मस्त उन्हें मेरी हाला,

643+जिस कर को छू दे, कर दे विक्षिप्त उसे मेरा प्याला,

644+आँख चार हों जिसकी मेरे साकी से दीवाना हो,

645+पागल बनकर नाचे वह जो आए मेरी मधुशाला।।१२९।

646+

647+हर जिव्हा पर देखी जाएगी मेरी मादक हाला

648+हर कर में देखा जाएगा मेरे साकी का प्याला

649+हर घर में चर्चा अब होगी मेरे मधुविक्रेता की

650+हर आंगन में गमक उठेगी मेरी सुरिभत मधुशाला।।१३०।

651+

652+मेरी हाला में सबने पाई अपनी-अपनी हाला,

653+मेरे प्याले में सबने पाया अपना-अपना प्याला,

654+मेरे साकी में सबने अपना प्यारा साकी देखा,

655+जिसकी जैसी रुचि थी उसने वैसी देखी मधुशाला।।१३१।

656+

657+यह मदिरालय के आँसू हैं, नहीं-नहीं मादक हाला,

658+यह मदिरालय की आँखें हैं, नहीं-नहीं मधु का प्याला,

659+किसी समय की सुखदस्मृति है साकी बनकर नाच रही,

660+नहीं-नहीं कवि का हृदयांगण, यह विरहाकुल मधुशाला।।१३२।

661+

662+कुचल हसरतें कितनी अपनी, हाय, बना पाया हाला,

663+कितने अरमानों को करके ख़ाक बना पाया प्याला!

664+पी पीनेवाले चल देंगे, हाय, न कोई जानेगा,

665+कितने मन के महल ढहे तब खड़ी हुई यह मधुशाला!।१३३।

666+

667+विश्व तुम्हारे विषमय जीवन में ला पाएगी हाला

668+यदि थोड़ी-सी भी यह मेरी मदमाती साकीबाला,

669+शून्य तुम्हारी घड़ियाँ कुछ भी यदि यह गुंजित कर पाई,

670+जन्म सफल समझेगी जग में अपना मेरी मधुशाला।।१३४।

671+

672+बड़े-बड़े नाज़ों से मैंने पाली है साकीबाला,

673+कलित कल्पना का ही इसने सदा उठाया है प्याला,

674+मान-दुलारों से ही रखना इस मेरी सुकुमारी को,

675+विश्व, तुम्हारे हाथों में अब सौंप रहा हूँ मधुशाला।।१३५।

676+

677+पिरिशष्ट से

678+

679+स्वयं नहीं पीता, औरों को, किन्तु पिला देता हाला,

680+स्वयं नहीं छूता, औरों को, पर पकड़ा देता प्याला,

681+पर उपदेश कुशल बहुतेरों से मैंने यह सीखा है,

682+स्वयं नहीं जाता, औरों को पहुंचा देता मधुशाला।

683+

684+मैं कायस्थ कुलोदभव मेरे पुरखों ने इतना ढ़ाला,

685+मेरे तन के लोहू में है पचहत्तर प्रतिशत हाला,

686+पुश्तैनी अधिकार मुझे है मदिरालय के आँगन पर,

687+मेरे दादों परदादों के हाथ बिकी थी मधुशाला।

688+

689+बहुतों के सिर चार दिनों तक चढ़कर उतर गई हाला,

690+बहुतों के हाथों में दो दिन छलक झलक रीता प्याला,

691+पर बढ़ती तासीर सुरा की साथ समय के, इससे ही

692+और पुरानी होकर मेरी और नशीली मधुशाला।

693+

694+पितृ पक्ष में पुत्र उठाना अर्ध्य न कर में, पर प्याला

695+बैठ कहीं पर जाना, गंगा सागर में भरकर हाला

696+किसी जगह की मिटटी भीगे, तृप्ति मुझे मिल जाएगी

697+तर्पण अर्पण करना मुझको, पढ़ पढ़ कर के मधुशाला।

698+

699+- बच्चन

benchmark/Streamly/Benchmark/Unicode/data/English.txtnew file+58

@@ -0,0 +1,58 @@

1+Origins[edit]

2+The standard Italian language has a poetic and literary origin in the twelfth century, and the modern standard of the language was largely shaped by relatively recent events. However, Italian as a language used in the Italian Peninsula has a longer history. In fact the earliest surviving texts that can definitely be called Italian (or more accurately, vernacular, as distinct from its predecessor Vulgar Latin) are legal formulae known as the Placiti Cassinesi from the Province of Benevento that date from 960–963, although the Veronese Riddle contains a late form of Vulgar Latin that can be seen as a very early Italian dialect.[13] What would come to be thought of as Italian was first formalized in the early fourteenth century through the works of Tuscan writer Dante Alighieri, written in his native Florentine. Dante's epic poems, known collectively as the Commedia, to which another Tuscan poet Giovanni Boccaccio later affixed the title Divina, were read throughout Italy and his written dialect became the "canonical standard" that all educated Italians could understand. Dante is still credited with standardizing the Italian language, and thus the dialect of Florence became the basis for what would become the official language of Italy.

4+Italian often was an official language of the various Italian states predating unification, slowly usurping Latin, even when ruled by foreign powers (such as the Spanish in the Kingdom of Naples, or the Austrians in the Kingdom of Lombardy-Venetia), even though the masses spoke primarily vernacular languages and dialects. Italian was also one of the many recognised languages in the Austro-Hungarian Empire.

6+Italy has always had a distinctive dialect for each city, because the cities, until recently, were thought of as city-states. Those dialects now have considerable variety. As Tuscan-derived Italian came to be used throughout Italy, features of local speech were naturally adopted, producing various versions of Regional Italian. The most characteristic differences, for instance, between Roman Italian and Milanese Italian are the gemination of initial consonants and the pronunciation of stressed "e", and of "s" in some cases: e.g. va bene "all right": is pronounced [va ˈbːɛne] by a Roman (and by any standard-speaker), [va ˈbene] by a Milanese (and by any speaker whose native dialect lies to the north of La Spezia–Rimini Line); a casa "at home" is [a ˈkːasa] for Roman and standard, [a ˈkaza] for Milanese and generally northern.

8+In contrast to the Northern Italian language, southern Italian dialects and languages were largely untouched by the Franco-Occitan influences introduced to Italy, mainly by bards from France, during the Middle Ages but, after the Norman conquest of southern Italy, Sicily became the first Italian land to adopt Occitan lyric moods (and words) in poetry. Even in the case of Northern Italian language, however, scholars are careful not to overstate the effects of outsiders on the natural indigenous developments of the languages.

10+The economic might and relatively advanced development of Tuscany at the time (Late Middle Ages) gave its dialect weight, though the Venetian language remained widespread in medieval Italian commercial life, and Ligurian (or Genoese) remained in use in maritime trade alongside the Mediterranean. The increasing political and cultural relevance of Florence during the periods of the rise of Medici's bank, Humanism, and the Renaissance made its dialect, or rather a refined version of it, a standard in the arts.

11+

12+Renaissance[edit]

13+Main article: Italian Renaissance

14+Starting with the Renaissance, Italian became the language used in the courts of every state in the peninsula. The rediscovery of Dante's De vulgari eloquentia and a renewed interest in linguistics in the sixteenth century, sparked a debate that raged throughout Italy concerning the criteria that should govern the establishment of a modern Italian literary and spoken language. Scholars divided into three factions:

15+

16+The purists, headed by Venetian Pietro Bembo (who, in his Gli Asolani, claimed the language might be based only on the great literary classics, such as Petrarch and some part of Boccaccio). The purists thought the Divine Comedy not dignified enough, because it used elements from non-lyric registers of the language.

17+Niccolò Machiavelli and other Florentines preferred the version spoken by ordinary people in their own times.

18+The courtiers, like Baldassare Castiglione and Gian Giorgio Trissino, insisted that each local vernacular contribute to the new standard.

19+A fourth faction claimed the best Italian was the one that the papal court adopted, which was a mix of Florentine and the dialect of Rome. Eventually, Bembo's ideas prevailed, and the foundation of the Accademia della Crusca in Florence (1582–1583), the official legislative body of the Italian language led to publication of Agnolo Monosini's Latin tome Floris italicae linguae libri novem in 1604 followed by the first Italian dictionary in 1612.

20+

21+Modern era[edit]

22+An important event that helped the diffusion of Italian was the conquest and occupation of Italy by Napoleon in the early nineteenth century (who was himself of Italian-Corsican descent). This conquest propelled the unification of Italy some decades after, and pushed the Italian language into a lingua franca used not only among clerks, nobility and functionaries in the Italian courts but also in the bourgeoisie.

23+

24+Contemporary times[edit]

25+Italian literature's first modern novel, I Promessi Sposi (The Betrothed), by Alessandro Manzoni, further defined the standard by "rinsing" his Milanese "in the waters of the Arno" (Florence's river), as he states in the Preface to his 1840 edition.

26+

27+After unification a huge number of civil servants and soldiers recruited from all over the country introduced many more words and idioms from their home languages ("ciao" is derived from Venetian word "s-cia[v]o" (slave), "panettone" comes from Lombard word "panatton" etc.). Only 2.5% of Italy’s population could speak the Italian standardized language properly when the nation unified in 1861.[14]

28+

29+Classification[edit]

30+Italian is a Romance language, and is therefore a descendant of Vulgar Latin. Standard Italian is based on Tuscan, especially its Florentine dialect, and is therefore an Italo-Dalmatian language, to which Sicilian and the extinct Dalmatian also belong, among a few others.

31+

32+Unlike most other Romance languages, Italian retains Latin's contrast between short and long consonants. As in most Romance languages, stress is distinctive. In particular, among the Romance languages, Italian is the closest to Latin in terms of vocabulary.[12] Lexical similarity is 89% with French, 88% with Catalan, 85% with Sardinian, 82% with Spanish and Portuguese, 78% with Rhaeto-Romance, and 77% with Romanian.[6][15]

33+

34+Geographic distribution[edit]

35+

36+The geographic distribution of the Italian language in the world: large Italian-speaking communities are shown in green; light blue indicates areas where the Italian language was used officially during the Italian colonial period.

37+

38+Use of the Italian language in Europe

39+

40+Use of the Italian language in Europe and former use in Africa

41+Europe[edit]

42+Italian is the official language of Italy and San Marino and is spoken fluently by the majority of the countries' populations. Italian is official, together with French, German and Romansch in Switzerland, with most of the 0.5 million speakers concentrated in the south of the country, in the cantons of Ticino and southern Graubünden (predominately in Italian Girgioni). Italian is the third most spoken language in Switzerland (after German and French), and its use has modestly declined since the 1970s.[16] Italian is also used in administration and official documents in Vatican City.[17]

43+

44+Italian is widely spoken in Malta, where nearly two-thirds of the population can speak it fluently, making it the most spoken non-official language in Europe in 2005.[18] Italian served as Malta's official language until 1934, while it is also recognized as an official language in Istria County, Croatia and Slovenian Istria, where there are significant and historic Italian populations.[citation needed]

45+

46+It is used as the official language of the Sovereign Military Order of Malta, a Roman Catholic chivalric order which, while not a nation per se, is still recognized as a sovereign subject of international law.

47+

48+Italian is also spoken by a minority in Monaco and France (especially in the southeast of the country and Corsica).[19][20] Small Italian-speaking minorities can also be found in Albania and Montenegro.[citation needed]

49+

50+Africa[edit]

51+Due to heavy Italian influence during the Italian colonial period, Italian is still widely understood in the countries of Libya and Eritrea.[6] Although it was the primary language since colonial rule, Italian greatly declined under the rule of Muammar Gaddafi, who expelled the Italian Libyan population and made Arabic the sole official language of the country.[21] Nevertheless, Italian remains an important language in the education and economic sectors in Libya. In Eritrea, Italian is a principal language in commerce and the capital city Asmara still has an Italian-language school.[22] Italian was also introduced to Somalia through colonialism and was the sole official language of administration and education during the colonial period but declined after government, educational and economic infrastructure was destroyed in the Somali Civil War. Italian remains spoken as a second language by the elderly and the educated and is also used in the new Federal Government of Somalia.[23][24]

52+

53+Italian was also used in administration in Ethiopia when the country was briefly occupied by Italy from 1936 to 1941.

54+

55+Immigrant communities[edit]

56+Although over 17 million Americans are of Italian descent, only a little over one million people in the United States speak Italian at home.[25] Nevertheless, an Italian language media market does exist in the country.[26]

57+

58+In Canada, Italian is the second most spoken non-official language when Chinese languages are not combined, with over 660,000 speakers (or abou

benchmark/Streamly/Benchmark/Unicode/data/Japanese.txtnew file+855

This diff is too big to show here.

benchmark/Streamly/Benchmark/Unicode/data/Korean.txtnew file+493

This diff is too big to show here.

benchmark/Streamly/Benchmark/Unicode/data/Vietnamese.txtnew file+402

This diff is too big to show here.

benchmark/bench-runner/Main.hsnew file+183

This diff is too big to show here.

benchmark/bench-runner/bench-runner.cabalnew file+42

This diff is too big to show here.

benchmark/bench-runner/cabal.projectnew file+4

This diff is too big to show here.

benchmark/bench-runner/default.nixnew file+164

This diff is too big to show here.

benchmark/lib/Streamly/Benchmark/Common.hs+65−17

This diff is too big to show here.

benchmark/lib/Streamly/Benchmark/Common/Handle.hs+47−32

This diff is too big to show here.

benchmark/lib/Streamly/Benchmark/Prelude.hs+69−15

This diff is too big to show here.

benchmark/streamly-benchmarks.cabal+440−175

This diff is too big to show here.

bin/bench-exec-one.shdeleted−184

This diff is too big to show here.

bin/bench.shdeleted−428

This diff is too big to show here.

bin/build-lib.shdeleted−246

This diff is too big to show here.

bin/mk-hscope.sh+2−2

This diff is too big to show here.

bin/replnew file+3

This diff is too big to show here.

bin/run-ci.sh+235−75

This diff is too big to show here.

bin/run-repl-quick.shnew file+113

This diff is too big to show here.

bin/targets.shdeleted−112

This diff is too big to show here.

bin/test.shdeleted−175

This diff is too big to show here.

cabal.project+2

This diff is too big to show here.

cabal.project.O0new file+24

This diff is too big to show here.

cabal.project.ci → cabal.project.Werrorrenamed+4

This diff is too big to show here.

cabal.project.Werror-nocodenew file+21

This diff is too big to show here.

cabal.project.coverage+5−4

This diff is too big to show here.

cabal.project.doctestnew file+24

This diff is too big to show here.

cabal.project.ghc-headnew file+35

This diff is too big to show here.

cabal.project.hpc-coveralls+1−1

This diff is too big to show here.

cabal.project.packdiffnew file+9

This diff is too big to show here.

cabal.project.reportnew file+30

This diff is too big to show here.

cabal.project.streamlynew file+10

This diff is too big to show here.

configure+1368−1516

This diff is too big to show here.

configure.ac+1−5

This diff is too big to show here.

core/Changelog.mdnew file+1

This diff is too big to show here.

core/LICENSEnew file+322

This diff is too big to show here.

core/Setup.hsnew file+6

This diff is too big to show here.

core/configurenew file+4349

This diff is too big to show here.

core/configure.acnew file+17

This diff is too big to show here.

core/docs/ApiChangelogs/0.1.0-0.2.0.txtnew file+1471

This diff is too big to show here.

core/docs/ApiChangelogs/0.1.0.txtnew file+405

This diff is too big to show here.

core/docs/ApiChangelogs/0.2.0-0.2.2.txtnew file+306

This diff is too big to show here.

core/docs/Changelog.mdnew file+97

This diff is too big to show here.

core/docs/Readme.mdnew file+1

This diff is too big to show here.

jsbits/clock.js → core/jsbits/clock.jsrenamed

The content is the same.

core/src/DocTestDataArray.hsnew file+22

This diff is too big to show here.

core/src/DocTestDataFold.hsnew file+27

This diff is too big to show here.

core/src/DocTestDataMutArray.hsnew file+10

This diff is too big to show here.

core/src/DocTestDataMutArrayGeneric.hsnew file+10

This diff is too big to show here.

core/src/DocTestDataParser.hsnew file+20

This diff is too big to show here.

core/src/DocTestDataParserK.hsnew file+15

This diff is too big to show here.

core/src/DocTestDataStream.hsnew file+39

This diff is too big to show here.

core/src/DocTestDataStreamK.hsnew file+21

This diff is too big to show here.

core/src/DocTestDataUnfold.hsnew file+12

This diff is too big to show here.

core/src/DocTestFileSystemHandle.hsnew file+15

This diff is too big to show here.

core/src/DocTestUnicodeParser.hsnew file+9

This diff is too big to show here.

core/src/DocTestUnicodeStream.hsnew file+12

This diff is too big to show here.

core/src/DocTestUnicodeString.hsnew file+5

This diff is too big to show here.

core/src/Streamly/Console/Stdio.hsnew file+30

This diff is too big to show here.

core/src/Streamly/Data/Array.hsnew file+167

This diff is too big to show here.

core/src/Streamly/Data/Array/Generic.hsnew file+51

This diff is too big to show here.

core/src/Streamly/Data/Fold.hsnew file+415

This diff is too big to show here.

core/src/Streamly/Data/MutArray.hsnew file+110

This diff is too big to show here.

core/src/Streamly/Data/MutArray/Generic.hsnew file+70

This diff is too big to show here.

core/src/Streamly/Data/MutByteArray.hsnew file+106

This diff is too big to show here.

core/src/Streamly/Data/Parser.hsnew file+247

This diff is too big to show here.

core/src/Streamly/Data/ParserK.hsnew file+139

This diff is too big to show here.

core/src/Streamly/Data/Stream.hsnew file+746

This diff is too big to show here.

core/src/Streamly/Data/StreamK.hsnew file+194

This diff is too big to show here.

core/src/Streamly/Data/Unfold.hsnew file+233

This diff is too big to show here.

core/src/Streamly/FileSystem/Dir.hsnew file+23

This diff is too big to show here.

core/src/Streamly/FileSystem/File.hsnew file+60

This diff is too big to show here.

core/src/Streamly/FileSystem/Handle.hsnew file+117

This diff is too big to show here.

core/src/Streamly/Internal/BaseCompat.hsnew file+37

This diff is too big to show here.

core/src/Streamly/Internal/Console/Stdio.hsnew file+228

This diff is too big to show here.

src/Streamly/Internal/Control/Exception.hs → core/src/Streamly/Internal/Control/Exception.hsrenamed+1−13

This diff is too big to show here.

core/src/Streamly/Internal/Control/ForkIO.hsnew file+50

This diff is too big to show here.

src/Streamly/Internal/Control/Monad.hs → core/src/Streamly/Internal/Control/Monad.hsrenamed

The content is the same.

core/src/Streamly/Internal/Data/Array.hsnew file+1018

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/ArrayMacros.hnew file+43

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/Generic.hsnew file+342

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/Stream.hsnew file+725

This diff is too big to show here.

core/src/Streamly/Internal/Data/Array/Type.hsnew file+1148

This diff is too big to show here.

src/Streamly/Internal/Data/Binary/Decode.hs → core/src/Streamly/Internal/Data/Binary/Parser.hsrenamed+165−44

This diff is too big to show here.

core/src/Streamly/Internal/Data/Binary/Stream.hsnew file+383

This diff is too big to show here.

core/src/Streamly/Internal/Data/Builder.hsnew file+82

This diff is too big to show here.

src/Streamly/Internal/Data/Either/Strict.hs → core/src/Streamly/Internal/Data/Either/Strict.hsrenamed+2

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold.hsnew file+33

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Chunked.hsnew file+379

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Combinators.hsnew file+2452

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Container.hsnew file+783

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Step.hsnew file+83

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Tee.hs → core/src/Streamly/Internal/Data/Fold/Tee.hsrenamed+37−33

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Type.hsnew file+2099

This diff is too big to show here.

core/src/Streamly/Internal/Data/Fold/Window.hsnew file+357

This diff is too big to show here.

src/Streamly/Internal/Data/IOFinalizer.hs → core/src/Streamly/Internal/Data/IOFinalizer.hsrenamed+20−22

This diff is too big to show here.

core/src/Streamly/Internal/Data/IORef/Unboxed.hsnew file+101

This diff is too big to show here.

core/src/Streamly/Internal/Data/IsMap.hsnew file+60

This diff is too big to show here.

core/src/Streamly/Internal/Data/List.hsnew file+234

This diff is too big to show here.

src/Streamly/Internal/Data/Maybe/Strict.hs → core/src/Streamly/Internal/Data/Maybe/Strict.hsrenamed+12−3

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/MutArray/Generic.hsnew file+947

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/MutArray/Type.hsnew file+3318

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.hsnew file+3621

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Parser/ParserD/Type.hs → core/src/Streamly/Internal/Data/Parser/Type.hsrenamed+660−306

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/ParserK/Type.hsnew file+752

This diff is too big to show here.

core/src/Streamly/Internal/Data/Pipe.hsnew file+273

This diff is too big to show here.

src/Streamly/Internal/Data/Pipe/Type.hs → core/src/Streamly/Internal/Data/Pipe/Type.hsrenamed−3

This diff is too big to show here.

src/Streamly/Internal/Data/Producer.hs → core/src/Streamly/Internal/Data/Producer.hsrenamed+7−14

This diff is too big to show here.

src/Streamly/Internal/Data/Producer/Source.hs → core/src/Streamly/Internal/Data/Producer/Source.hsrenamed+101−36

This diff is too big to show here.

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

This diff is too big to show here.

core/src/Streamly/Internal/Data/Refold/Type.hsnew file+251

This diff is too big to show here.

core/src/Streamly/Internal/Data/Ring.hsnew file+619

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/SVar/Type.hsnew file+540

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.hsnew file+42

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Container.hsnew file+310

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Eliminate.hsnew file+849

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Exception.hsnew file+501

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Generate.hsnew file+1191

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Lift.hsnew file+129

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Nesting.hs → core/src/Streamly/Internal/Data/Stream/Nesting.hsrenamed+947−249

This diff is too big to show here.

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

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/StreamD.hsnew file+16

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.hsnew file+1971

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Transformer.hsnew file+183

This diff is too big to show here.

core/src/Streamly/Internal/Data/Stream/Type.hsnew file+2220

This diff is too big to show here.

core/src/Streamly/Internal/Data/StreamK.hsnew file+1730

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamDK/Type.hs → core/src/Streamly/Internal/Data/StreamK/Alt.hsrenamed+144−4

This diff is too big to show here.

core/src/Streamly/Internal/Data/StreamK/Transformer.hsnew file+79

This diff is too big to show here.

core/src/Streamly/Internal/Data/StreamK/Type.hsnew file+2153

This diff is too big to show here.

core/src/Streamly/Internal/Data/Time/Clock.hsnew file+180

This diff is too big to show here.

src/Streamly/Internal/Data/Time/Clock/Darwin.c → core/src/Streamly/Internal/Data/Time/Clock/Darwin.crenamed

The content is the same.

src/Streamly/Internal/Data/Time/Clock/Type.hsc → core/src/Streamly/Internal/Data/Time/Clock/Type.hscrenamed+1−1

This diff is too big to show here.

src/Streamly/Internal/Data/Time/Clock/Windows.c → core/src/Streamly/Internal/Data/Time/Clock/Windows.crenamed

The content is the same.

src/Streamly/Internal/Data/Time/Clock/config-clock.h → core/src/Streamly/Internal/Data/Time/Clock/config-clock.hrenamed

The content is the same.

src/Streamly/Internal/Data/Time/TimeSpec.hsc → core/src/Streamly/Internal/Data/Time/TimeSpec.hscrenamed−3

This diff is too big to show here.

src/Streamly/Internal/Data/Time/Units.hs → core/src/Streamly/Internal/Data/Time/Units.hsrenamed+9−8

This diff is too big to show here.

src/Streamly/Internal/Data/Tuple/Strict.hs → core/src/Streamly/Internal/Data/Tuple/Strict.hsrenamed+11

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unbox.hsnew file+908

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.hsnew file+1077

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unfold/Enumeration.hsnew file+543

This diff is too big to show here.

core/src/Streamly/Internal/Data/Unfold/Type.hsnew file+999

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Dir.hs → core/src/Streamly/Internal/FileSystem/Dir.hsrenamed+191−84

This diff is too big to show here.

src/Streamly/Internal/FileSystem/File.hs → core/src/Streamly/Internal/FileSystem/File.hsrenamed+240−145

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Handle.hs → core/src/Streamly/Internal/FileSystem/Handle.hsrenamed+328−287

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/System/IO.hsnew file+58

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Array.hsnew file+104

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Parser.hsnew file+627

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/Stream.hsnew file+1123

This diff is too big to show here.

core/src/Streamly/Internal/Unicode/String.hsnew file+158

This diff is too big to show here.

core/src/Streamly/Unicode/Parser.hsnew file+69

This diff is too big to show here.

src/Streamly/Unicode/Stream.hs → core/src/Streamly/Unicode/Stream.hsrenamed+32−18

This diff is too big to show here.

core/src/Streamly/Unicode/String.hsnew file+30

This diff is too big to show here.

core/src/assert.hsnew file+6

This diff is too big to show here.

core/src/config.h.innew file+57

This diff is too big to show here.

core/src/inline.hsnew file+27

This diff is too big to show here.

core/streamly-core.cabalnew file+534

This diff is too big to show here.

credits/COPYRIGHTS.mddeleted−77

This diff is too big to show here.

credits/Yampa-0.10.6.2.txtdeleted−29

This diff is too big to show here.

credits/base-4.12.0.0.txtdeleted−83

This diff is too big to show here.

credits/bjoern-2008-2009.txtdeleted−19

This diff is too big to show here.

credits/clock-0.7.2.txtdeleted−32

This diff is too big to show here.

credits/foldl-1.4.5.txtdeleted−24

This diff is too big to show here.

credits/fsnotify-0.3.0.1.txtdeleted−30

This diff is too big to show here.

credits/hfsevents-0.1.6.txtdeleted−30

This diff is too big to show here.

credits/pipes-concurrency-2.0.8.txtdeleted−24

This diff is too big to show here.

credits/primitive-0.7.0.0.txtdeleted−30

This diff is too big to show here.

credits/transient-0.5.5.txtdeleted−18

This diff is too big to show here.

credits/vector-0.12.0.2.txtdeleted−30

This diff is too big to show here.

default.nix+48−11

This diff is too big to show here.

docs/Developer/Benchmarks.mdnew file+342

This diff is too big to show here.

docs/Developer/Contributing.mdnew file+271

This diff is too big to show here.

docs/Developer/Github.linknew file+1

This diff is too big to show here.

docs/Developer/MAINTAINING.mdnew file+422

This diff is too big to show here.

docs/Developer/Tests.mdnew file+139

This diff is too big to show here.

docs/Developer/ci-tests.mdnew file+64

This diff is too big to show here.

docs/Developer/container-api.mdnew file+124

This diff is too big to show here.

design/cps-vs-direct.rst → docs/Developer/cps-vs-direct.rstrenamed+4−4

This diff is too big to show here.

design/dfa-bytes.png → docs/Developer/dfa-bytes.pngrenamed

Binary file not shown.

design/dfa-classes.png → docs/Developer/dfa-classes.pngrenamed

Binary file not shown.

design/dfa-rearr.png → docs/Developer/dfa-rearr.pngrenamed

Binary file not shown.

design/linked-lists.md → docs/Developer/linked-lists.mdrenamed

The content is the same.

design/module-organization.md → docs/Developer/module-organization.mdrenamed+4−4

This diff is too big to show here.

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

This diff is too big to show here.

docs/Developer/overview.mdnew file+24

This diff is too big to show here.

design/paths.rst → docs/Developer/paths.rstrenamed+25−2

This diff is too big to show here.

docs/Developer/related-packages.mdnew file+71

This diff is too big to show here.

docs/Developer/resources.mdnew file+45

This diff is too big to show here.

docs/Developer/roadmap.mdnew file+36

This diff is too big to show here.

design/unicode.md → docs/Developer/unicode.mdrenamed

The content is the same.

design/utf8-decoder.md → docs/Developer/utf8-decoder.mdrenamed+3−3

This diff is too big to show here.

docs/Documentation.mdnew file+5

This diff is too big to show here.

docs/Setup.hsnew file+6

This diff is too big to show here.

docs/User/Explanatory/Overview.mdnew file+468

This diff is too big to show here.

docs/User/Explanatory/design.mdnew file+42

This diff is too big to show here.

docs/User/Explanatory/monad-transformers.mdnew file+65

This diff is too big to show here.

docs/User/Explanatory/performance.mdnew file+7

This diff is too big to show here.

docs/User/Explanatory/streaming-pradigms.rstnew file+117

This diff is too big to show here.

docs/User/Explanatory/unified-abstractions.mdnew file+275

This diff is too big to show here.

docs/User/HowTo/Compiling.mdnew file+145

This diff is too big to show here.

docs/User/HowTo/Examples.linknew file+1

This diff is too big to show here.

docs/User/HowTo/faq.mdnew file+94

This diff is too big to show here.

docs/User/HowTo/interoperation.mdnew file+11

This diff is too big to show here.

docs/Build.md → docs/User/HowTo/optimizing.mdrenamed+8−119

This diff is too big to show here.

docs/streamly-vs-async.md → docs/User/HowTo/streamly-vs-async.mdrenamed+6−4

This diff is too big to show here.

charts-0/streamly-vs-list-time.svg → docs/User/HowTo/streamly-vs-list-time.svgrenamed

The content is the same.

docs/streamly-vs-lists.md → docs/User/HowTo/streamly-vs-lists.mdrenamed+4−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/Project/ApiChangelogs/0.8.3.txtnew file+261

This diff is too big to show here.

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

This diff is too big to show here.

credits/CONTRIBUTORS.md → docs/User/Project/CONTRIBUTORS.mdrenamed+41−3

This diff is too big to show here.

Changelog.md → docs/User/Project/Changelog.mdrenamed+224−84

This diff is too big to show here.

credits/README.md → docs/User/Project/Credits.mdrenamed+3−1

This diff is too big to show here.

docs/User/Project/Github.linknew file+1

This diff is too big to show here.

docs/User/Project/README.mdnew file+141

This diff is too big to show here.

docs/User/Project/Roadmap.linknew file+1

This diff is too big to show here.

docs/User/Project/Upgrading-0.8-to-0.9.mdnew file+384

This diff is too big to show here.

docs/User/Tutorials/ConcurrentStreams.hsnew file+771

This diff is too big to show here.

docs/User/Tutorials/Examples.linknew file+1

This diff is too big to show here.

docs/User/Tutorials/ReactiveProgramming.hsnew file+126

This diff is too big to show here.

docs/User/Tutorials/Tutorial.hsnew file+521

This diff is too big to show here.

docs/User/Tutorials/before-you-begin.mdnew file+77

This diff is too big to show here.

docs/User/Tutorials/getting-started.mdnew file+225

This diff is too big to show here.

docs/User/Tutorials/haskell-lazy-evaluation.mdnew file+215

This diff is too big to show here.

docs/User/Tutorials/quick-overview.mdnew file+517

This diff is too big to show here.

docs/User/Tutorials/why-haskell-streamly.mdnew file+91

This diff is too big to show here.

docs/User/resources.mdnew file+18

This diff is too big to show here.

docs/streamly-docs.cabalnew file+49

This diff is too big to show here.

docs/transformers.mddeleted−32

This diff is too big to show here.

doctests.hsdeleted−14

This diff is too big to show here.

hie.yaml+103−32

This diff is too big to show here.

src/Streamly.hsdeleted−690

This diff is too big to show here.

src/Streamly/Data/Array.hsdeleted−43

This diff is too big to show here.

src/Streamly/Data/Array/Foreign.hs+52−6

This diff is too big to show here.

src/Streamly/Data/Fold.hsdeleted−263

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.hsnew file+16

This diff is too big to show here.

src/Streamly/Data/Prim/Array.hsdeleted−43

This diff is too big to show here.

src/Streamly/Data/SmallArray.hs+2−2

This diff is too big to show here.

src/Streamly/Data/Stream/MkType.hsnew file+115

This diff is too big to show here.

src/Streamly/Data/Stream/Prelude.hsnew file+232

This diff is too big to show here.

src/Streamly/Data/Unfold.hsdeleted−152

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/FileSystem/Handle.hsdeleted−86

This diff is too big to show here.

src/Streamly/Internal/BaseCompat.hsdeleted−42

This diff is too big to show here.

src/Streamly/Internal/Control/Concurrent.hs+51−63

This diff is too big to show here.

src/Streamly/Internal/Control/ForkLifted.hsnew file+66

This diff is too big to show here.

src/Streamly/Internal/Data/Array.hsdeleted−206

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Foreign.hsdeleted−606

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Foreign/Mut/Type.hsdeleted−1265

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Foreign/Type.hsdeleted−667

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim.hsdeleted−110

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/Mut/Type.hsdeleted−94

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/MutTypesInclude.hsdeleted−407

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/Pinned.hsdeleted−108

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/Pinned/Mut/Type.hsdeleted−176

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/Pinned/Type.hsdeleted−127

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/Type.hsdeleted−98

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Prim/TypesInclude.hsdeleted−703

This diff is too big to show here.

src/Streamly/Internal/Data/Array/PrimInclude.hsdeleted−185

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Stream/Fold/Foreign.hsdeleted−343

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Stream/Foreign.hsdeleted−703

This diff is too big to show here.

src/Streamly/Internal/Data/Array/Stream/Mut/Foreign.hsdeleted−311

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/Channel/Dispatcher.hsnew file+294

This diff is too big to show here.

src/Streamly/Internal/Data/Channel/Types.hsnew file+817

This diff is too big to show here.

src/Streamly/Internal/Data/Channel/Worker.hsnew file+375

This diff is too big to show here.

src/Streamly/Internal/Data/Fold.hsdeleted−1790

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Async.hsnew file+133

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent.hsnew file+57

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent/Channel.hsnew file+112

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Concurrent/Channel/Type.hsnew file+331

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.hsnew file+79

This diff is too big to show here.

src/Streamly/Internal/Data/Fold/Type.hsdeleted−1326

This diff is too big to show here.

src/Streamly/Internal/Data/IOFinalizer/Lifted.hsnew file+74

This diff is too big to show here.

src/Streamly/Internal/Data/IORef/Prim.hsdeleted−110

This diff is too big to show here.

src/Streamly/Internal/Data/IsMap/HashMap.hsnew file+42

This diff is too big to show here.

src/Streamly/Internal/Data/List.hsdeleted−188

This diff is too big to show here.

src/Streamly/Internal/Data/Parser.hsdeleted−1118

This diff is too big to show here.

src/Streamly/Internal/Data/Parser/ParserD.hsdeleted−1034

This diff is too big to show here.

src/Streamly/Internal/Data/Parser/ParserK/Type.hsdeleted−471

This diff is too big to show here.

src/Streamly/Internal/Data/Pipe.hsdeleted−1968

This diff is too big to show here.

src/Streamly/Internal/Data/SVar.hs+116−1989

This diff is too big to show here.

src/Streamly/Internal/Data/SVar/Dispatch.hsnew file+739

This diff is too big to show here.

src/Streamly/Internal/Data/SVar/Pull.hsnew file+164

This diff is too big to show here.

src/Streamly/Internal/Data/SVar/Worker.hsnew file+544

This diff is too big to show here.

src/Streamly/Internal/Data/Sink.hsdeleted−245

This diff is too big to show here.

src/Streamly/Internal/Data/Sink/Type.hsdeleted−24

This diff is too big to show here.

src/Streamly/Internal/Data/SmallArray.hs+40−33

This diff is too big to show here.

src/Streamly/Internal/Data/SmallArray/Type.hs+8−75

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Ahead.hs+98−124

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Async.hs+178−284

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Common.hsnew file+105

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent.hsnew file+903

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel.hsnew file+109

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Append.hsnew file+1046

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Consumer.hsnew file+127

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Dispatcher.hsnew file+417

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Interleave.hsnew file+252

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Operations.hsnew file+294

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Concurrent/Channel/Type.hsnew file+172

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Instances.hs+22−27

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Expand.hs+516−176

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Top.hs+263−122

This diff is too big to show here.

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

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Type.hsnew file+783

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/IsStream/Types.hsdeleted−74

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Lifted.hsnew file+335

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/MkType.hsnew file+641

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Parallel.hs+121−181

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Prelude.hs+8−341

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar.hs+7−678

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar/Eliminate.hsnew file+405

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/SVar/Generate.hsnew file+294

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Serial.hs+134−181

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD.hsdeleted−36

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hsdeleted−524

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Exception.hsdeleted−350

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Generate.hsdeleted−405

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Lift.hsdeleted−112

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Transform.hsdeleted−1226

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamD/Type.hsdeleted−971

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamDK.hsdeleted−156

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamK.hsdeleted−1127

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/StreamK/Type.hsdeleted−1195

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Time.hsnew file+950

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/Zip.hs+59−186

This diff is too big to show here.

src/Streamly/Internal/Data/Stream/ZipAsync.hsnew file+134

This diff is too big to show here.

src/Streamly/Internal/Data/Time.hsdeleted−74

This diff is too big to show here.

src/Streamly/Internal/Data/Time/Clock.hsdeleted−80

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold.hsdeleted−1335

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold/Exception.hsnew file+214

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.hsnew file+161

This diff is too big to show here.

src/Streamly/Internal/Data/Unfold/Type.hsdeleted−564

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event.hsnew file+245

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Darwin.hs+219−163

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Linux.hs+282−222

This diff is too big to show here.

src/Streamly/Internal/FileSystem/Event/Windows.hs+224−167

This diff is too big to show here.

src/Streamly/Internal/FileSystem/FD.hs+76−65

This diff is too big to show here.

src/Streamly/Internal/FileSystem/FDIO.hs+2−11

This diff is too big to show here.

src/Streamly/Internal/Foreign/Malloc.hsdeleted−49

This diff is too big to show here.

src/Streamly/Internal/Network/Inet/TCP.hs+180−143

This diff is too big to show here.

src/Streamly/Internal/Network/Socket.hs+226−285

This diff is too big to show here.

src/Streamly/Internal/Ring/Foreign.hsdeleted−250

This diff is too big to show here.

src/Streamly/Internal/System/IOVec.hsnew file+132

This diff is too big to show here.

src/Streamly/Internal/FileSystem/IOVec.hsc → src/Streamly/Internal/System/IOVec/Type.hscrenamed+2−2

This diff is too big to show here.

src/Streamly/Internal/Unicode/Array/Char.hsdeleted−92

This diff is too big to show here.

src/Streamly/Internal/Unicode/Array/Prim/Pinned.hsdeleted−91

This diff is too big to show here.

src/Streamly/Internal/Unicode/Char.hs+266−3

This diff is too big to show here.

src/Streamly/Internal/Unicode/Stream.hsdeleted−927

This diff is too big to show here.

src/Streamly/Internal/Unicode/Utf8.hsnew file+73

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+49−6

This diff is too big to show here.

src/Streamly/Network/Socket.hs+93−55

This diff is too big to show here.

src/Streamly/Prelude.hs+36−19

This diff is too big to show here.

src/Streamly/Tutorial.hsdeleted−1730

This diff is too big to show here.

src/assert.hsnew file+6

This diff is too big to show here.

src/config.h.in−36

This diff is too big to show here.

src/inline.hs+2−2

This diff is too big to show here.

stack.yaml+10−10

This diff is too big to show here.

streamly.cabal+345−349

This diff is too big to show here.

targets/Targets.hsnew file+213

This diff is too big to show here.

targets/cabal.projectnew file+1

This diff is too big to show here.

targets/default.nixnew file+163

This diff is too big to show here.

targets/streamly-targets.cabalnew file+12

This diff is too big to show here.

test/README.mdmode 100644 → 120000+1−97

This diff is too big to show here.

test/Streamly/Test/Common/Array.hsdeleted−284

This diff is too big to show here.

test/Streamly/Test/Data/Array.hs+268−3

This diff is too big to show here.

test/Streamly/Test/Data/Array/Common.hsnew file+101

This diff is too big to show here.

test/Streamly/Test/Data/Array/CommonImports.hsnew file+13

This diff is too big to show here.

test/Streamly/Test/Data/Array/Foreign.hsdeleted−12

This diff is too big to show here.

test/Streamly/Test/Data/Array/Generic.hsnew file+65

This diff is too big to show here.

test/Streamly/Test/Data/Array/Prim.hsdeleted−12

This diff is too big to show here.

test/Streamly/Test/Data/Array/Prim/Pinned.hsdeleted−12

This diff is too big to show here.

test/Streamly/Test/Data/Array/Stream.hsnew file+113

This diff is too big to show here.

test/Streamly/Test/Data/Fold.hs+361−76

This diff is too big to show here.

test/Streamly/Test/Data/Fold/Window.hsnew file+67

This diff is too big to show here.

test/Streamly/Test/Data/List.hs+20−27

This diff is too big to show here.

test/Streamly/Test/Data/MutArray.hsnew file+152

This diff is too big to show here.

test/Streamly/Test/Data/Parser.hs+817−202

This diff is too big to show here.

test/Streamly/Test/Data/Parser/ParserD.hs → test/Streamly/Test/Data/ParserK.hsrenamed+168−104

This diff is too big to show here.

test/Streamly/Test/Data/Ring/Unboxed.hsnew file+53

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/SmallArray.hs+20−3

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.hsnew file+363

This diff is too big to show here.

test/Streamly/Test/Data/Unbox.hsnew file+347

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+323−70

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event.hs+13−387

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Common.hsnew file+422

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Darwin.hsnew file+86

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Linux.hsnew file+163

This diff is too big to show here.

test/Streamly/Test/FileSystem/Event/Windows.hsnew file+51

This diff is too big to show here.

test/Streamly/Test/FileSystem/Handle.hs+89−33

This diff is too big to show here.

test/Streamly/Test/Network/Inet/TCP.hs+29−22

This diff is too big to show here.

test/Streamly/Test/Network/Socket.hs+39−30

This diff is too big to show here.

test/Streamly/Test/Prelude.hs+23−24

This diff is too big to show here.

test/Streamly/Test/Prelude/Ahead.hs+3−4

This diff is too big to show here.

test/Streamly/Test/Prelude/Async.hs+39−5

This diff is too big to show here.

test/Streamly/Test/Prelude/Concurrent.hs+12−9

This diff is too big to show here.

test/Streamly/Test/Prelude/Fold.hs+17−6

This diff is too big to show here.

test/Streamly/Test/Prelude/Parallel.hs+3−4

This diff is too big to show here.

test/Streamly/Test/Prelude/Rate.hs+20−16

This diff is too big to show here.

test/Streamly/Test/Prelude/Serial.hs+187−122

This diff is too big to show here.

test/Streamly/Test/Prelude/Top.hsnew file+224

This diff is too big to show here.

test/Streamly/Test/Prelude/WAsync.hs+55−5

This diff is too big to show here.

test/Streamly/Test/Prelude/WSerial.hs+5−5

This diff is too big to show here.

test/Streamly/Test/Prelude/ZipAsync.hs+3−1

This diff is too big to show here.

test/Streamly/Test/Prelude/ZipSerial.hs+3−4

This diff is too big to show here.

test/Streamly/Test/Serialize/Serializable.hsnew file+237

This diff is too big to show here.

test/Streamly/Test/Unicode/Char.hsnew file+133

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+34−30

This diff is too big to show here.

test/Streamly/Test/Unicode/extra/NormalizationTest.txtnew file+9

This diff is too big to show here.

test/Streamly/Test/Unicode/ucd/NormalizationTest.txt+18908

This diff is too big to show here.

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

This diff is too big to show here.

test/lib/Streamly/Test/Prelude/Common.hs+81−64

This diff is too big to show here.

test/streamly-tests.cabal+263−38

This diff is too big to show here.

test/test-runner/Main.hs+33

This diff is too big to show here.

test/test-runner/cabal.project+4

This diff is too big to show here.

test/test-runner/default.nix+164

This diff is too big to show here.

test/test-runner/test-runner.cabal+41

This diff is too big to show here.