Vous avez trois choix.
Plateforme Haskell
C'est une possibilité mais pas un choix populaire pour de nombreuses raisons que vous découvrirez en temps voulu si vous choisissez de suivre cette voie. Vous aurez une bien meilleure expérience et obtiendrez beaucoup meilleur support avec Stack ou Nix. Laquelle de ces deux personnes utilise semble être principalement une question de préférence personnelle. Ce sont des bêtes différentes, mais pour un débutant, les différences ne seront pas immédiatement évidentes, il y a donc peu d'espoir que vous puissiez prendre une "décision éclairée". Choisissez-en un et réévaluez-le plus tard.
Empiler
C'est ce que je suggérerais à tous ceux (qui ne connaissent pas Nix) qui souhaitent démarrer rapidement avec Haskell. Période. Vous n'avez pas besoin d'installer quoi que ce soit séparément, Stack gérera tous les éléments Haskell pour vous. Normalement, vous n'utilisez jamais cabal directement avec Stack. stack build utilise la cabale en interne, mais vous n'avez pas à vous en soucier. Une chose à noter, Stack n'est pas un gestionnaire de paquets. C'est un outil de construction. Normalement, il ne s'installe n'importe quoi. Il récupère cependant toutes les dépendances dont il a besoin et les stocke dans ~/.stack avec d'autres choses.
Nix
C'est ce que j'utilise personnellement donc j'ai peut-être un parti pris mais je pense que c'est globalement la meilleure solution à long terme. La mise en garde est qu'il y a une courbe d'apprentissage assez abrupte et que vous avez de nombreuses chances de vous tirer une balle dans le pied au début.
Je vous recommande vivement de commencer par Stack, mais de garder l'esprit ouvert à propos de Nix pendant que votre voyage avec Haskell se poursuit.
Voici une (longue) réponse alternative. Notez que je recommandais également Stack aux débutants, mais j'ai changé d'avis depuis.
TL;DR : La plate-forme Haskell ou une installation Stack pure peut vous fournir tout ce dont vous avez besoin, et vous ne « manquerez » rien en choisissant l'un ou l'autre. Vous trouverez probablement plus facile d'ignorer Stack et d'installer la plate-forme Haskell à l'aide du programme d'installation Linux "générique", car il est livré avec tout ce dont vous avez besoin et la configuration correspondra plus étroitement à ce qui est décrit dans le livre LYAH. Vous pouvez installer Stack plus tard lorsque vous effectuez un développement plus sérieux sur plusieurs projets. Si vous préférez vous en tenir à une installation Stack pure, je vous suggère de commencer par un flux de travail "projet global uniquement". Dans les deux cas, vous pouvez utiliser le "mode haskell" avec certains correctifs de configuration suggérés ci-dessous (y compris un paramètre de clé qui sera requis si vous travaillez dans le projet global d'une installation Stack uniquement).
Voici la réponse longue...
Pile contre plate-forme contre cabale
Le livre LYAH est antérieur à Stack, ce qui est certainement la principale raison pour laquelle il ne le mentionne pas. Sur haskell.org, ils recommandent d'utiliser soit un programme d'installation minimal, Stack, soit la plate-forme Haskell. Les trois méthodes sont des moyens parfaitement raisonnables en 2018 de mettre en place un environnement Haskell fonctionnel. Ils diffèrent à la fois dans la manière dont ils choisissent d'isoler différentes versions du compilateur et/ou des bibliothèques dans des "bacs à sable" pour le travail de développement, et dans la quantité qu'ils installent initialement , mais il ne manque rien à aucun d'entre eux qui ne puisse être installé à la demande. Selon ce que vous choisissez, il y aura des différences dans votre flux de travail (voir ci-dessous).
Stack et Cabal sont à la fois des gestionnaires de packages et des outils de construction. (Stack a la capacité supplémentaire de réellement amorcer une installation complète de Haskell, c'est pourquoi c'est aussi une méthode d'installation à part entière.) Pendant que vous travaillez avec LYAH, vous n'utiliserez pas directement la fonctionnalité "outil de construction" sur vos propres projets. (Les fonctionnalités de construction intégrées de GHC sont plus que suffisantes pour créer de petits projets multi-modules.) Vous aurez juste besoin de la fonctionnalité de gestionnaire de packages pour installer des bibliothèques supplémentaires.
Étant donné que Stack et Cabal gèrent leurs packages séparément, si vous utilisez Stack, vous n'aurez pas particulièrement besoin d'utiliser Cabal directement. Vous pouvez l'installer si vous le souhaitez (et en fait, Stack utilise Cabal pour certaines fonctionnalités ésotériques, comme "stack solver", et exigera qu'il soit installé dans ces cas) :
$ stack install cabal-install
Mais, même si cela mettra "cabal" dans "$HOME/.local/bin" (et vous voudrez vous assurer que c'est dans votre chemin), vous constaterez que vous devez sauter à travers des cerceaux pour l'exécuter :
$ stack exec --no-ghc-package-path cabal -- list
et cela ne fait vraiment rien d'utile en ce qui concerne votre environnement Stack.
Mise à jour : Une note sur le chemin "$HOME/.local/bin". Il semble que le script d'installation de https://get.haskellstack.org/ puisse installer Stack lui-même sur /usr/local/bin/stack par défaut s'il n'y a pas d'installation existante. Cependant, il devrait afficher un avertissement pour mettre $HOME/.local/bin dans votre chemin. Si vous mettez à niveau Stack à l'avenir avec stack upgrade , il installera la nouvelle version de stack là, et ce répertoire sera également utilisé si vous installez des packages qui incluent des binaires. Par exemple, stack install hlint installera le programme Haskell Lint hlint à ce répertoire. C'est donc une bonne idée de l'avoir sur votre chemin et quelque part avant /usr/local/bin .
Ce qui manque avec Stack
Je pense que cela couvre vos trois premières questions. Pour votre dernier, la principale chose qui vous manque après avoir installé Stack au lieu de la plate-forme Haskell est que, de par sa conception, Stack n'installe pas vraiment quoi que ce soit d'autre que la "pile" elle-même. Ainsi, tout votre travail Haskell, y compris l'exécution de l'interpréteur Haskell ("ghci") ou du compilateur ("ghc"), tout doit être fait dans un environnement Stack, soit en utilisant une commande Stack correspondante spécifique :
$ echo 'main = putStrLn "Hello, world!"' > Hello.hs
$ stack ghc -- Hello.hs
[1 of 1] Compiling Main ( Hello.hs, Hello.o )
Linking Hello ...
$ ./Hello
Hello, world!
$
ou bien en utilisant "stack exec" pour exécuter un programme générique dans un environnement Stack approprié. Par exemple, il peut parfois être utile d'exécuter un shell Bash sous la pile, après quoi les choses se comportent un peu comme un environnement de plate-forme Haskell installé globalement :
$ stack exec bash
$ ghci
GHCi, version 8.2.2: http://www.haskell.org/ghc/ :? for help
Prelude> :quit
$ ghc -O2 Hello.hs
[1 of 1] Compiling Main ( Hello.hs, Hello.o ) [flags changed]
Linking Hello ...
$ exit
$ ghc
The program 'ghc' is currently not installed. ...
$
L'autre chose qui vous manque est que la plate-forme Haskell installe par défaut tout un tas de bibliothèques communes, tandis qu'un nouvel environnement Stack démarre avec presque rien (pas même le compilateur, avant d'exécuter stack setup ). Lorsque vous travaillez avec LYAH, vous devrez peut-être installer périodiquement des bibliothèques supplémentaires. Par exemple, dans les Entrée et Sortie chapitre, les exemples utilisant des nombres aléatoires (module System.Random ) vous demandera d'exécuter :
$ stack install random
et redémarrez votre interpréteur.
Recommandation pour utiliser la plate-forme Haskell
Étant donné que Stack est un peu compliqué et que vous n'aurez pas vraiment besoin des fonctionnalités qu'il fournit au début, vous trouverez peut-être la plate-forme Haskell plus facile à utiliser lorsque vous débutez. (Le programme d'installation « Générique » devrait fonctionner correctement sur votre distribution.) Il est livré avec tout ce qui est installé, et la façon dont vous l'utilisez correspondra plus étroitement à la façon dont les choses sont décrites dans LYAH. Avec haskell-mode , vous devriez avoir un environnement Haskell assez décent.
En général, il ne devrait y avoir aucun problème à installer Stack et la plate-forme Haskell côte à côte (comme en témoigne le fait que la plate-forme Haskell inclut Empiler). Stack conservera tout séparément dans le sous-répertoire "$HOME/.stack", il n'y aura donc aucune interférence entre les compilateurs ou les packages ou quoi que ce soit. Notez que dans cette configuration, vous utiliserez cabal pour gérer les packages installés du côté de la plate-forme, et stack -- évidemment -- pour gérer les packages côté Stack.
Flux de travail débutant pour une installation Pure Stack
Si vous souhaitez vous en tenir à votre installation Stack pure, je pourrais suggérer le flux de travail suivant lorsque vous débutez :
Vous verrez des références aux projets Stack, créés avec "stack new" ou "stack init". Évitez-les au début et restez avec la pile "projet global". Il s'agit du projet implicite qui sera effectif lorsque vous exécuterez "stack" dans un répertoire qui n'a pas de fichier "stack.yaml" (directement ou dans un répertoire parent) :
$ cd
$ stack path --project-root
/u/buhr/.stack/global-project
$
Lorsque vous travaillez dans le projet global (c'est-à-dire pas quelque part sous un stack.yaml file), vous pouvez invoquer l'interpréteur et le compilateur avec :
$ stack exec ghci
$ stack ghc -- -O2 Hello.hs
et ils auront tous deux accès à toutes les bibliothèques supplémentaires (packages) que vous avez installées à l'aide de commandes telles que :
$ stack install random
Mise à jour : Une note sur la différence entre stack ghci et stack exec ghci . Le premier est destiné à exécuter GHCi dans le cadre d'un projet local (c'est-à-dire, travailler sous un stack.yaml dossier). Il passe quelques indicateurs supplémentaires pour masquer les packages installés globalement et pour rendre automatiquement disponibles les modules de votre package. Lorsque vous travaillez dans le projet global, je ne pense pas qu'il y ait de différence pratique, sauf que stack ghci génère un avertissement ; et peu importe ce que vous utilisez, vous devrez charger vos propres modules explicitement avec :load Whatever.hs . Il y a un peu plus d'informations sur la différence sur cette page de documentation Stack, en particulier en bas où elle essaie d'expliquer la différence.
Finalement, vous pouvez basculer vers un flux de travail qui utilise des projets Stack. Cela impliquera d'utiliser stack new pour créer un nouveau répertoire de projet Stack, stack setup pour installer/lier une version privée du compilateur dans ce répertoire, puis modifier le xxx.cabal du projet fichier (et éventuellement son stack.yaml file) pour indiquer quels packages supplémentaires sont requis, au lieu d'utiliser stack install . C'est un peu compliqué quand on veut juste commencer à écrire du code.
Vous pouvez également voir une référence à Intero, un mode Emacs conçu spécifiquement pour Stack. Intero est très agréable, mais il ne fonctionne pas très bien lorsque vous travaillez sur des fichiers dans le projet global. Il aura tendance à vouloir démarrer l'interpréteur dans le répertoire "~/.stack/global-project", ce qui est assez inutile. (J'utilise Intero, mais je l'ai corrigé pour mieux se comporter à cet égard.)
Configuration du mode Haskell (pour la plate-forme ou la pile)
Il est probablement préférable de s'en tenir au "mode haskell" à la place et de penser à Intero lorsque vous commencez à utiliser des projets non globaux. Je suggérerais d'installer "haskell-mode" à partir de MELPA conformément aux instructions, mais en ajoutant ce qui suit à votre .emacs fichier au lieu de ce qui est suggéré dans la documentation :
(require 'haskell)
;; add capability to submit code to interpreter and mark errors
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)
;; add missing keybindings for navigating errors
(define-key interactive-haskell-mode-map (kbd "M-n") 'haskell-goto-next-error)
(define-key interactive-haskell-mode-map (kbd "M-p") 'haskell-goto-prev-error)
(define-key interactive-haskell-mode-map (kbd "C-c M-p")
'haskell-goto-first-error)
;; merge this with your existing custom-set-variables
(custom-set-variables
;; NOTE: include following line to work around haskell-mode
;; bug if using GHC >= 8.2.1.
;; See: https://github.com/haskell/haskell-mode/issues/1553
'(haskell-process-args-stack-ghci
'("--ghci-options=-ferror-spans -fshow-loaded-modules"
"--no-build" "--no-load"))
;; some options suggested in the haskell-mode documentation
'(haskell-process-auto-import-loaded-modules t)
'(haskell-process-log t)
'(haskell-process-suggest-remove-import-lines t)
;; make sure "stack ghci" is used, even in the global project
'(haskell-process-type 'stack-ghci))
J'ai testé cela avec une installation Stack pure en utilisant "haskell-mode-20171022.26", et cela semble bien fonctionner. Je peux charger un nouveau fichier Haskell dans le projet global, le soumettre à une session interactive avec "C-c C-l" et parcourir les erreurs en surbrillance dans le fichier source avec "M-n" et "M-p". (Les erreurs apparaissent dans le mini-buffer.)
Si vous décidez d'utiliser la plate-forme Haskell à la place, je pense que toute cette configuration en "mode haskell" s'appliquera toujours, sauf que vous devez supprimer la toute dernière ligne de personnalisation. (Le haskell-process-type par défaut de auto choisira quelque chose d'approprié.)
J'espère que ça aide !