1 Introduction

Haskell Mode is a major mode providing a convenient environment for editing Haskell programs.

Some of its major features are:

• Syntax highlighting (font lock),
• automatic semi-intelligent indentation,
• on-the-fly documentation,
• interaction with inferior GHCi/Hugs instance,
• project building with cabal and stack
• scanning declarations and placing them in a menu.

The name Haskell Mode refers to the whole collection of modules in this package. There is specifically a file haskell-mode.el which defines a major mode called haskell-mode. Generally, in this documentation they will be distinguished by normal font and title case (Haskell Mode) and code font (haskell-mode).

• History

2 Installation

Haskell Mode is distributed as a package in MELPA repository. To use MELPA as Emacs package archive do the following:

1. Customize package-archives using

   M-x customize-option RET package-archives
   

2. Use INS to add new archive, use:

   Archive name:          melpa-stable
   URL or directory name: http://stable.melpa.org/packages/
   

3. Fetch new packages using:

   M-x package-refresh-contents
   

4. Install Haskell Mode using:

   M-x package-install RET haskell-mode RET
   

Voila! haskell-mode is installed! You should be able to edit Haskell source code in color now.

The above steps should result in the following snippet in your .emacs:

(require 'package)
(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(package-archives
   (quote
    (("gnu" . "http://elpa.gnu.org/packages/")
     ("melpa-stable" . "http://stable.melpa.org/packages/")))))

Haskell Mode is available from melpa-stable (releases) and melpa (git snapshots).

Other means of obtaining haskell-mode include el-get, Emacs Prelude and Debian package.

• Customizing

M-x customize-variable RET haskell-mode-hook

3 Editing Haskell Code

Haskell Mode as one of its components provides a major mode for editing Haskell source code called haskell-mode, which gave the name to the whole project. There is a derived mode provided called haskell-literate-mode that support Literate Haskell source code both in Bird and in Latex forms.

Haskell Mode supports files with the following extensions:

.hs

official file extension for Haskell files. Haskell Mode out of the box supports most of GHC extensions.

.lhs

official file extension for Literate Haskell files. Both Bird and Latex styles are supported.

.hsc

Haskell interfaces to C code used by hsc2hs pre-processor.

.cpphs

Haskell source with CPP pragmas used with cpphs pre-processor.

.c2hs

Haskell FFI bindings to C libraries used with c2hs pre-processor.

Haskell Mode offers many productivity tools described in following chapters in this manual.

• Managing imports
• Haskell Tags
• Profiling and Debugging support

(define-key haskell-mode-map (kbd "<f8>") 'haskell-navigate-imports)

4 Syntax highlighting

haskell-mode supports syntax highlighting via Emacs’ Font Lock minor mode which should be enabled by default in current Emacsen. See (emacs)Font Lock, for more information on how to control font-lock-mode.

Syntax highlighting facilities parse strings and string escape sequences and are able to highlight unrecognized constructs.

Haskell Mode shows keywords, identifiers, operators, constructors and types in different colors.

There is also support to use mode-specific syntax highlighing for quasiquotes.

At this point quasi quotes for HTML, XML, shell scripts, Hamlet templates and SQL are supported out of the box. Customize haskell-font-lock-quasi-quote-modes to make sure your quoters are supported.

The following customization variables are responsible for faces applied:

• haskell-keyword-face: for keywords
• haskell-type-face: for type names and type class names
• haskell-constructor-face: for constructors
• haskell-definition-face: function and operator name at the definition place
• haskell-operator-face: operators
• haskell-pragma-face: GHC pragmas
• haskell-literate-comment-face: literate comments
• haskell-quasi-quote-face: quasi quotes unless using mode specific highlighting
• haskell-c2hs-hook-pair-face: c2hs hooks
• haskell-c2hs-hook-name-face: c2hs hook names

All the above are available for customization.

GHC quasi quote syntax is ambiguous with list comprehension therefore syntax highlighting might get confused with situations like these:

result = [html| html <- htmlList]
result = [html| <html><body>...</body></html> |]

Please use spaces around a list comprehension variable to make this unambiguous. Any of the following will work:

result = [ html| html <- htmlList]
result = [html | html <- htmlList]

GHC’s ambiguity is an accident of the past but it is unlikely to be fixed due to backward compatibility baggage.

5 Completion support

haskell-mode can complete symbols, pragma directives, language extensions, and language keywords out-of-box. haskell-mode completes identifiers (symbols) using tags (see “Tags”), however you can get more precise completions with haskell-interactive-mode. In interactive mode completion candidates are produced by querying GHCi REPL.

If haskell-interactive-mode is enabled and working Haskell mode provides completions for import statements taking into account currently loaded and available packages. Also it completes symbols querying REPL with :complete command, hence completion candidate list also includes symbols from imported modules.

Unfortunately, it is not possible to provide candidates for identifiers defined locally in let and where blocks even in interactive mode. But if you’re using company-mode you can override company-backends variable for Haskell buffers to combine completion candidates from completion-at-point function (company-capf backend) and dynamic abbrevs. company-mode provides special backend for dabbrev code completions, namely company-dabbrev-code. To combine completions from different backends you can create grouped backends, it is very easy — a grouped backend is just a list of backends, for example:

(add-hook 'haskell-mode-hook
          (lambda ()
            (set (make-local-variable 'company-backends)
                 (append '((company-capf company-dabbrev-code))
                         company-backends))))

If you use a GHCi version prior to 8.0.1 you might want to set haskell-completions-complete-operators to nil, if you experience major slowdown while trying to complete after an Haskell operator (See GHC-Bug 10576).

6 Unicode support

See the Haskell Wiki’s entry on Unicode Symbols for general information about Unicode support in Haskell.

As Emacs supports editing files containing Unicode out of the box, so does Haskell Mode. As an add-on, Haskell Mode includes the haskell-unicode input method which allows you to easily type a number of Unicode symbols that are useful when writing Haskell code; See (emacs)Input Methods, for more details.

To automatically enable the haskell-unicode input method in haskell-mode buffers use M-x customize-variable RET haskell-mode-hook or put the following code in your .emacs file:

(add-hook 'haskell-mode-hook 'turn-on-haskell-unicode-input-method)

To temporarily enable this input method for a single buffer you can use M-x turn-on-haskell-unicode-input-method.

When the haskell-unicode input method is active, you can simply type ‘->’ and it is immediately replaced with ‘→’. Use C-\ to toggle the input method. To see a table of all key sequences use M-x describe-input-method RET haskell-unicode. A sequence like ‘<=’ is ambiguous and can mean either ‘⇐’ or ‘≤’. Typing it presents you with a choice. Type 1 or 2 to select an option or keep typing to use the default option.

Currently defined sequences are listed in the following table:

If you don’t like the highlighting of partially matching tokens you can turn it off by setting input-method-highlight-flag to nil via M-x customize-variable.

7 Indentation

In Haskell, code indentation has semantic meaning as it defines the block structure. Haskell also supports braces and semicolons notation for conveying the block structure. However, most Haskell programs written by humans use indentation for block structuring.

Haskell Mode ships with two indentation modes:

• haskell-indentation-mode (default).

  This is a semi-intelligent indentation mode doing a decent job at recognizing Haskell syntactical constructs. It is based on a recursive descent Haskell parser. TAB selects the next potential indentation position, S-TAB selects the previous one. If a block is selected you can use TAB to indent the block more and S-TAB to indent the block less.

  When electric-indent-mode is enabled or the variable haskell-indentation-electric-flag is non-nil, the insertion of some characters (by default , ; ) } ]) may trigger auto reindentation under appropriate conditions. See the documentation of haskell-indentation-common-electric-command for more details.

• haskell-indent-mode (optional).

  This is a semi-intelligent indentation mode doing a decent job at recognizing Haskell syntactical constructs. It is based on a decision table. Sadly it is no longer developed and does not recognize newer Haskell syntax. TAB cycles through all available indentation positions.

  To use haskell-indent-mode, add this to your ~/.emacs file:

  (add-hook 'haskell-mode-hook 'turn-on-haskell-indent)
  

  Note that turn-on-haskell-indent will disable haskell-indentation-mode.

For general information about indentation support in GNU Emacs, see (emacs)Indentation.

• Rectangle Commands
• Region indent is a no-op

8 Other ways to indent code

• Indentation with tabs, not spaces
• Structured indentation

9 Using external formatters

You can enable stylish-haskell by installing it:

$ cabal install stylish-haskell

And by enabling it with a customization

(custom-set-variables
 '(haskell-stylish-on-save t))

Now when you run save-buffer (or C-x C-s) the module will be automatically formatted.

Alternatively, you can run the function directly on demand with M-x haskell-mode-stylish-buffer.

10 Module templates

To enable auto-insertion of module templates, enable:

(add-hook 'haskell-mode-hook 'haskell-auto-insert-module-template)

When you open a file called Foo.hs, it will auto-insert

-- |

module Foo where

And put your cursor in the comment section.

11 Declaration scannning

haskell-decl-scan-mode is a minor mode which performs declaration scanning and provides M-x imenu support (see (emacs)Imenu for more information).

For non-literate and TeX-style literate scripts, the common convention that top-level declarations start at the first column is assumed. For Bird-style literate scripts, the common convention that top-level declarations start at the third column, ie. after ‘> ’, is assumed.

When haskell-decl-scan-mode is active, the standard Emacs top-level definition movement commands (see (emacs)Moving by Defuns) are enabled to operate on Haskell declarations:

C-M-a

Move to beginning of current or preceding declaration (beginning-of-defun).

C-M-e

Move to end of current or following declaration (end-of-defun).

C-M-h

Select whole current or following declaration (mark-defun).

Moreover, if enabled via the option haskell-decl-scan-add-to-menubar, a menu item “Declarations” is added to the menu bar listing the scanned declarations and allowing to jump to declarations in the source buffer.

It’s recommended to have font lock mode enabled (see (emacs)Font Lock) as haskell-decl-scan-mode ignores text highlighted with font-lock-comment-face.

As usual, in order to activate haskell-decl-scan-mode automatically for Haskell buffers, add haskell-decl-scan-mode to haskell-mode-hook:

(add-hook 'haskell-mode-hook 'haskell-decl-scan-mode)

haskell-decl-scan-mode enables the use of features that build upon imenu support such as Speedbar Frames (see (emacs)Speedbar) or the global “Which Function” minor mode (see (emacs)Which Function).

In order to enable which-function-mode for Haskell buffers you need to add the following to your Emacs initialization:

(eval-after-load "which-func"
  '(add-to-list 'which-func-modes 'haskell-mode))

• Speedbar

(speedbar-add-supported-extension ".hs")

    Imports
    Instances
    Data types
    Classes
    Bindings

~/Projects/ace/src/ACE/
0:<+> Types
0:[+] Combinators.hs
0:[-] Datalog.hs
1:   {-} Classes
2:      > ToTerm
1:   {-} Imports
2:      > ACE.Types.Syntax
2:      > Database.Datalog
1:   {-} Instances
2:    {+} ToTerm A
2:    {+} ToTerm Co to ToTerm Gen
2:    {+} ToTerm Intransitive to ToTerm N
2:    {+} ToTerm P
2:    {+} ToTerm Quotation to ToTerm Un
2:    {+} ToTerm V
0:[-] Html.hs
1:   {+} Imports
1:   {+} Instances
1:     > mtoMarkup
1:     > toMarkupm
1:     > wrap
0:[-] Parsers.hs
1:   {+} Imports
1:   {-} Datatypes
2:      > ACEParser
0:[+] Pretty.hs
0:[+] Tokenizer.hs

12 Compilation

Haskell mode comes equipped with a specialized Compilation mode tailored to GHC’s compiler messages with optional support for Cabal projects. See (emacs)Compilation Mode, for more information about the basic commands provided by the Compilation mode which are available in the Haskell compilation sub-mode as well. The additional features provided compared to Emacs’ basic Compilation mode are:

• DWIM-style auto-detection of compile command (including support for stack and cabal projects)
• Support for GHC’s compile messages and recognizing error, warning and info source locations (including -ferror-spans syntax)
• Support for filtering out GHC’s uninteresting ‘Loading package...’ linker messages

In order to use it, invoke the haskell-compile command instead of compile as you would for the ordinary Compilation mode. It’s recommended to bind haskell-compile to a convenient key binding. For instance, you can add the following to your Emacs initialization to bind haskell-compile to C-c C-c.

(eval-after-load "haskell-mode"
    '(define-key haskell-mode-map (kbd "C-c C-c") 'haskell-compile))

(eval-after-load "haskell-cabal"
    '(define-key haskell-cabal-mode-map (kbd "C-c C-c") 'haskell-compile))

The following description assumes that haskell-compile has been bound to C-c C-c.

When invoked, haskell-compile decides what build tool to run by consulting the value of haskell-compiler-type.

• If this is the symbol cabal, then cabal is run, using the command defined by haskell-compile-cabal-build-command. haskell-compile looks for a .cabal file in the current directory or its closet ancestor.
• If haskell-compiler-type is the symbol stack, then stack is run, using the command haskell-compile-stack-build-command, and looking for the closest stack.yaml file.
• If haskell-compiler-type is the symbol ghc, then ghc is run, using the command haskell-compile-command.
• But if haskell-compiler-type is the symbol auto (the default), then emacs tries to choose which build tool to use by looking for the closest stack.yaml or .cabal file. (This is similar to the way haskell-interactive-mode uses the variable haskell-process-type.)

Moreover, when a negative prefix argument is supplied (e.g. C-- C-c C-c), the alternative build command is used, that is, haskell-compile-cabal-build-command-alt or haskell-compile-stack-build-command-alt. By default, the alternative build commands force a full rebuild. (Note this does not affect haskell-compile-command.)

As usual you can change any of these variables using M-x customize-variable.

You can also inspect and modify the compile command to be invoked temporarily by invoking haskell-compile with a prefix argument (e.g. C-u C-c C-c). If later-on you want to recompile using the same customized compile command, invoke recompile (bound to g) inside the ‘*haskell-compilation*’ buffer.

• Keybindings

13 Interactive Haskell

REPL (read–eval–print loop) is provided both via Comint (inferior-haskell-mode) and an adhoc way called haskell-interactive-mode. The Comint based inferior-haskell-mode is just the REPL, it comes with the standard key bindings(like ielm or eshell).

haskell-interactive-mode comes with a different set of features:

• Separate sessions per Cabal project haskell-session.el.
• A new inferior Haskell process handling code haskell-process.el.
• New REPL implementation similar to SLIME/IELM
• Navigatable error overlays haskell-interactive-mode.el.

With haskell-interactive-mode, each Haskell source buffer is associated with at most one GHCi session, so when you call haskell-process-load-file for a Haskell source buffer which has no session associated yet, you’re asked which GHCi session to create or associate with.

• Goto Error
• Using GHCi 8+ or GHCi-ng
• Customizing
• Haskell Interactive Mode Setup
• Haskell Interactive Mode Tags Using GHCi
• Sessions
• Compiling
• Haskell Interactive Mode REPL
• Haskell Interactive Mode Querying
• Haskell Interactive Mode Cabal integration
• Haskell Interactive Mode Debugger

(define-key interactive-haskell-mode-map (kbd "M-.") 'haskell-mode-goto-loc)
(define-key interactive-haskell-mode-map (kbd "C-c C-t") 'haskell-mode-show-type-at)

(require 'haskell-interactive-mode)
(require 'haskell-process)
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)

(custom-set-variables
  '(haskell-process-suggest-remove-import-lines t)
  '(haskell-process-auto-import-loaded-modules t)
  '(haskell-process-log t))

(define-key haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload)
(define-key haskell-mode-map (kbd "C-`") 'haskell-interactive-bring)
(define-key haskell-mode-map (kbd "C-c C-t") 'haskell-process-do-type)
(define-key haskell-mode-map (kbd "C-c C-i") 'haskell-process-do-info)
(define-key haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
(define-key haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
(define-key haskell-mode-map (kbd "C-c c") 'haskell-process-cabal)

(define-key haskell-cabal-mode-map (kbd "C-`") 'haskell-interactive-bring)
(define-key haskell-cabal-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear)
(define-key haskell-cabal-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build)
(define-key haskell-cabal-mode-map (kbd "C-c c") 'haskell-process-cabal)

(custom-set-variables
  '(haskell-process-type 'cabal-repl))

(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-jump-to-def)

    $ cabal install hasktags

(custom-set-variables
  '(haskell-tags-on-save t))

(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-tag-find)

(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-jump-to-def-or-tag)

    M-x haskell-session-change

    M-x haskell-session-kill

    Kill the whole session (y or n)?

    M-x haskell-menu

    foo  14648 08:21:42 214MB /path/to/fpco/foo/  /path/to/fpco/foo/ ghci
    bar  29119 00:22:03 130MB /path/to/bar/       /path/to/bar/      ghci
    mu   22575 08:48:20 73MB  /path/to/fpco/mu/   /path/to/fpco/mu/  ghci

    M-x haskell-process-load

    M-x haskell-process-cabal-build

(custom-set-variables
  '(haskell-process-suggest-remove-import-lines t))

    Warning: The import of `Control.Monad' is redundant
      except perhaps to import instances from `Control.Monad'
    To import instances alone, use: import Control.Monad()

> The import line `Control.Monad' is redundant. Remove? (y, n, c: comment out)

(custom-set-variables
  '(haskell-process-suggest-hoogle-imports t))

newtype X a = X (IO a)
  deriving (Monad)

    x.hs:13:13: Can't make a derived instance of `Monad X': …
          `Monad' is not a derivable class
          Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension
        In the newtype declaration for `X'

> Add `{-# LANGUAGE GeneralizedNewtypeDeriving #-}` to the top of the
> file? (y or n)

    src/ACE/Tokenizer.hs:11:18: Could not find module `Data.Attoparsec.Text' …
        It is a member of the hidden package `attoparsec-0.11.1.0'.

    Add `attoparsec' to ace.cabal? (y or n)  y

    attoparsec >= 0.11.1.0

    Add to library? (y or n)  y

    The lambdas must flow.
    Changed directory: /path/to/your/project/
    λ>

    M-x haskell-interactive-bring

    λ> 123
    123

λ> :{
λ| let a = 10
λ|     b = 20
λ|     c = 30
λ| :}

    M-x haskell-interactive-mode-newline-indent

λ> let a = 10
       b = 20
       c = 30

    λ> :t id
    id :: a -> a

    λ> id
    id :: a -> a

    No instance for (Show (a0 -> a0))
      arising from a use of `print'
    Possible fix: add an instance declaration for (Show (a0 -> a0))
    In a stmt of an interactive GHCi command: print it

    λ> :t read "a"
    read "a" :: Read a => a

    Ambiguous type variable `a0' in the constraint:
      (Read a0) arising from a use of `read'
    Probable fix: add a type signature that fixes these type variable(s)
    In the expression: read \"a\"
    In an equation for `it': it = read \"a\"

(custom-set-variables
  '(haskell-interactive-types-for-show-ambiguous nil))

(setq haskell-interactive-mode-eval-mode 'haskell-mode)

(defun haskell-interactive-toggle-print-mode ()
  (interactive)
  (setq haskell-interactive-mode-eval-mode
        (intern
         (ido-completing-read "Eval result mode: "
                              '("fundamental-mode"
                                "haskell-mode"
                                "espresso-mode"
                                "ghc-core-mode"
                                "org-mode")))))

    M-x haskell-interactive-toggle-print-mode

(define-key haskell-interactive-mode-map (kbd "C-c C-v")
            'haskell-interactive-toggle-print-mode)

    {-# LANGUAGE OverloadedStrings #-}

    import Diagrams.Prelude
    import Diagrams.Backend.SVG

    myCircle :: Diagram B
    myCircle = circle 1 # lc purple # fc yellow

    circle = renderDia SVG (SVGOptions (mkWidth 250) Nothing "" [] True) myCircle

    λ> :present 123
    123

    λ> :present [1..]
    [1
    ,[Integer]]

    λ> :present [1..]
    [1
    ,2
    ,[Integer]]

(defun create-unfocused-frame ()
  (let*
    ((prv (window-frame))
     (created (make-frame)))
    (select-frame-set-input-focus prv) created))

(defun create-haskell-interactive-frame ()
  (interactive)
  (haskell-interactive-bring)
  (create-unfocused-frame)
  (delete-window))

    M-x haskell-process-clear

    M-x haskell-process-restart

    M-: (haskell-process)

    M-x haskell-process-do-type

    C-u M-x haskell-process-do-type

    M-x haskell-process-do-info

class Eq a => Ord a where
  compare :: a -> a -> Ordering
  (<) :: a -> a -> Bool
  (>=) :: a -> a -> Bool
  (>) :: a -> a -> Bool
  (<=) :: a -> a -> Bool
  max :: a -> a -> a
  min :: a -> a -> a
  	-- Defined in `GHC.Classes'

data Ordering = LT | EQ | GT 	-- Defined in `GHC.Types'
instance Bounded Ordering -- Defined in `GHC.Enum'
instance Enum Ordering -- Defined in `GHC.Enum'
instance Eq Ordering -- Defined in `GHC.Classes'
instance Ord Ordering -- Defined in `GHC.Classes'
instance Read Ordering -- Defined in `GHC.Read'
instance Show Ordering -- Defined in `GHC.Show'

    M-x haskell-process-do-info

    M-x haskell-process-cabal-build

    Compiling: ACE.Types.Tokens
    Compiling: ACE.Combinators
    Compiling: ACE.Tokenizer
    Compiling: ACE.Parsers
    Compiling: ACE.Pretty
    Compiling: ACE
    Complete: cabal build (0 compiler messages)

    Building ace-0.5...
    Preprocessing library ace-0.5...
    [4 of 9] Compiling ACE.Types.Tokens ( src/ACE/Types/Tokens.hs, dist/build/ACE/Types/Tokens.o )
    [5 of 9] Compiling ACE.Combinators  ( src/ACE/Combinators.hs, dist/build/ACE/Combinators.o ) [ACE.Types.Tokens changed]
    [6 of 9] Compiling ACE.Tokenizer    ( src/ACE/Tokenizer.hs, dist/build/ACE/Tokenizer.o ) [ACE.Types.Tokens changed]
    [7 of 9] Compiling ACE.Parsers      ( src/ACE/Parsers.hs, dist/build/ACE/Parsers.o )
    [8 of 9] Compiling ACE.Pretty       ( src/ACE/Pretty.hs, dist/build/ACE/Pretty.o )
    [9 of 9] Compiling ACE              ( src/ACE.hs, dist/build/ACE.o ) [ACE.Tokenizer changed]
    In-place registering ace-0.5...

    C-u M-x haskell-process-cabal

    M-x haskell-process-cabal

    M-x haskell-debug

    Debugging haskell

    You have to load a module to start debugging.

    g - refresh

    Modules

    No loaded modules.

main = do putStrLn "Hello!"
          putStrLn "World"

    Debugging haskell

    b - breakpoint, g - refresh

    Context

    Not debugging right now.

    Breakpoints

    No active breakpoints.

    Modules

    Main - hello.hs

    Debugging haskell

    s - step into an expression, b - breakpoint
    d - delete breakpoint, g - refresh

    Context

    Not debugging right now.

    Breakpoints

    0 - Main (1:8)

    Modules

    Main - hello.hs

    Debugging haskell

    s - step into an expression, b - breakpoint
    d - delete breakpoint, a - abandon context, c - continue
    p - previous step, n - next step
    g - refresh

    Context

    main - hello.hs (stopped)

    do putStrLn "Hello!"
       putStrLn "World"

    _result :: IO () = _

       1 do putStrLn "Hello!" putStrLn "World"

    Breakpoints

    0 - Main (1:8)

    Modules

    Main - hello.hs

do putStrLn "Hello!"
   putStrLn "World"

_result :: IO () = _

1 do putStrLn "Hello!" putStrLn "World"

main - hello.hs (stopped)

putStrLn "Hello!"

_result :: IO () = _

   1 do putStrLn "Hello!" putStrLn "World"

putStrLn "World"

_result :: IO () = _

   2 putStrLn "Hello!"
   1 do putStrLn "Hello!" putStrLn "World"

    Debugging haskell

    s - step into an expression, b - breakpoint
    d - delete breakpoint, g - refresh

    Context

    Finished debugging.

       2 putStrLn "Hello!"
       1 do putStrLn "Hello!" putStrLn "World"

    Breakpoints

    1 - Main (1:8)

    Modules

    Main - hello.hs

14 Editing Cabal files

haskell-cabal-mode is a major mode for editing Cabal package description files and is automatically associated with files having a .cabal extension.

For quickly locating and jumping to the nearest .cabal file from a Haskell source buffer, you can use M-x haskell-cabal-visit-file; with a prefix argument (i.e. C-u) find-file-other-window is used to visit the .cabal file. haskell-cabal-visit-file is bound to the key sequence C-c v c.

TODO/WRITEME

15 Browsing Haddocks using w3m

An experimental feature is use of the w3m browser to browse Haddock docs inside Emacs.

• Get w3m
• Configure w3m
• Import w3m-haddock
• Add a hook for w3m
• Configure your package locations
• Finally

$ sudo apt-get install w3m

(setq w3m-mode-map (make-sparse-keymap))

(define-key w3m-mode-map (kbd "RET") 'w3m-view-this-url)
(define-key w3m-mode-map (kbd "q") 'bury-buffer)
(define-key w3m-mode-map (kbd "<mouse-1>") 'w3m-maybe-url)
(define-key w3m-mode-map [f5] 'w3m-reload-this-page)
(define-key w3m-mode-map (kbd "C-c C-d") 'haskell-w3m-open-haddock)
(define-key w3m-mode-map (kbd "M-<left>") 'w3m-view-previous-page)
(define-key w3m-mode-map (kbd "M-<right>") 'w3m-view-next-page)
(define-key w3m-mode-map (kbd "M-.") 'w3m-haddock-find-tag)

(defun w3m-maybe-url ()
  (interactive)
  (if (or (equal '(w3m-anchor) (get-text-property (point) 'face))
          (equal '(w3m-arrived-anchor) (get-text-property (point) 'face)))
      (w3m-view-this-url)))

(require 'w3m-haddock)

(add-hook 'w3m-display-hook 'w3m-haddock-display)

(defcustom haskell-w3m-haddock-dirs
  '("~/.cabal/share/doc/"))

(define-key haskell-mode-map (kbd "C-c C-d") 'haskell-w3m-open-haddock)

16 Using with flyspell-prog-mode

Strings and comments can be checked for spelling mistakes. There is a standard Emacs mode for this purpose, flyspell-prog-mode, that can be enabled in Haskell buffers. Spelling errors are underlined using squiggly red lines.

Documentation for flyspell-prog-mode can be found in See (emacs)Spelling. Here we point to a couple of useful keybindings:

• M-$ - Check and correct spelling of the word at point (ispell-word).
• digit - Replace the word, just this time, with one of the displayed near-misses. Each near-miss is listed with a digit; type that digit to select it.
• SPC - Skip this word—continue to consider it incorrect, but don’t change it here.

To enable spell checking of strings and comments add this line to your ~/.emacs file:

(add-hook 'haskell-mode-hook 'flyspell-prog-mode)

17 Aligning code

Select a region you want to align text within, M-x align-regexp, and type a regexp representing the alignment delimiter.

For example, I often line up my Haddock comments:

f :: a -- ^ does a
  -> Foo b -- ^ and b
  -> c -- ^ to c

Select the region, and let the regexp be ‘--’:

f :: a     -- ^ does a
  -> Foo b -- ^ and b
  -> c     -- ^ to c

Of course, this works for just about anything. Personally, I’ve globally bound it to C-x a r:

(global-set-key (kbd "C-x a r") 'align-regexp)

Note that you can also just use the rules below for telling the aligner about Haskell. Once you evaluate this, you can just use M-x align, which I like to bind to M-[.

(add-to-list 'align-rules-list
             '(haskell-types
               (regexp . "\\(\\s-+\\)\\(::\\|∷\\)\\s-+")
               (modes quote (haskell-mode haskell-literate-mode))))
(add-to-list 'align-rules-list
             '(haskell-assignment
               (regexp . "\\(\\s-+\\)=\\s-+")
               (modes quote (haskell-mode haskell-literate-mode))))
(add-to-list 'align-rules-list
             '(haskell-arrows
               (regexp . "\\(\\s-+\\)\\(->\\|→\\)\\s-+")
               (modes quote (haskell-mode haskell-literate-mode))))
(add-to-list 'align-rules-list
             '(haskell-left-arrows
               (regexp . "\\(\\s-+\\)\\(<-\\|←\\)\\s-+")
               (modes quote (haskell-mode haskell-literate-mode))))

18 Using rectangular region commands

Emacs has a set of commands which operate on the region as if it were rectangular. This turns out to be extremely useful when dealing with whitespace sensitive languages.

• C-x r o is "Open Rectangle".

  It will shift any text within the rectangle to the right side. Also see:

• C-x r t is "String Rectangle".

  It will replace any text within the rectangle with the given string on all the lines in the region. If comment-region didn’t already exist, you could use this instead, for example.

• C-x r d is "Delete Rectangle".

  It will delete the contents of the rectangle and move anything on the right over.

• C-x r r is "Copy Rectangle to Register".

  It will prompt you for a register number so it can save it for later.

• C-x r g is "Insert register".

  This will insert the contents of the given register, overwriting whatever happens to be within the target rectangle. (So make room)

• C-x r k is "Kill rectangle".

  Delete rectangle and save contents for:

• C-x r y is "Yank rectangle".

  This will insert the contents of the last killed rectangle.

As with all Emacs modifier combos, you can type C-x r C-h to find out what keys are bound beginning with the C-x r prefix.

19 Using GHCi REPL within Emacs

To start the REPL you can run the following:

• M-x run-haskell

This repl works with Comint. So you will feel at home if you are already using M-x Shell or M-x ielm.

Inf-Haskell is a Major mode for running GHCi, with comint.

Important key bindings in Inf-haskell:

RET

invokes comint-send-input. Sends the input to the GHCi process, evaluates the line and returns the output.

C-d or <delete>

deletes the forward character

<C-up> or M-p

invokes comint-previous-input. Cycle backwards through input history, saving input.

<C-down> or M-n

invokes comint-next-input. Cycle forwards through input history.

C-c C-c

invokes comint-interrupt-subjob. Sends KeyboardInterrupt signal.

C-c C-\

invokes comint-quit-subjob. Sends KeyboardInterrupt signal.

C-c C-z

invokes comint-stop-subjob. Kills the GHCi process.

C-c M-r

invokes comint-previous-matching-input-from-input. If you are familiar with C-r in bash. This is the same as that. Searches backwards through input history for match for current input.

C-c M-s

invokes comint-next-matching-input-from-input. Searches forwards through input history for match for current input.

C-c C-l

invokes comint-dynamic-list-input-ring. Displays a list of recent inputs entered into the current buffer.

C-c M-o

invokes comint-clear-buffer. Clears the buffer (Only with Emacs 25.X and above)

C-c C-n

invokes comint-next-prompt. Goes to the start of the previous REPL prompt.

C-c C-p

invokes comint-previous-prompt. Goes to the start of the next REPL prompt.

C-c C-o

invokes comint-delete-output. Clears the output of the most recently evaluated expression.

C-c C-e

invokes comint-show-maximum-output. Moves the point to the end of the buffer.

C-c C-u

invokes comint-kill-input. Kills backward, the line at point. (Use this when you have typed in an expression into the prompt but you dont want to evaluate it.)

C-c C-w

invokes backward-kill-word. Kills backward, the word at point

C-c C-s

invokes comint-write-output. Write output from interpreter since last input to FILENAME. Any prompt at the end of the output is not written.

• Relevant defcustoms:
• More on haskell-process-type

20 Collapsing Haskell code

This is hs-minor-mode for haskell-mode. This module uses hideshow module.

To activate this minor mode (haskell-collapse-mode)

• M-x haskell-collapse-mode is "To start haskell-collapse-mode".

This minor mode works with indentation.

In a quick glance:

C-c  C-c

is bound to haskell-hide-toggle

C-c  C-M-c

C-c  C-M-h

C-c  C-M-s

are all bound to haskell-hide-toggle-all

How to use M-x haskell-hide-toggle?

Place your point on the code block that you want to collapse and hit the keybinding. Now the code collapses and you can see the first line of the block and elipsis.

Take this example code (example usage of M-x haskell-hide-toggle): when you place the cursor here, like this (notice the thick block in the first line):

f█x | rem i 3 == 0 = if i == 0 && (k /= 0) then (c k) else (h j) | otherwise = 0 where i = sum x j = g x (div i 3) 0 0 [] k = zeroes x 0

or

f x | rem i 3 == 0 = if i == 0 && (k /= 0) then (c k) else (h j) █ | otherwise = 0 where i = sum x j = g x (div i 3) 0 0 [] k = zeroes x 0

then when you collapse it becomes something like this:

f█x…

It works in terms of (indentation) blocks.

One more example:

f x | rem i 3 == 0 = if i == 0 && (k /= 0) then (c k) else (h j) | otherwise = 0 w█ere i = sum x j = g x (div i 3) 0 0 [] k = zeroes x 0

or

f x | rem i 3 == 0 = if i == 0 && (k /= 0) then (c k) else (h j) | otherwise = 0 where i = sum x j = g x (div i 3) 0 0 [] █ k = zeroes x 0

this, will result in something like:

f x | rem i 3 == 0 = if i == 0 && (k /= 0) then (c k) else (h j) | otherwise = 0 where i = sum █…

The other functionality M-x haskell-hide-toggle-all also works only for indentation and it collapses all toplevel functions.

So a file that looks like this:

main = interact $ show.f. map read .words
f (x:xs) = dp x xs

dp money a | money < 0 || null a = [1..1000]
dp 0 a = []
dp money a @ (coin:coins)
  | (length i) <= length j = i
  | otherwise = j
  where i = (coin:(dp (money-coin) a))
        j = (dp money coins)

will turn into this:

main = interact $ show.f. map read .words
f (x:xs) = dp x xs

dp money a | money < 0 || null a = [1..1000]
dp 0 a = []
dp money a @ (coin:coins)…

21 Getting Help and Reporting Bugs

Work on Haskell Mode is organized with Github haskell-mode project. To understand how the project is run please read the information in the project wiki pages.

To report any issues please use the Github’s issue mechanism available from Haskell Mode’s GitHub Home.

For a quick question visit #haskell-emacs channel on IRC irc.freenode.net.

There is also a (now defunct) Haskellmode-emacs mailing list, also available on Gmane via the gmane.comp.lang.haskell.emacs newsgroup.

We welcome code and non-code contributions so that we can all enjoy coding Haskell even more.