- Haskell-Cafe - Haskell.org

Announcing: LTS (Long Term Support) Haskell 2
by Michael Snoyman 02 Apr '15

02 Apr '15

The LTS Haskell 2.0 release is officially out the door. More details are available at: https://www.fpcomplete.com/blog/2015/04/announcing-lts-2 For the tl;dr crowd, run the following inside your project to get a cabal.config with appropriate constraints: wget https://www.stackage.org/lts/cabal.config There are some questions about policy at the end of the post that I'd appreciate feedback on.

1 0

Parallel Profiling
by Dominic Steinitz 02 Apr '15

02 Apr '15

Does anyone know of any tools for analysing parallel program performance? I am trying to use threadscope but it keeps crashing with my 100M log file and ghc-events-analyze is not going to help as I have many hundreds of threads all carrying out the same computation. I think I’d like a library that would allow me to construct my own analyses rather than display them via GTK. There is ghc-events but that seems to be just for parsing the logs and I couldn’t find anything that used it in the way I would like to (apart from threadscope and ghc-events-analyze of course). Thanks Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

2 2

Haskell Weekly News
by Kim-Ee Yeoh 01 Apr '15

01 Apr '15

*Top picks:* - Bot attack on Trac <https://mail.haskell.org/pipermail/ghc-devs/2015-March/008557.html> pummels GHC HQ productivity! Do you know a thing or two about hardening web apps? Can you help? - A month ago <http://haskell.1045720.n5.nabble.com/Haskell-Weekly-News-td5766529.html> you read about the absence of a correct operational spec for Core. Christiaan Baaij <http://ghc.haskell.org/trac/ghc/ticket/10121#comment:7> proffers rewriting rules for something "very much like Core" from his 2014 thesis on Digital Circuits in CλaSH, a tool designed for Computer Architecture for Embedded Systems (CAES). The consensus is that they probably also work for GHC Core. - Neil Mitchell reports Unable to load package Win32-2.3.1.0 <https://ghc.haskell.org/trac/ghc/ticket/10165>. The problem? SetWindowLongPtrW exists only on 64-bit. The haskell win32 shim wasn't switching to SetWindowLongW on 32-bit. Darren Grant steps up to offer a fix, which Austin Seipp promptly checks in. - Ki Yung Ahn <http://haskell.1045720.n5.nabble.com/Do-we-have-idiom-for-lifting-a-state-m…> asks for a "wrapper that lifts actions of (State s1 a) to (State (s1,s2) a). " The answer? A function called "zoom" in lens libraries. - Chris Done <https://groups.google.com/forum/#!msg/commercialhaskell/lRTDiTLIKi0/Kw0UGwa…> has started the ball rolling on GPG-based package signing. So far, Michael Snoyman and Neil Mitchell have had their keys signed by Chris. He invites others to join the party. - Levant Erkok <https://ghc.haskell.org/trac/ghc/ticket/10215> joins Lennart Augustsson <https://ghc.haskell.org/trac/ghc/ticket/9238> in hitting a bug with signed zeros <http://en.wikipedia.org/wiki/Signed_zero>. The function isNegativeZero breaks under optimizations. - James Stevenson <https://blog.safaribooksonline.com/2015/03/30/high-performance-log-parsing-…> over at Safari Books Online reveals how they use Haskell to parse web logs more efficiently than Python. The top comment <https://news.ycombinator.com/item?id=9294036> at Hacker News observes the absence of a proper benchmark pitting Python vs Haskell. James responds that they did an informal comparison that showed "the number of lines parsed/second [with Python] was far smaller than the attoparsec-based parser." Elsewhere, Luke Randall <http://www.reddit.com/r/haskell/comments/30xugp/highperformance_log_parsing…> submits the link on reddit and thinks it's a "very gentle intro to parsing using attoparsec". - Ian Ross <http://www.skybluetrades.net/blog/posts/2015/03/30/c2hs-snowmelt.html> announces a new C2HS release christened "Snowmelt". Originally authored by Manuel Chakravarty, C2HS eases the pain of manually creating FFI shims for C libraries. The latest release, thanks to work contributed by Philipp Balzarek, achieves better cross-language alignment of C enum and Haskell Enum types, among other improvements. Reddit discussion here. <http://www.reddit.com/r/haskell/comments/30u8pk/new_c2hs_release_0251_snowm…> - Michael Snoyman <https://www.fpcomplete.com/blog/2015/03/announce-ide-backend> announces FPComplete's open sourcing of their IDE backend, comprising a wrapper around the GHC API. - Jon Sterling at PivotCloud <https://ghc.haskell.org/trac/ghc/ticket/9539#comment:2> hits an STM TQueue bug initially reported by John Lato seven months ago. A sufficiently fast writer can cause the reader to never get scheduled, which leads to live-lock in Jon's production code. The fix looks to be as simple as lazifying a case into a let in readTQueue. Curiously, the code uses let in Simon Marlow's book on Haskell concurrency <http://chimera.labs.oreilly.com/books/1230000000929/ch10.html#CO37-2> but not in the STM package you have on your machine. *Tweets of the week:* - Michael Neale <https://twitter.com/michaelneale/status/567532684595851264>: Haskell Quickcheck enters a bar, asks for 1 beer, 42 beers, -Inifinity beers, shaves bartenders beard, sets off a tactical nuke. - Dierk König <https://twitter.com/mittie/status/582803534950862848>: #Haskell is the gold standard for programming languages and #Frege makes it available on the #JVM -- Kim-Ee

1 0

An Easy Solution to PVP Bounds and Cabal Hell
by Gershom B 01 Apr '15

01 Apr '15

Recently there has been some discussion about how we can fix the problem of “Cabal Hell”. Some people advocate restrictive upper bounds, to prevent packages from being broken by new updates. Some other people point out that too-restrictive bounds can lead to bad install plans, since some packages might want newer versions of some dependencies, and others older versions. Still other people say that we can _retroactively_ fix upper bounds (in either direction) by modifying cabal files using the new features in Hackage. Some people think this is a terrible idea because it looks like we are mutating things, and this confuses hashes. In turn, these people support either nix or a nix-like approach by which packages have hashes that encompass the full versions of all their transitive dependencies. With that in hand, we can cache builds and mix-and-match to build the precise environment we want for each package while reducing redundant computation. However, the cache of all the various binary combinations may still grow large! And none of this fully begins to address the dreaded “diamond dependency” problem. Here is a chart of some such solutions: http://www.well-typed.com/blog/aux/images/cabal-hell/cabal-hell-solutions.p… One way to look at a particular build is in an n-dimensional state space (of the Hilbert sort) determined by all its dependencies, not least the compiler itself. The solver acts as a particle traversing this space. But this description is too simple. Our state of dependencies and constraints itself varies and grows over time. So another approach is to think of the dependencies as a transitive graph, where each node may vary along a time axis, and as they slide along the axis, this in turn affects their children. We now have not just one Hilbert space, but a collection of them related by branching trees as authors locally modify the dependencies of their packages. If we keep this simple model in mind, it is easy to see why everyone is always having these debates. Some people want to fix the graph, and others want to simplify it. Some people want an immutable store, and some people want to rebase. But we can’t “really” rebase in our current model. Bearing in mind our model of a space-time continuum of hackage dependences, the solution emerges — enforce immutability, but allow retroactive mutation. For instance, suppose Fred tries to install package Foo on Friday evening, but discovers that it depends on version 1.0 of Bar (released the previous Friday) that in turn depends on version 0.5 of Baz but Foo also depends on version 0.8 of Baz. So Fred branches Bar and changes the dependency, which in turn informs Betty, that there is also a 1.0 of Bar with different dependencies and we have forked our package timeline. On getting this message on Monday, Betty can merge by pushing with --force-rewrites and this goes back in the timeline and makes it so that Baz retroactively had the right dependencies and now Fred, as of the previous Friday, no longer has this problem. (That way he still has the weekend). Now the failed build is cut off temporarily into a cycle in the package timeline that is disconnected from the rewrite. We stash it with “hackage stash” until Monday at which time the dependency graph is 100 percent equalized and primed for new patches. At this point we unstash Foo as of Friday and it is replaced by the Foo from the new timeline. Friday Fred needs to remain stashed lest he run into himself. The longer he can be avoided by his Monday self the better. Future work could include bots which automate pruning of artifacts from redundant branches. If this description was too abrupt, here is a diagram with a fuller description of the workflow: http://bit.ly/15IIGac I know there are some new ideas to take in here, and there is a little technical work necessary to make it feasible, but in my opinion if you can understand the current cabal situation, and you can understand how git and darcs work, then you should be able to understand this too. Hopefully by this time next year, we’ll be able to say that our problems with cabal have been truly wiped from our collective memory. HTH, HAND. Gershom

4 3

ANNOUNCE: Parsed 0.0.1
by Mike Izbicki 01 Apr '15

01 Apr '15

I'm pleased to announce the first release of the Parsed library (pronounced par-séd). Parsed is a reimplementation of Haskell's excellent Parsec library in the Unix shell. In particular, the Unix pipe operator | corresponds exactly to Haskell's Applicative bind *>. Here's a quick example to get a feel for the syntax. The following bash one liner creates a parser for matching balanced parenthesis: ``` parens() { choice "$1" "match '(' | parens \"$1\" | match ')'"; } ``` For more detailed examples and implementation notes, please see the Parsed paper accepted at SIGBOVIK2015: https://github.com/mikeizbicki/parsed/raw/master/sigbovik2015/paper.pdf You can download Parsed from its github page at: https://github.com/mikeizbicki/parsed

3 4

Specify OS version
by Sergey Bushnyak 01 Apr '15

01 Apr '15

Hi Cafe! I have program written in Haskell and Swift that runs on Mac. This program uses some features that was introduced in last version of OS X “Yosemite” 10.10, but some of my users use previous version "Maverics " 10.9. Is there some technique that allows me to extend my cabal file and specify which *version* of os is currently in use and don't load some of modules? AFAIK, Cabal's `conditional` doesn't provide such mechanism, but something like ``` if os(osx) && ver(=10.10) if os(osx) && ver(<=10.9) ``` will be nice. Maybe there is other approach to this problem?I don't want to use `CPP` extension to handle this within code. Thanks -- Best regards, Sergey Bushnyak

2 2

Speed up ghc -O2
by Kees Bleijenberg 01 Apr '15

01 Apr '15

My program reads a xls file and creates a haskell program that does exactly the same as what the xls does. Every cell in the xls is a function and contains 2 lines: the type declaration and 1 line the implementation. The type of a cell is XlsCell. data XlsCell = Reader ExternalCells XlsCellRes data XlsCellRes = XlsCellString String | XlsCellBool Bool | ..... type ExternalCells = Map String XlsCellRes -- search (or set) a value of a cell by its name. The externalCells are for the cells you can change at runtime. The generated program was first 30000 lines. When I compiled it with ghc 7.8.3. -O0 the program worked, but was terribly slow. With -O2 I got: out of memory. With a few trics the generated code is now split up in 2 files 5000 and 10000 lines. I've upgraded to ghc 7.8.4. If I do ghc -O2 the program takes more then 4 hours to compile. The -O2 compilation is essential. The resulting program is much (more then 10x) faster then without -O2. What can I do (changes in the generated code, changes to speed up ghc?) to make ghc faster with -O2? I tried ghc-make, but it doesn't make a big difference. Kees

1 0

Journal of Functional Programming - Call for PhD Abstracts
by Graham Hutton 01 Apr '15

01 Apr '15

============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 30th April 2015 http://tinyurl.com/jfp-phd-abstracts ============================================================ PREAMBLE: Many students complete PhDs in functional programming each year, but there is currently no common location in which to promote and advertise the resulting work. The Journal of Functional Programming would like to change that! As a service to the community, JFP recently launched a new feature, in the form of a regular publication of abstracts from PhD dissertations that were completed during the previous year. The abstracts are made freely available on the JFP website, i.e. not behind any paywall, and do not require any transfer for copyright, merely a license from the author. Please submit dissertation abstracts according to the instructions below. A dissertation is eligible if parts of it have or could have appeared in JFP, that is, if it is in the general area of functional programming. JFP will not have these abstracts reviewed. We welcome submissions from both the PhD student and PhD advisor/ supervisor although we encourage them to coordinate. ============================================================ SUBMISSION: Please submit the following information to Graham Hutton <graham.hutton(a)nottingham.ac.uk> by 30th April 2015. o Dissertation title: (including any subtitle) o Student: (full name) o Awarding institution: (full name and country) o Date of PhD award: (month and year; depending on the institution, this may be the date of the viva, corrections being approved, graduation ceremony, or otherwise) o Advisor/supervisor: (full names) o Dissertation URL: (please provide a permanently accessible link to the dissertation if you have one, such as to an institutional repository or other public archive; links to personal web pages should be considered a last resort) o Dissertation abstract: (plain text, maximum 1000 words; you may use \emph{...} for emphasis, but we prefer no other markup or formatting in the abstract, but do get in touch if this causes significant problems) Please do not submit a copy of the dissertation itself, as this is not required. JFP reserves the right to decline to publish abstracts that are not deemed appropriate. ============================================================ PHD ABSTRACT EDITOR: Graham Hutton School of Computer Science University of Nottingham Nottingham NG8 1BB United Kingdom ============================================================ This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system, you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Enforcing data structures invariant in the type system
by Nicola Gigante 31 Mar '15

31 Mar '15

Hi all. I’m very interested in what can be done with Haskell’s type system regarding the enforcing of algorithms and data structures invariants. For example, I remember I saw a paper about an implementation of a red-black tree in Haskell where the types guaranteed the invariant about the alternation of rad and black nodes. I would like to learn those techniques, in particular the use of language features that enable this kind of things and then how to do them in practice. In the past tried hacking something with GADTs and Data Kinds but I've always got stuck with GHC errors that I could not understand, so I think I’m missing something. Where could I start from? Are there simple walk-through examples and/or fundational material? For example is it possible to write a sorting function that guarantees in the types that the output is sorted? I don’t need this specific example but you got the point. Thank you very much, Nicola

5 9

Data.EnumMap ?
by Johannes Waldmann 31 Mar '15

31 Mar '15

Dear Cafe, in containers, we have Data.IntMap/IntSet . Because of the underlying implementation (patricia trees), keys/elements indeed have to be Int (we need their bits). This is a conflict with type-safety: I try to avoid Int, and use some newtype T = T Int instead. E.g., I want to distinguish several different indices for the same structure, like row and column numbers in (sparse) matrices, or vertices in bipartite graphs. So, I made these trivial wrappers EnumMap and EnumSet: https://github.com/jwaldmann/satchmo-solver/tree/master/src/Data Is this reasonable (do from/toEnum really have zero cost)? Would this be a useful addition to containers? - J.W.

4 5