Automatically reloading ghci & running hlint on file updates

Question

I was thinking about my ideal haskell editing workflow:

• I open three terminals (split using iterm2).
• Terminal 1 runs vim for editing the haskell source files.
• Terminal 2 automatically runs hlint on the changed files whenenver a file in the current directory or subdirectory updates or is created
• Terminal 3 runs ghci, automatically loading/reloading the changed files.

Has anyone set up anything like this? The goal is to have hlint constantly watch my code for styling problems and for ghci be available for quick changes, without having to do anything other than saving the file in vim.

I was thinking of using something like watchr for the automation.

Answer 1

You can run arbitrary shell commands in vim using the BufWrite autocommand:

For example, put this in your ~/.vimrc:

au BufWrite *.hs !echo % >> ~/saves.txt 

This will run echo <CURRENT FILENAME> >> ~/saves.txt every time you save a haskell file.

So this is an easy way to trigger external scripts.

Now you can write some iterm scripts to relay commands to your other terminals. Something like:

tell my_ghci_terminal
  write text ":r\n"
end tell
tell my_hlint_terminal
  write text "<RUN HLINT ON WHATEVER>"
end tell

So you can use the vim autocommand to trigger the appropriate iterm script (passing the current file name so the script can tell ghci and hlint which file to process).

You'll probably want to toggle this on and off (you may not want to do this for EVERY haskell file), so think about wrapping the functionality in a vim function that lets you toggle it (as well as set arguments for how iterm should find your ghci and hlint terminals).

Answer 2

You could try to write a script for your editor that hooks into ghci and send ":r\n" whenever you hit C-s. I don't know how you could do that, but I am quite optimistic that there's a way using vim.

Answer 3

Not sure if you're still looking, but the solution to your auto-hlint problem is Syntastic, which automatically runs hlint or ghc-mod on your file and highlights lines/puts up in locations list the error/warnings/style warnings.

In addition, when you move your cursor onto that line, it displays the message/comment in the status bar.

Answer 4

https://github.com/ndmitchell/ghcid supports auto reloading GHCi upon file changes.

For example: ghcid '--command=stack ghci' --test=main

Answer 5

Script

Here's a script inotifywait-stack-ghci.hs:

#!/bin/sh


$(while inotifywait -e close_write $1; do pkill ghc; done) &

while inotifywait -e close_write $1
do 
    sleep 2
    stack ghci $1    
done

Invoking the script

I usually run it at a terminal like this:

exec ./inotifywait-stack-ghci.hs abc.hs

Notes

• It assumes that you only have one instance of ghc running.
• For some reason, you have to save the file twice for the reload to happen.
• Works if the file is edited in vscode or nano. vim and emacs seem to not work well with the script.

Suggestions on improving these issues are welcome!

Answer 6

I managed to get this setup with neovim and stack.

1. In vim config (I have it under ftplugin/haskell.vim)

augroup Terminal
  au!
  au TermOpen * let g:last_terminal_chan_id = b:terminal_job_id
augroup END

function ReloadGhci()
   let ghc_running = system("pgrep ghc")
   if ghc_running && get(g:, 'last_terminal_chan_id', 0)
      :silent! :call chansend(g:last_terminal_chan_id, ":r\<cr>")
   endif
endfunction

augroup reload_ghci
au!
au BufWritePost *.hs :call ReloadGhci()
augroup END

2. Open your main project folder in neovim
3. Open Terminal window ex. :vsplit term://zsh (I have it mapped to F5)
4. In Terminal Window stack repl
5. Now on save for .hs files it should send :r to terminal window.

This is not ideal as if you have opened two terminal windows one with stack repl and second one with something else, the latter will get the :r so you just have to be aware of it and keep one terminal opened in your nvim.