Haskell Communities and Activities Reporthttp://tinyurl.com/haskcar

Thirty Second Edition — May 2017

Mihai Maruseac (ed.)Chris Allen Christopher Anand Moritz Angermann

Francesco Ariis Heinrich Apfelmus Emil AxelssonGershom Bazerman Doug Beardsley Ingo BlechschmidtEmanuel Borsboom Jan Bracker Jeroen BransenJoachim Breitner Björn Buckwalter Erik de Castro Lopo

Manuel M. T. Chakravarty Olaf Chitil Alberto Gómez CoronaNils Dallmeyer Tobias Dammers Kei Davis

Dimitri DeFigueiredo Richard Eisenberg Tom EllisMaarten Faddegon Dennis Felsing Olle Fredriksson

Phil Freeman PÁLI Gábor János Ben GamariMichael Georgoulopoulos Andrew Gill Mikhail Glushenkov

Mark Grebe Adam Gundry Jurriaan HageBastiaan Heeren Sylvain Henry Joey Hess

Guillaume Hoffmann Graham Hutton Nicu IonitaPatrik Jansson Anton Kholomiov Harendra KumarOleg Kiselyov Rob Leslie Ben LippmeierAndres Löh Rita Loogen Tim Matthews

Gilberto Melfe Simon Michael Andrey MokhovDino Morelli Antonio Nikishaev Wisnu Adi NurcahyoUlf Norell Ivan Perez Jens Petersen

Bryan Richter Herbert Valerio Riedel Sibi PrabakaranAlexey Radkov Michael Schröder Jeremy Shaw

Christian Höner zu Siederdissen Jeremy Singer Gideon SirelingMichael Snoyman David Sorokin Lennart SpitznerYuriy Syrovetskiy Jonathan Thaler Henk-Jan van TuylMichael Walker Ingo Wechsung Li-yao XiaKazu Yamamoto Yuji Yamamoto Brent YorgeyMarco Zocca Stack Builders

http://tinyurl.com/haskcar

Preface

This is the 32nd edition of the Haskell Communities and Activities Report. It comes shortlyafter the 31st edition because that one was delayed until December. It is my intention to keepthe next editions on schedule.This report has 125 entries, 67 of which were touched between December and today. Out of

these, 16 are new. As usual, fresh entries – either completely new or old entries which havebeen revived after a short temporarily disappearance – are formatted using a blue background,while updated entries have a header with a blue background.Since my goal is to keep only entries which are under active development (defined as receiv-

ing an update in a 3-editions sliding window), contributions from 2015 and before have beencompletely removed. However, they can be resurfaced in the next edition, should a new up-date be sent for them. For the 30th edition, for example, we had around 20 new entries whichresurfaced. We hope to see more entries revived and updated in the next edition.A call for new HCAR entries and updates to existing ones will be issued on the Haskell mailing

lists in late September/early October.Work on a new, modern HCAR pipeline continues to develop. Once that is done, the next

edition will look different, allowing for more expressivity. Details will follow on the usualcommunication channels, once they become available.Now enjoy the current report and see what other Haskellers have been up to lately. Any

feedback is very welcome, as always.

Mihai Maruseac, Leap Year Technologies, US〈hcar@haskell.org〉

2

mailto: hcar at haskell.org

Contents

1 Community 61.1 Haskell’ — Haskell 2020 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.2 Haskellers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Books, Articles, Tutorials 72.1 Oleg’s Mini Tutorials and Assorted Small Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2 School of Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.3 Haskell Programming from first principles, a book forall . . . . . . . . . . . . . . . . . . . . . . . 72.4 Learning Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5 Programming in Haskell - 2nd Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.6 Stack Builders Tutorials . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.7 Haskell MOOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Implementations 103.1 The Glasgow Haskell Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103.2 The Helium Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.3 Frege . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.4 Specific Platforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.4.1 Fedora Haskell SIG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.4.2 Debian Haskell Group . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.5 Related Languages and Language Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.5.1 Agda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133.5.2 Disciple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4 Libraries, Tools, Applications, Projects 154.1 Language Extensions and Related Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154.1.1 Dependent Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154.1.2 generics-sop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154.1.3 Supermonads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164.2 Build Tools and Related Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164.2.1 Cabal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164.2.2 The Stack build tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.2.3 Stackage: the Library Dependency Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174.2.4 Stackgo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.2.5 hsinstall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184.2.6 cab — A Maintenance Command of Haskell Cabal Packages . . . . . . . . . . . . . . . . . . . . . 184.2.7 yesod-rest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3 Repository Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3.1 Octohat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3.2 Darcs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3.3 git-annex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.3.4 openssh-github-keys (Stack Builders) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.4 Debugging and Profiling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204.4.1 Hoed – The Lightweight Algorithmic Debugger for Haskell . . . . . . . . . . . . . . . . . . . . . . 204.4.2 ghc-heap-view . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.4.3 ghc-vis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214.4.4 Hat — the Haskell Tracer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.5 Development Tools and Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.5.1 Haskell for Mac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224.5.2 haskell-ide-engine, a project for unifying IDE functionality . . . . . . . . . . . . . . . . . . . . . . 234.5.3 HyperHaskell – The strongly hyped Haskell interpreter . . . . . . . . . . . . . . . . . . . . . . . . 244.6 Formal Systems and Reasoners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3

4.6.1 The Incredible Proof Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.6.2 Exference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7 Education . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7.1 Holmes, Plagiarism Detection for Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7.2 Interactive Domain Reasoners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.7.3 DSLsofMath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264.8 Text and Markup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.8.1 Brittany . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.8.2 lhs2TEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.8.3 Unicode things . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.8.4 Lentil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.8.5 Fast Unicode Normalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.8.6 Ginger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.9 Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.9.1 WAI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.9.2 Warp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.9.3 Mighttpd2 — Yet another Web Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.9.4 Yesod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.9.5 Happstack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.9.6 Snap Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.9.7 Sprinkles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.9.8 MFlow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.9.9 PureScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.9.10 Hapistrano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.9.11 nginx-haskell-module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.10 Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.10.1 Persistent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.10.2 Opaleye . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.10.3 YeshQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344.10.4 Riak bindings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.11 Data Structures, Data Types, Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.11.1 Algebraic graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.11.2 Conduit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.11.3 Transactional Trie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.11.4 Random access zipper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.11.5 Generic random generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.11.6 Generalized Algebraic Dynamic Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374.11.7 Earley . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394.11.8 Transient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394.12 Parallelism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404.12.1 Eden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404.12.2 Auto-parallelizing Pure Functional Language System . . . . . . . . . . . . . . . . . . . . . . . . . 414.12.3 Déjà Fu: Concurrency Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.12.4 The Remote Monad Design Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.12.5 concurrent-output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.13 Systems programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.13.1 Haskell for Mobile development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.13.2 haskus-system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.13.3 Haskino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.13.4 Feldspar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.14 Mathematics, Simulations and High Performance Computing . . . . . . . . . . . . . . . . . . . . . 444.14.1 sparse-linear-algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.14.2 aivika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.15 Graphical User Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.15.1 threepenny-gui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454.15.2 wxHaskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.16 FRP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.16.1 Yampa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4

4.16.2 reactive-banana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.16.3 Functional Reactive Agent-Based Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.17 Graphics and Audio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.17.1 diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.17.2 Chordify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.17.3 csound-expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.18 Games . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.18.1 EtaMOO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.18.2 Barbarossa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.18.3 Tetris in Haskell in a Weekend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.18.4 tttool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.19 Data Tracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.19.1 hledger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.19.2 gipeda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534.19.3 arbtt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534.19.4 propellor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.20 Others . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.20.1 ADPfusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.20.2 leapseconds-announced . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554.20.3 Haskell in Green Land . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554.20.4 Kitchen Snitch server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.20.5 clr-haskell (Haskell interoperability with the Common Language Runtime) . . . . . . . . . . . . . 564.20.6 FRTrader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.20.7 shell-conduit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.20.8 Hapoid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.20.9 Hanum - OSM Dynamic Attributes Linter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.20.10 tldr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

5 Commercial Users 585.1 Well-Typed LLP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585.2 Keera Studios LTD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595.3 Stack Builders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605.4 McMaster Computing and Software Outreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6 Research and User Groups 626.1 DataHaskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626.2 Haskell at Eötvös Loránd University (ELTE), Budapest . . . . . . . . . . . . . . . . . . . . . . . . 626.3 Artificial Intelligence and Software Technology at Goethe-University Frankfurt . . . . . . . . . . . 636.4 Functional Programming at the University of Kent . . . . . . . . . . . . . . . . . . . . . . . . . . 636.5 Functional Programming at KU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.6 fp-syd: Functional Programming in Sydney, Australia . . . . . . . . . . . . . . . . . . . . . . . . . 646.7 Regensburg Haskell Meetup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.8 Curry Club Augsburg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.9 Italian Haskell Group . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.10 RuHaskell – the Russian-speaking haskellers community . . . . . . . . . . . . . . . . . . . . . . . 656.11 NY Haskell Users Group and Compose Conference . . . . . . . . . . . . . . . . . . . . . . . . . . 666.12 Japan Haskell User Group – Haskell-jp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666.13 Functional Programming at the Telkom University . . . . . . . . . . . . . . . . . . . . . . . . . . 66

5

1 Community

1.1 Haskell’ — Haskell 2020

Report by: Herbert Valerio RiedelParticipants: Andres Löh, Antonio Nikishaev, Austin

Seipp, Carlos Camarao de Figueiredo,Carter Schonwald, David Luposchainsky,

Henk-Jan van Tuyl, Henrik Nilsson,Herbert Valerio Riedel, Iavor Diatchki,John Wiegley, José Manuel Calderón

Trilla, Jurriaan Hage, Lennart Augustsson,M Farkas-Dyck, Mario Blaz̆ević, Nicolas

Wu, Richard Eisenberg, Vitaly Bragilevsky,Wren Romano

Haskell’ is an ongoing process to produce revisions tothe Haskell standard, incorporating mature languageextensions and well-understood modifications to thelanguage. New revisions of the language are expectedonce per year.The goal of the Haskell Language committee together

with the Core Libraries Committee is to work towards anew Haskell 2020 Language Report. The Haskell PrimeProcess relies on everyone in the community to help bycontributing proposals which the committee will thenevaluate and, if suitable, help formalise for inclusion.Everyone interested in participating is also invited tojoin the haskell-prime mailing list.Four years (or rather ~3.5 years) from now may seem

like a long time. However, given the magnitude of thetask at hand, to discuss, formalise, and implement pro-posed extensions (taking into account the recently en-acted three-release-policy) to the Haskell Report, theprocess shouldn’t be rushed. Consequently, this mayeven turn out to be a tight schedule after all. However,it’s not excluded there may be an interim revision ofthe Haskell Report before 2020.Based on this schedule, GHC 8.8 (likely to be re-

leased early 2020) would be the first GHC release tofeature Haskell 2020 compliance. Prior GHC releasesmay be able to provide varying degree of conformanceto drafts of the upcoming Haskell 2020 Report.The Haskell Language 2020 committee starts out

with 20 members which contribute a diversified skill-set. These initial members also represent the Haskellcommunity from the perspective of practitioners, im-plementers, educators, and researchers.The Haskell 2020 committee is a language commit-

tee; it will focus its efforts on specifying the Haskelllanguage itself. Responsibility for the libraries laid outin the Report is left to the Core Libraries Committee(CLC). Incidentally, the CLC still has an available seat;if you would like to contribute to the Haskell 2020 CoreLibraries you are encouraged to apply for this opening.

1.2 Haskellers

Report by: Michael SnoymanStatus: experimental

Haskellers is a site designed to promote Haskell as alanguage for use in the real world by being a centralmeeting place for the myriad talented Haskell develop-ers out there. It allows users to create profiles completewith skill sets and packages authored and gives employ-ers a central place to find Haskell professionals.Haskellers is a web site in maintenance mode. No

new features are being added, though the site remainsactive with many new accounts and job postings con-tinuing. If you have specific feature requests, feel freeto send them in (especially with pull requests!).Haskellers remains a site intended for all members

of the Haskell community, from professionals with 15years experience to people just getting into the lan-guage.

Further reading

http://www.haskellers.com/

6

http://www.haskellers.com/

2 Books, Articles, Tutorials

2.1 Oleg’s Mini Tutorials andAssorted Small Projects

Report by: Oleg Kiselyov

The collection of various Haskell mini tutorials andassorted small projects (http://okmij.org/ftp/Haskell/)has received a three-part addition:

Implementing Explicit and Finding Implicit Sharingin Embedded DSLs

The web page collects the materials for the tutorial onsharing and common subexpression elimination in em-bedded domain-specific language compilers. The tuto-rial was presented at DSL 2011: IFIP Working Con-ference on Domain-Specific Languages (6-8 September2011, Bordeaux, France). The material includes theextensively commented Haskell source code, with solu-tions to selected exercises.As the running example, the tutorial uses a DSL of

arithmetic expressions with the strong flavor of hard-ware description languages. In fact, the output of theDSL compilation is essentially a netlist (the list of prim-itive gates and connections among them). The tutorialreviews several ways to introduce sharing, so importantin hardware and so difficult to represent in functionalprogramming. The DSL approach advocated in thetutorial is probably the best compromise, hiding theessentially imperative nature of sharing.Read the tutorial online.

Explicit sharing across several expressions

We demonstrate how to add explicit sharing – a let-like form – to a DSL without introducing large no-tational inconvenience and, specifically, without re-writing the code in a monadic style. Recall that inpure functional code sharing is not observable: it is animperative feature. The challenge of explicit sharing inan embedded DSL was posed on Haskell-Cafe, back in2008.Read the tutorial online.

Historical note on hash consing

Hash-consing reminds one of lisp (where it has beenused widely). However, hash-consing has been inventedbefore lisp! Hash-consing – as well as hash functions,investigation of their properties and the algorithm forcompiling arithmetic expressions (still used, e.g., in

OCaml compiler) – were first described in the paperby A.P.Ershov published in 1958. Although publishedin Russian, the English translation appeared in Com-munications of the ACM later that year: the unheardof publishing speed for those times.Read the tutorial online.

2.2 School of Haskell

Report by: Michael SnoymanParticipants: Edward Kmett, Simon Peyton Jones

and othersStatus: active

The School of Haskell has been available since early2013. It’s main two functions are to be an educationresource for anyone looking to learn Haskell and asa sharing resources for anyone who has built a valu-able tutorial. The School of Haskell contains tutorials,courses, and articles created by both the Haskell com-munity and the developers at FP Complete. Coursesare available for all levels of developers.Since the last HCAR, School of Haskell has been

open sourced, and is available from its own do-main name (schoolofhaskell.com). In addition, theunderlying engine powering interactive code snippets,ide-backend, has also been released as open source.Currently 3150 tutorials have been created and 441

have been officially published. Some of the most visitedtutorials are Text Manipulation, Attoparsec, LearningHaskell at the SOH, Introduction to Haskell - HaskellBasics, and A Little Lens Starter Tutorial. Over thepast year the School of Haskell has averaged about 16kvisitors a month.All Haskell programmers are encouraged to visit the

School of Haskell and to contribute their ideas andprojects. This is another opportunity to showcase thevirtues of Haskell and the sophistication and high levelthinking of the Haskell community.

Further reading

https://www.schoolofhaskell.com/

2.3 Haskell Programming from firstprinciples, a book forall

Report by: Chris AllenParticipants: Julie MoronukiStatus: Content complete, in final editing

Haskell Programming is a book that aims to get peoplefrom the barest basics to being well-grounded in enoughintermediate Haskell concepts that they can self-learn

7

http://okmij.org/ftp/Haskell/http://okmij.org/ftp/tagless-final/sharing/sharing.htmlhttp://okmij.org/ftp/tagless-final/sharing/sharing.html#ex13http://okmij.org/ftp/tagless-final/sharing/sharing.html#historyschoolofhaskell.comhttps://www.schoolofhaskell.com/

what would be typically required to use Haskell in pro-duction or to begin investigating the theory and de-sign of Haskell independently. We’re writing this bookbecause many have found learning Haskell to be diffi-cult, but it doesn’t have to be. What particularly con-tributes to the good results we’ve been getting has beenan aggressive focus on effective pedagogy and extensivetesting with reviewers as well as feedback from readers.My coauthor Julie Moronuki is a linguist who’d neverprogrammed before learning Haskell and authoring thebook with me.Haskell Programming is currently content complete

and is approximately 1,200 pages long in the v0.12.0release. The book is available for sale during the earlyaccess, which includes the 1.0 release of the book inPDF. We’re still editing the material. We expect torelease the final version of the book this winter.

Further reading

◦ http://haskellbook.com◦ https://superginbaby.wordpress.com/2015/05/30/

learning-haskell-the-hard-way/◦ http://bitemyapp.com/posts/

2015-08-23-why-we-dont-chuck-readers-into-web-apps.html

2.4 Learning Haskell

Report by: Manuel M. T. ChakravartyParticipants: Gabriele KellerStatus: Work in progress with eight published

chapters

Learning Haskell is a new Haskell tutorial that inte-grates text and screencasts to combine in-depth expla-nations with the hands-on experience of live coding. Itis aimed at people who are new to Haskell and func-tional programming. Learning Haskell does not assumeprevious programming expertise, but it is structuredsuch that an experienced programmer who is new tofunctional programming will also find it engaging.Learning Haskell combines perfectly with the Haskell

for Mac programming environment, but it also includesinstructions on working with a conventional command-line Haskell installation. It is a free resource thatshould benefit anyone who wants to learn Haskell.Learning Haskell is still work in progress with eight

chapters already available. The current material cov-ers all the basics, including higher-order functions andalgebraic data types. Learning Haskell is approachableand fun – it includes topics such as illustrating variousrecursive structures using fractal graphics, such as thisfractal tree.

Further chapters will be made available as we com-plete them.

Further reading

◦ Learning Haskell is free at http://learn.hfm.io◦ Blog post with some background:

http://blog.haskellformac.com/blog/learning-haskell

2.5 Programming in Haskell - 2nd Edition

Report by: Graham HuttonStatus: published September 2016

Overview

Haskell is a purely functional language that allows pro-grammers to rapidly develop software that is clear, con-cise and correct. This book is aimed at a broad spec-trum of readers who are interested in learning the lan-guage, including professional programmers, universitystudents and high-school students. However, no pro-gramming experience is required or assumed, and allconcepts are explained from first principles with theaid of carefully chosen examples and exercises. Most of

8

http://haskellbook.comhttps://superginbaby.wordpress.com/2015/05/30/learning-haskell-the-hard-way/https://superginbaby.wordpress.com/2015/05/30/learning-haskell-the-hard-way/http://bitemyapp.com/posts/2015-08-23-why-we-dont-chuck-readers-into-web-apps.htmlhttp://bitemyapp.com/posts/2015-08-23-why-we-dont-chuck-readers-into-web-apps.htmlhttp://learn.hfm.iohttp://blog.haskellformac.com/blog/learning-haskell

the material in the book should be accessible to any-one over the age of around sixteen with a reasonableaptitude for scientific ideas.

Structure

The book is divided into two parts. Part I introducesthe basic concepts of pure programming in Haskell andis structured around the core features of the language,such as types, functions, list comprehensions, recursionand higher-order functions. Part II covers impure pro-gramming and a range of more advanced topics, suchas monads, parsing, foldable types, lazy evaluation andreasoning about programs. The book contains manyextended programming examples, and each chapter in-cludes suggestions for further reading and a series ofexercises. The appendices provide solutions to selectedexercises, and a summary of some of the most com-monly used definitions from the Haskell standard pre-lude.

What’s New

The book is an extensively revised and expanded ver-sion of the first edition. It has been extended with newchapters that cover more advanced aspects of Haskell,new examples and exercises to further reinforce the con-cepts being introduced, and solutions to selected ex-ercises. The remaining material has been completelyreworked in response to changes in the language andfeedback from readers. The new edition uses the Glas-gow Haskell Compiler (GHC), and is fully compatiblewith the latest version of the language, including recentchanges concerning applicative, monadic, foldable andtraversable types.

Further reading

http://www.cs.nott.ac.uk/~pszgmh/pih.html

2.6 Stack Builders Tutorials

Report by: Stack Builders

At Stack Builders, we consider it our mission not onlyto develop robust and reliable applications for clients,but to help the industry as a whole by lowering thebarrier to entry for technology that we consider im-portant. We hope that you enjoy our tutorials – we’resure you’ll find them useful. Any suggestions for futurepublications, don’t hesitate to contact us.

Further reading

◦ https://www.stackbuilders.com/tutorials/◦ https://github.com/stackbuilders/tutorials

2.7 Haskell MOOC

Report by: Jeremy SingerParticipants: Wim VanderbauwhedeStatus: First run of a six-week online Haskell

course has just completed

The School of Computing Science at the University ofGlasgow partnered with the FutureLearn platform todeliver a six week massive open online course (MOOC)entitled Functional Programming in Haskell. Thecourse goes through the basics of the Haskell language,using short videos, an online REPL, multiple choicequizzes and articles.The first run of the course completed on 30 Oct 2016.

Over 6000 people signed up for the course, 50% ofwhom actively engaged with the materials. Around 800students completed the full course. The most engagingaspect of the activity was the comradely atmosphere inthe discussion forums.The course will run again, probably in Sep–Oct 2017.

Visit our site to register your interest.We hope to refine the learning materials, based on

the first run of the course. We also intend to write upour experiences as a scholarly report.

Further reading

https://www.futurelearn.com/courses/functional-programming-haskell/1

9

http://www.cs.nott.ac.uk/~pszgmh/pih.htmlhttps://www.stackbuilders.com/tutorials/https://github.com/stackbuilders/tutorialshttps://www.futurelearn.com/courses/functional-programming-haskell/1https://www.futurelearn.com/courses/functional-programming-haskell/1https://www.futurelearn.com/courses/functional-programming-haskell/1

3 Implementations

3.1 The Glasgow Haskell Compiler

Report by: Ben GamariParticipants: the GHC developersStatus: GHC continues to improve in performance

and stability in 8.2

By the time of publication GHC will be nearing re-lease of its 8.2.1 release. While GHC 8.0 was a feature-oriented release, the past year of GHC development hasbeen focused on stabilization and consolidation of ex-isting features. This has included an effort to reducecompilation times, improve code generation, and placethe levity polymorphism story introduced in GHC 8.0on a stable theoretical footing.While priorities for the 8.4 release have not yet been

discussed, they will very likely include further focus oncompilation time reduction, improved error messages,and additional improvements to code generation.

Major changes in GHC 8.2

While the emphasis of 8.2 is on performance, stability,and consolidation, it also includes a number of newfeatures.

Libraries, source language, and type system

◦ Indexed Typeable representations. While GHChas long supported runtime type reflection throughthe Typeable typeclass, its current incarnation re-quires careful use, providing little in the way of type-safety. For this reason the implementation of typeslike Data.Dynamic must be implemented in terms ofunsafeCoerce with no compiler verification.GHC 8.2 will address this by introducing indexedtype representations, leveraging the type-checker toverify many programs using type reflection. This al-lows facilities like Data.Dynamic to be implementedin a fully type-safe manner. See the paper1 for a de-scription of the proposed interface and the Wiki2 forcurrent implementation status.

◦ Backpack. Backpack has merged with GHC, Ca-bal and cabal-install, allowing you to write li-braries which are parametrized by signatures, let-ting users decide how to instantiate them at a later

1https://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-dynamic/

2https://ghc.haskell.org/trac/ghc/wiki/Typeable/BenGamari

point in time. If you want to just play around withthe signature language, there is a new major modeghc –backpack; at the Cabal syntax level, there aretwo new fields signatures and mixins which permityou to define parametrized packages, and instantiatethem in a flexible way. More details are on the Back-pack wiki page3.

◦ Levity polymorphism. GHC 8.0 reworked GHC’skind system introducing the notion of levity to de-scribe a type’s runtime representation. However, theability to write functions which were polymorphicover levity was purposefully withheld.While GHC’s current compilation model doesn’t al-low arbitrary levity polymorphism, GHC 8.2 enablescertain classes of polymorphism which were eitherdisallowed or broken in 8.0. See the paper for details4.

◦ deriving strategies. GHC now provides the pro-grammer with a precise mechanism to distinguish be-tween the three ways to derive typeclass instances:the usual way, the GeneralizedNewtypeDerivingway, and the DeriveAnyClass way. See theDerivingStrategies Wiki page for more details 5.

◦ New classes in base. The Bifoldable, andBitraversable typeclasses are now included in thebase library.

◦ Unboxed sums. GHC 8.2 has a new languageextension, UnboxedSums, that enables unboxed rep-resentation for non-recursive sum types. GHC 8.2doesn’t use unboxed sums automatically, but the ex-tension comes with new syntax, so users can manu-ally unpack sums. More details can be found in theWiki page 6.

Runtime system

◦ Compact regions. This runtime system feature al-lows a referentially “closed” set of heap objects to becollected into a “compact region,” allowing cheapergarbage collection, sharing of heap-objects betweenprocesses, and the possibility of inexpensive serial-ization. See the paper 7 for details.

◦ Better profiling support. The cost-center profilernow better integrates with the GHC event-log. Heap

3https://ghc.haskell.org/trac/wiki/Backpack4https://www.microsoft.com/en-us/research/publication/

levity-polymorphism/5https://ghc.haskell.org/trac/wiki/DerivingStrategies6https://ghc.haskell.org/trac/ghc/wiki/UnpackedSumTypes7http://ezyang.com/papers/ezyang15-cnf.pdf

10

https://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-dynamic/https://research.microsoft.com/en-us/um/people/simonpj/papers/haskell-dynamic/https://ghc.haskell.org/trac/ghc/wiki/Typeable/BenGamarihttps://ghc.haskell.org/trac/wiki/Backpackhttps://www.microsoft.com/en-us/research/publication/levity-polymorphism/https://www.microsoft.com/en-us/research/publication/levity-polymorphism/https://ghc.haskell.org/trac/wiki/DerivingStrategieshttps://ghc.haskell.org/trac/ghc/wiki/UnpackedSumTypeshttp://ezyang.com/papers/ezyang15-cnf.pdf

profile samples can now be dumped to the event log,allowing heap behavior to be more easily correlatedwith other program events. Moreover, the cost cen-ter stack output (e.g. .prof files) can now be pro-duced in a machine-readable JSON format for easierintegration with external tooling.

◦ More robust DWARF output. GHC 8.2 will bethe first release with reliable support for DWARFdebugging information. A number of bugs leadingto incorrect debug information for foreign calls havebeen fixed, meaning it should now be safe to enabledebugging information in production builds.With stable DWARF support comes a number of op-portunities for new performance analysis and debug-ging tools (e.g. statistical profiling, cheap executionstacks). As GHC’s debugging information improves,we expect to see tooling developed to support theseapplications. See the DWARF status page on theGHC Wiki8 for further information.

◦ Better support for NUMA platforms. Ma-chines with non-uniform memory access costs arebecoming more and more common as core countscontinue to rise. The runtime system is now betterequipped to efficiently run on such systems.

◦ Experimental changes to the scheduler that en-able the number of threads used for garbage collec-tion to be lower than the -N setting.

◦ Support for StaticPointers in GHCi. At longlast programs making use of the StaticPointerslanguage extension will have first-class bytecode in-terpreter support, allowing such programs to beloaded into GHCi.

◦ Reduced CPU usage at idle. A long-standingregression resulting in unnecessary wake-ups in anotherwise idle program was fixed. This should lowerCPU utilization and improve power consumption forsome programs.

Miscellaneous

◦ Compiler Determinism. GHC 8.0.2 is the first re-lease of GHC which produces deterministic interfacefiles. This helps consumers like Nix and caching buildsystems, and presents new opportunities for compile-time improvements. See the Wiki 9 for details.

Development updates and acknowledgments

Since the 8.0 release nearly a year ago, GHC’s devel-opment community has continued to grow. Over thelast year we have seen sixty new developers submitpatches, many of whom have become regular contrib-utors. These include new generations of researchers,

8https://ghc.haskell.org/trac/ghc/wiki/DWARF/Status9https://ghc.haskell.org/trac/ghc/wiki/DeterministicBuilds

as well as, increasingly, regular Haskell users from in-dustry and elsewhere. GHC has had an exciting fewmonths...Moritz Angermann has been hard at work improving

cross-compilation and bringing remoting support to the-fexternal-interpreter feature introduced in GHC8.0. He has also contributed a number of patches im-proving support for iOS and Android targets and hasbeen pondering how to enable Template Haskell duringcross-compilation.Ryan Scott and Matthew Pickering have been fixing

bugs all over the compiler, in addition to their respec-tive work on deriving strategies and the new COMPLETEpragma mentioned above.Tamar Christina has been hard at work as our res-

ident Windows expert. In addition to introducingsplit sections support, reworking dynamic linking, fix-ing toolchain breakage due to the recent Windows 10Creator’s Update, and maintaining GHC packaging forthe Chocolatey package manager, he is also an invalu-able source of knowledge.Andrey Mokhov and Jose Calderon have been con-

tinuing work on Hadrian, GHC’s new build systembuilt on Shake. Hadrian is already very usable, lackingonly in support for a some non-standard build config-urations, building documentation, and producing bi-nary and source distributions. These would be great,fairly self-contained projects for any interested devel-oper with a Haskell experience. Contact Andrey if anyof these sound intriguing to you.Michal Terepeta has been performing a long-overdue

grooming of GHC’s nofib benchmark suite. This suiteis one of the primary windows into the performance ofthe compiler, yet has fallen into somewhat of a state ofdisrepair. Michal has been fixing broken tests, refac-toring the build system, and generally making nofib anicer place. In addition, he has been gradually cleaningup native code generator, revisiting GHC’s use of thehoopl library. Also working in the native code gen-erator is Thomas Jakway, who has been working onimproving the register allocator’s treatment of loops.Another contributor working on runtime perfor-

mance is Luke Maurer, who has contributed a reworkof GHC’s treatment of join points, one of the major fea-tures of 8.2. Join points are an essential optimizationwhich allows GHC to eliminate closure allocation forsome types of calls. Prior to GHC 8.2 the join pointsoptimization was fragile due to the lack of a sound the-oretical footing. With Luke’s work, GHC is much bet-ter at preserving join point opportunities, leading toimproved code generation in many performance criti-cal settings. More details can be found in his paper10.As always, this is just a fraction of the contributions

which we’ve seen in the past months. GHC improves

10https://www.microsoft.com/en-us/research/publication/compiling-without-continuations

11

https://ghc.haskell.org/trac/ghc/wiki/DWARF/Statushttps://ghc.haskell.org/trac/ghc/wiki/DeterministicBuildshttps://www.microsoft.com/en-us/research/publication/compiling-without-continuationshttps://www.microsoft.com/en-us/research/publication/compiling-without-continuations

through the efforts of everyone who offers patches, bugreports, code review, and discussion. If you have con-tributed any of these in the past year, thank you!GHC HQ has also taken a number of steps in the

past months to try to improve contributor workflow.Our new proposal process11 officially began in Decem-ber and has been extremely active ever since: theghc-proposals repository now has over fifty pull re-quests and has facilitated hundreds of messages of greatdiscussion. Thanks to our everyone who has partici-pated! GHC also now accepts GitHub pull requests forsmall changes to the user guide and library documents,which several contributors have made use of this. Wehope that this channel will make it easier for users tocontribute and perhaps feel compelled to pick up largertasks in the future.As always, if you are interested in contributing

to any facet of GHC, be the runtime system, type-checker, documentation, simplifier, or anything in be-tween, please come speak to us either on IRC (#ghcon irc.freeenode.net) or ghc-devs@haskell.org.Happy Haskelling!

Further reading

◦ GHC website:https://haskell.org/ghc/

◦ GHC users guide:https://downloads.haskell.org/~ghc/master/users_guide/

◦ ghc-devs mailing list:https://mail.haskell.org/mailman/listinfo/ghc-devs

3.2 The Helium Compiler

Report by: Jurriaan HageParticipants: Bastiaan Heeren

Helium is a compiler that supports a substantial sub-set of Haskell 98 (but, e.g., n+k patterns are missing).Type classes are restricted to a number of built-in typeclasses and all instances are derived. The advantage ofHelium is that it generates novice friendly error feed-back, including domain specific type error diagnosis bymeans of specialized type rules. Helium and its asso-ciated packages are available from Hackage. Install itby running cabal install helium. You should alsocabal install lvmrun on which it dynamically de-pends for running the compiled code.Currently Helium is at version 1.8.1. The major

change with respect to 1.8 is that Helium is againwell-integrated with the Hint programming environ-ment that Arie Middelkoop wrote in Java. The jar-filefor Hint can be found on the Helium website, which is11https://github.com/ghc-proposals/ghc-proposals

located at http://www.cs.uu.nl/wiki/Helium. This web-site also explains in detail what Helium is about, whatit offers, and what we plan to do in the near and farfuture.A student has added parsing and static checking for

type class and instance definitions to the language, buttype inferencing and code generating still need to beadded. Completing support for type classes is the sec-ond thing on our agenda, the first thing being makingupdates to the documentation of the workings of He-lium on the website.

3.3 Frege

Report by: Ingo WechsungParticipants: Dierk König, Mark Perry, Marimuthu

Madasami, Sean Corfield, Volker Steissand others

Status: actively maintained

Frege is a Haskell dialect for the Java Virtual Machine(JVM). It covers essentially Haskell 2010, though thereare some mostly insubstantial differences. Several GHClanguage extensions are supported, most prominentlyhigher rank types.As Frege wants to be a practical JVM language, in-

teroperability with existing Java code is essential. Toachieve this, it is not enough to have a foreign functioninterface as defined by Haskell 2010. We must also havethe means to inform the compiler about existing datatypes (i.e. Java classes and interfaces). We have thusreplaced the FFI by a so called native interface whichis tailored for the purpose.The compiler, standard library and associated tools

like Eclipse IDE plugin, REPL (interpreter) and severalbuild tools are in a usable state, and development isactively ongoing. The compiler is self hosting and hasno dependencies except for the JDK.In the growing, but still small community, a con-

sensus developed last summer that existing differencesto Haskell shall be eliminated. Ideally, Haskell sourcecode could be ported by just compiling it with the Fregecompiler. Thus, the ultimate goal is for Frege to be-come the Haskell implementation on the JVM.Already, in the last months, some of the most of-

fending differences have been removed: lambda syn-tax, instance/class context syntax, recognition of Trueand False as boolean literals, lexical syntax for variablesand layout-mode issues. Frege now also supports codewithout module headers.Frege is available under the BSD-3 license at the

GitHub project page. A ready to run JAR file canbe downloaded or retrieved through JVM-typical buildtools like Maven, Gradle or Leiningen.All new users and contributors are welcome!Currently, we have a new version of code generation

in alpha status. This will be the base for future inter-operability with Java 8 and above.

12

https://haskell.org/ghc/https://downloads.haskell.org/~ghc/master/users_guide/https://downloads.haskell.org/~ghc/master/users_guide/https://mail.haskell.org/mailman/listinfo/ghc-devshttps://github.com/ghc-proposals/ghc-proposalshttp://www.cs.uu.nl/wiki/Helium

In April, a community member submitted his mas-ters thesis about implementation of a STM library forFrege.

Further reading

https://github.com/Frege/frege

3.4 Specific Platforms

3.4.1 Fedora Haskell SIG

Report by: Jens PetersenStatus: active

The Fedora Haskell SIG works to provide good Haskellsupport in the Fedora Project Linux distribution.For the coming Fedora 26 release ghc has been up-

dated to 8.0.2 and all the Haskell packages have beenrebuilt and most updated to LTS 8.2 (except pandocand hledger, due to missing dependencies). For currentreleases there is a ghc-8.0.2 Fedora Copr repo avail-able for Fedora and EPEL 7, and also a Fedora Coprrepo for stack. We use the cabal-rpm packaging toolto create and update Haskell packages, and improvedfedora-haskell/fedora-haskell-tools to build them.If you are interested in Fedora Haskell packag-

ing, please join our mailing-list and the Freenode#fedora-haskell channel. You can also follow @fedo-rahaskell for occasional updates.

Further reading

◦ Homepage:http://fedoraproject.org/wiki/Haskell_SIG

◦ Mailing-lists: https://lists.fedoraproject.org/archives/list/haskell@lists.fedoraproject.org/ andhttps://lists.fedoraproject.org/archives/list/haskell-devel@lists.fedoraproject.org/

◦ Package list: https://admin.fedoraproject.org/pkgdb/packager/haskell-sig/

◦ Copr repos: https://copr.fedorainfracloud.org/coprs/petersen/ghc-8.0.2and https://copr.fedorainfracloud.org/coprs/petersen/stack

◦ Fedora Haskell Tools: https://github.com/fedora-haskell/fedora-haskell-tools

3.4.2 Debian Haskell Group

Report by: Joachim BreitnerStatus: working

The Debian Haskell Group aims to provide an optimalHaskell experience to users of the Debian GNU/Linux

distribution and derived distributions such as Ubuntu.We try to follow the Haskell Platform versions for thecore package and package a wide range of other use-ful libraries and programs. At the time of writing, wemaintain 995 source packages.A system of virtual package names and dependen-

cies, based on the ABI hashes, guarantees that a systemupgrade will leave all installed libraries usable. Mostlibraries are also optionally available with profiling en-abled and the documentation packages register withthe system-wide index.The current stable Debian release (“jessie”) provides

the Haskell Platform 2013.2.0.0 and GHC 7.6.3, withGHC 7.10.3 being available via “jessie-backports”. InDebian unstable and testing (the soon-to-be releasedrelease “stretch”) we ship GHC 8.0.1.Debian users benefit from the Haskell ecosystem

on 17 architecture/kernel combinations, including thenon-Linux-ports KFreeBSD and Hurd.

Further reading

http://wiki.debian.org/Haskell

3.5 Related Languages and LanguageDesign

3.5.1 Agda

Report by: Ulf NorellParticipants: Ulf Norell, Nils Anders Danielsson,

Andreas Abel, Jesper Cockx, MakotoTakeyama, Stevan Andjelkovic,

Jean-Philippe Bernardy, James Chapman,Dominique Devriese, Peter Divianszki,

Fredrik Nordvall Forsberg, OlleFredriksson, Daniel Gustafsson, Alan

Jeffrey, Fredrik Lindblad, Guilhem Moulin,Nicolas Pouillard, Andrés Sicard-Ramírez

and many othersStatus: actively developed

Agda is a dependently typed functional programminglanguage (developed using Haskell). A central featureof Agda is inductive families, i.e., GADTs which canbe indexed by values and not just types. The lan-guage also supports coinductive types, parameterizedmodules, and mixfix operators, and comes with an in-teractive interface—the type checker can assist you inthe development of your code.A lot of work remains in order for Agda to become a

full-fledged programming language (good libraries, ma-ture compilers, documentation, etc.), but already in itscurrent state it can provide lots of value as a platformfor research and experiments in dependently typed pro-gramming.Some highlights from the past six months:

13

https://github.com/Frege/fregehttp://fedoraproject.org/wiki/Haskell_SIGhttps://lists.fedoraproject.org/archives/list/haskell@lists.fedoraproject.org/https://lists.fedoraproject.org/archives/list/haskell@lists.fedoraproject.org/https://lists.fedoraproject.org/archives/list/haskell-devel@lists.fedoraproject.org/https://lists.fedoraproject.org/archives/list/haskell-devel@lists.fedoraproject.org/https://admin.fedoraproject.org/pkgdb/packager/haskell-sig/https://admin.fedoraproject.org/pkgdb/packager/haskell-sig/https://copr.fedorainfracloud.org/coprs/petersen/ghc-8.0.2https://copr.fedorainfracloud.org/coprs/petersen/ghc-8.0.2https://copr.fedorainfracloud.org/coprs/petersen/stackhttps://copr.fedorainfracloud.org/coprs/petersen/stackhttps://github.com/fedora-haskell/fedora-haskell-toolshttps://github.com/fedora-haskell/fedora-haskell-toolshttp://wiki.debian.org/Haskell

◦ Agda 2.5.2 was released in December 2016.

◦ The Agda documentation at http://agda.readthedocs.org/en/stable/ is being continuouslyimproved.

◦ Experimental support for homotopy type theory hasbeen added to the developement branch by AndreaVezzosi.

Release of Agda 2.5.3 is planned for summer 2017.

Further reading

The Agda Wiki: http://wiki.portal.chalmers.se/agda/

3.5.2 Disciple

Report by: Ben LippmeierParticipants: Ben Lippmeier, Jacob StanleyStatus: experimental, active development

The Disciplined Disciple Compiler (DDC) is a researchcompiler used to investigate program transformationin the presence of computational effects. It compilesa family of strict functional core languages and sup-ports region and effect typing. This extra informa-tion provides a handle on the operational behaviour ofcode that isn’t available in other languages. Programscan be written in either a pure/functional or effect-ful/imperative style, and one of our goals is to provideboth styles coherently in the same language.

What is new?

DDC is in an experimental, pre-alpha state, thoughparts of it do work. In September this year we releasedDDC 0.4.3, with the following new features:◦ Completed desugaring of pattern alternatives.◦ Better type inference for higher ranked types, which

allows explicit dictonaries for Functor, Applicative,Monad and friends to be written easily.

◦ Automatic insertion of run and box casts is now morewell baked.

◦ Automatic interrogation of LLVM compiler versionand generation of matching LLVM assembly syntax.

◦ Added code generation for partial applications ofdata constructors.

◦ Added support for simple type synonyms.

Further reading

http://disciple.ouroborus.net

14

http://agda.readthedocs.org/en/stable/http://agda.readthedocs.org/en/stable/http://wiki.portal.chalmers.se/agda/http://disciple.ouroborus.net

4 Libraries, Tools, Applications, Projects

4.1 Language Extensions and RelatedProjects

4.1.1 Dependent Haskell

Report by: Richard EisenbergStatus: work in progress

I am working on an ambitious update to GHC that willbring full dependent types to the language. In GHC 8,the Core language and type inference have already beenupdated according to the description in our ICFP’13paper [1]. Accordingly, all type-level constructs aresimultaneously kind-level constructs, as there is no dis-tinction between types and kinds. Specifically, GADTsand type families are promotable to kinds. At thispoint, I conjecture that any construct writable in thoseother dependently-typed languages will be expressiblein Haskell through the use of singletons.Building on this prior work, I have written my dis-

sertation on incorporating proper dependent types inHaskell [2]. I have yet to have the time to start gen-uine work on the implementation, but I plan to do sostarting summer 2017.Here is a sneak preview of what will be possible with

dependent types, although much more is possible, too!

data Vec :: ∗ → Integer→ ∗ whereNil :: Vec a 0(:::) :: a → Vec a n → Vec a (1 ’+ n)

replicate :: π n. ∀a. a → Vec a nreplicate @0 = Nilreplicate x = x ::: replicate x

Of course, the design here (especially for the proper de-pendent types) is preliminary, and input is encouraged.

Further reading

◦ [1]: System FC with Explicit Kind Equality, byStephanie Weirich, Justin Hsu, and RichardA. Eisenberg. ICFP ’13. http://www.cis.upenn.edu/~eir/papers/2013/fckinds/fckinds.pdf

◦ [2]: Dependent Types in Haskell: Theory andPractice, by Richard A. Eisenberg. PhD Thesis,2015. https://github.com/goldfirere/thesis/tree/master/built

4.1.2 generics-sop

Report by: Andres LöhParticipants: Andres Löh, Edsko de Vries

The generics-sop (“sop” is for “sum of products”)package is a library for datatype-generic program-ming in Haskell, in the spirit of GHC’s built-inDeriveGeneric construct and the generic-derivingpackage.Datatypes are represented using a structurally iso-

morphic representation that can be used to definefunctions that work automatically for a large class ofdatatypes (comparisons, traversals, translations, andmore). In contrast with the previously existing li-braries, generics-sop does not use the full powerof current GHC type system extensions to modeldatatypes as an n-ary sum (choice) between the con-structors, and the arguments of each constructor as ann-ary product (sequence, i.e., heterogeneous lists). Thelibrary comes with several powerful combinators thatwork on n-ary sums and products, allowing to definegeneric functions in a very concise and compositionalstyle.The current release is 0.2.0.0.A new talk from ZuriHack 2016 is available on

Youtube. The most interesting upcoming feature isprobably type-level metadata, making use of the factthat GHC 8 now offers type-level metadata for thebuilt-in generics. While the feature is in principle im-plemented, there are still a few open questions aboutwhat representation would be most convenient to workwith in practice. Help or opinions are welcome!

Further reading

◦ generics-sop package:https://hackage.haskell.org/package/generics-sop/

◦ Tutorial (summer school lecture notes):https://github.com/kosmikus/SSGEP/

◦ ZuriHac 2016 talk:https://www.youtube.com/watch?v=sQxH349HOik

◦ WGP 2014 talk:https://www.youtube.com/watch?v=jzgfM6NFE3Y

◦ Paper:http://www.andres-loeh.de/TrueSumsOfProducts/

15

http://www.cis.upenn.edu/~eir/papers/2013/fckinds/fckinds.pdfhttp://www.cis.upenn.edu/~eir/papers/2013/fckinds/fckinds.pdfhttps://github.com/goldfirere/thesis/tree/master/builthttps://github.com/goldfirere/thesis/tree/master/builthttps://hackage.haskell.org/package/generics-sop/https://github.com/kosmikus/SSGEP/https://www.youtube.com/watch?v=sQxH349HOikhttps://www.youtube.com/watch?v=jzgfM6NFE3Yhttp://www.andres-loeh.de/TrueSumsOfProducts/

4.1.3 Supermonads

Report by: Jan BrackerParticipants: Henrik NilssonStatus: Experimental fully working version

The supermonad package provides a unified way to rep-resent different monadic notions. In other words, itprovides a way to use standard and generalized mon-ads (with additional indices or constraints) with eachother without having to manually disambiguate whichnotion is referred to in every computation. To achievethis, the library represents monads as a set of two typeclasses that are general enough to allow instances for allof the different notions and then aids constraint check-ing through a GHC plugin to ensure that everythingtype checks properly. Due to the plugin the library canonly be used with GHC.If you are interested in using the library, we have

a few examples of different size in the repository toshow how it can be utilized. The generated Haddockdocumentation also has full coverage and can be seenon the libraries Hackage page.The project had its first release shortly before ICFP

and the Haskell Symposium 2016. We are currentlyworking on providing the same kind of support for ap-plicative functors and arrows, so that generalizationsof these notions can be used as freely as the differentnotions of monads.If you are interested in contributing, found a bug or

have a suggestion to improve the project we are happyto hear from you in person, by email or over the projectsbug tracker on GitHub.

Further reading

◦ Hackage:http://hackage.haskell.org/package/supermonad

◦ Repository:https://github.com/jbracker/supermonad

◦ Paper:http://www.cs.nott.ac.uk/~psxjb5/publications/2016-BrackerNilsson-Supermonads.pdf

◦ Bug-Tracker:https://github.com/jbracker/supermonad/issues

◦ Haskell Symposium presentation:https://youtu.be/HRofw58sySw

4.2 Build Tools and Related Projects

4.2.1 Cabal

Report by: Mikhail GlushenkovStatus: Stable, actively developed

Background

Cabal is the standard packaging system for Haskellsoftware. It specifies a standard way in which Haskelllibraries and applications can be packaged so that it

is easy for consumers to use them, or re-package them,regardless of the Haskell implementation or installationplatform.cabal-install is the command line interface for the

Cabal and Hackage system. It provides a command lineprogram cabal which has sub-commands for installingand managing Haskell packages.

Recent Progress

We’ve recently produced new point releases of Ca-bal/cabal-install from the 1.24 branch. Amongother things, Cabal 1.24.2.0 includes a fix necessary tomake soon-to-be-released GHC 8.0.2 work on macOSSierra.Almost 1500 commits were made to the master

branch by 53 different contributors since the 1.24 re-lease. Among the highlights are:◦ Convenience, or internal libraries – named libraries

that are only intended for use inside the package. Acommon use case is sharing code between the testsuite and the benchmark suite without exposing itto the users of the package.

◦ Support for foreign libraries, which are Haskell li-braries intended to be used by foreign languages likeC. Foreign libraries only work with GHC 7.8 andlater.

◦ Initial support for building Backpack packages.Backpack is an exciting new project adding an ML-style module system to Haskell, but on the packagelevel. See here and here for a more thorough intro-duction to Backpack.

◦ ./Setup configure now accepts an argument spec-ifying the component to be configured. This ismainly an internal change, but it means thatcabal-install can now perform component-levelparallel builds (among other things).

◦ A lot of improvements in the new-build feature(a.k.a. nix-style local builds). Git HEAD versionof cabal-install is now recommended if you usenew-build. For an introduction to new-build, seethis chapter of the manual.

◦ Special support for the Nix package manager incabal-install. See here for more details.

◦ cabal upload now uploads a package candidate bydefault. Use cabal upload --publish to upload afinal version. cabal upload --check has been re-moved in favour of package candidates.

◦ An --index-state flag for requesting a specific ver-sion of the package index.

◦ New cabal reconfigure command, which re-runsconfigure with most recently used flags.

◦ New autogen-modules field for modules built auto-matically (like Paths_PACKAGENAME).

◦ New version range operator ˆ>=, which is equivalentto >= intersected with an automatically-inferred ma-jor version bound. For example, ˆ>= 2.0.3 is equiv-alent to >= 2.0.3 && < 2.1.

16

http://hackage.haskell.org/package/supermonadhttps://github.com/jbracker/supermonadhttp://www.cs.nott.ac.uk/~psxjb5/publications/2016-BrackerNilsson-Supermonads.pdfhttp://www.cs.nott.ac.uk/~psxjb5/publications/2016-BrackerNilsson-Supermonads.pdfhttps://github.com/jbracker/supermonad/issueshttps://youtu.be/HRofw58sySwhttps://mail.haskell.org/pipermail/cabal-devel/2016-December/010384.htmlhttps://ghc.haskell.org/trac/ghc/ticket/12479https://gist.github.com/23Skidoo/1a291fd56a18b51f415db5fbaff56ec6http://cabal.readthedocs.io/en/latest/developing-packages.html#libraryhttp://cabal.readthedocs.io/en/latest/developing-packages.html#foreign-librarieshttps://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rsthttp://blog.ezyang.com/category/haskell/backpack/https://github.com/ghc-proposals/ghc-proposals/pull/4https://github.com/ghc-proposals/ghc-proposals/pull/4http://cabal.readthedocs.io/en/latest/nix-local-build-overview.htmlhttp://cabal.readthedocs.io/en/latest/nix-integration.htmlhttp://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-field-index-statehttps://github.com/haskell/cabal/pull/3818http://cabal.readthedocs.io/en/latest/developing-packages.html#autogenerated-moduleshttp://cabal.readthedocs.io/en/latest/developing-packages.html#pkg-field-build-depends

◦ An --allow-older flag, dual to --allow-newer.◦ New Parsec-based parser for .cabal files has beenmerged, but not enabled by default yet.

◦ The manual has been converted to reST/Sphinx for-mat, improved and expanded.

◦ Hackage Security has been enabled by default.◦ A lot of bug fixes and performance improvements.

Looking Forward

The next Cabal/cabal-install versions will be re-leased either in early 2017, or simultaneously with GHC8.2 (April/May 2017). Our main focus at this stage isgetting the new-build feature to the state where it canbe enabled by default, but there are many other areasof Cabal that need work.We would like to encourage people considering con-

tributing to take a look at the bug tracker on GitHuband the Wiki, take part in discussions on tickets andpull requests, or submit their own. The bug tracker isreasonably well maintained and it should be relativelyclear to new contributors what is in need of attentionand which tasks are considered relatively easy. Formore in-depth discussion there is also the cabal-develmailing list.

Further reading

◦ Cabal homepage: https://www.haskell.org/cabal/◦ Cabal on GitHub: https://github.com/haskell/cabal

4.2.2 The Stack build tool

Report by: Emanuel BorsboomStatus: stable

Stack is a modern, cross-platform build tool for Haskellcode. It is intended for Haskellers both new and expe-rienced.Stack handles the management of your toolchain (in-

cluding GHC - the Glasgow Haskell Compiler - and,for Windows users, MSYS), building and registeringlibraries, building build tool dependencies, and more.While it can use existing tools on your system, Stackhas the capacity to be your one-stop shop for all Haskelltooling you need.The primary design point is reproducible builds. If

you run stack build today, you should get the sameresult running stack build tomorrow. There are somecases that can break that rule (changes in your oper-ating system configuration, for example), but, overall,Stack follows this design philosophy closely. To makethis a simple process, Stack uses curated package setscalled snapshots.Stack has also been designed from the ground up to

be user friendly, with an intuitive, discoverable com-mand line interface.Since its first release in June 2015, many people are

using it as their primary Haskell build tool, both com-

mercially and as hobbyists. New features and refine-ments are continually being added, with regular newreleases.Binaries and installers/packages are available for

common operating systems to make it easy to getstarted. Download it at http://haskellstack.org/.

Further reading

http://haskellstack.org/

4.2.3 Stackage: the Library Dependency Solution

Report by: Michael SnoymanStatus: new

Stackage began in November 2012 with the missionof making it possible to build stable, vetted sets ofpackages. The overall goal was to make the Cabalexperience better. Two years into the project, a lotof progress has been made and now it includes bothStackage and the Stackage Server. To date, there areover 1900 packages available in Stackage. The officialsite is https://www.stackage.org.The Stackage project consists of many different com-

ponents, linked to from the Stackage Github reposi-tory https://github.com/fpco/stackage#readme. Theseinclude:◦ Stackage Nightly, a daily build of the Stackage pack-

age set◦ LTS Haskell, which provides major-version compati-

bility for a package set over a longer period of time◦ Stackage Server, which runs on stackage.org and

provides browsable docs, reverse dependencies, andother metadata on packages

◦ Stackage Curator, a tool for running the variousbuildsThe Stackage package set has first-class support in

the Stack build tool (→ 4.2.2). There is also supportfor cabal-install via cabal.config files, e.g. https://www.stackage.org/lts/cabal.config.There are dozens of individual maintainers for pack-

ages in Stackage. Overall Stackage curation is han-dled by the “Stackage curator” team, which consists ofMichael Snoyman, Adam Bergmark, Dan Burton, JensPetersen, and Luke Murphy.Stackage provides a well-tested set of packages

for end users to develop on, a rigorous continuous-integration system for the package ecosystem, some ba-sic guidelines to package authors on minimal packagecompatibility, and even a testing ground for new ver-sions of GHC. Stackage has helped encourage packageauthors to keep compatibility with a wider range of de-pendencies as well, benefiting not just Stackage users,but Haskell developers in general.If you’ve written some code that you’re actively

maintaining, don’t hesitate to get it in Stackage. You’ll

17

http://cabal.readthedocs.io/en/latest/installing-packages.html#cmdoption-setup-configure--allow-newerhttps://github.com/haskell/cabal/pull/3602https://github.com/haskell/cabal/pull/3602http://cabal.readthedocs.io/en/latest/https://www.well-typed.com/blog/2015/08/hackage-security-beta/https://github.com/haskell/cabal/issues/https://github.com/haskell/cabal/wiki/Hackathon-2016https://mail.haskell.org/mailman/listinfo/cabal-develhttps://www.haskell.org/cabal/https://github.com/haskell/cabalhttp://haskellstack.org/http://haskellstack.org/https://www.stackage.orghttps://github.com/fpco/stackage#readmehttps://www.stackage.org/lts/cabal.confighttps://www.stackage.org/lts/cabal.config

be widening the potential audience of users for yourcode by getting your package into Stackage, and you’llget some helpful feedback from the automated buildsso that users can more reliably build your code.Since the last HCAR, we have moved Stackage

Nightly to GHC 8.0.2, as well as released LTS 8 basedon that same GHC release. We continue to make re-leases of LTS 6 and 7 concurrently, which are based onGHC 7.10.3 and 8.0.1, respectively.

4.2.4 Stackgo

Report by: Sibi PrabakaranStatus: active

A browser plugin (currently supported for Fire-fox/Google Chrome) to automatically redirect Had-dock documentation on Hackage to correspondingStackage pages, when the request is via search engineslike Google/Bing etc. For the case where the packagehasn’t been added yet to Stackage, no redirect will bemade and the Hackage documentation will be available.This plugin also tries to guess when the user wouldwant to go to a Hackage page instead of the Stackageone and tries to do the right thing there.Compared to the previous version, stackgo now al-

ways takes you to the latest lts page of the package.

Further reading

◦ https://github.com/psibi/stackgo◦ https:

//addons.mozilla.org/en-US/firefox/addon/stackgo◦ https://chrome.google.com/webstore/detail/

ojjalokgookadeklnffglgbnlbaiackn

4.2.5 hsinstall

Report by: Dino MorelliStatus: stable, actively developed

This is a utility to install Haskell programs on a sys-tem using stack. Although stack does have an installcommand, it only copies binaries. Sometimes more isneeded, other files and some directory structure. hsin-stall tries to install the binaries, the LICENSE file andalso the resources directory if it finds one.Installations can be performed in one of two directory

structures. FHS, or the Filesystem Hierarchy Standard(most UNIX-like systems) and what I call “bundle”which is a portable directory for the app and all ofits files. They look like this:◦ bundle is sort-of a self-contained structure like this:

$PREFIX/$PROJECT-$VERSION/bin/...doc/LICENSEresources/...

◦ fhs is the more traditional UNIX structure like this:

$PREFIX/bin/...share/$PROJECT-$VERSION/doc/LICENSEresources/...

There are two parts to hsinstall that are intended towork together. The first part is a Haskell shell script,util/install.hs. Take a copy of this script and checkit into a project you’re working on. This will be yourinstallation script. Running the script with the –helpswitch will explain the options. Near the top of thescript are default values for these options that shouldbe tuned to what your project needs.The other part of hsinstall is a library. The install

script will try to install a resources directory if itfinds one. the HSInstall library can then be used inyour code to locate the resources at runtime.Note that you only need the library if your software

has data files it needs to locate at runtime in the in-stallation directories. Many programs don’t have thisrequirement and can ignore the library altogether.Source code is available on darcshub, Hackage and

Stackage

Further reading

◦ hsinstall on darcshubhttp://hub.darcs.net/dino/hsinstall

◦ hsinstall on Hackagehttps://hackage.haskell.org/package/hsinstall

◦ hsinstall on Stackagehttps://www.stackage.org/package/hsinstall

4.2.6 cab — A Maintenance Command of HaskellCabal Packages

Report by: Kazu YamamotoStatus: open source, actively developed

cab is a MacPorts-like maintenance command ofHaskell cabal packages. Some parts of this programare a wrapper to ghc-pkg and cabal.If you are always confused due to inconsistency of

ghc-pkg and cabal, or if you want a way to check alloutdated packages, or if you want a way to remove out-dated packages recursively, this command helps you.Since the last HCAR, Cabal 2.0 was supported

thanks to Ryan Scott.

Further reading

http://www.mew.org/~kazu/proj/cab/en/

18

https://github.com/psibi/stackgohttps://addons.mozilla.org/en-US/firefox/addon/stackgohttps://addons.mozilla.org/en-US/firefox/addon/stackgohttps://chrome.google.com/webstore/detail/ojjalokgookadeklnffglgbnlbaiacknhttps://chrome.google.com/webstore/detail/ojjalokgookadeklnffglgbnlbaiacknhttp://hub.darcs.net/dino/hsinstallhttps://hackage.haskell.org/package/hsinstallhttps://www.stackage.org/package/hsinstallhttp://www.mew.org/~kazu/proj/cab/en/

4.2.7 yesod-rest

Report by: Sibi PrabakaranStatus: active

A Yesod scaffolding site with Postgres backend. It pro-vides a JSON API backend as a separate subsite. Theprimary purpose of this repository is to use Yesod as aAPI server backend and do the frontend developmentusing a tool like React or Angular. The current codeincludes a basic example using React and Babel whichis bundled finally by webpack and added in the handlergetHomeR in a type safe manner.The future work is to integrate it as part of yesod-

scaffold and make it as part of stack template.

Further reading

◦ https://github.com/psibi/yesod-rest◦ https:

//github.com/yesodweb/yesod-scaffold/issues/136

4.3 Repository Management

4.3.1 Octohat

Report by: Stack BuildersParticipants: Juan Carlos Paucar, Sebastian Estrella,

Juan Pablo SantosStatus: Working, well-tested minimal wrapper

around GitHub’s API

Octohat is a comprehensively test-covered Haskell li-brary that wraps GitHub’s API. While we have usedit successfully in an open-source project to automategranting access control to servers, it is in very earlydevelopment, and it only covers a small portion ofGitHub’s API.Octohat is available on Hackage, and the source code

can be found on GitHub.We have already received some contributions from

the community for Octohat, and we are looking forwardto more contributions in the future.

Further reading

◦ https://github.com/stackbuilders/octohat◦ Octohat announcement◦ Octohat update

4.3.2 Darcs

Report by: Guillaume HoffmannParticipants: darcs-users listStatus: active development

Darcs is a distributed revision control system writtenin Haskell. In Darcs, every copy of your source codeis a full repository, which allows for full operation in a

disconnected environment, and also allows anyone withread access to a Darcs repository to easily create theirown branch and modify it with the full power of Darcs’revision control. Darcs is based on an underlying the-ory of patches, which allows for safe reordering andmerging of patches even in complex scenarios. For allits power, Darcs remains a very easy to use tool for ev-ery day use because it follows the principle of keepingsimple things simple.In April 2016, we released Darcs 2.12, with mi-

nors update in September 2016 and January 2017to fix compiling with GHC 8 and other minorbugs. This new major release includes the newdarcs show dependencies command (for exportingthe patch dependencies graph of a repository to theGraphviz format), improvements for Git import, andimprovements to darcs whatsnew to facilitate supportof Darcs by third-party version control front ends likeMeld and Diffuse.

SFC and donations Darcs is free software licensed un-der the GNU GPL (version 2 or greater). Darcs is aproud member of the Software Freedom Conservancy,a US tax-exempt 501(c)(3) organization. We acceptdonations at http://darcs.net/donations.html.

Further reading

◦ http://darcs.net◦ http://darcs.net/Releases/2.12◦ http://hub.darcs.net

4.3.3 git-annex

Report by: Joey HessStatus: stable, actively developed

git-annex allows managing files with git, without check-ing the file contents into git. While that may seemparadoxical, it is useful when dealing with files largerthan git can currently easily handle, whether due tolimitations in memory, time, or disk space.As well as integrating with the git command-line

tools, git-annex includes a graphical app which can beused to keep a folder synchronized between computers.This is implemented as a local webapp using yesod andwarp.git-annex runs on Linux, OSX and other Unixes, and

has been ported to Windows. There is also an incom-plete but somewhat usable port to Android.Five years into its development, git-annex has a wide

user community. It is being used by organizations forpurposes as varied as keeping remote Brazilian com-munities in touch and managing Neurological imagingdata. It is available in a number of Linux distributions,in OSX Homebrew, and is one of the most downloadedutilities on Hackage. It was my first Haskell program.

19

https://github.com/psibi/yesod-resthttps://github.com/yesodweb/yesod-scaffold/issues/136https://github.com/yesodweb/yesod-scaffold/issues/136https://hackage.haskell.org/package/openssh-github-keyshttps://hackage.haskell.org/package/openssh-github-keyshttp://hackage.haskell.org/package/octohathttps://github.com/stackbuilders/octohathttps://github.com/stackbuilders/octohathttp://www.stackbuilders.com/news/announcing-octohat-a-new-haskell-wrapper-for-github-s-apihttp://www.stackbuilders.com/news/new-octohat-releasehttp://darcs.net/donations.htmlhttp://darcs.nethttp://darcs.net/Releases/2.12http://hub.darcs.net

At this point, my goals for git-annex are to continueto improve its foundations, while at the same time keep-ing up with the constant flood of suggestions from itsuser community, which range from adding support forstoring files on more cloud storage platforms (around20 are already supported), to improving its usability fornew and non technically inclined users, to scaling bet-ter to support Big Data, to improving its support forcreating metadata driven views of files in a git reposi-tory.At some point I’d also like to split off any one of a

half-dozen general-purpose Haskell libraries that havegrown up inside the git-annex source tree.

Further reading

http://git-annex.branchable.com/

4.3.4 openssh-github-keys (Stack Builders)

Report by: Stack BuildersParticipants: Justin LeitgebStatus: active

It is common to control access to a Linux server bychanging public keys listed in the authorized_keysfile. Instead of modifying this file to grant and revokeaccess, a relatively new feature of OpenSSH allows theaccepted public keys to be pulled from standard outputof a command.This package acts as a bridge between the OpenSSH

daemon and GitHub so that you can manage accessto servers by simply changing a GitHub Team, in-stead of manually modifying the authorized_keys file.This package uses the Octohat wrapper library for theGitHub API which we released.openssh-github-keys is still experimental, but we are

using it on a couple of internal servers for testing pur-poses. It is available on Hackage and contributions andbug reports are welcome in the GitHub repository.While we don’t have immediate plans to put openssh-

github-keys into heavier production use, we are inter-ested in seeing if community members and system ad-ministrators find it useful for managing server access.

Further reading

https://github.com/stackbuilders/openssh-github-keys

4.4 Debugging and Profiling

4.4.1 Hoed – The Lightweight AlgorithmicDebugger for Haskell

Report by: Maarten FaddegonStatus: active

Hoed is a lightweight algorithmic debugger that is prac-tical to use for real-world programs because it workswith any Haskell run-time system and does not requiretrusted libraries to be transformed.To locate a defect with Hoed you annotate suspected

functions and compile as usual. Then you run yourprogram, information about the annotated functions iscollected. Finally you connect to a debugging sessionusing a webbrowser.

Using Hoed

Let us consider the following program, a defective im-plementation of a parity function with a test property.

isOdd :: Int -> BoolisOdd n = isEven (plusOne n)

isEven :: Int -> BoolisEven n = mod2 n == 0

plusOne :: Int -> IntplusOne n = n + 1

mod2 :: Int -> Intmod2 n = div n 2

prop_isOdd :: Int -> Boolprop_isOdd x = isOdd (2*x+1)

main :: IO ()main = printO (prop_isOdd 1)

main :: IO ()main = quickcheck prop_isOdd

Using the property-based test tool QuickCheck wefind the counter example 1 for our property.

./MyProgram*** Failed! Falsifiable (after 1 test): 1

Hoed can help us determine which function is de-fective. We annotate the functions isOdd, isEven,plusOne and mod2 as follows:

import Debug.Hoed.Pure

isOdd :: Int -> BoolisOdd = observe "isOdd" isOdd’isOdd’ n = isEven (plusOne n)

isEven :: Int -> BoolisEven = observe "isEven" isEven’isEven’ n = mod2 n == 0

20

http://git-annex.branchable.com/http://hackage.haskell.org/package/octohathttp://hackage.haskell.org/package/openssh-github-keyshttps://github.com/stackbuilders/openssh-github-keyshttps://github.com/stackbuilders/openssh-github-keys

plusOne :: Int -> IntplusOne = observe "plusOne" plusOne’plusOne’ n = n + 1

mod2 :: Int -> Intmod2 = observe "mod2" mod2’mod2’ n = div n 2

prop_isOdd :: Int -> Boolprop_isOdd x = isOdd (2*x+1)

main :: IO ()main = printO (prop_isOdd 1)

And run our program:

./MyProgramFalseListening on http://127.0.0.1:10000/

Now you can use your webbrowser to interact withHoed.There is a classic algorithmic debugging interface in

which you are shown computation statements, these arefunction applications and their result, and are asked tojudge if these are correct. After judging enough com-putation statements the algorithmic debugger tells youwhere the defect is in your code.

In the explore mode, you can also freely browse thetree of computation statements to get a better un-derstanding of your program. The observe mode isinspired by HOOD and gives a list of computationstatements. Using regular expressions this list can besearched. Algorithmic debugging normally starts atthe top of the tree, e.g. the application of isOdd to(2*x+1) in the program above, using explore or ob-serve mode a different starting point can be chosen.To reduce the number of questions the programmer

has to answer, we added a new mode Assisted Algo-rithmic Debugging in version 0.3.5 of Hoed. In thismode (QuickCheck) properties already present in pro-gram code for property-based testing can be used toautomatically judge computation statements

Further reading

◦ http://wiki.haskell.org/Hoed◦ http://hackage.haskell.org/package/Hoed

4.4.2 ghc-heap-view

Report by: Joachim BreitnerParticipants: Dennis FelsingStatus: active development

The library ghc-heap-view provides means to inspectthe GHC’s heap and analyze the actual layout ofHaskell objects in memory. This allows you to inves-tigate memory consumption, sharing and lazy evalua-tion.This means that the actual layout of Haskell objects

in memory can be analyzed. You can investigate shar-ing as well as lazy evaluation using ghc-heap-view.The package also provides the GHCi command

:printHeap, which is similar to the debuggers’ :printcommand but is able to show more closures and theirsharing behaviour:

> let x = cycle [True, False]> :printHeap x_bco> head xTrue> :printHeap xlet x1 = True : _thunk x1 [False]in x1> take 3 x[True,False,True]> :printHeap xlet x1 = True : False : x1in x1

The graphical tool ghc-vis (→ 4.4.3) builds on ghc-heap-view.Since version 0.5.6, ghc-heap-view supports GHC 8.

Further reading

◦ http://www.joachim-breitner.de/blog/archives/548-ghc-heap-view-Complete-referential-opacity.html

◦ http://www.joachim-breitner.de/blog/archives/580-GHCi-integration-for-GHC.HeapView.html

◦ http://www.joachim-breitner.de/blog/archives/590-Evaluation-State-Assertions-in-Haskell.html

4.4.3 ghc-vis

Report by: Joachim BreitnerStatus: active development

The tool ghc-vis visualizes live Haskell data structuresin GHCi. Since it does no