Haskell

I recently merged linear let- and where-bindings in GHC. Which means that we’ll have these in GHC 9.10, which is cause for celebration for me. Though they are much overdue, so maybe I should instead apologise to you.

Anyway, I thought I’d take the opportunity to discuss some of GHC’s inner workings and how they explain some of the features of linear types in Haskell. We’ll be discussing a frequently asked question: why can’t Ur be a newtype? And some new questions such as: why must linear let-bindings have a !? But first…

News about the Haskell programming language from 2024-01-18.

Sometimes, for example when working with type-level lists, you have to compute with constraints. For example, you might want to say that a constraint holds for all types in a type-level list. In this episode, we will explore this special case of type-level programming in Haskell. We will also revisit type class aliases and take a closer look at exactly how and why they work.

Today, Matthías and Joachim are interviewing Moritz Angermann. Moritz knew he wanted to use Haskell before he knew Haskell, fixed cross-compilation as his first GHC contribution. We'll talk more about cross-compilation to Windows and mobile platforms, why Template Haskell is the cause of most headaches, why you should be careful if your sister calls and tells you to cabal install a package, and finally how we can reduce the fear of new GHC releases, by improving stability.

News about the Haskell programming language from 2024-01-11.

Consider a Haskell thread trying to read from a TMVar:

x <- atomically $ takeTMVar v

If the TMVar is currently empty and there are no other threads that could write to the TMVar, then this thread will never be able to make progress. The GHC runtime detects such situations, and this call to atomically will throw a BlockedIndefinitelyOnSTM exception, rendered as

thread blocked indefinitely in an STM transaction

Occasionally, however, the runtime will throw this exception even when progress is possible.

Avi Press gave an excellent talk at Scale By the Bay 2023 about difficulties using Haskell at a startup. He mentions that even experienced Haskellers don’t always know how to use fundamental parts of the language. In particular,

even experienced Haskell engineers aren’t always going to know whether to foldl or foldr.

In this article I’ll deduce a firm rule that allows you to make the correct choice...

Hello everyone, Two years ago I created get-tested, a tool that reads your cabal file, extracts the tested-with stanza and produces a test matrix for GitHub Actions. It has served me well to this day, but it also recently received a very useful contribution from @turion, who wrote a reusable Github Action for it! I am extremely grateful for this effort.

Some random thoughts after discussions at the FP Dag yesterday:

We need more learning resources based on pracitcal projects like https://learn-haskell.blog/, and the practical project should not be compiler related. Perhaps the Haskell School of Expression is also a good example of this but it is a bit outdated.

One objection to teaching Haskell through more practical Haskell projects is that it wouldn't show off the benefits if all you're working with I/O almost all of the time. I asked Jaap van der Woude who was sitting next to me - and is a fervent proponent of program design by calculation (e.g. as described in this book) - the question: "Could you calculate a game from its specification?" His immediate response was no, but later he did explain that he used to give students an assignment to specify the game Snake, which was already often too much for his students.

I'll have to try doing that exercise myself sometime. I still think that if we ever want to get to a future where we can write correct and reusable software, then we'll have to find a way to make it easier to formally specify our programs.

#haskell

News about the Haskell programming language from 2024-01-04.

In this edition of our “Haskell in Production” series we interview Jeroen Bransen from Chordify, an online platform, which turns any music or song into chords. Jeroen has been working at Chordify since 2016. We discussed how Chordify ensures the correctness of Haskell code and scalability of its codebase, which libraries they use in their work, and more.

In this episode, Andres and Matti talk to Mike Sperber, CEO of Active Group in Germany. They discuss how to successfully develop an application based on deep learning in Haskell, contrast learning by example with the German bureaucratic approach, and highlight the virtues of having fewer changes in the language.

News about the Haskell programming language from 2023-12-21.

A circular program is a program that depends on its own result. It may be surprising that this works at all, but laziness makes it possible if output becomes available sooner than it is required. In this final episode of 2023, which will be longer than usual (probably 45-60 minutes), we will take a look at several examples of circular programs: the classic yet somewhat contrived RepMin problem, the naming of bound variables in a lambda expression, and breadth-first labelling.

The Haskell Symposium is a two-day workshop co-located with the International Conference on Functional Programming (ICFP). In a previous blog post we discussed the Haskell Implementors’ Workshop (HIW), which is another Haskell-workshop co-located with ICFP, but unlike HIW, the Haskell Symposium is a scientific workshop with peer-reviewed papers.

This year Well-Typed presented one paper at the Haskell Symposium: Edsko de Vries presented the theory that underlies his new library for property based testing, called falsify...

Welcome to the comedy of errors that is our tale of four tumultuous, yet rewarding, years deploying Haskell in a production environment at Scarf...

In this episode, we are joined by Rebecca Skinner. She talks about her new book, Effective Haskell, which takes you from list manipulation to thunks to type-level programming. She also tells us about large scale industrial applications in Haskell, and how the architecture is shaped by the organization of the engineering teams.

News about the Haskell programming language from 2023-12-14.

News about the Haskell programming language from 2023-12-07.

In this episode, we'll see how deriving-via can be used to capture rules that relate type classes to each other. As a specific example, we will discuss the definition of the Monad type class: ever since this definition was changed back in 2015 in the Applicative Monad Proposal, instantiating Monad to a new datatype requires quite a bit of boilerplate code. By making the relation between

Andres and Wouter interview Edwin Brady, most famous for his work on the Idris programming language. We talk about how he got interested in programming with dependent types, his thoughts on dependently typed programming in Haskell, and his vision for Idris.

News about the Haskell programming language from 2023-11-30.