Haskell layer

• syntax highlighting for haskell source, cabal files, C– source
• auto-completion and syntax-checking with one of the selected backends (dante or lsp).

To use this configuration layer, add it to your ~/.spacemacs. You will need to add haskell to the existing dotspacemacs-configuration-layers list in this file.

This layer requires some cabal packages:

• apply-refact (required by hlint-refactor)
• hlint (required by hlint-refactor)
• stylish-haskell (optional for haskell-mode)
• hasktags (optional)
• hoogle (optional for haskell-mode and helm-hoogle)

To install them, use the following command (or the stack equivalent):

$ cabal install apply-refact hlint stylish-haskell hasktags hoogle

First of all, make sure that your $PATH contains the installation path for Haskell tools like ghc, ghci etc. It depends on how you have installed ghc, but you can always check it by running which ghc in your terminal. Stack users should only add the installation path of stack itself. Usually it's ~/.local/bin.

Then make sure that your $PATH contains the installation path for the cabal packages. If you are using cabal it should be ~/.cabal/bin or ~/Library/Haskell/bin (for 'Haskell for Mac' users). If you are using stack then it should be ~/.local/bin.

For more information about setting up $PATH, check out the corresponding section in the FAQ (SPC h SPC $PATH RET).

Language backend is the core component of a language layer - it has the responsibility of compiling/parsing the actual code and reporting errors, warnings, suggesting fixes, auto-completions and more.

To get the most out of the language backend, you will want to ensure that you have auto-completion and syntax-checking layers enabled.

Then, to choose a haskell backend, set the haskell layer variable haskell-completion-backend:

(haskell :variables haskell-completion-backend 'dante)

Supported values for haskell-completion-backend are dante and lsp.

If you don't specify any value for haskell-completion-backend, dante will be used as default backend, unless the layer lsp is enabled, in which case lsp is used as default backend.

Backend can be chosen on a per project basis using directory local variables (files named .dir-locals.el at the root of a project). An example of .dir-locals.el to use the lsp backend:

;;; Directory Local Variables
;;; For more information see (info "(emacs) Directory Variables")

((haskell-mode (haskell-completion-backend . lsp)))

Note: you can easily add a directory local variable with SPC f v d.

There are two backends available: dante and lsp.

dante is lightweight, requires no setup and works out of the box in most cases, which is why it is also a default backend.

lsp (hie or hls) is a more ambitious, heavy-weight, cutting-edge backend that is however still somewhat rough on the edges and requires some additional setup.

The Haskell layer supports some extra features, which can be enabled through the layer variables.

Documentation commands are prefixed by SPC m h

Debug commands are prefixed by SPC m d:

REPL commands are prefixed by SPC m s:

Cabal commands are prefixed by SPC m c:

These commands are available in a cabal file.

Refactor commands are prefixed by SPC m r:

Only some of the HLint suggestions can be applied.

This is the standard Spacemacs way of syntax checking, and it's also the most elaborate. You need to install the syntax-checking layer first, which will bring flycheck. Please read the layer's documentation on how to interact with flycheck.

Flycheck has different Haskell checkers: haskell-dante, haskell-ghc, haskell-stack-ghc and haskell-hlint. Normally it can detect the best one to use automatically, but if it doesn't work, then you can change it with SPC e s.

HLint is a linter for Haskell. It doesn't detect errors (as long as it can parse the file) but bad coding style and code smell. The HLint checker is called after the flycheck GHC checker.

HLint can be configured per project via .hlint.yaml (check Hlint docs for more details).

The cause might be that Dante is not loading appropriate packages for the test suite target, instead it is loading packages for the library.

Solution is to create .dir-local.el in the directory where the test suite (usually test/ or tests/) is and to put the line ((haskell-mode . ((dante-target . "--test")))) into it. This tells Dante to use test suite target when working with test files.

Usually haskell-mode is great at figuring out which interactive process to bring up. But if you are experiencing problems with it, then you can help haskell-mode by setting haskell-process-type as in following code:

(setq-default dotspacemacs-configuration-layers
  '((haskell :variables haskell-process-type 'stack-ghci)))

Available options are:

• ghci
• cabal-repl
• cabal-new-repl
• cabal-dev
• cabal-ghci
• stack-ghci

Make sure that there's a space between the REPL's λ> prompt and the cursor. When there is no space, then the REPL will behave as if it's stuck. Usually, when you enter normal state, the cursor moves backwards by one character, so there is no required space when you switch to insert mode. There is a possible workaround - just add the following snippet to your dotspacemacs/user-config function:

(when (configuration-layer/layer-used-p 'haskell)
  (add-hook 'haskell-interactive-mode-hook
            (lambda ()
              (setq-local evil-move-cursor-back nil))))

It makes the cursor stay in the right place in the REPL buffer when you enter normal state. Which in most cases helps you to avoid the problem with 'stuck' REPL.

Also, some users might want to start the REPL in insert mode. This is done by placing the following snippet in your dotspacemacs/user-config function:

(when (configuration-layer/layer-used-p 'haskell)
  (define-advice haskell-interactive-switch (:after (&rest _) spacemacs/haskell-interactive-switch-advice)
    (when (eq dotspacemacs-editing-style 'vim)
      (call-interactively 'evil-insert))))

This is the intended behavior in haskell-indentation-mode. If you want to reset the indentation when pressing return after an empty line, add the following snippet into your dotspacemacs/user-config function.

(defun haskell-indentation-advice ()
  (when (and (< 1 (line-number-at-pos))
             (save-excursion
               (forward-line -1)
               (string= "" (s-trim (buffer-substring (line-beginning-position) (line-end-position))))))
    (delete-region (line-beginning-position) (point))))

(advice-add 'haskell-indentation-newline-and-indent
            :after 'haskell-indentation-advice)

The HLint checker is called after the normal flycheck checker, even if the checker fails. Check the Flycheck doesn't work section.

If HLint is not correctly configured (e.g. does not load some extensions that you are using in your project) it might fail while parsing the file.

Check HLint docs for more details.

The error list is only set by flycheck. You are probably seeing errors highlighted by haskell-mode. Check the Flycheck doesn't work section.

You can use the flycheck-compile command to check what's wrong with flycheck. This will show you the exact command line that's used, and its output.

If you are using stack, check the Flycheck doesn't work with stack section.

First check that flycheck uses the correct checker, and all the paths are properly configured using flycheck-verify-setup (SPC e v). You can force the checker with flycheck-select-checker (SPC e s) to ensure that it uses haskell-stack-ghc. If it still doesn't work, then it could be one of the following problems:

• The stack build directory is wrong
• The project root is not set properly

Some (most) of the haskell-mode commands only work when haskell-mode is in interactive mode, i.e. has an interactive session associated with it. Load it using SPC m s b.