Support Vim, Tmux, Emacs with Stow

After moving off of Meta, Dotfiles has a greater responsibility to
manage configs. Vim, Tmux, and Emacs are now within Stow's purview.

1 files changed, 2425 insertions, 0 deletions

diff --git a/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode.info b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode.info
new file mode 100644
index 000000000000..69dcfd97abe5
--- /dev/null
+++ b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode.info
@@ -0,0 +1,2425 @@
+This is haskell-mode.info, produced by makeinfo version 6.1 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 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.8 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.9 Cancelling commands
+--------------------------
+
+To cancel a running REPL command, run ‘C-c C-c’.
+
+13.8.10 Clear the REPL
+----------------------
+
+Run ‘C-c C-k’ to clear the REPL.
+
+13.8.11 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.12 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
+*************
+
+
+* 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)
+* indentation:                           Indentation.         (line   6)
+* layout rule:                           Indentation.         (line   6)
+* off-side rule:                         Indentation.         (line   6)
+* rectangle:                             Indentation.         (line  49)
+* 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
+**************
+
+
+* 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)
+
+
+File: haskell-mode.info,  Node: Variable index,  Prev: Function index,  Up: Top
+
+Variable 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-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 files62914
+Node: Browsing Haddocks63661
+Node: Spell checking strings and comments66486
+Node: Aligning code67592
+Node: Rectangular commands69337
+Node: REPL70857
+Node: Collapsing Haskell code75635
+Node: Getting Help and Reporting Bugs78243
+Node: Concept index79287
+Node: Function index80326
+Node: Variable index81048
+
+End Tag Table
+
+
+Local Variables:
+coding: utf-8
+End: