Haskell Weekly

Issue 83

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.

Featured

  • Monad of no return proposal

    To complete the Monad-hierarchy refactoring started with AMP (& MFP) and unify return/pure & >>/*>, move Monad(return) and Monad((>>)) methods out of the Monad class into top-level bindings aliasing Applicative(pure) and Applicative((*>)) respectively.

  • Hamiltonian dynamics in Haskell

    At the end of this, we should be able to have Haskell automatically generate equations of motions for any arbitrary system described in arbitrary coordinate systems, and simulate that system.

  • Haskell exceptions and FFI wrappers

    The Haskell FFI is incredibly powerful, allowing you to convert Haskell functions into C function pointers. In this post I’ll give a quick example, then go into what happens if the Haskell function throws an exception.

  • Exception handling in Haskell jobs

    I am using yesod-job-queue to define the job. The use-case was, that this was a scheduled job and we needed to log the failures. But on running this; there was an error, since runJob in yesod-job-queue does not have the MonadCatch constraint.

  • Bracket: A tale of partially applied functions

    In this post, we describe how we can use partially applied functions as a design building block though the study of a practical example: the bracket function.

  • Deciphering Haskell’s applicative and monadic parsers

    This post follows the construction of parsers described in Graham Hutton’s “Programming in Haskell”. It’s my attempt to work through chapter 13 in this book and understand the details of applicative and monadic combination of parsers presented therein.

  • WebAssembly call to action: Syscalls needed!

    In the effort to port GHC to WebAssembly, the biggest challenge has been the C toolchain. We have a compiler, a static linker, a libc, and Nix glue for all of this. But we don’t have many syscalls.

  • How to unit test code that uses polymorphic interfaces?

    I’ve been largely happy with a lot of the solutions I’ve come up with, but there’s one sort of problem I’ve always been unsatisfied with. It’s quite easy to unit test code that uses plain old monomorphic functions, but it’s comparatively difficult as soon as polymorphism is involved.

  • GHC: Warn on recursive bindings

    When you accidentally write something like let x = .. x ... it can take hours to realize where you made your mistake. This hits me once in a while, and my colleagues often.

  • Total Haskell is reasonable Coq

    We would like to use the Coq proof assistant to mechanically verify properties of Haskell programs. To that end, we present a tool, named hs-to-coq, that translates total Haskell programs into Coq programs via a shallow embedding.

Jobs

In brief

Package of the week

This week’s package of the week is Validity, a library that makes invariants explicit by providing a function to check whether the invariants hold.

Call for participation

Check out 24 Pull Requests for some additional Haskell projects to work on!

Events