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.

For automatically running `hlint`, see my answer [here](http://stackoverflow.com/questions/6323150/sbt-like-features-in-the-haskell-build-ecosystem/6324784#6324784). GHCi is a bit trickier since it's interactive. — hammar, Oct 09 '11 at 19:02
IMO you don't really want ghci to automatically reload on change, since all bindings are lost. As I have the habit to occasionally hit `C-s` while typing, I would always be angry about myself, since I have to reload those temporary bindings. I could also place them in the file, but I am too lazy to do so. Reloading a file is as easy as pressing [:], [r], [enter] in that sequence, so what's the matter? — fuz, Oct 09 '11 at 19:14
@FUZxxl [Switch terminal] [:] [r] [enter] [switch terminal back] - five extra keystrokes (assuming [switch terminal] is only one), aside from CTRL-[ [:] [w] [enter] to save in vim. I'd much rather just send a brainwave to do it all without even lifting a finger. :) — Dan Burton, Oct 09 '11 at 20:37

score 8 · Accepted Answer · answered Oct 10 '11 at 19:27

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).

score 5 · Answer 2 · answered Jan 16 '18 at 12:09

5

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

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

answered Jan 16 '18 at 12:09

Chris Stryczynski

30,145
48
175
286

2

Worth noting from the README of ghcid is that it "doesn't provide access to the ghci it starts" – Marcus Buffett Jul 11 '20 at 16:24

score 2 · Answer 3 · answered Jul 28 '13 at 08:44

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.

score 1 · Answer 4 · answered Oct 09 '11 at 19:32

1

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.

answered Oct 09 '11 at 19:32

fuz

88,405
25
200
352

dharmatech · Answer 5 · 2021-07-28T20:13:27.603

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!

Adam · Answer 6 · 2021-12-18T21:39:31.073

I managed to get this setup with neovim and stack.

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

Open your main project folder in neovim
Open Terminal window ex. :vsplit term://zsh (I have it mapped to F5)
In Terminal Window stack repl
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.

Automatically reloading ghci & running hlint on file updates

6 Answers6

Script

Invoking the script

Notes