halberd: A tool to generate missing import statements for Haskell modules.

[ bsd3, development, library, program ] [ Propose Tags ]

This tool uses the Haskell Suite [0] to determine the unbound variables and types in your source code, and generate import statements for them. If there are multiple choices, it provides a simple interactive menu for you to choose from. See the home page for more details. [0] https://github.com/haskell-suite

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS] 0.1, 0.1.1, 0.1.2,,,,,,,,,
Change log CHANGELOG
Dependencies base (>=4.5 && <4.8), Cabal (>=1.16 && <1.22), containers (>=0.4 && <0.6), halberd, haskell-names (>=0.2 && <0.5), haskell-packages (>=0.2 && <0.3), haskell-src-exts (>=1.14 && <1.17), mtl (>=2.0 && <2.3), safe (>=0.3 && <0.4), syb (>=0.3 && <0.5), tagged (>=0.4 && <0.8) [details]
License BSD-3-Clause
Author Erik Hesselink, Simon Meier, Tom Lokhorst, Roman Cheplyaka
Maintainer hesselink@gmail.com
Category Development
Home page http://github.com/haskell-suite/halberd/
Source repo head: git clone git://github.com/haskell-suite/halberd.git
Uploaded by ErikHesselink at 2014-09-17T08:40:25Z
Distributions NixOS:
Reverse Dependencies 1 direct, 0 indirect [details]
Executables halberd
Downloads 8608 total (16 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for halberd-

[back to package description]

Halberd: generating imports

Halberd is a tool to help you add missing imports to your Haskell source files. With it, you can write your source without imports, call Halberd, and just paste in the import lines.

Currently, it tries to automatically choose an import if there is a single sensible option. If it can't, it will prompt you with a simple menu. After running, it prints the imports, which you need to copy manually. Editor integration is planned.

The imports generated are either qualified, if the unbound function looks like M.lookup, or explicit, if it looks like void.


As an example, say you have written the following (nonsensical and type incorrect) Haskell file called test.hs:

main :: IO Int8
main = do
    forM_ [1,2] $ \x -> print $ M.lookup x table
    liftM id $ return $ headNote "Impossible" [10]

table :: M.Map String Int8
table = M.fromList [("Odeca", 1), ("Hackathon",2)]

You can run Halberd on this by running halberd test.hs. It will prompt you with three questions:

1) Control.Monad
2) Data.Foldable

1) Data.List
2) GHC.List
3) Prelude
4) Data.IntMap
5) Data.IntMap.Lazy
6) Data.IntMap.Strict
7) Data.Map
8) Data.Map.Lazy
9) Data.Map.Strict

1) Data.Int
2) Foreign
3) Foreign.Safe
4) GHC.Int

After making the choices by typing 1, 7 and 1, it generated the folling output:

------------- Could not find import for -------------
 - headNote

-------- Insert these imports into your file --------

import qualified Data.Map as M
import Control.Monad ( forM_, liftM )
import Data.Int ( Int8 )

As you can see, it didn't ask questions about M.Map, M.fromList, liftM and the second usage of Int8. It figured these out either because of previous choices, or because there was only a single option.


Halberd uses the Haskell Suite packages (haskell-src-exts, haskell-packages and haskell-names) for parsing, name resolution and finding exposed identifiers of packages. While these can be installed from hackage, generating databases of names for new packages currently needs a custom version of the cabal install executable. See the documentation for haskell-names for more details.

To install Halberd, just do

cabal install halberd

This will give you a halberd executable that takes a single argument, the file to generate imports for. By default, it only draws names from base. If you want to add more names, use hs-gen-iface from the haskell-names package.


Halberd is still in an unfinished state. Some planned improvements are:

  • Smarter automatic choices.
  • Editor integration.
  • Easier installation of name databases (haskell-names).
  • Integration with existing imports.
  • Better choice UI.
  • Choices based on type information (haskell-type-exts).

Contributions are welcome!