Haskell Weekly


Issue 233 2020-10-15

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 safe, purely functional programming language with a fast, concurrent runtime. This is a weekly summary of what’s going on in its community.


  • [ANN] “Production Haskell” alpha book release (ad)

    Are you excited about Haskell, but don’t know where to begin? Are you thrilled by the technical advantages, but worried about the unknown pitfalls? This book has you covered. The early release has 240 pages of excellent content to get you started building production applications, with much more to come.

  • Neuron 1.0 by Sridhar Ratnakumar

    Neuron is a note-taking app with static site publishing; version 1.0 comes with wiki-links and static binary via Nix.

  • GHC Generics Cheat Sheet by Jasper Woudenberg

    This site is intended to help create a fuzzy intuition for Generics, by showing some types and their generics representation side by side.

  • GHC activities report: August–September 2020 by Well-Typed

    This is the second edition of our new GHC activities report, which is intended to provide regular updates on the work on GHC and related projects that we are doing at Well-Typed.

  • Haskell.org GSoC results for 2020 by Jasper Van der Jeugt

    Despite unfortunately receiving less slots from Google this year, we had a number of highly successful projects. In this blogpost, I’ve collected all write-ups and reports from the students for your convenience.

  • Multiple Home Units for GHC - GSoC Aftermath by Fendor

    In this blogpost, I will tell you a bit about my own Google Summer of Code project, in the scope of which I tackled bringing multiple home units to GHC.

  • Normal Forms by Travis Whitaker

    Lazy programs will have live heap objects that are not in normal form. What is “normal form?”

  • Bottlenecked on Haskell’s text library by Falco Peijnenburg

    In one particular feed, we found that processing took much longer than expected. We set out to investigate, and the bottleneck we found came from an unlikely place: the text library.

  • Towards Tactic Metaprogramming in Haskell by Sandy Maguire

    This blog post describes what a tactics engine is and why you want one, and is a good introduction to how in the hell we can automatically write your code for you.

  • Episode 25: Strategic Deriving by Haskell Weekly Podcast

    Cameron Gera and Taylor Fausak discuss the pros and cons of various deriving strategies.


Trying to hire a Haskell developer? You should advertise with us!

In brief

  • cabal-install- and Cabal- are now available by Oleg Grenrus

    The Cabal developers are happy to announce the fourth (and hopefully final) release candidate for cabal-install-

  • Configure services with Dhall by Peter Trško

    For services, running inside a docker container, parsing command line options may be an overkill.

  • Delivering with Haskell by Sam Halliday

    This is my advice to teams that are interested in using Haskell, for the first time, to ship a project.

  • Edge computing with Servant on Cloudflare by Cheng Shao

    In this post we go one step further and show that you can deploy full-fledged servant applications just as well.

  • Force your code to break by Michael Snoyman

    I can definitely make an argument for static typing: I want to find out, as early as possible, that my code is broken.

  • Haskell Templates by Tom Sydney Kerckhove

    I have had the idea of selling Haskell templates for a while now, and I am now getting around to validating this idea.

  • Haskellings 2: Better Configuration by Monday Morning Haskell

    There’s a few interesting things we’ll learn here around using the directory package. We’ll also explore how to use the Seq data structure to implement a quick Bread-First-Search algorithm!

  • @rae: Hello, world! by Richard Eisenberg

    An introduction to a new video series by Tweager Richard Eisenberg, where he will blather on about Haskell, share some brain-bending code, debug in public, and generally provide flashes of insight.

  • ScopedTypeVariables to fix type safety flaws by Alexey Radkov

    How do I get rid of the explicit type declaration? Why did I put it here after all?

  • Silly job interview questions in Haskell by Chris Penner

    Today I thought it’d be fun to take a look at a few common & simple “interview questions” in Haskell.

  • Tutorial: Verify Haskell Programs with hs-to-coq by Li-yao Xia

    This tutorial shows a glimpse of interactive theorem proving in practice. It is a skill you can pick up like another programming language, and you can start to apply it to verify libraries and programs.

  • Unpack your Existentials by Matt Parsons

    If you find yourself packing your existentials to great dismay, consider this approach instead.

  • What are Algebraic Data Types? by Diego Cabrejas

    In this post, we will explore what they are as well as some simple mathematics behind them. The idea is that we are able to count how many possible values a given type can hold.

Show & tell

  • pastebin-haskell by Tom Smeding

    A simple pastebin service for the #haskell IRC channel on Freenode, written in Haskell: paste.tomsmeding.com.

  • ircbrowse by Chris Done & Tom Smeding

    Originally by Chris Done, the IRC Browse service is online again, and now builds with a recent GHC.

  • in-other-words by Love Waern

    Its hallmark feature is the novel approach it takes to support higher-order effects, making it significantly more powerful – and sometimes easier to use – than other effect libraries of its kind.

  • prolens by Kowainik

    The prolens package is a Haskell library with a minimal and lightweight implementation of optics. Optic is a high-level concept for values that provide composable access to different parts of structures.

  • servant-openapi3 by Maxim Koltsov

    Generate a Swagger/OpenAPI/OAS 3.0 specification for your Servant API.

  • stm-incremental by Samuel Schlesinger

    This library is meant to expose an interface for incremental computation using software transactional memory in Haskell.

Call for participation