Solución:
Aquí hay una respuesta alternativa (larga). Tenga en cuenta que también solía recomendar Stack para principiantes, pero desde entonces he cambiado de opinión.
TL; DR: Tanto la plataforma Haskell como la instalación pura de Stack pueden proporcionarle todo lo que necesita, y no se perderá nada eligiendo una u otra. Probablemente le resulte más fácil omitir Stack e instalar Haskell Platform usando el instalador de Linux “genérico”, porque viene con todo lo que necesita y la configuración coincidirá más estrechamente con lo que se describe en el libro LYAH. Puede instalar Stack más tarde cuando esté realizando un desarrollo más serio en varios proyectos. Si prefiere seguir con una instalación pura de Stack, le sugiero que comience con un flujo de trabajo de “solo proyecto global”. De cualquier manera, puede usar “haskell-mode” con algunas correcciones de configuración sugeridas a continuación (incluida una configuración clave que será necesaria si está trabajando en el proyecto global de una instalación solo de pila).
Aquí está la respuesta larga …
Pila vs.Plataforma vs.Cabal
El libro de LYAH es anterior a Stack, que es sin duda la principal razón por la que no lo menciona. En haskell.org, recomiendan usar un instalador mínimo, Stack o la plataforma Haskell. Los tres métodos son formas perfectamente razonables en 2018 para configurar un entorno Haskell que funcione. Se diferencian tanto en la forma en que eligen aislar las diferentes versiones del compilador y / o las bibliotecas en “entornos aislados” para el trabajo de desarrollo, como en la cantidad de instalación. inicialmente, pero no hay nada que “falte” en ninguno de ellos que no se pueda instalar bajo demanda. Dependiendo de lo que elija, habrá algunas diferencias en su flujo de trabajo (ver más abajo).
Tanto Stack como Cabal son administradores de paquetes y herramientas de compilación combinados. (Stack tiene la capacidad adicional de iniciar una instalación completa de Haskell, razón por la cual también es un método de instalación por derecho propio). Mientras trabaja con LYAH, en realidad no utilizará la funcionalidad de “herramienta de compilación” directamente en sus propios proyectos. (Las funciones de compilación integradas de GHC son más que adecuadas para compilar proyectos pequeños de varios módulos). Solo necesitará la funcionalidad del administrador de paquetes para instalar bibliotecas adicionales.
Dado que Stack y Cabal administran sus paquetes por separado, si usa Stack, no tendrá una necesidad particular de usar Cabal directamente. Puede instalarlo si lo desea (y, de hecho, Stack hace uso de Cabal para algunas funciones esotéricas, como “solucionador de pila”, y requerirá que se instale en esos casos):
$ stack install cabal-install
Pero, aunque esto pondrá “cabal” en “$ HOME / .local / bin” (y querrá asegurarse de que esto esté en su camino), encontrará que necesita saltar a través de aros para ejecutarlo :
$ stack exec --no-ghc-package-path cabal -- list
y realmente no hace nada útil en lo que respecta a su entorno Stack.
Actualizar: Una nota sobre la ruta “$ HOME / .local / bin”. Parece que el script de instalación de https://get.haskellstack.org/ puede instalar Stack para /usr/local/bin/stack de forma predeterminada si no hay ninguna instalación existente. Sin embargo, debería mostrar una advertencia para poner $HOME/.local/bin en tu camino. Si actualiza Stack en el futuro con stack upgrade, instalará la nueva versión de stack allí, y ese directorio también se utilizará si instala paquetes que incluyen binarios. Por ejemplo, stack install hlint instalará el programa Haskell Lint hlint a ese directorio. Por lo tanto, es una buena idea tenerlo en tu camino y en algún lugar antes /usr/local/bin.
¿Qué falta con Stack?
Creo que eso cubre tus tres primeras preguntas. Por último, lo principal que le falta al haber instalado Stack en lugar de la plataforma Haskell es que, por diseño, Stack realmente no instala nada globalmente más que “stack” en sí. Por lo tanto, todo su trabajo de Haskell, incluida la ejecución del intérprete de Haskell (“ghci”) o el compilador (“ghc”), todo debe realizarse dentro de un entorno Stack, ya sea utilizando un comando Stack correspondiente específico:
$ 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!
$
o bien usando “stack exec” para ejecutar un programa genérico dentro de un entorno Stack apropiado. Por ejemplo, a veces puede ser útil ejecutar un shell Bash debajo de la pila, después de lo cual las cosas se comportan como un entorno de plataforma Haskell instalado globalmente:
$ 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. ...
$
La otra cosa que te falta es que la plataforma Haskell instala un montón de bibliotecas comunes de forma predeterminada, mientras que un nuevo entorno Stack comienza con casi nada (ni siquiera el compilador, antes de ejecutar stack setup). Mientras trabaja con LYAH, es posible que necesite instalar periódicamente bibliotecas adicionales. Por ejemplo, en el Entrada y salida capítulo, los ejemplos que utilizan números aleatorios (módulo System.Random) requerirá que ejecute:
$ stack install random
y reinicie su intérprete.
Recomendación para utilizar la plataforma Haskell
Debido a que Stack es un poco complicado y realmente no necesitará las facilidades que brinda al principio, es posible que la plataforma Haskell le resulte más fácil de usar cuando esté comenzando. (El instalador “genérico” debería funcionar bien en su distribución). Viene con todo instalado, y la forma en que lo usa coincidirá más estrechamente con la forma en que se describen las cosas en LYAH. Juntos con haskell-mode, deberías tener un entorno Haskell bastante decente.
En general, no debería haber ningún problema para tener Stack y la plataforma Haskell instalados uno al lado del otro (como lo demuestra el hecho de que la plataforma Haskell realmente incluye Apilar). Stack mantendrá todo por separado bajo el subdirectorio “$ HOME / .stack”, por lo que no habrá interferencia entre compiladores o paquetes ni nada. Tenga en cuenta que en esta configuración, utilizará cabal para administrar los paquetes instalados en el lado de la plataforma, y stack – obviamente – para administrar paquetes en el lado de la pila.
Flujo de trabajo para principiantes para una instalación de pila pura
Si desea seguir con su instalación pura de Stack, podría sugerir el siguiente flujo de trabajo cuando esté comenzando:
Verá referencias a proyectos Stack, creados con “stack new” o “stack init”. Evítelos al principio y quédese con el “proyecto global” de la pila. Este es el proyecto implícito que estará en vigor cuando ejecute “stack” en un directorio que no tenga un archivo “stack.yaml” (directamente o en un directorio principal):
$ cd
$ stack path --project-root
/u/buhr/.stack/global-project
$
Cuando está trabajando en el proyecto global (es decir, no en algún lugar bajo un stack.yaml file), puede invocar el intérprete y el compilador con:
$ stack exec ghci
$ stack ghc -- -O2 Hello.hs
y ambos tendrán acceso a las bibliotecas (paquetes) adicionales que haya instalado usando comandos como:
$ stack install random
Actualizado: Una nota sobre la diferencia entre stack ghci y stack exec ghci. El primero está destinado a ejecutar GHCi dentro del contexto de un proyecto local (es decir, trabajar bajo un stack.yaml expediente). Pasa algunas banderas adicionales para ocultar los paquetes instalados globalmente y hacer que los módulos estén disponibles automáticamente desde su paquete. Cuando trabajo en el proyecto global, no creo que haya ninguna diferencia práctica excepto que stack ghci genera una advertencia; y no importa cuál uses, necesitarás cargar tus propios módulos explícitamente con :load Whatever.hs. Hay un poco más de información sobre la diferencia en esta página de documentación de Stack, particularmente en la parte inferior donde intenta explicar la diferencia.
Eventualmente, puede cambiar a un flujo de trabajo que use proyectos Stack. Esto implicará usar stack new para crear un nuevo directorio de proyectos de Stack, stack setup para instalar / vincular una versión privada del compilador en ese directorio, y luego modificar el proyecto xxx.cabal archivo (y posiblemente su stack.yaml file) para indicar qué paquetes adicionales se requieren, en lugar de usar stack install. Todo es un poco complicado cuando solo quieres empezar a escribir código.
También puede ver una referencia a Intero, un modo de Emacs diseñado específicamente para Stack. Intero es muy bueno, pero no funciona muy bien cuando se trabaja con archivos en el proyecto global. Tendrá tendencia a querer iniciar el intérprete en el directorio “~ / .stack / global-project”, lo cual es bastante inútil. (Yo uso Intero, pero lo parcheé para que se comporte mejor a este respecto).
Configuración del modo Haskell (para plataforma o pila)
Probablemente sea mejor seguir con el “modo haskell” y pensar en Intero cuando empiece a utilizar proyectos no globales. Sugeriría instalar “haskell-mode” de MELPA según las instrucciones, pero agregando lo siguiente a su .emacs archivo en lugar de lo que se sugiere en la documentación:
(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))
Probé esto con una instalación pura de Stack usando “haskell-mode-20171022.26”, y parece que funciona bien. Puedo cargar un nuevo archivo Haskell en el proyecto global, enviarlo a una sesión interactiva con “Cc Cl” y buscar errores resaltados en el archivo fuente con “Mn” y “Mp”. (Los errores aparecen en el mini-búfer).
Si decide utilizar la plataforma Haskell en su lugar, creo que toda esta configuración de “modo haskell” se aplicará, excepto que debe eliminar la última línea de personalización. (El valor por defecto haskell-process-type de auto elegirá algo apropiado.)
¡Espero que ayude!
Tienes tres opciones.
Plataforma Haskell
Es una posibilidad, pero no una opción popular, por muchas razones que descubrirás a su debido tiempo si eliges ir por este camino. Tendrás una experiencia mucho mejor y obtendrás mucho mejor soporte con Stack o Nix. Cuál de esas dos personas usa parece ser principalmente una preferencia personal. Son bestias diferentes, pero para un principiante las diferencias no serán obvias de inmediato, por lo que hay pocas esperanzas de que pueda tomar una “decisión informada”. Simplemente elija uno y reevalúe más tarde.
Apilar
Esto es lo que le sugeriría a cualquiera (que no esté familiarizado con Nix) que desee comenzar con Haskell rápidamente. Período. No es necesario que instales nada por separado, Stack se encargará de todas las cosas de Haskell por ti. Normalmente nunca usas cabal directamente con Stack. stack build usa cábala internamente pero no necesitas preocuparte por eso. Una cosa a tener en cuenta, Stack no es un administrador de paquetes. Es una herramienta de construcción. Normalmente no Instalar en pc cualquier cosa. Sin embargo, recupera todas las dependencias que necesita y las almacena en ~/.stack junto con otras cosas.
Nada
Esto es lo que uso personalmente, por lo que puedo estar sesgado, pero creo que esta es la mejor solución en general a largo plazo. La advertencia es que hay una curva de aprendizaje bastante empinada y se le dan muchos posibilidades de dispararse en el pie al comenzar.
Recomiendo encarecidamente comenzar con Stack, pero mantener la mente abierta sobre Nix a medida que continúa su viaje con Haskell.