Skip to content

jyp/dante

master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
October 26, 2016 10:35
doc
October 17, 2022 10:45
November 16, 2022 09:40

Dante: Emacs mode for Interactive Haskell

https://badges.gitter.im/dante-mode/Lobby.svg https://melpa.org/packages/dante-badge.svg https://stable.melpa.org/packages/dante-badge.svg

Dante provides a frontend to GHCi features: type-checking, execution, completion and cross referencing. It integrates with standard Emacs tooling as much as possible.

Feature summary and cheat-sheet

FeatureMode/CommandKeybinding
On the fly type checkingflymake-mode
Completioncompany-mode
Type in echo areaeldoc-mode
Goto definitionxref-find-definitionsM-.
Find usesxref-find-referencesM-?
Remote operation(automatic with tramp)
Error correctionattrap-attrap
Type of selectiondante-type-atC-c .
Info at pointdante-infoC-c ,
REPLoiddante-eval-blockC-c ”
Restartdante-restart
Diagnosisdante-diagnose

REPLoid

You can evaluate code by writing it in a comment of the form -- >>> and run dante-eval-block.

Example:

example :: [String]
example = ["This is an example", "of", "interactive", "evaluation"]

-- >>> intercalate " " example

In the above file, if you invoke dante-eval-block on the line containing “intercalate”, you’ll get:

-- >>> intercalate " " example
-- "This is an example of interactive evaluation"
--

Several commands in the same block will be executed in at once, so you can have local let statements.

-- >>> let foo = "foo"
--
-- >>> foo ++ "bar"
-- "foobar"
---

Any GHCi command can be put in such a block, but note however that:

  1. The GHCi state will not be maintained across several calls to dante-eval-block. In fact, Dante liberally executes :r and :l, and (re)sets various GHCi options.
  2. It is not supported to load and/or unload modules in such blocks, or set unexpected options. This may work, or may mess with Dante internals.

So if your goal is run your webserver/database/etc. within GHCi, you should not do it using dante.

Completion

Completion works only when the current file can be loaded by GHCi (ie. is free of errors). So, this is not very useful. To mitigate the problem, Dante defers type-errors to runtime when loading.

Remote operation

When loading a remote (Tramp) path, GHCi will be run on the remote host, automatically.

However, if programs such as nix-shell are not found on the remote host, you may need to adjust the tramp path. For example:

(add-to-list 'tramp-remote-path 'tramp-own-remote-path)

Error correction

Error correction is implemented in the sister package attrap.

Using hlint

Dante is a GHCi interaction mode. Therefore it does not provide any support for hlint. However, you can use a third party support for hlint in addition to Dante. In fact attrap even provides support for interactive application of hints. See that package documentation for configuration.

Installation

Dante can be installed by any usual means. (Use-package is a pretty popular option)

Configuration

Eldoc

Dante has builtin Eldoc support (showing info about the symbol at point in the echo area when idle.) Unfortunately, at the time of writing (Oct 2022), the standard Haskell mode uses the old eldoc API, overriding Dante’s Eldoc support. I recommend just disabling the standard Haskell mode Eldoc support, which IMO isn’t very helpful anyway, like so:

(add-hook 'haskell-mode-hook
          (defun my-fix-hs-eldoc ()
            (setq eldoc-documentation-strategy #'eldoc-documentation-default)))

Configuring the GHCi loading method

Configuration can be important to make sure that GHCi is properly loaded by dante. Even though Dante will do its best to figure out the proper way to load GHCi for your project, it may still fail. You can guide Dante’s behavior by customizing variables. Note in particular that customization can be done on a per-file, per-package or per-project basis by using file- and directory-local variables (as recommended above).

In fact typical way to configure GHCi command line is to a add a .dir-locals.el file to your project root which sets the loading method. The loading method is a recipe to find out the root of the project and the command line to use to start GHCi.

((nil . ((dante-methods . (new-impure-nix)))))

Replace new-impure-nix with the proper value, which you can figure out by M-x describe-variable <RET> dante-methods-alist.

Configuring the Cabal target

For a multi-target project, it can be necessary to tell dante which target to pass to the cabal repl or stack command. The best method is to create another .dir-locals.el file in the top-level directory of the sources of the target in question. For instance, if a sil-parser-test executable resides in stand-in-language/test/, you can create the following file in that directory:

((nil . ((dante-target . "sil:sil-parser-test"))))

When using stack and a test suite, the following configuration in the test source directory will cause the --test flag to be passed when loading the files there:

((nil . ((dante-target . "--test"))))

More control over the GHCi command line

For more direct control over the command line, you can set dante-repl-command-line directly. If Dante additionally fails to find the project root using any of the dante-methods, configure dante-project-root explicitly. (Do it using dir-locals.el.)

Example full configuration

(use-package dante
  :ensure t ; ask use-package to install the package
  :after haskell-mode
  :commands 'dante-mode
  :init
  ;; flycheck backend deprecated October 2022
  ;; (add-hook 'haskell-mode-hook 'flycheck-mode)

  (add-hook 'haskell-mode-hook 'flymake-mode)
  (remove-hook 'flymake-diagnostic-functions 'flymake-proc-legacy-flymake)
  (add-hook 'haskell-mode-hook 'dante-mode)
  (add-hook 'haskell-mode-hook
            (defun my-fix-hs-eldoc ()
              (setq eldoc-documentation-strategy #'eldoc-documentation-default)))
  :config
  (require 'flymake-flycheck)
  (defalias 'flymake-hlint
    (flymake-flycheck-diagnostic-function-for 'haskell-hlint))
  (add-to-list 'flymake-diagnostic-functions 'flymake-hlint)
  ;; flycheck backend deprecated October 2022
  ;; (flycheck-add-next-checker 'haskell-dante '(info . haskell-hlint)))

Troubleshooting

If dante-type-at gives Couldn't guess that module name. Does it exist? or xref-find-definitions gives ~No definitions found for: “/tmp/danteTqJJvj.hs” ~, you may need to add your targets to .dir-locals.el; see the Configuration section above.

Finally, Use M-x customize-group dante to read the documentation for all customizable variables.

In the “press”

About

No description, website, or topics provided.

Resources

Stars

Watchers

Forks

Packages

No packages published