Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Fetching contributors…
Cannot retrieve contributors at this time
535 lines (358 sloc) 16.6 KB
;;;### (autoloads (ghc-core-mode ghc-core-create-core) "ghc-core"
;;;;;; "ghc-core.el" (20448 8432))
;;; Generated autoloads from ghc-core.el
(autoload 'ghc-core-create-core "ghc-core" "\
Compiled and load the current buffer as tidy core
\(fn)" t nil)
(add-to-list 'auto-mode-alist '("\\.hcr\\'" . ghc-core-mode))
(autoload 'ghc-core-mode "ghc-core" "\
Major mode for GHC Core files.
\(fn)" t nil)
;;;### (autoloads (haskell-align-imports) "haskell-align-imports"
;;;;;; "haskell-align-imports.el" (20448 8432))
;;; 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 (haskell-c-mode) "haskell-c" "haskell-c.el" (20448
;;;;;; 8432))
;;; Generated autoloads from haskell-c.el
(add-to-list 'auto-mode-alist '("\\.hsc\\'" . haskell-c-mode))
(autoload 'haskell-c-mode "haskell-c" "\
Major mode for Haskell FFI files.
\(fn)" t nil)
;;;### (autoloads (haskell-cabal-get-dir haskell-cabal-mode) "haskell-cabal"
;;;;;; "haskell-cabal.el" (20508 11604))
;;; Generated autoloads from haskell-cabal.el
(add-to-list (quote auto-mode-alist) (quote ("\\.cabal\\'" . haskell-cabal-mode)))
(autoload (quote haskell-cabal-mode) "haskell-cabal" "\
Major mode for Cabal package description files.
\(fn)" t nil)
(autoload (quote 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)" nil nil)
;;;### (autoloads (haskell-decl-scan-mode) "haskell-decl-scan" "haskell-decl-scan.el"
;;;;;; (20448 8432))
;;; Generated autoloads from haskell-decl-scan.el
(autoload 'haskell-decl-scan-mode "haskell-decl-scan" "\
Minor mode for declaration scanning for Haskell mode.
Top-level declarations are scanned and listed in the menu item \"Declarations\".
Selecting an item from this menu will take point to the start of the
\\[haskell-ds-forward-decl] and \\[haskell-ds-backward-decl] move forward and backward to the start of a declaration.
Under XEmacs, the following keys are also defined:
\\[fume-list-functions] lists the declarations of the current buffer,
\\[fume-prompt-function-goto] prompts for a declaration to move to, and
\\[fume-mouse-function-goto] moves to the declaration whose name is at point.
This may link with `haskell-doc' (only for Emacs currently).
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.
To turn on declaration scanning for all Haskell buffers, add this to
(add-hook 'haskell-mode-hook 'turn-on-haskell-decl-scan)
To turn declaration scanning on for the current buffer, call
Literate Haskell scripts are supported: If the value of
`haskell-literate' (automatically set by the Haskell mode of
Moss&Thorn) 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'.
\(fn &optional ARG)" t nil)
;;;### (autoloads (haskell-doc-show-type haskell-doc-mode) "haskell-doc"
;;;;;; "haskell-doc.el" (20567 13022))
;;; Generated autoloads from haskell-doc.el
(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)
(autoload 'haskell-doc-show-type "haskell-doc" "\
Show the type of the function near point.
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 (haskell-indent-mode) "haskell-indent" "haskell-indent.el"
;;;;;; (20448 8432))
;;; Generated autoloads from haskell-indent.el
(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:
inserts an =
inserts an |
inserts an | otherwise =
these functions also align the guards and rhs of the current definition
inserts a where keyword
aligns the guards and rhs of the region
makes the region a piece of literate code in a literate script
Invokes `haskell-indent-hook' if not nil.
\(fn &optional ARG)" t nil)
;;;### (autoloads (haskell-indentation-mode) "haskell-indentation"
;;;;;; "haskell-indentation.el" (20567 13022))
;;; Generated autoloads from haskell-indentation.el
(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. It supports
\(fn &optional ARG)" t nil)
;;;### (autoloads (haskell-interactive-mode-echo haskell-interactive-switch
;;;;;; haskell-interactive-bring haskell-interactive-mode) "haskell-interactive-mode"
;;;;;; "haskell-interactive-mode.el" (20568 37399))
;;; Generated autoloads from haskell-interactive-mode.el
(autoload 'haskell-interactive-mode "haskell-interactive-mode" "\
Interactive mode for Haskell.
\(fn SESSION)" t nil)
(autoload 'haskell-interactive-bring "haskell-interactive-mode" "\
Bring up the interactive mode for this session.
\(fn)" t nil)
(autoload 'haskell-interactive-switch "haskell-interactive-mode" "\
Switch to the interactive mode for this session.
\(fn)" t nil)
(autoload 'haskell-interactive-mode-echo "haskell-interactive-mode" "\
Echo a read only piece of text before the prompt.
\(fn SESSION MESSAGE)" nil nil)
;;;### (autoloads (haskell-hayoo haskell-hoogle literate-haskell-mode
;;;;;; haskell-mode) "haskell-mode" "haskell-mode.el" (20567 13022))
;;; Generated autoloads from haskell-mode.el
(add-to-list 'load-path (or (file-name-directory load-file-name) (car load-path)))
(autoload 'haskell-mode "haskell-mode" "\
Major mode for editing Haskell programs.
Blank lines separate paragraphs, comments start with `-- '.
Literate 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.
Modules can hook in via `haskell-mode-hook'. The following modules
are supported with an `autoload' command:
`haskell-decl-scan', Graeme E Moss
Scans top-level declarations, and places them in a menu.
`haskell-doc', Hans-Wolfgang Loidl
Echoes types of functions or syntax of keywords when the cursor is idle.
`haskell-indentation', Kristof Bastiaensen
Intelligent semi-automatic indentation Mk2
`haskell-indent', Guy Lapalme
Intelligent semi-automatic indentation.
`haskell-simple-indent', Graeme E Moss and Heribert Schuetz
Simple indentation.
Module X is activated using the command `turn-on-X'. For example,
`haskell-indent' is activated using `turn-on-haskell-indent'.
For more information on a module, see the help for its `X-mode'
function. Some modules can be deactivated using `turn-off-X'. (Note
that `haskell-doc' is irregular in using `turn-(on/off)-haskell-doc-mode'.)
Use `haskell-version' to find out what version this is.
Invokes `haskell-mode-hook'.
\(fn)" 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\\|hi\\)\\'" . haskell-mode))
(add-to-list 'auto-mode-alist '("\\.l[gh]s\\'" . literate-haskell-mode))
(add-to-list 'interpreter-mode-alist '("runghc" . haskell-mode))
(add-to-list 'interpreter-mode-alist '("runhaskell" . haskell-mode))
(autoload 'haskell-hoogle "haskell-mode" "\
Do a Hoogle search for QUERY.
\(fn QUERY)" t nil)
(defalias 'hoogle 'haskell-hoogle)
(autoload 'haskell-hayoo "haskell-mode" "\
Do a Hayoo search for QUERY.
\(fn QUERY)" t nil)
(defalias 'hayoo 'haskell-hayoo)
;;;### (autoloads (haskell-move-nested) "haskell-move-nested" "haskell-move-nested.el"
;;;;;; (20508 11604))
;;; Generated autoloads from haskell-move-nested.el
(autoload (quote haskell-move-nested) "haskell-move-nested" "\
Not documented
\(fn COLUMNS)" nil nil)
;;;### (autoloads (haskell-navigate-imports-return haskell-navigate-imports-go
;;;;;; haskell-navigate-imports) "haskell-navigate-imports" "haskell-navigate-imports.el"
;;;;;; (20448 8432))
;;; 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 consequtive 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 (haskell-process haskell-process-start haskell-process-cabal
;;;;;; haskell-process-cabal-build haskell-process-reload-file haskell-process-load-file)
;;;;;; "haskell-process" "haskell-process.el" (20568 11072))
;;; Generated autoloads from haskell-process.el
(autoload 'haskell-process-load-file "haskell-process" "\
Load the current buffer file.
\(fn)" t nil)
(autoload 'haskell-process-reload-file "haskell-process" "\
Load the current buffer file.
\(fn)" t nil)
(autoload 'haskell-process-cabal-build "haskell-process" "\
Build the Cabal project.
\(fn)" t nil)
(autoload 'haskell-process-cabal "haskell-process" "\
Prompts for a Cabal command to run.
\(fn)" t nil)
(autoload 'haskell-process-start "haskell-process" "\
Start the inferior Haskell process.
\(fn SESSION)" nil nil)
(autoload 'haskell-process "haskell-process" "\
Get the current process from the current session.
\(fn)" nil nil)
;;;### (autoloads (haskell-session-process haskell-session) "haskell-session"
;;;;;; "haskell-session.el" (20566 45512))
;;; Generated autoloads from haskell-session.el
(autoload (quote haskell-session) "haskell-session" "\
Get the Haskell session, prompt if there isn't one or fail.
\(fn)" nil nil)
(autoload (quote haskell-session-process) "haskell-session" "\
Get the session process.
\(fn S)" nil nil)
;;;### (autoloads (haskell-virthualenv-prompt-prefix haskell-virthualenv-activate
;;;;;; haskell-virthualenv-get-dir haskell-session-virthualenv haskell-session-set-virthualenv)
;;;;;; "haskell-session-virthualenv" "haskell-session-virthualenv.el"
;;;;;; (20568 36956))
;;; Generated autoloads from haskell-session-virthualenv.el
(autoload 'haskell-session-set-virthualenv "haskell-session-virthualenv" "\
Set the sessions virthualenv directory
\(fn S V)" nil nil)
(autoload 'haskell-session-virthualenv "haskell-session-virthualenv" "\
Get the sessions virthualenv directory
\(fn S)" nil nil)
(autoload 'haskell-virthualenv-get-dir "haskell-session-virthualenv" "\
Get the .virthualenv dir for a new project. Various ways of figuring this out,
and indeed just prompting the user. Do them all.
\(fn)" nil nil)
(autoload 'haskell-virthualenv-activate "haskell-session-virthualenv" "\
Activate the virthualenv for this session
\(fn)" t nil)
(autoload 'haskell-virthualenv-prompt-prefix "haskell-session-virthualenv" "\
Get the name of the currently active virthualenv
If there isn't one active retruns empty string
\(fn)" nil nil)
;;;### (autoloads (haskell-show-parse haskell-show-parse-and-insert
;;;;;; haskell-show-replace) "haskell-show" "haskell-show.el" (20508
;;;;;; 11604))
;;; Generated autoloads from haskell-show.el
(autoload (quote haskell-show-replace) "haskell-show" "\
Replace the given region containing a Show value with a pretty
printed collapsible version.
\(fn START END)" nil nil)
(autoload (quote haskell-show-parse-and-insert) "haskell-show" "\
Parse a `string' containing a Show instance value and insert
it pretty printed into the current buffer.
\(fn GIVEN)" nil nil)
(autoload (quote haskell-show-parse) "haskell-show" "\
Parse the given input into a tree.
\(fn GIVEN)" nil nil)
;;;### (autoloads (haskell-sort-imports) "haskell-sort-imports" "haskell-sort-imports.el"
;;;;;; (20448 8432))
;;; Generated autoloads from haskell-sort-imports.el
(autoload 'haskell-sort-imports "haskell-sort-imports" "\
Sort the import list at the point.
\(fn)" t nil)
;;;### (autoloads (haskell-is-prefix-of haskell-string-take haskell-trim)
;;;;;; "haskell-string" "haskell-string.el" (20508 11604))
;;; Generated autoloads from haskell-string.el
(autoload (quote haskell-trim) "haskell-string" "\
Not documented
\(fn STRING)" nil nil)
(autoload (quote haskell-string-take) "haskell-string" "\
Take n chars from string.
\(fn STRING N)" nil nil)
(autoload (quote haskell-is-prefix-of) "haskell-string" "\
Is x string a prefix of y string?
\(fn X Y)" nil nil)
;;;### (autoloads (inferior-haskell-find-haddock inferior-haskell-find-definition
;;;;;; inferior-haskell-info inferior-haskell-kind inferior-haskell-type
;;;;;; inferior-haskell-send-decl inferior-haskell-load-and-run
;;;;;; inferior-haskell-load-file switch-to-haskell) "inf-haskell"
;;;;;; "inf-haskell.el" (20567 13022))
;;; Generated autoloads from inf-haskell.el
(defalias 'run-haskell 'switch-to-haskell)
(autoload 'switch-to-haskell "inf-haskell" "\
Show the inferior-haskell buffer. Start the process if needed.
\(fn &optional ARG)" t nil)
(autoload 'inferior-haskell-load-file "inf-haskell" "\
Pass the current buffer's file to the inferior haskell process.
If prefix arg \\[universal-argument] is given, just reload the previous file.
\(fn &optional RELOAD)" t nil)
(autoload 'inferior-haskell-load-and-run "inf-haskell" "\
Pass the current buffer's file to haskell and then run a COMMAND.
\(fn COMMAND)" t nil)
(autoload 'inferior-haskell-send-decl "inf-haskell" "\
Send current declaration to inferior-haskell process.
\(fn)" t nil)
(autoload 'inferior-haskell-type "inf-haskell" "\
Query the haskell process for the type of the given expression.
If optional argument `insert-value' is non-nil, insert the type above point
in the buffer. This can be done interactively with the \\[universal-argument] prefix.
The returned info is cached for reuse by `haskell-doc-mode'.
\(fn EXPR &optional INSERT-VALUE)" t nil)
(autoload 'inferior-haskell-kind "inf-haskell" "\
Query the haskell process for the kind of the given expression.
\(fn TYPE)" t nil)
(autoload 'inferior-haskell-info "inf-haskell" "\
Query the haskell process for the info of the given expression.
\(fn SYM)" t nil)
(autoload 'inferior-haskell-find-definition "inf-haskell" "\
Attempt to locate and jump to the definition of the given expression.
\(fn SYM)" t nil)
(autoload 'inferior-haskell-find-haddock "inf-haskell" "\
Find and open the Haddock documentation of SYM.
Make sure to load the file into GHCi or Hugs first by using C-c C-l.
Only works for functions in a package installed with ghc-pkg, or
whatever the value of `haskell-package-manager-name' is.
This function needs to find which package a given module belongs
to. In order to do this, it computes a module-to-package lookup
alist, which is expensive to compute (it takes upwards of five
seconds with more than about thirty installed packages). As a
result, we cache it across sessions using the cache file
referenced by `inferior-haskell-module-alist-file'. We test to
see if this is newer than `haskell-package-conf-file' every time
we load it.
\(fn SYM)" t nil)
;;;### (autoloads nil nil ("haskell-checkers.el" "haskell-font-lock.el"
;;;;;; "haskell-ghci.el" "haskell-hugs.el" "haskell-package.el"
;;;;;; "haskell-simple-indent.el") (20568 38833 279214))
Jump to Line
Something went wrong with that request. Please try again.