Issue 120

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.


  • Breaking the space-time barrier with Haskell: Time-traveling and debugging in CodeWorld

    This summer, as part of Google Summer of Code, I created debugging tools to be used by students programming in the CodeWorld environment. As a current learner of Haskell and of CodeWorld, I believe tools that help users reason about logic are very useful. I wanted to help users identify breaks in logic, and reason about mathematics and code.

  • GSoC 2018 wrap-up: Haskell dataframes, Postgres type providers and more

    Frames-beam is the library I worked on during Google Summer of Code 2018 as part of the open source organization. It is primarily intended as a extension to the Frames library, and adds Postgres as an additional data source to it.

  • Hi Haddock: Google Summer of Code is over

    While the Google Summer of Code ends today, my work on Hi Haddock hasn’t finished yet. Initially I had some pretty good progress: A preview version of the GHCi :doc command made it into GHC 8.6. Closing this 10 year old GHC ticket felt great!

  • Image processing: GSoC’18 with Haskell

    This summer, I worked towards implementing different classes of image processing algorithms using Haskell and incorporating the same to the existing code base of Haskell Image Processing (HIP) package to enhance its scope.

  • lsp-test: A functional test framework for LSP servers

    My Haskell Summer of Code project, lsp-test, is now available via Hackage. It’s a framework for writing end-to-end tests for LSP servers, made for testing haskell-ide-engine. But it’s not just limited to haskell-ide-engine: It’s language agnostic and works with any server that conforms to the Language Server Protocol.

  • Enable all the warnings

    The compiler by default enables 18 warnings, and you can enroll in an additional 8 with -Wextra, and even more with -Wall. You’ve probably seen packages compiling with -Wall, but did you know that -Wall doesn’t enable all of GHC’s warnings?

  • Fast Sudoku solver in Haskell #3: Picking the right data structures

    In the previous part in this series of posts, we optimized the simple Sudoku solver by implementing a new strategy to prune cells, and were able to achieve a speedup of almost 200x. In this post, we are going to follow the profiler and use the right data structures to improve the solution further and make it faster.

  • My Haskell journey from C#

    I became a strong believer in FP, in strong typing, and in compilers guiding me through programming. I strongly believe that any programmer can benefit from learning Haskell. Even though I am still relatively new in this journey, I consider myself a better programmer than I was when I started this journey.

  • RFC compliant data-parallel CSV parsing

    In last week’s post I described how to exploit data-parallelism to build a rank-select bit-string for a cut compatible delimeter-separated-values format, parsing 8-bytes at-a-time. In this post we will look at how to do the same for the CSV format described in RFC4180.

  • Typesafe versioned APIs

    We’re going to look at a fun way to write a monadic action which alters its behaviour based on which version of a system it’s embedded in, simultaneously gaining ground on the expression problem and giving us compile-time guarantees that we haven’t accidentally mixed up code from different versions of our app!


If you’re interested in a Haskell job, look no futher than the who’s hiring thread from the Haskell subreddit! There are no fewer than 9 companies hiring Haskellers right now.

In brief

Package of the week

This week’s package of the week is GRIFT, the Galois RISC-V Formal Tools. It contains a concrete representation of the semantics of the RISC-V instruction set, along with an elegant encoding/decoding mechanism, and simulation and analysis front-ends.

Call for participation