ghcid

ghcid is advertisied as “a very low feature GHCi based IDE”. When one uses ghcid, Haskell’s lack of formal IDE support becomes less of an issue; because ghcid provides the most important feature of instant-recompilation feedback, all in the terminal.

https://github.com/ndmitchell/ghcid

Zombie processes with process-compose

When running ghcid under process-compose, the child GHC process (i.e., the backend server) can survive after process-compose exits, leaving the port bound. This happens because process-compose sends SIGTERM (15) by default, which ghcid does not forward to its child GHC process.

Fix: Configure shutdown.signal = 2 (SIGINT) on the ghcid process in process-compose. SIGINT causes ghcid to terminate gracefully along with its children. 

backend:
  command: "ghcid ..."
  shutdown:
    signal: 2  # SIGINT — ensures child GHC process is terminated

In Nix (using process-compose-flake): 

backend = {
  command = "ghcid ...";
  shutdown.signal = 2;
};

Haskell

Links to this page
  • haskell-template
    Run the main executable via ghcid (auto-recompiles)
  • PureScript mini-tutorial using Nix

    Not using any fancy IDE, I find ghcid to be critical to my Haskell development workflow; its fast compile-reload cycle facilitates a very delightful development experience. I wanted to have this with PureScript. Fortunately, such a tool exists — pscid. pscid is available in Nix, so you may simply restart that nix-shell as:

  • Philosophy
    ghcid (for instant auto-recompilation and re-running of the program)
  • Nix recipes for Haskellers

    You can use the above nix-shell command in the shebang to create self-contained Haskell scripts. Let us see an example, but using ghcid, instead of runhaskell:

  • Haskell Gotchas
  • Getting started
    This will launch ghcid to run the main entrypoint in src/Main.hs.

    Test that ghcid works

  • Announcing Ema - Static Sites in Haskell

    A little over a year ago I created the rib static site generator in Haskell based on Shake and ghcid. The idea was to be able to write a more intuitive (so no Makefile-like rules) set of instructions for building a static site, in a type-safe language while enabling quick recompilation cycle that ghcid provided, all made reproducible in Nix.

  • A brief F# exploration
    Fast development reload workflow works super well in Haskell, thanks to ghcid. In .NET, you have dotnet watch - but that recompiles the whole project on every change leading to annoying delay*; it made me switch back to using Haskell for DSL-based static sites, while live-reload is essential to get quick feedback on things like CSS changes.