Haskell Weekly


Issue 242 2020-12-17

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.


  • Developer Economics Survey (ad)

    It’s our 20th survey anniversary! Discover new questions, prizes, and surprise perks.

  • Dependently typed folds by Ryan Orendorff

    We will look at the standard fold functions, and how they take on a new meaning in a dependently typed context.

  • Advent of Haskell 2020 Day 11: The retry package by Wander Hillen

    In this blog post we will have a look at the retry package, which implements some higher order functions that allow for retrying arbitrary monadic actions with various retry policies.

  • Foo to bar: Naming conventions in Haskell by Veronika Romashkina & Dmitrii Kovanikov

    In this post, we will explore common naming conventions in Haskell together. It is going to be useful for both creators (library and API developers) and consumers (library users), as it establishes norms accepted in the libraries’ APIs.

  • Getting acquainted with Lens (part 1) by Pawel Szulc

    In this post we will explore a concept of a Lens. More concretely the Lens library.

  • Hackage Search: Regex-Based Online Code Search by Vladislav Zavialov

    And thus, Hackage Search was born: an online grep for Hackage. Just type in your query and get the results.

  • Roll your own Holly Jolly streaming combinators with Free by Justin Le

    I wanted to share a recent application I have been able to use apply it with where just thinking about the primitives gave me almost all the functionality I needed for a type: composable streaming combinators.

  • Simpler And Safer API Design Using GADTs by Chris Penner

    In this post we’ll take a look at a very real example where we can leveraged GADTs in a real-world Haskell library to build a simple and expressive end-user interface.

  • Structure your Errors by Tikhon Jelvis

    To fix these problems, I’ve started using dedicated types for my errors. This took some up-front effort but has more than paid for itself over time.

  • Talking about Toys by Alejandro Serrano

    There’s not one, but a group of present-bringing people, distributed across the globe, each with their own part of the world to cover (or you really thought just one man and eight reindeers could do it all by their own?)


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

In brief

  • Amazing animations using the Reader monad by Mike Solomon

    It’s the Most Wonderful Time of the Year, and to celebrate, I created a small web-arrangement of Silent Night using PureScript and LilyPond.

  • Dependencies and Package Databases by Monday Morning Haskell

    Here’s the final video in our Haskellings series! We’ll figure out how to add dependencies to our exercises.

  • Enumerating Trees by Donnacha Oisín Kidney

    Consider the following puzzle: Given a list of n labels, list all the trees with those labels in order.

  • Goodbye, JavaScript! by Victor Maia

    Formality has now received its largest and most important update to date: it is now entirely implemented in itself!

  • Haskell coreutils - tee by Austin

    Seems simple enough; tee is like cat except that it additionally writes whatever passes between stdin and stdout to any number of files along the way.

  • Haskell - Doomed to Succeed? by Ari Fordsham

    This seems an odd statement. What’s wrong with a bit of success?

  • (Haskell in Haskell) 2. Lexing by Lúcás Meier

    In this post, we’ll go over creating a lexer for our subset of Haskell. This stage of the compiler goes from the raw characters in our a source file, to a more structured stream of tokens.

  • How to setup IHP with Elm by Lars Lillo Ulvestad

    Get Elm with hot reloading on top of IHP, the new framework that makes Haskell a cool kid in web dev.

  • Haskell memoization and evaluation model by Boro Sitnikovski

    That article is good, but it only explains the how, not the why. I will cover both how and why in this blog post.

  • On hiring Haskellers by Alexander Granin

    There is a single reason, a single core problem that causes difficulties of hiring and being hired in the Haskell community, and we should clearly articulate this problem if we want to increase the Haskell adoption.

  • A law-breaking hack

    I’ll show how to abuse laziness and what kind of horrible consequences that has (spoiler: you can break a law by being lazy).

  • Parser Combinators by Haskell Weekly Podcast

    Are you curious about how Parsec is implemented behind the scenes? Cameron Gera and Taylor Fausak follow Antoine Leblanc’s walkthrough.

  • Pattern matching by Michael Snoyman

    Using a case expression in Haskell, or a match expression in Rust, always felt natural. But it took years to realize that patterns appeared in other parts of the languages than just these expressions, and what terms like irrefutable meant.

  • Precise Typing Implies Functional Programming by Pavel Potoček

    I will try to present an unified argument for all the FP characteristics in this article.

  • A Vivid Christmas Carol by Tom Murphy

    In Vivid / SuperCollider, you make sounds by creating Synths. Synths are created using Synth Definitions, or SynthDefs.

Show & tell

Call for participation