diff options
| author | William Carroll <wpcarro@gmail.com> | 2019-01-13T19·33-0500 |
|---|---|---|
| committer | William Carroll <wpcarro@gmail.com> | 2019-01-13T19·45-0500 |
| commit | 481df5a3855ccd5ea3bf4d5f41ae780f4773b7b4 (patch) | |
| tree | 3aeb7e20eaba176536cb8d10ba531ac39674fc4a /configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info | |
| parent | 18b9930b8604134f087ca61fe94740b31f94327c (diff) | |
Remove Emacs spam
My inconsistent git history-keeping is coming to bite me here. At the moment, I can only speculate about what went wrong here. The gist is this: I unintentionally committed files that were supposed to be ignored This commit removes those files which includes: - auto-save-list - elpa packages - quelpa packages - misc
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info')
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info | 2457 |
1 files changed, 0 insertions, 2457 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info deleted file mode 100644 index 65bb8b00aaae..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180913.348/haskell-mode.info +++ /dev/null @@ -1,2457 +0,0 @@ -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 -************* - - -* 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 -************** - - -* 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 -************** - - -* 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: |