From 17ee0e400bef47c371afcae76037f9ea6a44ad13 Mon Sep 17 00:00:00 2001
From: William Carroll <wpcarro@gmail.com>
Date: Mon, 10 Sep 2018 14:51:14 -0400
Subject: 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.
---
 .../haskell-mode-autoloads.el                      | 1011 ++++++++++++++++++++
 1 file changed, 1011 insertions(+)
 create mode 100644 configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode-autoloads.el

(limited to 'configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode-autoloads.el')

diff --git a/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode-autoloads.el b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode-autoloads.el
new file mode 100644
index 000000000000..8e49f2f0b474
--- /dev/null
+++ b/configs/shared/emacs/.emacs.d/elpa/haskell-mode-20180601.143/haskell-mode-autoloads.el
@@ -0,0 +1,1011 @@
+;;; haskell-mode-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
+
+;;;### (autoloads nil "ghc-core" "ghc-core.el" (23377 61614 464227
+;;;;;;  981000))
+;;; Generated autoloads from ghc-core.el
+
+(let ((loads (get 'ghc-core 'custom-loads))) (if (member '"ghc-core" loads) nil (put 'ghc-core 'custom-loads (cons '"ghc-core" loads))))
+
+(autoload 'ghc-core-create-core "ghc-core" "\
+Compile and load the current buffer as tidy core.
+
+\(fn)" t nil)
+
+(add-to-list 'auto-mode-alist '("\\.hcr\\'" . ghc-core-mode))
+
+(add-to-list 'auto-mode-alist '("\\.dump-simpl\\'" . ghc-core-mode))
+
+(autoload 'ghc-core-mode "ghc-core" "\
+Major mode for GHC Core files.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "ghci-script-mode" "ghci-script-mode.el" (23377
+;;;;;;  61614 444618 708000))
+;;; Generated autoloads from ghci-script-mode.el
+
+(autoload 'ghci-script-mode "ghci-script-mode" "\
+Major mode for working with .ghci files.
+
+\(fn)" t nil)
+
+(add-to-list 'auto-mode-alist '("\\.ghci\\'" . ghci-script-mode))
+
+;;;***
+
+;;;### (autoloads nil "haskell" "haskell.el" (23377 61614 468670
+;;;;;;  911000))
+;;; Generated autoloads from haskell.el
+
+(autoload 'interactive-haskell-mode "haskell" "\
+Minor mode for enabling haskell-process interaction.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'haskell-interactive-mode-return "haskell" "\
+Handle the return key.
+
+\(fn)" t nil)
+
+(autoload 'haskell-session-kill "haskell" "\
+Kill the session process and buffer, delete the session.
+0. Prompt to kill all associated buffers.
+1. Kill the process.
+2. Kill the interactive buffer unless LEAVE-INTERACTIVE-BUFFER is not given.
+3. Walk through all the related buffers and set their haskell-session to nil.
+4. Remove the session from the sessions list.
+
+\(fn &optional LEAVE-INTERACTIVE-BUFFER)" t nil)
+
+(autoload 'haskell-interactive-kill "haskell" "\
+Kill the buffer and (maybe) the session.
+
+\(fn)" t nil)
+
+(autoload 'haskell-session "haskell" "\
+Get the Haskell session, prompt if there isn't one or fail.
+
+\(fn)" nil nil)
+
+(autoload 'haskell-interactive-switch "haskell" "\
+Switch to the interactive mode for this session.
+
+\(fn)" t nil)
+
+(autoload 'haskell-session-change "haskell" "\
+Change the session for the current buffer.
+
+\(fn)" t nil)
+
+(autoload 'haskell-kill-session-process "haskell" "\
+Kill the process.
+
+\(fn &optional SESSION)" t nil)
+
+(autoload 'haskell-interactive-mode-visit-error "haskell" "\
+Visit the buffer of the current (or last) error message.
+
+\(fn)" t nil)
+
+(autoload 'haskell-mode-jump-to-tag "haskell" "\
+Jump to the tag of the given identifier.
+
+Give optional NEXT-P parameter to override value of
+`xref-prompt-for-identifier' during definition search.
+
+\(fn &optional NEXT-P)" t nil)
+
+(autoload 'haskell-mode-after-save-handler "haskell" "\
+Function that will be called after buffer's saving.
+
+\(fn)" nil nil)
+
+(autoload 'haskell-mode-tag-find "haskell" "\
+The tag find function, specific for the particular session.
+
+\(fn &optional NEXT-P)" t nil)
+
+(autoload 'haskell-interactive-bring "haskell" "\
+Bring up the interactive mode for this session.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-load-file "haskell" "\
+Load the current buffer file.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-reload "haskell" "\
+Re-load the current buffer file.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-reload-file "haskell" "\
+
+
+\(fn)" nil nil)
+
+(autoload 'haskell-process-load-or-reload "haskell" "\
+Load or reload. Universal argument toggles which.
+
+\(fn &optional TOGGLE)" t nil)
+
+(autoload 'haskell-process-cabal-build "haskell" "\
+Build the Cabal project.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-cabal "haskell" "\
+Prompts for a Cabal command to run.
+
+\(fn P)" t nil)
+
+(autoload 'haskell-process-minimal-imports "haskell" "\
+Dump minimal imports.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-align-imports" "haskell-align-imports.el"
+;;;;;;  (23377 61614 510222 266000))
+;;; Generated autoloads from haskell-align-imports.el
+
+(autoload 'haskell-align-imports "haskell-align-imports" "\
+Align all the imports in the buffer.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-c2hs" "haskell-c2hs.el" (23377 61614
+;;;;;;  473135 401000))
+;;; Generated autoloads from haskell-c2hs.el
+
+(add-to-list 'auto-mode-alist '("\\.chs\\'" . haskell-c2hs-mode))
+
+(autoload 'haskell-c2hs-mode "haskell-c2hs" "\
+Mode for editing *.chs files of the c2hs haskell tool.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-cabal" "haskell-cabal.el" (23377 61614
+;;;;;;  491779 380000))
+;;; Generated autoloads from haskell-cabal.el
+
+(add-to-list 'auto-mode-alist '("\\.cabal\\'" . haskell-cabal-mode))
+
+(autoload 'haskell-cabal-mode "haskell-cabal" "\
+Major mode for Cabal package description files.
+
+\(fn)" t nil)
+
+(autoload 'haskell-cabal-get-field "haskell-cabal" "\
+Read the value of field with NAME from project's cabal file.
+If there is no valid .cabal file to get the setting from (or
+there is no corresponding setting with that name in the .cabal
+file), then this function returns nil.
+
+\(fn NAME)" t nil)
+
+(autoload 'haskell-cabal-get-dir "haskell-cabal" "\
+Get the Cabal dir for a new project. Various ways of figuring this out,
+   and indeed just prompting the user. Do them all.
+
+\(fn &optional USE-DEFAULTS)" nil nil)
+
+(autoload 'haskell-cabal-visit-file "haskell-cabal" "\
+Locate and visit package description file for file visited by current buffer.
+This uses `haskell-cabal-find-file' to locate the closest
+\".cabal\" file and open it.  This command assumes a common Cabal
+project structure where the \".cabal\" file is in the top-folder
+of the project, and all files related to the project are in or
+below the top-folder.  If called with non-nil prefix argument
+OTHER-WINDOW use `find-file-other-window'.
+
+\(fn OTHER-WINDOW)" t nil)
+
+(let ((loads (get 'haskell-cabal 'custom-loads))) (if (member '"haskell-cabal" loads) nil (put 'haskell-cabal 'custom-loads (cons '"haskell-cabal" loads))))
+
+;;;***
+
+;;;### (autoloads nil "haskell-collapse" "haskell-collapse.el" (23377
+;;;;;;  61614 449081 791000))
+;;; Generated autoloads from haskell-collapse.el
+
+(autoload 'haskell-collapse-mode "haskell-collapse" "\
+Minor mode to collapse and expand haskell expressions
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-commands" "haskell-commands.el" (23377
+;;;;;;  61614 507848 25000))
+;;; Generated autoloads from haskell-commands.el
+
+(autoload 'haskell-process-restart "haskell-commands" "\
+Restart the inferior Haskell process.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-clear "haskell-commands" "\
+Clear the current process.
+
+\(fn)" t nil)
+
+(autoload 'haskell-process-interrupt "haskell-commands" "\
+Interrupt the process (SIGINT).
+
+\(fn)" t nil)
+
+(autoload 'haskell-describe "haskell-commands" "\
+Describe the given identifier IDENT.
+
+\(fn IDENT)" t nil)
+
+(autoload 'haskell-rgrep "haskell-commands" "\
+Grep the effective project for the symbol at point.
+Very useful for codebase navigation.
+
+Prompts for an arbitrary regexp given a prefix arg PROMPT.
+
+\(fn &optional PROMPT)" t nil)
+
+(autoload 'haskell-process-do-info "haskell-commands" "\
+Print info on the identifier at point.
+If PROMPT-VALUE is non-nil, request identifier via mini-buffer.
+
+\(fn &optional PROMPT-VALUE)" t nil)
+
+(autoload 'haskell-process-do-type "haskell-commands" "\
+Print the type of the given expression.
+
+Given INSERT-VALUE prefix indicates that result type signature
+should be inserted.
+
+\(fn &optional INSERT-VALUE)" t nil)
+
+(autoload 'haskell-mode-jump-to-def-or-tag "haskell-commands" "\
+Jump to the definition.
+Jump to definition of identifier at point by consulting GHCi, or
+tag table as fallback.
+
+Remember: If GHCi is busy doing something, this will delay, but
+it will always be accurate, in contrast to tags, which always
+work but are not always accurate.
+If the definition or tag is found, the location from which you jumped
+will be pushed onto `xref--marker-ring', so you can return to that
+position with `xref-pop-marker-stack'.
+
+\(fn &optional NEXT-P)" t nil)
+
+(autoload 'haskell-mode-goto-loc "haskell-commands" "\
+Go to the location of the thing at point.
+Requires the :loc-at command from GHCi.
+
+\(fn)" t nil)
+
+(autoload 'haskell-mode-jump-to-def "haskell-commands" "\
+Jump to definition of identifier IDENT at point.
+
+\(fn IDENT)" t nil)
+
+(autoload 'haskell-process-cd "haskell-commands" "\
+Change directory.
+
+\(fn &optional NOT-INTERACTIVE)" t nil)
+
+(autoload 'haskell-process-cabal-macros "haskell-commands" "\
+Send the cabal macros string.
+
+\(fn)" t nil)
+
+(autoload 'haskell-mode-show-type-at "haskell-commands" "\
+Show type of the thing at point or within active region asynchronously.
+This function requires GHCi 8+ or GHCi-ng.
+
+\\<haskell-interactive-mode-map>
+To make this function works sometimes you need to load the file in REPL
+first using command `haskell-process-load-file' bound to
+\\[haskell-process-load-file].
+
+Optional argument INSERT-VALUE indicates that
+recieved type signature should be inserted (but only if nothing
+happened since function invocation).
+
+\(fn &optional INSERT-VALUE)" t nil)
+
+(autoload 'haskell-process-unignore "haskell-commands" "\
+Unignore any ignored files.
+Do not ignore files that were specified as being ignored by the
+inferior GHCi process.
+
+\(fn)" t nil)
+
+(autoload 'haskell-session-change-target "haskell-commands" "\
+Set the build TARGET for cabal REPL.
+
+\(fn TARGET)" t nil)
+
+(autoload 'haskell-mode-stylish-buffer "haskell-commands" "\
+Apply stylish-haskell to the current buffer.
+
+Use `haskell-mode-stylish-haskell-path' to know where to find
+stylish-haskell executable. This function tries to preserve
+cursor position and markers by using
+`haskell-mode-buffer-apply-command'.
+
+\(fn)" t nil)
+
+(autoload 'haskell-mode-find-uses "haskell-commands" "\
+Find use cases of the identifier at point and highlight them all.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-compile" "haskell-compile.el" (23377
+;;;;;;  61614 495238 977000))
+;;; Generated autoloads from haskell-compile.el
+
+(let ((loads (get 'haskell-compile 'custom-loads))) (if (member '"haskell-compile" loads) nil (put 'haskell-compile 'custom-loads (cons '"haskell-compile" loads))))
+
+(autoload 'haskell-compile "haskell-compile" "\
+Compile the Haskell program including the current buffer.
+Tries to locate the next cabal description in current or parent
+folders via `haskell-cabal-find-dir' and if found, invoke
+`haskell-compile-cabal-build-command' from the cabal package root
+folder. If no cabal package could be detected,
+`haskell-compile-command' is used instead.
+
+If prefix argument EDIT-COMMAND is non-nil (and not a negative
+prefix `-'), `haskell-compile' prompts for custom compile
+command.
+
+If EDIT-COMMAND contains the negative prefix argument `-',
+`haskell-compile' calls the alternative command defined in
+`haskell-compile-cabal-build-alt-command' if a cabal package was
+detected.
+
+`haskell-compile' uses `haskell-compilation-mode' which is
+derived from `compilation-mode'. See Info
+node `(haskell-mode)compilation' for more details.
+
+\(fn &optional EDIT-COMMAND)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-completions" "haskell-completions.el"
+;;;;;;  (23377 61614 502566 919000))
+;;; Generated autoloads from haskell-completions.el
+
+(let ((loads (get 'haskell-completions 'custom-loads))) (if (member '"haskell-completions" loads) nil (put 'haskell-completions 'custom-loads (cons '"haskell-completions" loads))))
+
+(autoload 'haskell-completions-completion-at-point "haskell-completions" "\
+Provide completion list for thing at point.
+This function is used in non-interactive `haskell-mode'.  It
+provides completions for haskell keywords, language pragmas,
+GHC's options, and language extensions, but not identifiers.
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-customize" "haskell-customize.el"
+;;;;;;  (23377 61614 493162 389000))
+;;; Generated autoloads from haskell-customize.el
+
+(let ((loads (get 'haskell 'custom-loads))) (if (member '"haskell-customize" loads) nil (put 'haskell 'custom-loads (cons '"haskell-customize" loads))))
+
+(let ((loads (get 'haskell-interactive 'custom-loads))) (if (member '"haskell-customize" loads) nil (put 'haskell-interactive 'custom-loads (cons '"haskell-customize" loads))))
+
+;;;***
+
+;;;### (autoloads nil "haskell-debug" "haskell-debug.el" (23377 61614
+;;;;;;  443095 895000))
+;;; Generated autoloads from haskell-debug.el
+
+(let ((loads (get 'haskell-debug 'custom-loads))) (if (member '"haskell-debug" loads) nil (put 'haskell-debug 'custom-loads (cons '"haskell-debug" loads))))
+
+(defface haskell-debug-warning-face '((t :inherit 'compilation-warning)) "\
+Face for warnings." :group (quote haskell-debug))
+
+(defface haskell-debug-trace-number-face '((t :weight bold :background "#f5f5f5")) "\
+Face for numbers in backtrace." :group (quote haskell-debug))
+
+(defface haskell-debug-newline-face '((t :weight bold :background "#f0f0f0")) "\
+Face for newlines in trace steps." :group (quote haskell-debug))
+
+(defface haskell-debug-keybinding-face '((t :inherit 'font-lock-type-face :weight bold)) "\
+Face for keybindings." :group (quote haskell-debug))
+
+(defface haskell-debug-heading-face '((t :inherit 'font-lock-keyword-face)) "\
+Face for headings." :group (quote haskell-debug))
+
+(defface haskell-debug-muted-face '((t :foreground "#999")) "\
+Face for muteds." :group (quote haskell-debug))
+
+;;;***
+
+;;;### (autoloads nil "haskell-decl-scan" "haskell-decl-scan.el"
+;;;;;;  (23377 61614 526149 653000))
+;;; Generated autoloads from haskell-decl-scan.el
+
+(let ((loads (get 'haskell-decl-scan 'custom-loads))) (if (member '"haskell-decl-scan" loads) nil (put 'haskell-decl-scan 'custom-loads (cons '"haskell-decl-scan" loads))))
+
+(autoload 'haskell-ds-create-imenu-index "haskell-decl-scan" "\
+Function for finding `imenu' declarations in Haskell mode.
+Finds all declarations (classes, variables, imports, instances and
+datatypes) in a Haskell file for the `imenu' package.
+
+\(fn)" nil nil)
+
+(autoload 'turn-on-haskell-decl-scan "haskell-decl-scan" "\
+Unconditionally activate `haskell-decl-scan-mode'.
+
+\(fn)" t nil)
+
+(autoload 'haskell-decl-scan-mode "haskell-decl-scan" "\
+Toggle Haskell declaration scanning minor mode on or off.
+With a prefix argument ARG, enable minor mode if ARG is
+positive, and disable it otherwise.  If called from Lisp, enable
+the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
+
+See also info node `(haskell-mode)haskell-decl-scan-mode' for
+more details about this minor mode.
+
+Top-level declarations are scanned and listed in the menu item
+\"Declarations\" (if enabled via option
+`haskell-decl-scan-add-to-menubar').  Selecting an item from this
+menu will take point to the start of the declaration.
+
+\\[beginning-of-defun] and \\[end-of-defun] move forward and backward to the start of a declaration.
+
+This may link with `haskell-doc-mode'.
+
+For non-literate and LaTeX-style literate scripts, we assume the
+common convention that top-level declarations start at the first
+column.  For Bird-style literate scripts, we assume the common
+convention that top-level declarations start at the third column,
+ie. after \"> \".
+
+Anything in `font-lock-comment-face' is not considered for a
+declaration.  Therefore, using Haskell font locking with comments
+coloured in `font-lock-comment-face' improves declaration scanning.
+
+Literate Haskell scripts are supported: If the value of
+`haskell-literate' (set automatically by `literate-haskell-mode')
+is `bird', a Bird-style literate script is assumed.  If it is nil
+or `tex', a non-literate or LaTeX-style literate script is
+assumed, respectively.
+
+Invokes `haskell-decl-scan-mode-hook' on activation.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-doc" "haskell-doc.el" (23377 61614
+;;;;;;  465805 530000))
+;;; Generated autoloads from haskell-doc.el
+
+(let ((loads (get 'haskell-doc 'custom-loads))) (if (member '"haskell-doc" loads) nil (put 'haskell-doc 'custom-loads (cons '"haskell-doc" loads))))
+
+(autoload 'haskell-doc-mode "haskell-doc" "\
+Enter `haskell-doc-mode' for showing fct types in the echo area.
+See variable docstring.
+
+\(fn &optional ARG)" t nil)
+
+(defalias 'turn-on-haskell-doc-mode 'haskell-doc-mode)
+
+(defalias 'turn-on-haskell-doc 'haskell-doc-mode)
+
+(autoload 'haskell-doc-current-info "haskell-doc" "\
+Return the info about symbol at point.
+Meant for `eldoc-documentation-function'.
+
+\(fn)" nil nil)
+
+(autoload 'haskell-doc-show-type "haskell-doc" "\
+Show the type of the function near point or given symbol SYM.
+For the function under point, show the type in the echo area.
+This information is extracted from the `haskell-doc-prelude-types' alist
+of prelude functions and their types, or from the local functions in the
+current buffer.
+
+\(fn &optional SYM)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-font-lock" "haskell-font-lock.el"
+;;;;;;  (23377 61614 481501 453000))
+;;; Generated autoloads from haskell-font-lock.el
+
+(let ((loads (get 'haskell-appearance 'custom-loads))) (if (member '"haskell-font-lock" loads) nil (put 'haskell-appearance 'custom-loads (cons '"haskell-font-lock" loads))))
+
+(defface haskell-keyword-face '((t :inherit font-lock-keyword-face)) "\
+Face used to highlight Haskell keywords." :group (quote haskell-appearance))
+
+(defface haskell-type-face '((t :inherit font-lock-type-face)) "\
+Face used to highlight Haskell types" :group (quote haskell-appearance))
+
+(defface haskell-constructor-face '((t :inherit font-lock-type-face)) "\
+Face used to highlight Haskell constructors." :group (quote haskell-appearance))
+
+(defface haskell-operator-face '((t :inherit font-lock-variable-name-face)) "\
+Face used to highlight Haskell operators." :group (quote haskell-appearance))
+
+(defface haskell-pragma-face '((t :inherit font-lock-preprocessor-face)) "\
+Face used to highlight Haskell pragmas ({-# ... #-})." :group (quote haskell-appearance))
+
+(defface haskell-liquid-haskell-annotation-face '((t :inherit haskell-pragma-face)) "\
+Face used to highlight LiquidHaskell annotations ({-@ ... @-})." :group (quote haskell-appearance))
+
+(defface haskell-literate-comment-face '((t :inherit font-lock-doc-face)) "\
+Face with which to fontify literate comments.
+Inherit from `default' to avoid fontification of them." :group (quote haskell-appearance))
+
+;;;***
+
+;;;### (autoloads nil "haskell-hoogle" "haskell-hoogle.el" (23377
+;;;;;;  61614 467321 953000))
+;;; Generated autoloads from haskell-hoogle.el
+
+(autoload 'haskell-hoogle "haskell-hoogle" "\
+Do a Hoogle search for QUERY.
+When `haskell-hoogle-command' is non-nil, this command runs
+that.  Otherwise, it opens a hoogle search result in the browser.
+
+If prefix argument INFO is given, then `haskell-hoogle-command'
+is asked to show extra info for the items matching QUERY..
+
+\(fn QUERY &optional INFO)" t nil)
+
+(defalias 'hoogle 'haskell-hoogle)
+
+(autoload 'haskell-hoogle-lookup-from-local "haskell-hoogle" "\
+Lookup by local hoogle.
+
+\(fn)" t nil)
+
+(autoload 'haskell-hayoo "haskell-hoogle" "\
+Do a Hayoo search for QUERY.
+
+\(fn QUERY)" t nil)
+
+(defalias 'hayoo 'haskell-hayoo)
+
+;;;***
+
+;;;### (autoloads nil "haskell-indent" "haskell-indent.el" (23377
+;;;;;;  61614 517159 450000))
+;;; Generated autoloads from haskell-indent.el
+
+(let ((loads (get 'haskell-indent 'custom-loads))) (if (member '"haskell-indent" loads) nil (put 'haskell-indent 'custom-loads (cons '"haskell-indent" loads))))
+
+(autoload 'turn-on-haskell-indent "haskell-indent" "\
+Turn on ``intelligent'' Haskell indentation mode.
+
+\(fn)" nil nil)
+
+(autoload 'haskell-indent-mode "haskell-indent" "\
+``Intelligent'' Haskell indentation mode.
+This deals with the layout rule of Haskell.
+\\[haskell-indent-cycle] starts the cycle which proposes new
+possibilities as long as the TAB key is pressed.  Any other key
+or mouse click terminates the cycle and is interpreted except for
+RET which merely exits the cycle.
+Other special keys are:
+    \\[haskell-indent-insert-equal]
+      inserts an =
+    \\[haskell-indent-insert-guard]
+      inserts an |
+    \\[haskell-indent-insert-otherwise]
+      inserts an | otherwise =
+these functions also align the guards and rhs of the current definition
+    \\[haskell-indent-insert-where]
+      inserts a where keyword
+    \\[haskell-indent-align-guards-and-rhs]
+      aligns the guards and rhs of the region
+    \\[haskell-indent-put-region-in-literate]
+      makes the region a piece of literate code in a literate script
+
+If `ARG' is falsey, toggle `haskell-indent-mode'.  Else sets
+`haskell-indent-mode' to whether `ARG' is greater than 0.
+
+Invokes `haskell-indent-hook' if not nil.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-indentation" "haskell-indentation.el"
+;;;;;;  (23377 61614 474683 85000))
+;;; Generated autoloads from haskell-indentation.el
+
+(let ((loads (get 'haskell-indentation 'custom-loads))) (if (member '"haskell-indentation" loads) nil (put 'haskell-indentation 'custom-loads (cons '"haskell-indentation" loads))))
+
+(autoload 'haskell-indentation-mode "haskell-indentation" "\
+Haskell indentation mode that deals with the layout rule.
+It rebinds RET, DEL and BACKSPACE, so that indentations can be
+set and deleted as if they were real tabs.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-haskell-indentation "haskell-indentation" "\
+Turn on the haskell-indentation minor mode.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-interactive-mode" "haskell-interactive-mode.el"
+;;;;;;  (23377 61614 446289 590000))
+;;; Generated autoloads from haskell-interactive-mode.el
+
+(defface haskell-interactive-face-prompt '((t :inherit font-lock-function-name-face)) "\
+Face for the prompt." :group (quote haskell-interactive))
+
+(defface haskell-interactive-face-prompt2 '((t :inherit font-lock-keyword-face)) "\
+Face for the prompt2 in multi-line mode." :group (quote haskell-interactive))
+
+(defface haskell-interactive-face-compile-error '((t :inherit compilation-error)) "\
+Face for compile errors." :group (quote haskell-interactive))
+
+(defface haskell-interactive-face-compile-warning '((t :inherit compilation-warning)) "\
+Face for compiler warnings." :group (quote haskell-interactive))
+
+(defface haskell-interactive-face-result '((t :inherit font-lock-string-face)) "\
+Face for the result." :group (quote haskell-interactive))
+
+(defface haskell-interactive-face-garbage '((t :inherit font-lock-string-face)) "\
+Face for trailing garbage after a command has completed." :group (quote haskell-interactive))
+
+(autoload 'haskell-interactive-mode-reset-error "haskell-interactive-mode" "\
+Reset the error cursor position.
+
+\(fn SESSION)" t nil)
+
+(autoload 'haskell-interactive-mode-echo "haskell-interactive-mode" "\
+Echo a read only piece of text before the prompt.
+
+\(fn SESSION MESSAGE &optional MODE)" nil nil)
+
+(autoload 'haskell-process-show-repl-response "haskell-interactive-mode" "\
+Send LINE to the GHCi process and echo the result in some fashion.
+Result will be printed in the minibuffer or presented using
+function `haskell-presentation-present', depending on variable
+`haskell-process-use-presentation-mode'.
+
+\(fn LINE)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-load" "haskell-load.el" (23377 61614
+;;;;;;  434479 297000))
+;;; Generated autoloads from haskell-load.el
+
+(defface haskell-error-face '((((supports :underline (:style wave))) :underline (:style wave :color "#dc322f")) (t :inherit error)) "\
+Face used for marking error lines." :group (quote haskell-mode))
+
+(defface haskell-warning-face '((((supports :underline (:style wave))) :underline (:style wave :color "#b58900")) (t :inherit warning)) "\
+Face used for marking warning lines." :group (quote haskell-mode))
+
+(defface haskell-hole-face '((((supports :underline (:style wave))) :underline (:style wave :color "#6c71c4")) (t :inherit warning)) "\
+Face used for marking hole lines." :group (quote haskell-mode))
+
+(autoload 'haskell-process-reload-devel-main "haskell-load" "\
+Reload the module `DevelMain' and then run `DevelMain.update'.
+
+This is for doing live update of the code of servers or GUI
+applications.  Put your development version of the program in
+`DevelMain', and define `update' to auto-start the program on a
+new thread, and use the `foreign-store' package to access the
+running context across :load/:reloads in GHCi.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-menu" "haskell-menu.el" (23377 61614
+;;;;;;  486880 305000))
+;;; Generated autoloads from haskell-menu.el
+
+(autoload 'haskell-menu "haskell-menu" "\
+Launch the Haskell sessions menu.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-mode" "haskell-mode.el" (23377 61614
+;;;;;;  513037 533000))
+;;; Generated autoloads from haskell-mode.el
+
+(autoload 'haskell-version "haskell-mode" "\
+Show the `haskell-mode` version in the echo area.
+With prefix argument HERE, insert it at point.
+
+\(fn &optional HERE)" t nil)
+
+(autoload 'haskell-mode-view-news "haskell-mode" "\
+Display information on recent changes to haskell-mode.
+
+\(fn)" t nil)
+
+(autoload 'haskell-mode "haskell-mode" "\
+Major mode for editing Haskell programs.
+
+\\<haskell-mode-map>
+
+Literate Haskell scripts are supported via `literate-haskell-mode'.
+The variable `haskell-literate' indicates the style of the script in the
+current buffer.  See the documentation on this variable for more details.
+
+Use `haskell-version' to find out what version of Haskell mode you are
+currently using.
+
+Additional Haskell mode modules can be hooked in via `haskell-mode-hook'.
+
+Indentation modes:
+
+    `haskell-indentation-mode', Kristof Bastiaensen, Gergely Risko
+      Intelligent semi-automatic indentation Mk2
+
+    `haskell-indent-mode', Guy Lapalme
+      Intelligent semi-automatic indentation.
+
+Interaction modes:
+
+    `interactive-haskell-mode'
+      Interact with per-project GHCi processes through a REPL and
+      directory-aware sessions.
+
+Other modes:
+
+    `haskell-decl-scan-mode', Graeme E Moss
+      Scans top-level declarations, and places them in a menu.
+
+    `haskell-doc-mode', Hans-Wolfgang Loidl
+      Echoes types of functions or syntax of keywords when the cursor is idle.
+
+To activate a minor-mode, simply run the interactive command. For
+example, `M-x haskell-doc-mode'. Run it again to disable it.
+
+To enable a mode for every haskell-mode buffer, add a hook in
+your Emacs configuration. To do that you can customize
+`haskell-mode-hook' or add lines to your .emacs file. For
+example, to enable `interactive-haskell-mode', use the following:
+
+    (add-hook 'haskell-mode-hook 'interactive-haskell-mode)
+
+Minor modes that work well with `haskell-mode':
+
+- `smerge-mode': show and work with diff3 conflict markers used
+  by git, svn and other version control systems.
+
+\(fn)" t nil)
+
+(autoload 'haskell-forward-sexp "haskell-mode" "\
+Haskell specific version of `forward-sexp'.
+
+Move forward across one balanced expression (sexp).  With ARG, do
+it that many times.  Negative arg -N means move backward across N
+balanced expressions.  This command assumes point is not in a
+string or comment.
+
+If unable to move over a sexp, signal `scan-error' with three
+arguments: a message, the start of the obstacle (a parenthesis or
+list marker of some kind), and end of the obstacle.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'literate-haskell-mode "haskell-mode" "\
+As `haskell-mode' but for literate scripts.
+
+\(fn)" t nil)
+
+(add-to-list 'auto-mode-alist '("\\.[gh]s\\'" . haskell-mode))
+
+(add-to-list 'auto-mode-alist '("\\.hsig\\'" . haskell-mode))
+
+(add-to-list 'auto-mode-alist '("\\.l[gh]s\\'" . literate-haskell-mode))
+
+(add-to-list 'auto-mode-alist '("\\.hsc\\'" . haskell-mode))
+
+(add-to-list 'interpreter-mode-alist '("runghc" . haskell-mode))
+
+(add-to-list 'interpreter-mode-alist '("runhaskell" . haskell-mode))
+
+(add-to-list 'completion-ignored-extensions ".hi")
+
+(autoload 'haskell-mode-generate-tags "haskell-mode" "\
+Generate tags using Hasktags.  This is synchronous function.
+
+If optional AND-THEN-FIND-THIS-TAG argument is present it is used
+with function `xref-find-definitions' after new table was
+generated.
+
+\(fn &optional AND-THEN-FIND-THIS-TAG)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-modules" "haskell-modules.el" (23377
+;;;;;;  61614 520638 53000))
+;;; Generated autoloads from haskell-modules.el
+
+(autoload 'haskell-session-installed-modules "haskell-modules" "\
+Get the modules installed in the current package set.
+
+\(fn SESSION &optional DONTCREATE)" nil nil)
+
+(autoload 'haskell-session-all-modules "haskell-modules" "\
+Get all modules -- installed or in the current project.
+If DONTCREATE is non-nil don't create a new session.
+
+\(fn SESSION &optional DONTCREATE)" nil nil)
+
+(autoload 'haskell-session-project-modules "haskell-modules" "\
+Get the modules of the current project.
+If DONTCREATE is non-nil don't create a new session.
+
+\(fn SESSION &optional DONTCREATE)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-move-nested" "haskell-move-nested.el"
+;;;;;;  (23377 61614 514693 505000))
+;;; Generated autoloads from haskell-move-nested.el
+
+(autoload 'haskell-move-nested "haskell-move-nested" "\
+Shift the nested off-side-rule block adjacent to point by COLS columns to the right.
+
+In Transient Mark mode, if the mark is active, operate on the contents
+of the region instead.
+
+\(fn COLS)" nil nil)
+
+(autoload 'haskell-move-nested-right "haskell-move-nested" "\
+Increase indentation of the following off-side-rule block adjacent to point.
+
+Use a numeric prefix argument to indicate amount of indentation to apply.
+
+In Transient Mark mode, if the mark is active, operate on the contents
+of the region instead.
+
+\(fn COLS)" t nil)
+
+(autoload 'haskell-move-nested-left "haskell-move-nested" "\
+Decrease indentation of the following off-side-rule block adjacent to point.
+
+Use a numeric prefix argument to indicate amount of indentation to apply.
+
+In Transient Mark mode, if the mark is active, operate on the contents
+of the region instead.
+
+\(fn COLS)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-navigate-imports" "haskell-navigate-imports.el"
+;;;;;;  (23377 61614 522273 319000))
+;;; Generated autoloads from haskell-navigate-imports.el
+
+(autoload 'haskell-navigate-imports "haskell-navigate-imports" "\
+Cycle the Haskell import lines or return to point (with prefix arg).
+
+\(fn &optional RETURN)" t nil)
+
+(autoload 'haskell-navigate-imports-go "haskell-navigate-imports" "\
+Go to the first line of a list of consecutive import lines. Cycles.
+
+\(fn)" t nil)
+
+(autoload 'haskell-navigate-imports-return "haskell-navigate-imports" "\
+Return to the non-import point we were at before going to the module list.
+   If we were originally at an import list, we can just cycle through easily.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-session" "haskell-session.el" (23377
+;;;;;;  61614 476646 160000))
+;;; Generated autoloads from haskell-session.el
+
+(autoload 'haskell-session-maybe "haskell-session" "\
+Maybe get the Haskell session, return nil if there isn't one.
+
+\(fn)" nil nil)
+
+(autoload 'haskell-session-process "haskell-session" "\
+Get the session process.
+
+\(fn S)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-sort-imports" "haskell-sort-imports.el"
+;;;;;;  (23377 61614 489920 40000))
+;;; Generated autoloads from haskell-sort-imports.el
+
+(autoload 'haskell-sort-imports "haskell-sort-imports" "\
+Sort the import list at point. It sorts the current group
+i.e. an import list separated by blank lines on either side.
+
+If the region is active, it will restrict the imports to sort
+within that region.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "haskell-unicode-input-method" "haskell-unicode-input-method.el"
+;;;;;;  (23377 61614 457460 312000))
+;;; Generated autoloads from haskell-unicode-input-method.el
+
+(autoload 'turn-on-haskell-unicode-input-method "haskell-unicode-input-method" "\
+Set input method `haskell-unicode'.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "highlight-uses-mode" "highlight-uses-mode.el"
+;;;;;;  (23377 61614 499589 351000))
+;;; Generated autoloads from highlight-uses-mode.el
+
+(autoload 'highlight-uses-mode "highlight-uses-mode" "\
+Minor mode for highlighting and jumping between uses.
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "inf-haskell" "inf-haskell.el" (23377 61614
+;;;;;;  441568 997000))
+;;; Generated autoloads from inf-haskell.el
+
+(let ((loads (get 'inferior-haskell 'custom-loads))) (if (member '"inf-haskell" loads) nil (put 'inferior-haskell 'custom-loads (cons '"inf-haskell" loads))))
+
+(defalias 'run-haskell 'switch-to-haskell)
+
+(autoload 'switch-to-haskell "inf-haskell" "\
+Show the inferior-haskell buffer.  Start the process if needed.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "w3m-haddock" "w3m-haddock.el" (23377 61614
+;;;;;;  505606 375000))
+;;; Generated autoloads from w3m-haddock.el
+
+(defface w3m-haddock-heading-face '((((class color)) :inherit highlight)) "\
+Face for quarantines." :group (quote haskell))
+
+;;;***
+
+;;;### (autoloads nil nil ("haskell-compat.el" "haskell-complete-module.el"
+;;;;;;  "haskell-ghc-support.el" "haskell-lexeme.el" "haskell-mode-pkg.el"
+;;;;;;  "haskell-presentation-mode.el" "haskell-process.el" "haskell-repl.el"
+;;;;;;  "haskell-sandbox.el" "haskell-string.el" "haskell-utils.el")
+;;;;;;  (23377 61614 524498 941000))
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; haskell-mode-autoloads.el ends here
-- 
cgit 1.4.1