Développer en Haskell avec Nix, en 2023
Voir aussi : video youtube - code source
Dans l’article Développer en Haskell avec ghcup et vscode, en 2022, on a vu que ghcup permet désormais d’installer facilement un environnement pour développer en Haskell. Dans Comment utiliser Nix pour développer en Haskell, on avait vu que Nix fournit également un environnement intéressant. Cet environnement a évolué et ce nouvel article en fait une présentation plus à jour.
Rappels sur Nix
Nix est un système de paquets logiciels basé sur une approche déclarative et sans effet de bord. Concrètement, il s’agit à la fois d’un langage de programmation permettant d’écrire des expressions Nix (définir des paquets) et d’un outil permettant d’évaluer ces expressions (construire des paquets…). Basés sur ces deux outils, il existe aussi une logithèque (nixpkgs), un système d’exploitation (nixos)…
Nix apporte de nombreux avantages pour développer des logiciels, dans les principaux langages de programmation dont Haskell. Actuellement, il existe deux façons de configurer un projet Haskell avec Nix : Haskell4nix et Nix Flakes.
Haskell4nix
Haskell4nix est le support de Haskell dans l’infrastructure de nixpkgs. Concrètement, il fournit des compilateurs Haskell (ghc, ghcjs…) , des outils de développement (cabal, ghcid, hls…), des bibliothèques et des outils de packaging spécifiques.
En pratique, il s’agit d’utiliser la logithèque Nix classique. Par exemple, pour connaitre les compilateurs supportés, ou les bibliothèques Haskell disponibles :
$ nix-env -f "<nixpkgs>" -qaP -A haskell.compiler
haskell.compiler.ghc8107 ghc-8.10.7
haskell.compiler.ghc884 ghc-8.8.4
haskell.compiler.ghc902 ghc-9.0.2
...
$ nix-env -f "<nixpkgs>" -qaP -A haskell.packages.ghc925
haskell.packages.ghc925.a50 a50-0.5
haskell.packages.ghc925.AAI AAI-0.2.0.1
haskell.packages.ghc925.aasam aasam-0.2.0.0
...On peut également lancer un environnement Nix spécifique, par exemple via un fichier shell.nix. Mais généralement, on configure un projet Haskell avec l’outil Cabal, qui est compatible avec Haskell4nix. Il suffit donc d’écrire un fichier .cabal, classique en Haskell, puis d’écrire le fichier default.nix suivant pour avoir automatiquement une configuration Nix du projet :
{ pkgs ? import <nixpkgs> {} }:
let
# ghc = pkgs.haskellPackages; # version par défaut du compilateur
ghc = pkgs.haskell.packages.ghc925; # version 9.2.5
in ghc.developPackage {
root = ./.;
modifier = drv:
pkgs.haskell.lib.addBuildTools drv (with ghc; [
cabal-install
]);
}Par exemple pour travailler sur le projet, on peut lancer un nix-shell (pour lancer un environnement avec toutes les dépendances nécessaires, déterminées d’après le fichier .cabal) puis utiliser les commandes Cabal habituelles :
$ nix-shell
these 2 derivations will be built:
/nix/store/0dlwbm8gll94aw22zb01v85h409bik82-hoogle-with-packages.drv
/nix/store/9yb2mfx3a17hsv81xjnpdl8hl0cghz9j-ghc-9.0.2-with-packages.drv
...
[nix-shell]$ cabal build
Resolving dependencies...
Build profile: -w ghc-9.0.2 -O1
In order, the following will be built (use -v for more details):
- myproject-0.1.0.0 (lib) (first run)
- myproject-0.1.0.0 (exe:myproject) (first run)
...
[nix-shell]$ cabal run
<h1>Hello World!</h1>On peut également contruire complètement le projet via Nix :
$ nix-build
this derivation will be built:
/nix/store/rimxqr1avc7ycyzgqcd5lqdw0z0wgcqr-myproject-0.1.0.0.drv
...
$ ./result/bin/myproject
<h1>Hello World!</h1>Installer le projet sur la machine, via le système de paquet :
$ nix-env -if .
installing 'myproject-0.1.0.0'
this derivation will be built:
/nix/store/8xf8mc0m1cvnfb3c0ybpy38rrxsa0gq2-myproject-0.1.0.0.drv
...
$ myproject
<h1>Hello World!</h1>Ou encore, intégrer le projet dans la logithèque, par exemple via un overlay Nix qui récupère le code du projet depuis un dépôt git :
# ~/.config/nixpkgs/overlays/myproject.nix
self: super:
let
myproject-src = self.fetchFromGitLab {
owner = "nokomprendo";
repo = "nokomprendo.gitlab.io";
rev = "0bb6f2e";
sha256 = "sha256-4F4GXnMVWrE5BzJcewopr6xGmdPySeawwbvN66Cu9b0=";
};
in {
myproject = self.callPackage "${myproject-src}/posts/tuto_093/code/myproject-h4n/default.nix" {};
}Enfin, on peut également fixer plus précisemment la version de la logithèque à utiliser, modifier des paquets (changer de version, patcher), etc.
Nix Flakes
Les Nix Flakes sont des fonctionnalités, encore expérimentales, disponibles via Nix. Celles-ci permettent de définir des unités de constructions d’un package, d’un déploiement, voire d’un système complet.
Les Flakes visent à rendre le packaging plus reproductible (meilleure gestion des fichiers de configuration, gel de versions…), composable et performant (meilleure mise en cache).
Ici, on s’intéresse uniquement à comment utiliser les Flakes pour configurer simplement un projet en Haskell. Pour cela, on peut écrire le fichier flake.nix suivant :
{
inputs = {
nixpkgs.url = "github:nixos/nixpkgs";
flake-utils.url = "github:numtide/flake-utils";
};
outputs = { self, nixpkgs, flake-utils }:
#flake-utils.lib.eachDefaultSystem (system:
flake-utils.lib.eachSystem [ "x86_64-linux" ] (system:
with nixpkgs.legacyPackages.${system};
let
t = lib.trivial;
hl = haskell.lib;
name = "myproject";
# ghc = haskellPackages; # version par défaut
ghc = pkgs.haskell.packages.ghc925; # version 9.2.5
project = devTools:
let addBuildTools = (t.flip hl.addBuildTools) devTools;
in ghc.developPackage {
root = lib.sourceFilesBySuffices ./. [ ".cabal" ".hs" ];
name = name;
returnShellEnv = !(devTools == [ ]);
modifier = (t.flip t.pipe) [
addBuildTools
hl.dontHaddock
hl.enableStaticLibraries
hl.justStaticExecutables
hl.disableLibraryProfiling
hl.disableExecutableProfiling
];
};
in {
packages.pkg = project [];
defaultPackage = self.packages.${system}.pkg;
devShell = project (with ghc; [
cabal-install
]);
});
}Grossièrement, ce fichier définit les entrées (ici : nixpkgs, pour récupérer les outils et bibliothèques Haskell nécessaires, et flake-utils, pour configurer le flake), et les sorties du flake (ici, un package et un environnement de développement correspondant).
On peut interroger la configuration du flake, par exemple pour connaitre ses sorties :
$ nix flake show --allow-import-from-derivation
path:/home/test/code/code/myproject-flake...
├───defaultPackage
│ └───x86_64-linux: package 'myproject-0.1.0.0'
├───devShell
│ └───x86_64-linux: development environment 'ghc-shell-for-myproject-0.1.0.0'
└───packages
└───x86_64-linux
└───pkg: package 'myproject-0.1.0.0'On peut alors lancer un environnement de développement :
$ nix develop
$ cabal build
Resolving dependencies...
Build profile: -w ghc-9.2.4 -O1
In order, the following will be built (use -v for more details):
- myproject-0.1.0.0 (lib) (first run)
- myproject-0.1.0.0 (exe:myproject) (first run)
...
$ cabal run
<h1>Hello World!</h1>Ou lancer le package (si besoin après avoir été recompilé) :
$ nix run
<h1>Hello World!</h1>Enfin, on peut également configurer le système avec des flakes et y inclure notre projet.
Voir aussi :
- Tweag, Nix Flakes Series
- Serokell, Practical Nix Flakes
- NixOS wiki, Flakes
- Getting started with Nix Flakes and devshell
- Simple nix flake for Haskell development
Conclusion
Pour développer en Haskell, il est généralement plus simple d’utiliser Ghcup. Si le projet est complexe (plusieurs langages de programmation, besoin de builds reproductibles, déploiements complexes…), alors il peut être intéressant d’utiliser Nix : soit l’environnement Haskell4nix (qui est plutôt complet et mature), soit l’environnement Flakes (qui apporte quelques améliorations concernant la reproductibilité, composabilité…).