Haskell Weekly


Issue 66 2017-08-03

Subscribe now! We'll never send you spam. You can also follow our feed. Read more issues in the archives.

Welcome to another issue of Haskell Weekly! Haskell is a purely functional programming language that focuses on correctness, productivity, and expressiveness. This is a weekly summary of what’s going on in its community.

Want to see something featured in Haskell Weekly? We love contributions! Tweet us at @HaskellWeekly or open a pull request.


  • Faster command line tools with Haskell

    What I wish to be true: I write high level Haskell code as declaratively and naively as possible and sufficiently smart compiler optimizations make it as fast as hand tuned Go code. Let’s see if it works out that way!

  • Using GHC CallStacks

    Haskell doesn’t really have a call stack. The evaluation strategy is more like a graph reduction. If you don’t understand that, that’s okay — I don’t either! All I know about it is that it makes questions like “What’s the stack trace for this error?” surprisingly difficult to answer.

  • GHC warnings you should use in addition to -Wall

    There are some useful warnings that are not turned on by -Wall. This post will describe which additional warnings you should enable. It will also show examples of bad code that will trigger the warnings. Keep in mind that this bad code will not get caught by -Wall.

  • To Void or to void

    Unfortunately, intuition and reasoning are not appearing in our types, and therefore we need to rely on our own inner reasoning checker instead of letting GHC enforce things for us. As things scale up, eventually it gets difficult to know what’s happening in the code.

  • Reflections on GHC’s release schedule

    With 8.2.1 at long last behind us, now is a good time to reflect on why these cycles are so long, what release schedule we would like to have, and what we can change to realize such a schedule.

  • Coping with (code) failures

    Haskell’s error facilities are a lot better than most languages. This week we’ll look at some common error handling patterns. We’ll see a couple clear instances where Haskell has simpler and cleaner code.

  • Elm in production: 25,000 lines later

    We have managed to take a set of functionality that would have been exceptionally difficult to build using our old methods, and using the strengths of the Elm language and architecture, successfully developed the largest feature in our entire software product to date.

  • Encode state transitions in types using linear types

    One has to be careful not to use s ever again to avoid ill effects: types have failed us once again. What we need is the ability to consume the old s, to make it inaccessible. Which, coincidentally, is exactly what linear types enable.

  • How is coinduction the dual of induction?

    The coinduction rule is not the direct dual of the induction rule, but both are specializations of more general, relational proof methods, where the duality is clearly present.

  • Faster (re)deploys with docker-build-cacher

    We traced these shortcomings to a missing key feature: It is not possible to carry statically generated cache files from one build to another once certain source files in the project change.


  • FP Complete hiring devops engineers

    We are currently seeking to fill multiple devops positions, focusing on rolling out new build, deploy, and monitoring infrastructure. We are looking to hire both remote workers, and at least one engineer in the Phoenix, Arizona area for on site customer work.

In brief

Package of the week

This week’s package of the week is justified-containers, a library that provide guarantees about the presence of keys within containers.

Call for participation