9da3ffee41
This is a massive diff that I had to do in a hurry - when leaving Urbint. I'm pretty sure that most of these are updating Emacs packages, but I'm not positive.
2457 lines
83 KiB
Text
2457 lines
83 KiB
Text
This is haskell-mode.info, produced by makeinfo version 6.5 from
|
||
haskell-mode.texi.
|
||
|
||
This manual is for Haskell mode, version 16.1-git
|
||
|
||
Copyright © 2013-2017 Haskell Mode contributors.
|
||
|
||
Permission is granted to copy, distribute and/or modify this
|
||
document under the terms of the GNU Free Documentation License
|
||
(http://www.gnu.org/licenses/fdl.html), Version 1.3 or any later
|
||
version published by the Free Software Foundation; with no
|
||
Invariant Sections, no Front-Cover Texts and no Back-Cover Texts.
|
||
INFO-DIR-SECTION Emacs
|
||
START-INFO-DIR-ENTRY
|
||
* Haskell Mode: (haskell-mode). Haskell Development Environment for Emacs(en)
|
||
END-INFO-DIR-ENTRY
|
||
|
||
|
||
File: haskell-mode.info, Node: Top, Next: Introduction, Up: (dir)
|
||
|
||
Haskell Mode
|
||
************
|
||
|
||
Haskell Mode is an Haskell development Environment for GNU Emacs version
|
||
24.3 or later. It provides syntax-based indentation, font locking,
|
||
editing cabal files, and supports running an inferior Haskell
|
||
interpreter (e.g. GHCi).
|
||
|
||
* Menu:
|
||
|
||
* Introduction:: An introduction to Haskell Mode
|
||
* Installation:: How to get started
|
||
* Editing Haskell Code:: How to edit code
|
||
* Syntax highlighting:: Haskell Mode has colors
|
||
* Completion support:: Autocomplete
|
||
* Unicode support:: How to use Unicode
|
||
* Indentation:: Notes about indentation
|
||
* External indentation:: Other ways to indent code
|
||
* Autoformating:: Using external formatters
|
||
* Module templates:: Module templates
|
||
* Declaration scanning:: How to navigate in a source file
|
||
* Compilation:: How to compile
|
||
* Interactive Haskell:: How to interact with GHCi
|
||
* Editing Cabal files:: Cabal support
|
||
* Browsing Haddocks:: Using ‘w3m’ to browse documentation
|
||
* Spell checking strings and comments:: Using ‘flyspell-prog-mode’
|
||
* Aligning code:: Aligning code using ‘align-regexp’
|
||
* Rectangular commands:: Manage indentation manually
|
||
* REPL:: GHCi REPL
|
||
* Collapsing Haskell code:: View more code on screen
|
||
* Getting Help and Reporting Bugs:: How to improve Haskell Mode
|
||
* Concept index:: Index of Haskell Mode concepts
|
||
* Function index:: Index of commands
|
||
* Variable index:: Index of options and types
|
||
|
||
|
||
File: haskell-mode.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top
|
||
|
||
1 Introduction
|
||
**************
|
||
|
||
“Haskell Mode” is a major mode providing a convenient environment for
|
||
editing Haskell (http://www.haskell.org) 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’).
|
||
|
||
1.1 History
|
||
===========
|
||
|
||
‘haskell-mode’ has a long history. It goes all the way back to 1992.
|
||
Since then, it has received many contributions in many forms. Some
|
||
design choices that remain in haskell-mode today are historical. Some
|
||
modules are outdated or no longer used, or are used by a few people.
|
||
|
||
Historically there hasn’t been a single individual or set of
|
||
individuals directing the package’s architecture for a long period of
|
||
time, rather, patches and new modules were accepted in liberally and we
|
||
are left with a box full of interesting toys that may or may not work.
|
||
|
||
As of 2016 Haskell Mode is coordinated using Github at
|
||
<https://github.com/haskell/haskell-mode>.
|
||
|
||
|
||
File: haskell-mode.info, Node: Installation, Next: Editing Haskell Code, Prev: Introduction, Up: Top
|
||
|
||
2 Installation
|
||
**************
|
||
|
||
Haskell Mode is distributed as a package in MELPA repository
|
||
(https://melpa.org). 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 supports GNU Emacs versions 24.3+, including 25
|
||
(snapshot).
|
||
|
||
Haskell Mode is available from melpa-stable (releases)
|
||
(http://stable.melpa.org) and melpa (git snapshots) (http://melpa.org).
|
||
|
||
Other means of obtaining ‘haskell-mode’ include el-get
|
||
(https://github.com/dimitri/el-get), Emacs Prelude
|
||
(https://github.com/bbatsov/prelude) and Debian package
|
||
(https://packages.debian.org/search?keywords=haskell-mode).
|
||
|
||
Last version of ‘haskell-mode’ that supported Emacs 23, 24.1, and
|
||
24.2 is ‘haskell-mode’ 13.16 available at
|
||
<https://github.com/haskell/haskell-mode/releases/tag/v13.16>.
|
||
|
||
2.1 Customizing
|
||
===============
|
||
|
||
Most of Haskell Mode’s settings are configurable via customizable
|
||
variables (*note (emacs)Easy Customization::, for details). You can use
|
||
‘M-x customize-group <RET> haskell’ to browse the ‘haskell’
|
||
customization sub-tree.
|
||
|
||
One of the important setting you should customize is the
|
||
‘haskell-mode-hook’ variable (*note (emacs)Hooks::) which gets run right
|
||
after the ‘haskell-mode’ major mode is initialized for a buffer. You
|
||
can customize ‘haskell-mode-hook’ by
|
||
|
||
M-x customize-variable RET haskell-mode-hook
|
||
|
||
There you can enable or disable a couple of predefined options or add
|
||
any function to the list.
|
||
|
||
|
||
File: haskell-mode.info, Node: Editing Haskell Code, Next: Syntax highlighting, Prev: Installation, Up: Top
|
||
|
||
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
|
||
‘literate-haskell-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
|
||
(http://www.haskell.org/ghc/docs/latest/html/users_guide/hsc2hs.html)
|
||
pre-processor.
|
||
‘.cpphs’
|
||
Haskell source with CPP pragmas used with cpphs
|
||
(http://projects.haskell.org/cpphs) pre-processor.
|
||
‘.c2hs’
|
||
Haskell FFI bindings to C libraries used with c2hs
|
||
(https://github.com/haskell/c2hs) pre-processor.
|
||
|
||
Haskell Mode offers many productivity tools described in following
|
||
chapters in this manual.
|
||
|
||
3.1 Managing imports
|
||
====================
|
||
|
||
There are a few functions for managing imports.
|
||
|
||
3.1.1 Jump to imports
|
||
---------------------
|
||
|
||
To jump to your import list, run
|
||
|
||
‘M-x’ ‘haskell-navigate-imports’
|
||
|
||
It’s nicer to have a keybinding to do this, for example:
|
||
|
||
(define-key haskell-mode-map (kbd "<f8>") 'haskell-navigate-imports)
|
||
|
||
You can hit it repeatedly to jump between groups of imports. It will
|
||
cycle.
|
||
|
||
3.1.2 Format imports
|
||
--------------------
|
||
|
||
To generally format (sort, align) your imports, you can run
|
||
|
||
‘M-x’ ‘haskell-mode-format-imports’
|
||
|
||
Or ‘C-c C-,’.
|
||
|
||
3.1.3 Sort imports
|
||
------------------
|
||
|
||
To just sort imports, jump to an import section and run
|
||
|
||
‘M-x’ ‘haskell-sort-imports’
|
||
|
||
3.1.4 Align imports
|
||
-------------------
|
||
|
||
To just align imports, jump to an import section and run
|
||
|
||
‘M-x’ ‘haskell-align-imports’
|
||
|
||
3.1.5 stylish-haskell
|
||
---------------------
|
||
|
||
As an alternative to the elisp functions described above, haskell-mode
|
||
can use the program stylish-haskell
|
||
(http://hackage.haskell.org/package/stylish-haskell) to format imports.
|
||
You can set this behavior by typing: ‘M-x’ ‘customize-variable’ ‘RET’
|
||
‘haskell-stylish-on-save’. You can install ‘stylish-haskell’ by running
|
||
‘stack install stylish-haskell’, or if you have not installed ‘stack’,
|
||
‘cabal install stylish-haskell’.
|
||
|
||
3.2 Haskell Tags
|
||
================
|
||
|
||
‘haskell-mode’ can generate tags when saving source files. To generate
|
||
tags ‘haskell-mode’ uses external program — Hasktags
|
||
(https://github.com/MarcWeber/hasktags) (wiki-article
|
||
(https://wiki.haskell.org/Tags)). To turn on tags generatation
|
||
customize or set to ‘t’ ‘haskell-tags-on-save’ variable. Also, you may
|
||
find useful to revert tags tables automatically, this can be done by
|
||
customizing ‘tags-revert-without-query’ variable (either globally or for
|
||
Haskell buffers only).
|
||
|
||
3.3 Profiling and Debugging support
|
||
===================================
|
||
|
||
When profiling code with GHC, it is often useful to add cost centres
|
||
(https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.html#cost-centres)
|
||
by hand. These allow finer-grained information about program behavior.
|
||
‘haskell-mode’ provides the function ‘haskell-mode-toggle-scc-at-point’
|
||
to make this more convenient. It will remove an SCC annotation at point
|
||
if one is present, or add one if point is over whitespace. By default
|
||
it is bound to ‘C-c C-s’.
|
||
|
||
|
||
File: haskell-mode.info, Node: Syntax highlighting, Next: Completion support, Prev: Editing Haskell Code, Up: Top
|
||
|
||
4 Syntax highlighting
|
||
*********************
|
||
|
||
‘haskell-mode’ supports “syntax highlighting” via Emacs’ Font Lock minor
|
||
mode which should be enabled by default in current Emacsen. *Note
|
||
(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.
|
||
|
||
|
||
File: haskell-mode.info, Node: Completion support, Next: Unicode support, Prev: Syntax highlighting, Up: Top
|
||
|
||
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.
|
||
|
||
Unfortunatelly, 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
|
||
(http://company-mode.github.io/) 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
|
||
diffrent 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 (https://ghc.haskell.org/trac/ghc/ticket/10576)).
|
||
|
||
|
||
File: haskell-mode.info, Node: Unicode support, Next: Indentation, Prev: Completion support, Up: Top
|
||
|
||
6 Unicode support
|
||
*****************
|
||
|
||
See the Haskell Wiki’s entry on Unicode Symbols
|
||
(http://www.haskell.org/haskellwiki/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; *Note
|
||
(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:
|
||
|
||
SequenceUnicode SequenceUnicode SequenceUnicode SequenceUnicode
|
||
----------------------------------------------------------------------------
|
||
alpha α Alpha Α beta β Beta Β
|
||
gamma γ Gamma Γ delta δ Delta Δ
|
||
epsilonε EpsilonΕ zeta ζ Zeta Ζ
|
||
eta η Eta Η theta θ Theta Θ
|
||
iota ι Iota Ι kappa κ Kappa Κ
|
||
lambda λ Lambda Λ lamda λ Lamda Λ
|
||
mu μ Mu Μ nu ν Nu Ν
|
||
xi ξ Xi Ξ omicronο OmicronΟ
|
||
pi π Pi Π rho ρ Rho Ρ
|
||
sigma σ Sigma Σ tau τ Tau Τ
|
||
upsilonυ UpsilonΥ phi φ Phi Φ
|
||
chi χ Chi Χ psi ψ Psi Ψ
|
||
omega ω Omega Ω digammaϝ DigammaϜ
|
||
san ϻ San Ϻ qoppa ϙ Qoppa Ϙ
|
||
sampi ϡ Sampi Ϡ stigma ϛ Stigma Ϛ
|
||
heta ͱ Heta Ͱ sho ϸ Sho Ϸ
|
||
|A| 𝔸 |B| 𝔹 |C| ℂ |D| 𝔻
|
||
|E| 𝔼 |F| 𝔽 |G| 𝔾 |H| ℍ
|
||
|I| 𝕀 |J| 𝕁 |K| 𝕂 |L| 𝕃
|
||
|M| 𝕄 |N| ℕ |O| 𝕆 |P| ℙ
|
||
|Q| ℚ |R| ℝ |S| 𝕊 |T| 𝕋
|
||
|U| 𝕌 |V| 𝕍 |W| 𝕎 |X| 𝕏
|
||
|Y| 𝕐 |Z| ℤ |gamma|ℽ |Gamma|ℾ
|
||
|pi| ℼ |Pi| ℿ :: ∷ forall ∀
|
||
exists ∃ -> → <- ← => ⇒
|
||
~> ⇝ <~ ⇜ && ∧ || ∨
|
||
== ≡ /= ≢, ≠ <= ≤ >= ≥
|
||
/< ≮ /> ≯ * ⋅ elem ∈
|
||
notElem∉ member ∈ notMember∉ union ∪
|
||
intersection∩ isSubsetOf⊆ isProperSubsetOf⊂ <<< ⋘
|
||
>>> ⋙ <| ⊲ |> ⊳ >< ⋈
|
||
mappend⊕ . ∘ undefined⊥ := ≔
|
||
=: ≕ =def ≝ =? ≟ ... …
|
||
_0 ₀ _1 ₁ _2 ₂ _3 ₃
|
||
_4 ₄ _5 ₅ _6 ₆ _7 ₇
|
||
_8 ₈ _9 ₉ ^0 ⁰ ^1 ¹
|
||
^2 ² ^3 ³ ^4 ⁴ ^5 ⁵
|
||
^6 ⁶ ^7 ⁷ ^8 ⁸ ^9 ⁹
|
||
|
||
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’.
|
||
|
||
|
||
File: haskell-mode.info, Node: Indentation, Next: External indentation, Prev: Unicode support, Up: Top
|
||
|
||
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, *note
|
||
(emacs)Indentation::.
|
||
|
||
7.1 Rectangle Commands
|
||
======================
|
||
|
||
GNU Emacs provides so-called “rectangle commands” which operate on
|
||
rectangular areas of text, which are particularly useful for languages
|
||
with a layout rule such as Haskell. *Note (emacs)Rectangles::, to learn
|
||
more about rectangle commands.
|
||
|
||
Moreover, CUA mode (*note (emacs)CUA Bindings::) provides enhanced
|
||
rectangle support with visible rectangle highlighting. When CUA mode is
|
||
active, you can initiate a rectangle selection by ‘C-RET’ and extend it
|
||
simply by movement commands. You don’t have to enable full CUA mode to
|
||
benefit from these enhanced rectangle commands; you can activate CUA
|
||
selection mode (without redefining ‘C-x’,‘C-c’,‘C-v’, and ‘C-z’) by
|
||
calling ‘M-x cua-selection-mode’ (or adding ‘(cua-selection-mode nil)’
|
||
to your ‘haskell-mode-hook’).
|
||
|
||
7.2 Region indent is a no-op
|
||
============================
|
||
|
||
There is a ‘indent-region’ function that supposedly could be used to
|
||
indent code region without changing its semantics. Sadly it does not
|
||
work that way because usual use case for ‘indent-region’ is:
|
||
|
||
1. Alter first line of code in region.
|
||
2. Call ‘indent-region’ to fix indentation for remaining lines.
|
||
|
||
Note that between 1 and 2 program is already semantically broken and
|
||
knowing how to indent it preserving semantic from before step 1 would
|
||
require time travel.
|
||
|
||
To stay on the safe side ‘indent-region-function’ is bound to a no-op
|
||
in ‘haskell-mode’.
|
||
|
||
|
||
File: haskell-mode.info, Node: External indentation, Next: Autoformating, Prev: Indentation, Up: Top
|
||
|
||
8 Other ways to indent code
|
||
***************************
|
||
|
||
8.1 Indentation with tabs, not spaces
|
||
=====================================
|
||
|
||
Some projects require indenting code with tabs and forbid indenting it
|
||
with spaces. For hacking on such projects, check out
|
||
haskell-tab-indent-mode
|
||
(https://spwhitton.name/tech/code/haskell-tab-indent).
|
||
|
||
8.2 Structured indentation
|
||
==========================
|
||
|
||
Another alternative is to install structured-haskell-mode
|
||
(https://github.com/chrisdone/structured-haskell-mode). which indents
|
||
code by parsing the code with a full Haskell parser and deciding where
|
||
to indent based on that.
|
||
|
||
|
||
File: haskell-mode.info, Node: Autoformating, Next: Module templates, Prev: External indentation, Up: Top
|
||
|
||
9 Using external formatters
|
||
***************************
|
||
|
||
You can enable stylish-haskell
|
||
(https://github.com/jaspervdj/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’.
|
||
|
||
|
||
File: haskell-mode.info, Node: Module templates, Next: Declaration scanning, Prev: Autoformating, Up: Top
|
||
|
||
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.
|
||
|
||
|
||
File: haskell-mode.info, Node: Declaration scanning, Next: Compilation, Prev: Module templates, Up: Top
|
||
|
||
11 Declaration scannning
|
||
************************
|
||
|
||
‘haskell-decl-scan-mode’ is a minor mode which performs declaration
|
||
scanning and provides ‘M-x imenu’ support (*note (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 (*note (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 (*note (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 (*note (emacs)Speedbar::) or the
|
||
global “Which Function” minor mode (*note (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))
|
||
|
||
11.1 Speedbar
|
||
=============
|
||
|
||
Haskell-mode comes with declaration scanning support. This means that
|
||
if you enable Haskell support for speedbar:
|
||
|
||
(speedbar-add-supported-extension ".hs")
|
||
|
||
And open speedbar with
|
||
|
||
‘M-x speedbar’
|
||
|
||
It gives a listing of each module and under each module:
|
||
|
||
Imports
|
||
Instances
|
||
Data types
|
||
Classes
|
||
Bindings
|
||
|
||
You will get a bar that looks like this:
|
||
|
||
~/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
|
||
|
||
The hierarchy is expandable/collapsible and each entry will jump to
|
||
the line in the right file when clicked/selected.
|
||
|
||
|
||
File: haskell-mode.info, Node: Compilation, Next: Interactive Haskell, Prev: Declaration scanning, Up: Top
|
||
|
||
12 Compilation
|
||
**************
|
||
|
||
Haskell mode comes equipped with a specialized “Compilation mode”
|
||
tailored to GHC’s compiler messages with optional support for Cabal
|
||
projects. *Note (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
|
||
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’ tries to guess how to compile the
|
||
Haskell program your currently visited buffer belongs to, by searching
|
||
for a ‘.cabal’ file in the current of enclosing parent folders. If a
|
||
‘.cabal’ file was found, the command defined in the
|
||
‘haskell-compile-cabal-build-command’ option is used. Note that to
|
||
compile a ‘stack’ based project you will need to set this variable to
|
||
‘stack build’. As usual you can do it using ‘M-x customize-variable’ or
|
||
with:
|
||
|
||
(setq haskell-compile-cabal-build-command "stack build")
|
||
|
||
Moreover, when requesting to compile a ‘.cabal’-file is detected and
|
||
a negative prefix argument (e.g. ‘C-- C-c C-c’) was given, the
|
||
alternative ‘haskell-compile-cabal-build-command-alt’ is invoked. By
|
||
default, ‘haskell-compile-cabal-build-command-alt’ contains a ‘cabal
|
||
clean -s’ command in order to force a full rebuild.
|
||
|
||
Otherwise if no ‘.cabal’ could be found, a single-module compilation
|
||
is assumed and ‘haskell-compile-command’ is used (_if_ the currently
|
||
visited buffer contains Haskell source code).
|
||
|
||
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.
|
||
|
||
12.1 Keybindings
|
||
================
|
||
|
||
Key Function
|
||
binding
|
||
------------
|
||
TAB compilation-next-error
|
||
|
||
RET compile-goto-error
|
||
|
||
C-o compilation-display-error
|
||
|
||
SPC scroll-up-command
|
||
|
||
- negative-argument
|
||
|
||
0 digit-argument
|
||
..
|
||
9
|
||
< beginning-of-buffer
|
||
|
||
> end-of-buffer
|
||
|
||
? describe-mode
|
||
|
||
g recompile
|
||
|
||
h describe-mode
|
||
|
||
q quit-window
|
||
|
||
DEL scroll-down-command
|
||
|
||
S-SPC scroll-down-command
|
||
|
||
<backtab>compilation-previous-error
|
||
|
||
<follow-link>mouse-face
|
||
|
||
<mouse-2>compile-goto-error
|
||
|
||
<remap>Prefix
|
||
Command
|
||
|
||
M-n compilation-next-error
|
||
|
||
M-p compilation-previous-error
|
||
|
||
M-{ compilation-previous-file
|
||
|
||
M-} compilation-next-file
|
||
|
||
C-c compile-goto-error
|
||
C-c
|
||
C-c next-error-follow-minor-mode
|
||
C-f
|
||
C-c kill-compilation
|
||
C-k
|
||
|
||
|
||
File: haskell-mode.info, Node: Interactive Haskell, Next: Editing Cabal files, Prev: Compilation, Up: Top
|
||
|
||
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 similiar 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.
|
||
|
||
13.1 Goto Error
|
||
===============
|
||
|
||
In a Haskell source buffer associated with a GHCi session, errors that
|
||
prevent the file from loading are highlighted with ‘haskell-error-face’.
|
||
You can move between these error lines with
|
||
|
||
‘M-n’
|
||
is bound to ‘haskell-goto-next-error’
|
||
‘M-p’
|
||
is bound to ‘haskell-goto-prev-error’
|
||
‘C-c M-p’
|
||
is bound to ‘haskell-goto-first-error’
|
||
|
||
13.2 Using GHCi 8+ or GHCi-ng
|
||
=============================
|
||
|
||
If you use either of the above, then you can use these functions:
|
||
|
||
(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)
|
||
|
||
You have to load the module before it works, after that it will
|
||
remember for the current GHCi session.
|
||
|
||
13.3 Customizing
|
||
================
|
||
|
||
What kind of Haskell REPL ‘haskell-interactive-mode’ will start up
|
||
depends on the value of ‘haskell-process-type’. This can be one of the
|
||
symbols ‘auto’, ‘ghci’, ‘cabal-repl’, ‘cabal-new-repl’, or ‘stack-ghci’.
|
||
If it’s ‘auto’, the directory contents and available programs will be
|
||
used to make a best guess at the process type. The actual process type
|
||
will then determine which variables ‘haskell-interactive-mode’ will
|
||
access to determine the program to start and its arguments:
|
||
|
||
• If it’s ‘ghci’, ‘haskell-process-path-ghci’ and
|
||
‘haskell-process-args-ghci’ will be used.
|
||
• If it’s ‘cabal-repl’, ‘haskell-process-path-cabal’ and
|
||
‘haskell-process-args-cabal-repl’.
|
||
• If it’s ‘cabal-new-repl’, ‘haskell-process-path-cabal’ and
|
||
‘haskell-process-args-cabal-new-repl’.
|
||
• If it’s ‘stack-ghci’, ‘haskell-process-path-stack’ and
|
||
‘haskell-process-args-stack-ghci’ will be used.
|
||
|
||
With each of these pairs, the the ‘haskell-process-path-...’ variable
|
||
needs to be a string specifying the program path, or a list of strings
|
||
where the first element is the program path and the rest are initial
|
||
arguments. The ‘haskell-process-args-...’ is a list of strings
|
||
specifying (further) command-line arguments.
|
||
|
||
13.4 Haskell Interactive Mode Setup
|
||
===================================
|
||
|
||
The most straight-forward way to get setup with Interactive Mode is to
|
||
bind the right keybindings and set some customizations. This page
|
||
contains a good base setup.
|
||
|
||
To enable the minor mode which activates keybindings associated with
|
||
interactive mode, use:
|
||
|
||
(require 'haskell-interactive-mode)
|
||
(require 'haskell-process)
|
||
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)
|
||
|
||
13.4.1 Customizations
|
||
---------------------
|
||
|
||
This enables some handy and benign features.
|
||
|
||
(custom-set-variables
|
||
'(haskell-process-suggest-remove-import-lines t)
|
||
'(haskell-process-auto-import-loaded-modules t)
|
||
'(haskell-process-log t))
|
||
|
||
13.4.2 Haskell-mode bindings
|
||
----------------------------
|
||
|
||
This gives the basic ways to start a session. In a Haskell buffer:
|
||
|
||
• Run ‘C-`’ to make a REPL open, this will create a session, start
|
||
GHCi, and open the REPL.
|
||
• Or: run ‘C-c C-l’ to load the file. This will first try to start a
|
||
session as the previous command does.
|
||
• Or: run any command which requires a running session. It will
|
||
always prompt to create one if there isn’t one already for the
|
||
current project.
|
||
|
||
(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)
|
||
|
||
13.4.3 Cabal-mode bindings
|
||
--------------------------
|
||
|
||
The below commands pretty much match the ones above, but are handy to
|
||
have in cabal-mode, too:
|
||
|
||
(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)
|
||
|
||
13.4.4 GHCi process type
|
||
------------------------
|
||
|
||
By default ‘haskell-process-type’ is set to ‘auto’. It is smart enough
|
||
to pick the right type based on your project structure and installed
|
||
tools, but in case something goes funky or you want to explicitly set
|
||
the process type and ignore the inferred type, you can customize this
|
||
setting by running ‘M-x’ ‘customize-variable’ ‘RET’
|
||
‘haskell-process-type’ ‘RET’, or by setting the code:
|
||
|
||
(custom-set-variables
|
||
'(haskell-process-type 'cabal-repl))
|
||
|
||
Here is a list of available process types:
|
||
|
||
• ghci
|
||
• cabal-repl
|
||
• cabal-new-repl
|
||
• cabal-dev
|
||
• cabal-ghci
|
||
• stack-ghci
|
||
|
||
Please, check the documentation for ‘haskell-process-type’ to see how
|
||
the real type is guessed, when it’s set to ‘auto’.
|
||
|
||
13.4.5 Troubleshooting
|
||
----------------------
|
||
|
||
Launching your GHCi process can fail when you’re first getting setup,
|
||
depending on the type you choose. If it does fail to launch, switch to
|
||
the buffer ‘*haskell-process-log*’ and see what’s up. The buffer
|
||
contains a log of incoming/outgoing messages to the GHCi process.
|
||
|
||
13.5 Haskell Interactive Mode Tags Using GHCi
|
||
=============================================
|
||
|
||
You can bind the following to use GHCi to find definitions of things:
|
||
|
||
(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-jump-to-def)
|
||
|
||
The one problem with this approach is that if your code doesn’t
|
||
compile, GHCi doesn’t give any location info. So you need to make sure
|
||
your code compiles and the modules you want to jump to are loaded
|
||
byte-compiled.
|
||
|
||
Note: I think that when you restart GHCi you lose location
|
||
information, even if you have the ‘.o’ and ‘.hi’ files lying around.
|
||
I’m not sure. But sometimes ‘:i foo’ will give ‘foo is defined in Bar’
|
||
rather than ‘foo is defined in /foo/Bar.hs:123:23’.
|
||
|
||
Alternatively, you can use tags generation, which doesn’t require a
|
||
valid compile.
|
||
|
||
13.5.1 Tags Setup
|
||
-----------------
|
||
|
||
Make sure to install ‘hasktags’.
|
||
|
||
$ cabal install hasktags
|
||
|
||
Then add the customization variable to enable tags generation on
|
||
save:
|
||
|
||
(custom-set-variables
|
||
'(haskell-tags-on-save t))
|
||
|
||
And make sure ‘hasktags’ is in your ‘$PATH’ which Emacs can see.
|
||
|
||
13.5.2 Generating tags
|
||
----------------------
|
||
|
||
Now, every time you run ‘save-buffer’ (‘C-x C-s’), there is a hook that
|
||
will run and generate Emacs *Note (emacs)Tags:: for the whole project
|
||
directory. The resulting file will be called ‘TAGS’.
|
||
|
||
WARNING: You should be careful that your project root isn’t your home
|
||
directory or something, otherwise it will traverse all the way down and
|
||
take an impossibly long time.
|
||
|
||
13.5.3 Jumping to tags
|
||
----------------------
|
||
|
||
Bind the following keybinding:
|
||
|
||
(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-tag-find)
|
||
|
||
To jump to the location of the top-level identifier at point, run
|
||
‘M-x’ ‘haskell-mode-tag-find’ or ‘M-.’.
|
||
|
||
13.5.4 Hybrid: GHCi and fallback to tags
|
||
----------------------------------------
|
||
|
||
To use GHCi first and then if that fails to fallback to tags for
|
||
jumping, use:
|
||
|
||
(define-key haskell-mode-map (kbd "M-.") 'haskell-mode-jump-to-def-or-tag)
|
||
|
||
13.5.5 Troubleshooting tags
|
||
---------------------------
|
||
|
||
Sometimes a ‘TAGS’ file is deleted (by you or some other process).
|
||
Emacs will complain that it doesn’t exist anymore. To resolve this
|
||
simply do ‘M-x’ ‘tags-reset-tags-tables’.
|
||
|
||
13.6 Sessions
|
||
=============
|
||
|
||
All commands in Haskell Interactive Mode work within a session.
|
||
Consider it like a “project” or a “solution” in popular IDEs. It tracks
|
||
the root of your project and an associated process and REPL.
|
||
|
||
13.6.1 Start a session
|
||
----------------------
|
||
|
||
To start a session run the following steps:
|
||
|
||
• Open some Cabal or Haskell file.
|
||
• Run ‘C-`’ to make a REPL open, this will create a session, start
|
||
GHCi, and open the REPL.
|
||
• Or: run ‘C-c C-l’ to load the file. This will first try to start a
|
||
session as the previous command does.
|
||
• Or: run any command which requires a running session. It will
|
||
always prompt to create one if there isn’t one already for the
|
||
current project.
|
||
|
||
It will prompt for a Cabal directory and a current directory. It
|
||
figures out where the cabal directory is and defaults for the current
|
||
directory, so you should be able to just hit RET twice.
|
||
|
||
13.6.2 Switch a session
|
||
-----------------------
|
||
|
||
Sometimes a particular file is used in two different sessions/projects.
|
||
You can run
|
||
|
||
M-x haskell-session-change
|
||
|
||
If it prompts you to make a new session, tell it no (that’s a bug).
|
||
It will ask you to choose from a list of sessions.
|
||
|
||
13.6.3 Killing a session
|
||
------------------------
|
||
|
||
To kill a session you can run
|
||
|
||
M-x haskell-session-kill
|
||
|
||
Which will prompt to kill all associated buffers, too. Hit ‘n‘ to
|
||
retain them.
|
||
|
||
Alternatively, you can switch to the REPL and just kill the buffer
|
||
normally with ‘C-x k RET’. It will prompt
|
||
|
||
Kill the whole session (y or n)?
|
||
|
||
You can choose ‘y’ to kill the session itself, or ‘n’ to just kill
|
||
the REPL buffer. You can bring it back with ‘M-x’
|
||
‘haskell-interactive-bring’.
|
||
|
||
13.6.4 Menu
|
||
-----------
|
||
|
||
To see a list of all sessions you have open with some simple statistics
|
||
about memory usage, etc. run
|
||
|
||
M-x haskell-menu
|
||
|
||
For example:
|
||
|
||
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
|
||
|
||
13.7 Compiling
|
||
==============
|
||
|
||
There are a bunch of ways to compile Haskell modules. This page covers
|
||
a few of them.
|
||
|
||
13.7.1 Load into GHCi
|
||
---------------------
|
||
|
||
To compile and load a Haskell module into GHCi, run the following
|
||
|
||
M-x haskell-process-load
|
||
|
||
Or ‘C-c C-l’. You’ll see any compile errors in the REPL window.
|
||
|
||
13.7.2 Build the Cabal project
|
||
------------------------------
|
||
|
||
To compile the whole Cabal project, run the following
|
||
|
||
M-x haskell-process-cabal-build
|
||
|
||
Or ‘C-c C-c’. You’ll see any compile errors in the REPL window.
|
||
|
||
13.7.3 Reloading modules
|
||
------------------------
|
||
|
||
To reload the current module, even when you’re in other modules, you can
|
||
run ‘C-u M-x’ ‘haskell-process-load-or-reload’ or ‘C-u C-c C-l’. It
|
||
will now reload that module whenever you run ‘C-c C-l’ in the future
|
||
from whatever module you’re in. To disable this mode, just run ‘C-u C-c
|
||
C-l’ again.
|
||
|
||
13.7.4 Jumping to compile errors
|
||
--------------------------------
|
||
|
||
You can use the standard compile error navigation function ‘C-x `’ —
|
||
jump to the next error.
|
||
|
||
Or you can move your cursor to an error in the REPL and hit ‘RET’ to
|
||
jump to it.
|
||
|
||
13.7.5 Auto-removing imports
|
||
----------------------------
|
||
|
||
If the customization variable
|
||
‘haskell-process-suggest-remove-import-lines’ is enabled.
|
||
|
||
(custom-set-variables
|
||
'(haskell-process-suggest-remove-import-lines t))
|
||
|
||
Building and loading modules which output warnings like,
|
||
|
||
Warning: The import of `Control.Monad' is redundant
|
||
except perhaps to import instances from `Control.Monad'
|
||
To import instances alone, use: import Control.Monad()
|
||
|
||
will prompt the user with
|
||
|
||
> The import line `Control.Monad' is redundant. Remove? (y, n, c: comment out)
|
||
|
||
If you answer
|
||
|
||
• ‘y’: it will delete the import, but leave the empty line remaining
|
||
(this avoids messing with line positions in subsequent error
|
||
messages).
|
||
• ‘n’: it will leave the import.
|
||
• ‘c’: it will comment out the import (this is handy for when you
|
||
just want to temporarily hide an import).
|
||
|
||
13.7.6 Auto-adding of modules to import
|
||
---------------------------------------
|
||
|
||
Enable the customization variable
|
||
‘haskell-process-suggest-hoogle-imports’.
|
||
|
||
(custom-set-variables
|
||
'(haskell-process-suggest-hoogle-imports t))
|
||
|
||
Whenever GHC says something is not in scope, it will hoogle that
|
||
symbol. If there are results, it will prompt to add one of the modules
|
||
from Hoogle’s results.
|
||
|
||
You need to make sure you’ve generated your Hoogle database properly.
|
||
|
||
13.7.7 Auto-adding of extensions
|
||
--------------------------------
|
||
|
||
It you use an extension which is not enabled, GHC will often inform you.
|
||
For example, if you write:
|
||
|
||
newtype X a = X (IO a)
|
||
deriving (Monad)
|
||
|
||
Then you’ll see a message like:
|
||
|
||
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'
|
||
|
||
This ‘-XFoo’ pattern will be picked up and you will be prompted:
|
||
|
||
> Add `{-# LANGUAGE GeneralizedNewtypeDeriving #-}` to the top of the
|
||
> file? (y or n)
|
||
|
||
If you answer ‘y‘, it will temporarily jump to the buffer and it to
|
||
the top of the file.
|
||
|
||
13.7.8 Orphan instances
|
||
-----------------------
|
||
|
||
If GHC complains about orphan instances, you usually are doing it
|
||
intentionally, so it prompts to add ‘-fno-warn-orphans’ to the top of
|
||
the file with an ‘OPTIONS’ pragma.
|
||
|
||
13.7.9 Auto-adding of dependencies
|
||
----------------------------------
|
||
|
||
When doing a build, you will sometimes get a message from GHC like:
|
||
|
||
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'.
|
||
|
||
This message contains all the necessary information to add this to
|
||
your .cabal file, so you will be prompted to add it to your .cabal file:
|
||
|
||
Add `attoparsec' to ace.cabal? (y or n) y
|
||
|
||
If you hit ‘y’, it will prompt with this:
|
||
|
||
attoparsec >= 0.11.1.0
|
||
|
||
Which you can edit (e.g. do some PVP decision or remove constraints
|
||
entirely), and then it will open up your ‘.cabal’ file and go through
|
||
each section:
|
||
|
||
Add to library? (y or n) y
|
||
|
||
This will add it to the top of the ‘build-depends’ field in your
|
||
library section. If you have any executables, it will go through each
|
||
of those, prompting, too.
|
||
|
||
Now you can rebuild with ‘C-c C-c’ again.
|
||
|
||
13.8 Haskell Interactive Mode REPL
|
||
==================================
|
||
|
||
When GHCi has been launched, it works on a read-eval-print basis. So
|
||
you will be presented with the prompt:
|
||
|
||
The lambdas must flow.
|
||
Changed directory: /path/to/your/project/
|
||
λ>
|
||
|
||
13.8.1 Changing REPL target
|
||
---------------------------
|
||
|
||
With ‘haskell-session-change-target’ you can change the target for REPL
|
||
session.
|
||
|
||
After REPL session started, in ‘haskell-interactive-mode’ buffer
|
||
invoke the ‘haskell-session-change-target’ and select from available
|
||
targets for
|
||
|
||
- Testing
|
||
|
||
- Benchmark
|
||
|
||
- Executable
|
||
|
||
- Library
|
||
|
||
Answer “yes” to restart the session and run your tests, benchmarks,
|
||
executables.
|
||
|
||
TODO/WRITEME
|
||
|
||
13.8.2 Bringing the REPL
|
||
------------------------
|
||
|
||
If you don’t know where the REPL buffer is, you can always bring it
|
||
with:
|
||
|
||
M-x haskell-interactive-bring
|
||
|
||
Or ‘C-`’.
|
||
|
||
13.8.3 Evaluating expressions
|
||
-----------------------------
|
||
|
||
To evaluate expressions, simply type one out and hit ‘RET‘.
|
||
|
||
λ> 123
|
||
123
|
||
|
||
13.8.4 Evaluating multiline expressions
|
||
---------------------------------------
|
||
|
||
GHCi features two ways to evaluate multiline expressions. You can use
|
||
‘:set +m’ to enable multiline input
|
||
(https://www.haskell.org/ghc/docs/latest/html/users_guide/ghci.html#multiline-input)
|
||
for all expressions, or you can wrap your expression in ‘:{’ and ‘:}’
|
||
(they have to be on their own lines).
|
||
|
||
The prompt will change to indicate that you’re inputting a multiline
|
||
expression:
|
||
|
||
λ> :{
|
||
λ| let a = 10
|
||
λ| b = 20
|
||
λ| c = 30
|
||
λ| :}
|
||
|
||
You can also simulate multiline mode by having your input contain
|
||
newline characters. You can input a literal newline character with ‘C-q
|
||
C-j’, or you can use:
|
||
|
||
M-x haskell-interactive-mode-newline-indent
|
||
|
||
which is bound to ‘C-j’. This command indents after the newline.
|
||
You can simulate the above example like so:
|
||
|
||
λ> let a = 10
|
||
b = 20
|
||
c = 30
|
||
|
||
13.8.5 Type of expressions
|
||
--------------------------
|
||
|
||
You can use normal ‘:type’ which is part of GHCi to get the type of
|
||
something:
|
||
|
||
λ> :t id
|
||
id :: a -> a
|
||
|
||
But you can also just write out the value directly,
|
||
|
||
λ> id
|
||
id :: a -> a
|
||
|
||
and because there’s no ‘Show’ instance for ‘(a -> a)’. This would
|
||
normally yield a compile error:
|
||
|
||
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
|
||
|
||
It will run ‘:type id’ in the background and print out the result.
|
||
The same is true for ambiguous things:
|
||
|
||
λ> :t read "a"
|
||
read "a" :: Read a => a
|
||
|
||
Because this would normally be an ambiguous constraint:
|
||
|
||
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\"
|
||
|
||
Which is less useful than just printing the type out.
|
||
|
||
You can disable this behaviour by disabling the customization option:
|
||
|
||
(custom-set-variables
|
||
'(haskell-interactive-types-for-show-ambiguous nil))
|
||
|
||
13.8.6 Printing mode
|
||
--------------------
|
||
|
||
You can choose between printing modes used for the results of evaluating
|
||
expressions. To do that, configure the variable
|
||
‘haskell-interactive-mode-eval-mode’. Example:
|
||
|
||
(setq haskell-interactive-mode-eval-mode 'haskell-mode)
|
||
|
||
A handy function you can use is:
|
||
|
||
(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")))))
|
||
|
||
(Add whichever modes you want to use.)
|
||
|
||
And then run
|
||
|
||
M-x haskell-interactive-toggle-print-mode
|
||
|
||
Or ‘C-c C-v’:
|
||
|
||
(define-key haskell-interactive-mode-map (kbd "C-c C-v")
|
||
'haskell-interactive-toggle-print-mode)
|
||
|
||
There you can choose ‘haskell-mode‘, for example, to pretty print the
|
||
output as Haskell.
|
||
|
||
13.8.7 SVG images rendering
|
||
---------------------------
|
||
|
||
If you are working on SVG images, you can instruct Emacs to render the
|
||
image as the output of an image producing command at the REPL.
|
||
|
||
The following example uses the ‘diamgrams’ library with the default
|
||
SVG backend to produce a circle:
|
||
|
||
{-# 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
|
||
|
||
After enabling SVG rendering with ‘M-x
|
||
haskell-svg-toggle-render-images’, if you load the above code and type
|
||
‘circle’ at the REPL, you will see the rendered circle instead of the
|
||
XML representation of the image.
|
||
|
||
This feature can be enabled by default by setting the customization
|
||
variable ‘haskell-svg-render-images’ to a non-nil value.
|
||
|
||
13.8.8 Presentations
|
||
--------------------
|
||
|
||
If you have the ‘present’ package installed, you can use the following
|
||
syntax to print anything which is an instance of ‘Data’:
|
||
|
||
λ> :present 123
|
||
123
|
||
|
||
It will print data structures lazily:
|
||
|
||
λ> :present [1..]
|
||
[1
|
||
,[Integer]]
|
||
|
||
It shows types when there is an unevaluated field in a constructor.
|
||
You can click the ‘[Integer]’ or press ‘RET’ on it to expand further:
|
||
|
||
λ> :present [1..]
|
||
[1
|
||
,2
|
||
,[Integer]]
|
||
|
||
Etc. Remember: this only works for instances of ‘Data.Data.Data’.
|
||
|
||
13.8.9 History
|
||
--------------
|
||
|
||
A history is maintained for the duration of the REPL buffer. To go up
|
||
and down in the history, run ‘M-p’ for previous and ‘M-n’ for next.
|
||
|
||
13.8.10 Cancelling commands
|
||
---------------------------
|
||
|
||
To cancel a running REPL command, run ‘C-c C-c’.
|
||
|
||
13.8.11 Clear the REPL
|
||
----------------------
|
||
|
||
Run ‘C-c C-k’ to clear the REPL.
|
||
|
||
13.8.12 Trick: Put Interactive REPL in Separate Frame
|
||
-----------------------------------------------------
|
||
|
||
The following ‘create-haskell-interactive-frame’ is a quick hack to move
|
||
the repl to a separate frame, for those that want a more predictable
|
||
layout of windows in Emacs.
|
||
|
||
(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))
|
||
|
||
|
||
13.8.13 Troubleshooting
|
||
-----------------------
|
||
|
||
If the REPL ever goes funny, you can clear the command queue via:
|
||
|
||
M-x haskell-process-clear
|
||
|
||
Alternatively, you can just restart the process:
|
||
|
||
M-x haskell-process-restart
|
||
|
||
You can also switch to the buffer ‘*haskell-process-log*’, which can
|
||
be enabled and disabled with the customization variable
|
||
‘haskell-process-log‘, to see what the cause of your troubles are.
|
||
|
||
If the process fails and nothing unusual is in the process log, the
|
||
following command can dump the ‘haskell-process’ state:
|
||
|
||
M-: (haskell-process)
|
||
|
||
The output can be copied from the ‘*Messages*’ buffer.
|
||
|
||
13.9 Haskell Interactive Mode Querying
|
||
======================================
|
||
|
||
There a few ways GHCi lets you query information about your code.
|
||
|
||
13.9.1 Get identifer type
|
||
-------------------------
|
||
|
||
To print the type of the top-level identifier at point in the REPL and
|
||
in the message buffer, run the following command:
|
||
|
||
M-x haskell-process-do-type
|
||
|
||
or ‘C-c C-t’.
|
||
|
||
13.9.2 Insert identifier’s type as type signature
|
||
-------------------------------------------------
|
||
|
||
To print the type of the top-level identifier at point, run the
|
||
following command:
|
||
|
||
C-u M-x haskell-process-do-type
|
||
|
||
or ‘C-u C-c C-t’.
|
||
|
||
13.9.3 Get identifier info
|
||
--------------------------
|
||
|
||
To print the info of the identifier at point, run the following command:
|
||
|
||
M-x haskell-process-do-info
|
||
|
||
or ‘C-c C-i’.
|
||
|
||
13.9.4 Presentation mode
|
||
------------------------
|
||
|
||
When using ‘C-c C-i’ or ‘C-c C-t’ it will open a buffer in
|
||
haskell-presentation-mode. You can hit ‘q’ to close the buffer.
|
||
|
||
But you can also continue to use ‘C-c C-i’ inside the buffer to drill
|
||
further down data types and classes.
|
||
|
||
E.g. if you go to ‘Ord’ in your code buffer and ‘C-c C-i’, it will
|
||
popup a buffer containing
|
||
|
||
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'
|
||
|
||
And all the instances of that class. But then you can also move your
|
||
cursor to ‘Ordering’ and hit ‘C-c C-i’ again to get another popup:
|
||
|
||
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'
|
||
|
||
And so on. It’s a very good way of exploring a new codebase.
|
||
|
||
13.9.5 Browse import’s module
|
||
-----------------------------
|
||
|
||
To print all exported identifiers of the module imported by the import
|
||
line at point, run the following command:
|
||
|
||
M-x haskell-process-do-info
|
||
|
||
or ‘C-c C-i’. It will print all exports by running ‘:browse
|
||
The.Module’ in the GHCi process.
|
||
|
||
13.10 Haskell Interactive Mode Cabal integration
|
||
================================================
|
||
|
||
There’s some integration with Cabal in Haskell Interactive Mode. Once
|
||
you’ve started a session, the features below are available.
|
||
|
||
13.10.1 Cabal building
|
||
----------------------
|
||
|
||
The most common Cabal action is building, so that has a specific
|
||
command:
|
||
|
||
M-x haskell-process-cabal-build
|
||
|
||
Or ‘C-c C-c’. When building, it will hide unneccessary output.
|
||
|
||
For example, to build the ‘ace‘ package, the output is simply:
|
||
|
||
Compiling: ACE.Types.Tokens
|
||
Compiling: ACE.Combinators
|
||
Compiling: ACE.Tokenizer
|
||
Compiling: ACE.Parsers
|
||
Compiling: ACE.Pretty
|
||
Compiling: ACE
|
||
Complete: cabal build (0 compiler messages)
|
||
|
||
Whereas the complete output is normally:
|
||
|
||
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...
|
||
|
||
Which is considerably more verbose but rarely useful or interesting.
|
||
|
||
13.10.2 Arbitrary cabal commands
|
||
--------------------------------
|
||
|
||
To run an arbitrary Cabal command:
|
||
|
||
C-u M-x haskell-process-cabal
|
||
|
||
Or run ‘C-u C-c c’.
|
||
|
||
It will prompt for an input, so you can write ‘configure -fdev’, for
|
||
example.
|
||
|
||
13.10.3 Completing cabal commands
|
||
---------------------------------
|
||
|
||
To run some common Cabal commands, just run:
|
||
|
||
M-x haskell-process-cabal
|
||
|
||
Or ‘C-c c’. This is commonly used to do ‘install’, ‘haddock’,
|
||
‘configure’, etc.
|
||
|
||
13.11 Haskell Interactive Mode Debugger
|
||
=======================================
|
||
|
||
There is limited support for debugging in GHCi. Haskell Interactive
|
||
Mode provides an interface for interacting with this.
|
||
|
||
13.11.1 Opening the debug buffer
|
||
--------------------------------
|
||
|
||
To open the debug buffer run the following command from any buffer
|
||
associated with a session:
|
||
|
||
M-x haskell-debug
|
||
|
||
It will open a buffer that looks like this:
|
||
|
||
Debugging haskell
|
||
|
||
You have to load a module to start debugging.
|
||
|
||
g - refresh
|
||
|
||
Modules
|
||
|
||
No loaded modules.
|
||
|
||
13.11.2 Loading modules
|
||
-----------------------
|
||
|
||
To debug anything you need to load something into GHCi. Switch to a
|
||
normal file, for example:
|
||
|
||
main = do putStrLn "Hello!"
|
||
putStrLn "World"
|
||
|
||
and load it into GHCi (‘C-c C-l’). Now when you hit ‘g’ (to refresh)
|
||
in the debugging buffer, you’ll see something like:
|
||
|
||
|
||
Debugging haskell
|
||
|
||
b - breakpoint, g - refresh
|
||
|
||
Context
|
||
|
||
Not debugging right now.
|
||
|
||
Breakpoints
|
||
|
||
No active breakpoints.
|
||
|
||
Modules
|
||
|
||
Main - hello.hs
|
||
|
||
13.11.3 Setting a breakpoint
|
||
----------------------------
|
||
|
||
To set a breakpoint hit ‘b’ in the debugger buffer. It will prompt for
|
||
a name. Enter ‘main’ and hit ‘RET’.
|
||
|
||
Now the buffer will look like this:
|
||
|
||
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
|
||
|
||
13.11.4 Start stepping
|
||
----------------------
|
||
|
||
Hit ‘s’ to step through an expression: it will prompt for an expression
|
||
to evaluate and step through. Enter ‘main’ and hit ‘RET’. Now the
|
||
buffer will look like this:
|
||
|
||
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
|
||
|
||
What we see here is the current expression being evaluated:
|
||
|
||
do putStrLn "Hello!"
|
||
putStrLn "World"
|
||
|
||
And we see the type of it:
|
||
|
||
_result :: IO () = _
|
||
|
||
And we see a backtrace of steps so far:
|
||
|
||
1 do putStrLn "Hello!" putStrLn "World"
|
||
|
||
13.11.5 Continue stepping
|
||
-------------------------
|
||
|
||
To continue stepping, just hit ‘s’ again. Now the context will change
|
||
to:
|
||
|
||
main - hello.hs (stopped)
|
||
|
||
putStrLn "Hello!"
|
||
|
||
_result :: IO () = _
|
||
|
||
1 do putStrLn "Hello!" putStrLn "World"
|
||
|
||
Hitting ‘s’ once more, we see the context change to:
|
||
|
||
putStrLn "World"
|
||
|
||
_result :: IO () = _
|
||
|
||
2 putStrLn "Hello!"
|
||
1 do putStrLn "Hello!" putStrLn "World"
|
||
|
||
Finally hitting ‘s’ again will say "Computation finished". Hitting
|
||
‘s’ a final time will change the display back to:
|
||
|
||
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
|
||
|
||
And you’re done debugging.
|
||
|
||
|
||
File: haskell-mode.info, Node: Editing Cabal files, Next: Browsing Haddocks, Prev: Interactive Haskell, Up: Top
|
||
|
||
14 Editing Cabal files
|
||
**********************
|
||
|
||
‘haskell-cabal-mode’ is a major mode for editing Cabal package
|
||
description files
|
||
(http://www.haskell.org/cabal/users-guide/developing-packages.html) 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
|
||
|
||
|
||
File: haskell-mode.info, Node: Browsing Haddocks, Next: Spell checking strings and comments, Prev: Editing Cabal files, Up: Top
|
||
|
||
15 Browsing Haddocks using ‘w3m’
|
||
********************************
|
||
|
||
An experimental feature is use of the w3m browser to browse Haddock docs
|
||
inside Emacs.
|
||
|
||
15.1 Get w3m
|
||
============
|
||
|
||
Most Linux distributions will have a package for the binary:
|
||
|
||
$ sudo apt-get install w3m
|
||
|
||
Now grab ‘w3m.el’ from:
|
||
|
||
• <http://emacs-w3m.namazu.org/>
|
||
• ‘M-x’ ‘package-install’ ‘RET’ ‘w3m’ ‘RET’
|
||
|
||
Confirm installation by trying ‘M-x’ ‘w3m-browse-url’ ‘RET’
|
||
‘haskell.org’ ‘RET’.
|
||
|
||
If this works, you’re good to go.
|
||
|
||
15.2 Configure w3m
|
||
==================
|
||
|
||
Now that you have w3m, you probably want to configure it to be more of a
|
||
passive viewer than a full-fledged browser. For example:
|
||
|
||
(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)))
|
||
|
||
15.3 Import w3m-haddock
|
||
=======================
|
||
|
||
It’s not enabled by default in haskell-mode at present, so you need to
|
||
import it manually:
|
||
|
||
(require 'w3m-haddock)
|
||
|
||
15.4 Add a hook for w3m
|
||
=======================
|
||
|
||
In order to make haddock pages a little more palatable (and add syntax
|
||
highlighting to source view), you can add this hook:
|
||
|
||
(add-hook 'w3m-display-hook 'w3m-haddock-display)
|
||
|
||
It’s a little rough around the edges, but it’s a start.
|
||
|
||
15.5 Configure your package locations
|
||
=====================================
|
||
|
||
By default, the package locations is set to:
|
||
|
||
(defcustom haskell-w3m-haddock-dirs
|
||
'("~/.cabal/share/doc/"))
|
||
|
||
If you are using an hsenv or a custom package directory, you should
|
||
configure this variable with M-x customize-variable or by writing the
|
||
custom-set-variables code for it.
|
||
|
||
15.6 Finally
|
||
============
|
||
|
||
You did all that! Now you’re ready to bind a useful key:
|
||
|
||
(define-key haskell-mode-map (kbd "C-c C-d") 'haskell-w3m-open-haddock)
|
||
|
||
Now when you press ‘C-c’ ‘C-d’ it will prompt for a package to browse
|
||
to.
|
||
|
||
This feature will be improved gradually as time goes on.
|
||
|
||
|
||
File: haskell-mode.info, Node: Spell checking strings and comments, Next: Aligning code, Prev: Browsing Haddocks, Up: Top
|
||
|
||
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 *Note
|
||
(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)’
|
||
|
||
|
||
File: haskell-mode.info, Node: Aligning code, Next: Rectangular commands, Prev: Spell checking strings and comments, Up: Top
|
||
|
||
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 literate-haskell-mode))))
|
||
(add-to-list 'align-rules-list
|
||
'(haskell-assignment
|
||
(regexp . "\\(\\s-+\\)=\\s-+")
|
||
(modes quote (haskell-mode literate-haskell-mode))))
|
||
(add-to-list 'align-rules-list
|
||
'(haskell-arrows
|
||
(regexp . "\\(\\s-+\\)\\(->\\|→\\)\\s-+")
|
||
(modes quote (haskell-mode literate-haskell-mode))))
|
||
(add-to-list 'align-rules-list
|
||
'(haskell-left-arrows
|
||
(regexp . "\\(\\s-+\\)\\(<-\\|←\\)\\s-+")
|
||
(modes quote (haskell-mode literate-haskell-mode))))
|
||
|
||
|
||
File: haskell-mode.info, Node: Rectangular commands, Next: REPL, Prev: Aligning code, Up: Top
|
||
|
||
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.
|
||
|
||
|
||
File: haskell-mode.info, Node: REPL, Next: Collapsing Haskell code, Prev: Rectangular commands, Up: Top
|
||
|
||
19 Using GHCi REPL within Emacs
|
||
*******************************
|
||
|
||
To start the REPL you can run one of the following:
|
||
|
||
• ‘M-x run-haskell’
|
||
• ‘M-x switch-to-haskell’
|
||
|
||
This repl works with Comint
|
||
(https://www.emacswiki.org/emacs/ComintMode). 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.
|
||
|
||
19.1 Relevant defcustoms:
|
||
=========================
|
||
|
||
Interpreter (defcustom) Default Possible Values
|
||
Value
|
||
---------------------------------------------------------------------------
|
||
‘haskell-process-type’ ‘'auto’ ‘'stack-ghci, 'cabal-repl,
|
||
'ghci, 'auto’
|
||
‘inferior-haskell-hook’ ‘nil’ -
|
||
‘haskell-process-path-ghci’ ‘ghci’ -
|
||
‘haskell-process-args-ghci’ ‘-ferror-spans’-
|
||
‘haskell-process-path-cabal’ ‘cabal’ -
|
||
‘haskell-process-args-cabal-repl’‘--ghc-option=-ferror-spans’-
|
||
‘haskell-process-path-stack’ ‘stack’ -
|
||
‘haskell-process-args-stack-ghci’‘--ghci-options=-ferror-spans-
|
||
--no-build
|
||
--no-load’
|
||
|
||
19.2 More on ‘haskell-process-type’
|
||
===================================
|
||
|
||
The Haskell interpreter used by ‘Inf-Haskell’ is auto-detected by
|
||
default, but is customizable with defcustom ‘haskell-process-type’. The
|
||
values recognized by it are (default is ’auto):
|
||
|
||
• ‘'stack-ghci’
|
||
• ‘'cabal-repl’
|
||
• ‘'ghci’
|
||
• ‘'auto’
|
||
|
||
if the ‘haskell-process-type’ is ‘'auto’, the directories are
|
||
searched for ‘cabal.sandbox.config’ or ‘stack.yaml’ or ‘*.cabal’ file.
|
||
If the file is present, then appropriate process is started.
|
||
|
||
When ‘cabal.sandbox.config’ is found ‘haskell-process-type’ is
|
||
‘'cabal-repl’. Similarly, when ‘stack.yaml’ is found
|
||
‘haskell-process-type’ is ‘'stack-ghci’. Similarly, when ‘xyz.cabal’ is
|
||
found ‘haskell-process-type’ is ‘'cabal-repl’. When nothing is found
|
||
‘haskell-process-type’ is ‘'ghci’. When more than one file such as
|
||
‘cabal.sandbox.config’ and ‘stack.yaml’ are found the following
|
||
preference is followed.
|
||
|
||
‘cabal.sandbox.config’ > ‘stack.yaml’ > ‘*.cabal’
|
||
|
||
|
||
File: haskell-mode.info, Node: Collapsing Haskell code, Next: Getting Help and Reporting Bugs, Prev: REPL, Up: Top
|
||
|
||
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)...
|
||
|
||
|
||
File: haskell-mode.info, Node: Getting Help and Reporting Bugs, Next: Concept index, Prev: Collapsing Haskell code, Up: Top
|
||
|
||
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 (https://github.com/haskell/haskell-mode/wiki).
|
||
|
||
To report any issues please use the Github’s issue mechanism
|
||
available from Haskell Mode’s GitHub Home
|
||
(https://github.com/haskell/haskell-mode).
|
||
|
||
For a quick question visit ‘#haskell-emacs’ channel on IRC
|
||
‘irc.freenode.net’.
|
||
|
||
There is also a (now defunct) Haskellmode-emacs mailing list
|
||
(http://projects.haskell.org/cgi-bin/mailman/listinfo/haskellmode-emacs),
|
||
also available on Gmane (http://gmane.org/) via the
|
||
gmane.comp.lang.haskell.emacs
|
||
(http://dir.gmane.org/gmane.comp.lang.haskell.emacs) newsgroup.
|
||
|
||
We welcome code and non-code contributions so that we can all enjoy
|
||
coding Haskell even more.
|
||
|
||
|
||
File: haskell-mode.info, Node: Concept index, Next: Function index, Prev: Getting Help and Reporting Bugs, Up: Top
|
||
|
||
Concept index
|
||
*************
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* benchmarking: Interactive Haskell. (line 472)
|
||
* CUA mode: Indentation. (line 49)
|
||
* customizing: Installation. (line 55)
|
||
* customizing <1>: Interactive Haskell. (line 53)
|
||
* haskell-mode: Editing Haskell Code.
|
||
(line 6)
|
||
* Images, rendering SVG images: Interactive Haskell. (line 614)
|
||
* indentation: Indentation. (line 6)
|
||
* layout rule: Indentation. (line 6)
|
||
* off-side rule: Indentation. (line 6)
|
||
* rectangle: Indentation. (line 49)
|
||
* Rendering SVG images: Interactive Haskell. (line 614)
|
||
* SVG images, rendering: Interactive Haskell. (line 614)
|
||
* testing: Interactive Haskell. (line 470)
|
||
* Unicode: Unicode support. (line 6)
|
||
|
||
|
||
File: haskell-mode.info, Node: Function index, Next: Variable index, Prev: Concept index, Up: Top
|
||
|
||
Function index
|
||
**************
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* haskell-cabal-mode: Editing Cabal files. (line 6)
|
||
* haskell-cabal-visit-file: Editing Cabal files. (line 11)
|
||
* haskell-compile: Compilation. (line 6)
|
||
* haskell-decl-scan-mode: Declaration scanning.
|
||
(line 6)
|
||
* haskell-mode: Editing Haskell Code.
|
||
(line 6)
|
||
* haskell-session-change-target: Interactive Haskell. (line 463)
|
||
* haskell-svg-toggle-render-images: Interactive Haskell. (line 630)
|
||
|
||
|
||
File: haskell-mode.info, Node: Variable index, Prev: Function index, Up: Top
|
||
|
||
Variable index
|
||
**************
|
||
|
||
[index ]
|
||
* Menu:
|
||
|
||
* haskell-c2hs-hook-name-face: Syntax highlighting. (line 39)
|
||
* haskell-c2hs-hook-pair-face: Syntax highlighting. (line 38)
|
||
* haskell-cabal-mode-hook: Editing Cabal files. (line 6)
|
||
* haskell-compile-cabal-build-command: Compilation. (line 35)
|
||
* haskell-compile-cabal-build-command-alt: Compilation. (line 35)
|
||
* haskell-compile-command: Compilation. (line 35)
|
||
* haskell-constructor-face: Syntax highlighting. (line 30)
|
||
* haskell-decl-scan-mode-hook: Declaration scanning.
|
||
(line 6)
|
||
* haskell-definition-face: Syntax highlighting. (line 31)
|
||
* haskell-interactive-mode-hook: Interactive Haskell. (line 463)
|
||
* haskell-keyword-face: Syntax highlighting. (line 28)
|
||
* haskell-literate-comment-face: Syntax highlighting. (line 35)
|
||
* haskell-mode-hook: Installation. (line 60)
|
||
* haskell-operator-face: Syntax highlighting. (line 33)
|
||
* haskell-pragma-face: Syntax highlighting. (line 34)
|
||
* haskell-process-args-cabal-new-repl: Interactive Haskell. (line 76)
|
||
* haskell-process-args-cabal-repl: Interactive Haskell. (line 76)
|
||
* haskell-process-args-ghci: Interactive Haskell. (line 76)
|
||
* haskell-process-args-stack-ghci: Interactive Haskell. (line 75)
|
||
* haskell-process-path-cabal: Interactive Haskell. (line 76)
|
||
* haskell-process-path-ghci: Interactive Haskell. (line 76)
|
||
* haskell-process-path-stack: Interactive Haskell. (line 76)
|
||
* haskell-process-type: Interactive Haskell. (line 76)
|
||
* haskell-quasi-quote-face: Syntax highlighting. (line 36)
|
||
* haskell-svg-render-images: Interactive Haskell. (line 635)
|
||
* haskell-type-face: Syntax highlighting. (line 29)
|
||
|
||
|
||
|
||
Tag Table:
|
||
Node: Top683
|
||
Node: Introduction2588
|
||
Node: Installation4173
|
||
Node: Editing Haskell Code6796
|
||
Node: Syntax highlighting10556
|
||
Node: Completion support12816
|
||
Node: Unicode support14860
|
||
Node: Indentation19532
|
||
Node: External indentation23008
|
||
Node: Autoformating23736
|
||
Node: Module templates24364
|
||
Node: Declaration scanning24794
|
||
Node: Compilation28082
|
||
Node: Interactive Haskell31987
|
||
Node: Editing Cabal files63864
|
||
Node: Browsing Haddocks64611
|
||
Node: Spell checking strings and comments67436
|
||
Node: Aligning code68542
|
||
Node: Rectangular commands70287
|
||
Node: REPL71807
|
||
Node: Collapsing Haskell code76585
|
||
Node: Getting Help and Reporting Bugs79193
|
||
Node: Concept index80237
|
||
Node: Function index81495
|
||
Node: Variable index82290
|
||
|
||
End Tag Table
|
||
|
||
|
||
Local Variables:
|
||
coding: utf-8
|
||
End:
|