dpren/haskell-ide-engine

The engine for haskell ide-integration. Not an IDE

Haskell IDE Engine

This project aims to be the universal interface to a growing number of Haskell tools, providing a full-featured and easy to query backend for editors and IDEs that require Haskell-specific functionality.

We are currently focusing on using the Language Server Protocol as the interface via which we talk to clients.

• Haskell IDE Engine
  • Features
  • Installation
    • Installation with stack or Nix
    • ArchLinux
  • Editor Integration
    • Using HIE with VS Code, Sublime Text, Neovim or Atom
  • Hoogle Docs on hover
  • Contributing
    • Planned Features
    • This is not yet another ghc-mod or ide-backend project
    • It's time to join the project!
    • Development
  • Architecture
    • 1. BIOS layer
    • 2. Plugin layer
    • 3. IDE interfacing layer
  • Documentation

Features

• Supports plain GHC projects, cabal projects(sandboxed and non sandboxed) and stack projects

• Fast due to caching of compile info

• Uses LSP, so should be easy to integrate with a wide selection of editors

• Diagnostics via hlint and GHC warnings/errors

  

• Code actions and quick fixes via apply-refact

  

• Type information and documentation(via hoogle) on hover

  

• Jump to definition

  

• List all top level definitions

  

• Highlight references in document

  

• Completion

  

• Formatting via brittany

  

• Renaming via HaRe

  

Installation

Both methods build HIE from the source code, so first,

$ git clone https://github.com/haskell/haskell-ide-engine
$ cd haskell-ide-engine

Installation with stack

To install HIE, you need Stack version >= 1.6.1

For GHC 8.2.2

stack install

For GHC 8.2.1

stack --stack-yaml=stack-8.2.1.yaml install

For GHC 8.0.2

stack --stack-yaml=stack-8.0.2.yaml install

Installation on Windows

In order to avoid problems with long paths you can do the following:

1. Edit the group policy: set "Enable Win32 long paths" to "Enabled". Works only for Windows 10

2. Clone the haskell-ide-engine to the root of your logical drive (e.g. to E:\hie)

Installation with Nix

Alternatively, given that you have Nix installed:

$ stack install --nix

ArchLinux

An haskell-ide-engine-git package is available on the AUR.

Using Aura:

$ aura -A haskell-ide-engine-git

Editor Integration

All of the editor integrations assume that you have already installed HIE (see above) and that stack put the hie binary in your path (usually ~/.local/bin on linux and macOS).

Using HIE with VS Code

Install from the VSCode marketplace, or manually from the repository vscode-hie-server.

Using HIE with Sublime Text

• Make sure HIE is installed (see above) and directory stack put the hie binary in is in your path
  • (usually ~/.local/bin on unix)
• Install LSP using Package Control
• From Sublime Text, press Command+Shift+P and search for Preferences: LSP Settings
• Paste in these settings. Make sure to change the command path to your hie

"clients": {
  "haskell-ide-engine": {
    "command": ["hie", "--lsp"],
    "scopes": ["source.haskell"],
    "syntaxes": ["Packages/Haskell/Haskell.sublime-syntax"],
    "languageId": "haskell",
  },
},

Now open a haskell project with Sublime Text. You should have these features available to you:

1. Errors are underlined in red
2. LSP: Show Diagnostics will show a list of hints and errors
3. LSP: Format Document will prettify the file

Using HIE with Neovim

As above, make sure HIE is installed. Install and load the neovim plugin LanguageClient. If you use vim-plug, then you can do this by e.g. including the following line in the Plug section of your init.vim:

Plug 'autozimu/LanguageClient-neovim', {
    \ 'branch': 'next',
    \ 'do': './install.sh'
    \ }

and issuing a :PlugInstall command within neovim.

Finally, make sure that hie is included as the language server source for haskell:

let g:LanguageClient_serverCommands = {
    ...
    \ 'haskell': ['hie', '--lsp'],
    ...
    \ }

For asynchronous auto-completion, follow the setup instructions on LanguageClient.

Using HIE with Atom

Make sure HIE is install, then install the two Atom packages atom-ide-ui and ide-haskell-hie,

$ apm install atom-ide-ui ide-haskell-hie

Hoogle Docs on hover

HIE supports fetching docs from hoogle on hover. It can use the Hoogle database for your user, or a project specific database.

To generate a global hoogle database for your user from hackage, run

$ hoogle generate

To generate a global database for a stack installation, run

$ stack exec hoogle generate

To generate a project specific database for a stack project, run

$ stack hoogle
$ stack build

To generate a project specific database for a sandboxed cabal project, run

$ cabal install --enable-documentation --haddock-hoogle
$ hoogle generate --database=hiehoogledb.hoo --local=.

in the root dir of your cabal project

If you don't have the dependencies built with haddock/documentation enabled, you need to remove the sandbox and build everything again before running the commands given above

$ cabal sandbox delete
$ cabal sandbox init

To generate a project specific database for a non-sandboxed cabal project, run

$ cabal install
$ hoogle generate --local --database=hiehoogledb.hoo

If HIE detects a project specific hoogle DB, it will use it over the global db.

Contributing

Planned Features

• Multiproject support
• Project wide references
• Cross project find definition
• New-build support
• HaRe refactorings
• More code actions
• Cross project/dependency Find Definition
• Case splitting, type insertion etc.

This is not yet another ghc-mod or ide-backend project

Both the ghc-mod and ide-backend maintainers have agreed to contribute code to this new repository and then rebase the old repos on this. The reason we're using a new repo instead of modifying one of the existing ones is so that the existing projects experience no disruption during this migration process. If this was a new set of people starting a new project without support from existing projects, I'd agree with you. But Alan's reached out to existing players already, which is an important distinction.

This project is not started from scratch:

1. See why we should supersede previous tools
2. Check the list of existing tools and functionality
3. See more other tools and IDEs for inspiration

It's time to join the project!

❤️ Haskell tooling dream is near, we need your help! ❤️

• Register in our google group mailing list.
• Join our IRC channel at #haskell-ide-engine on freenode.
• Fork this repo and hack as much as you can.
• Ask @alanz or @hvr to join the project.

Development

Apart from stack you need cask for the emacs tests. You can install it using

curl -fsSL https://raw.githubusercontent.com/cask/cask/master/go | python

Architecture

Below you find a short overview of the main architectural layers of haskell-ide-engine. For more info have a look in the docs folder at the root of this project, especially:

• The Architecture discussion
• The Protocol discussion
• The Design discussion

1. BIOS layer

ghc-mod stays an AGPL project, and is used for its "awesome sauce" in terms of the BIOS functions that it does so well. This interface is straightforward to use, and if a license-constrained user wants to do something else it is also easy to replace, if there is strong control of the operating environment.

2. Plugin layer

A layer providing a point to integrate tools and existing functions, probably including ghci.

3. IDE interfacing layer

The focus is currently on LSP as the protocol we use to interface with IDEs.

Existing transports are still functional for the time being.

Documentation

All the documentation is in the docs folder at the root of this project.