Débuter avec Haskell sans prise de tête

Haskell a la réputation d’être un langage exigeant, réservé aux universitaires. C’est une image injuste. Certes, il repose sur des idées puissantes — fonctions pures, évaluation paresseuse, typage très expressif — mais on peut écrire son premier programme en quelques minutes. Le vrai obstacle historique était l’installation. Aujourd’hui, l’outillage a énormément mûri, et se mettre à Haskell est devenu presque trivial. Ce guide vous accompagne de l’installation aux notions fondamentales.

Oublier l’ancienne « Haskell Platform »

Pendant des années, on recommandait d’installer la Haskell Platform, un gros paquet regroupant le compilateur et des bibliothèques. Cette approche est aujourd’hui dépréciée. La communauté s’est ralliée à deux outils bien plus souples : GHCup et Stack. Tous deux gèrent proprement les versions du compilateur, ce qui évite les conflits qui décourageaient tant de débutants.

GHCup est le gestionnaire officiel : il installe GHC (le compilateur), Cabal (le gestionnaire de projets et de paquets) et l’excellent HLS (Haskell Language Server) qui apporte l’autocomplétion dans l’éditeur.
Stack est une alternative complète, appréciée pour ses snapshots de paquets testés ensemble, gage de builds reproductibles.

Pour un débutant, GHCup est le point de départ le plus simple.

Installer Haskell avec GHCup

L’installation se fait par un script unique. Sur Linux ou macOS :

curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

Sous Windows, GHCup fournit un installeur PowerShell dédié, documenté sur son site officiel. Le script est interactif : il propose d’installer GHC, Cabal, Stack et HLS. Acceptez les valeurs par défaut, c’est le choix recommandé.

Une fois terminé, vérifiez que tout répond :

ghc --version      # le compilateur
cabal --version    # le gestionnaire de projet
ghci --version     # l'interpréteur interactif

Côté éditeur, VS Code avec l’extension Haskell détecte automatiquement HLS et offre types au survol, autocomplétion et erreurs en direct — un confort qui change tout pour apprendre.

Votre premier programme

Créez un fichier bonjour.hs :

main :: IO ()
main = putStrLn "Bonjour, Coder Studio !"

La première ligne est une signature de type : elle annonce que main est une action d’entrée/sortie ne renvoyant rien d’utile (()). La seconde définit ce que fait main. On compile et on exécute :

ghc bonjour.hs -o bonjour
./bonjour

Vous pouvez aussi lancer directement le fichier sans produire d’exécutable avec runghc bonjour.hs, pratique pendant l’apprentissage.

GHCi, votre bac à sable

Le meilleur allié du débutant est GHCi, l’interpréteur interactif. Lancez-le avec la commande ghci. Vous obtenez une invite où tout s’essaie à la volée :

ghci> 2 + 3 * 4
14
ghci> reverse "Haskell"
"lleksaH"
ghci> map (*2) [1,2,3]
[2,4,6]
ghci> :type map
map :: (a -> b) -> [a] -> [b]

La commande :type (ou :t) affiche le type d’une expression : c’est l’outil idéal pour comprendre ce que fait une fonction. :load bonjour.hs charge votre fichier pour tester ses fonctions une par une. Prenez l’habitude de garder un GHCi ouvert à côté de votre éditeur.

Les trois idées clés à assimiler

Haskell tourne autour de quelques concepts qui le distinguent des langages impératifs. Les comprendre vaut mieux que d’accumuler de la syntaxe.

La pureté des fonctions

Une fonction pure renvoie toujours le même résultat pour les mêmes arguments et ne modifie rien d’extérieur. carre x = x * x est pure. Tout ce qui touche au monde réel — afficher, lire un fichier, obtenir l’heure — est isolé dans le type IO. Cette séparation stricte entre calcul pur et effets rend le code prévisible et facile à tester.

L’évaluation paresseuse

Haskell est paresseux : une expression n’est calculée que lorsque son résultat est réellement nécessaire. Conséquence surprenante, on peut manipuler des structures infinies :

ghci> take 5 [1..]
[1,2,3,4,5]

[1..] décrit la liste infinie des entiers, mais take 5 n’en force que les cinq premiers. La paresse permet des définitions élégantes, à condition d’en comprendre le coût mémoire dans certains cas.

Un typage fort et inféré

Le système de types de Haskell est strict mais rarement pénible, car le compilateur infère les types tout seul. Vous n’êtes pas obligé de tout annoter, mais écrire les signatures de vos fonctions est une excellente habitude : elles documentent le code et le compilateur vérifie qu’elles sont respectées. Beaucoup de bugs sont ainsi attrapés avant même l’exécution.

Démarrer un vrai projet

Dès que votre code dépasse un fichier, créez un projet structuré :

cabal init --simple
cabal run

Cela génère un fichier .cabal décrivant votre programme et ses dépendances. Pour ajouter une bibliothèque, on l’inscrit dans build-depends, et Cabal se charge de la télécharger depuis Hackage, le dépôt central de paquets Haskell.

Et ensuite ?

Vous avez maintenant un environnement fonctionnel et les repères mentaux essentiels. La suite logique consiste à pratiquer : listes, filtrage par motifs, types de données algébriques, puis les fameuses monades — qui paraissent mystérieuses mais ne sont, au fond, qu’une façon élégante d’enchaîner des calculs. Écrivez de petits programmes, gardez GHCi ouvert, et laissez le typage vous guider.