Mercurial > hg > Members > kokubo > emacs

comparison .emacs.d/haskell-mode/haskell-mode-autoloads.el @ 0:2764b4f45f9f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
1st commit
author Shohei KOKUBO <e105744@ie.u-ryukyu.ac.jp>
date Mon, 21 Apr 2014 04:30:59 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:2764b4f45f9f
1 ;;; haskell-mode-autoloads.el --- automatically extracted autoloads
2 ;;
3 ;;; Code:
4
5
6 ;;;### (autoloads (ghc-core-mode ghc-core-create-core) "ghc-core"
7 ;;;;;; "ghc-core.el" (21298 32076 0 0))
8 ;;; Generated autoloads from ghc-core.el
9
10 (autoload 'ghc-core-create-core "ghc-core" "\
11 Compile and load the current buffer as tidy core.
12
13 \(fn)" t nil)
14
15 (add-to-list 'auto-mode-alist '("\\.hcr\\'" . ghc-core-mode))
16
17 (autoload 'ghc-core-mode "ghc-core" "\
18 Major mode for GHC Core files.
19
20 \(fn)" t nil)
21
22 ;;;***
23
24 ;;;### (autoloads (haskell-align-imports) "haskell-align-imports"
25 ;;;;;; "haskell-align-imports.el" (21298 32076 0 0))
26 ;;; Generated autoloads from haskell-align-imports.el
27
28 (autoload 'haskell-align-imports "haskell-align-imports" "\
29 Align all the imports in the buffer.
30
31 \(fn)" t nil)
32
33 ;;;***
34
35 ;;;### (autoloads (haskell-c-mode) "haskell-c" "haskell-c.el" (21298
36 ;;;;;; 32076 0 0))
37 ;;; Generated autoloads from haskell-c.el
38
39 (add-to-list 'auto-mode-alist '("\\.hsc\\'" . haskell-c-mode))
40
41 (autoload 'haskell-c-mode "haskell-c" "\
42 Major mode for Haskell FFI files.
43
44 \(fn)" t nil)
45
46 ;;;***
47
48 ;;;### (autoloads (haskell-cabal-visit-file haskell-cabal-get-dir
49 ;;;;;; haskell-cabal-mode) "haskell-cabal" "haskell-cabal.el" (21298
50 ;;;;;; 32076 0 0))
51 ;;; Generated autoloads from haskell-cabal.el
52
53 (add-to-list 'auto-mode-alist '("\\.cabal\\'" . haskell-cabal-mode))
54
55 (autoload 'haskell-cabal-mode "haskell-cabal" "\
56 Major mode for Cabal package description files.
57
58 \(fn)" t nil)
59
60 (autoload 'haskell-cabal-get-dir "haskell-cabal" "\
61 Get the Cabal dir for a new project. Various ways of figuring this out,
62 and indeed just prompting the user. Do them all.
63
64 \(fn)" nil nil)
65
66 (autoload 'haskell-cabal-visit-file "haskell-cabal" "\
67 Locate and visit package description file for file visited by current buffer.
68 This uses `haskell-cabal-find-file' to locate the closest
69 \".cabal\" file and open it. This command assumes a common Cabal
70 project structure where the \".cabal\" file is in the top-folder
71 of the project, and all files related to the project are in or
72 below the top-folder. If called with non-nil prefix argument
73 OTHER-WINDOW use `find-file-other-window'.
74
75 \(fn OTHER-WINDOW)" t nil)
76
77 ;;;***
78
79 ;;;### (autoloads (haskell-compile) "haskell-compile" "haskell-compile.el"
80 ;;;;;; (21298 32076 0 0))
81 ;;; Generated autoloads from haskell-compile.el
82
83 (autoload 'haskell-compile "haskell-compile" "\
84 Compile the Haskell program including the current buffer.
85 Tries to locate the next cabal description in current or parent
86 folders via `haskell-cabal-find-dir' and if found, invoke
87 `haskell-compile-cabal-build-command' from the cabal package root
88 folder. If no cabal package could be detected,
89 `haskell-compile-command' is used instead.
90
91 If prefix argument EDIT-COMMAND is non-nil (and not a negative
92 prefix `-'), `haskell-compile' prompts for custom compile
93 command.
94
95 If EDIT-COMMAND contains the negative prefix argument `-',
96 `haskell-compile' calls the alternative command defined in
97 `haskell-compile-cabal-build-alt-command' if a cabal package was
98 detected.
99
100 `haskell-compile' uses `haskell-compilation-mode' which is
101 derived from `compilation-mode'. See Info
102 node `(haskell-mode)compilation' for more details.
103
104 \(fn &optional EDIT-COMMAND)" t nil)
105
106 ;;;***
107
108 ;;;### (autoloads (haskell-decl-scan-mode turn-on-haskell-decl-scan
109 ;;;;;; haskell-ds-create-imenu-index) "haskell-decl-scan" "haskell-decl-scan.el"
110 ;;;;;; (21298 32076 0 0))
111 ;;; Generated autoloads from haskell-decl-scan.el
112
113 (autoload 'haskell-ds-create-imenu-index "haskell-decl-scan" "\
114 Function for finding `imenu' declarations in Haskell mode.
115 Finds all declarations (classes, variables, imports, instances and
116 datatypes) in a Haskell file for the `imenu' package.
117
118 \(fn)" nil nil)
119
120 (autoload 'turn-on-haskell-decl-scan "haskell-decl-scan" "\
121 Unconditionally activate `haskell-decl-scan-mode'.
122
123 \(fn)" t nil)
124
125 (autoload 'haskell-decl-scan-mode "haskell-decl-scan" "\
126 Toggle Haskell declaration scanning minor mode on or off.
127 With a prefix argument ARG, enable minor mode if ARG is
128 positive, and disable it otherwise. If called from Lisp, enable
129 the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
130
131 See also info node `(haskell-mode)haskell-decl-scan-mode' for
132 more details about this minor mode.
133
134 Top-level declarations are scanned and listed in the menu item
135 \"Declarations\" (if enabled via option
136 `haskell-decl-scan-add-to-menubar'). Selecting an item from this
137 menu will take point to the start of the declaration.
138
139 \\[beginning-of-defun] and \\[end-of-defun] move forward and backward to the start of a declaration.
140
141 This may link with `haskell-doc-mode'.
142
143 For non-literate and LaTeX-style literate scripts, we assume the
144 common convention that top-level declarations start at the first
145 column. For Bird-style literate scripts, we assume the common
146 convention that top-level declarations start at the third column,
147 ie. after \"> \".
148
149 Anything in `font-lock-comment-face' is not considered for a
150 declaration. Therefore, using Haskell font locking with comments
151 coloured in `font-lock-comment-face' improves declaration scanning.
152
153 Literate Haskell scripts are supported: If the value of
154 `haskell-literate' (set automatically by `literate-haskell-mode')
155 is `bird', a Bird-style literate script is assumed. If it is nil
156 or `tex', a non-literate or LaTeX-style literate script is
157 assumed, respectively.
158
159 Invokes `haskell-decl-scan-mode-hook' on activation.
160
161 \(fn &optional ARG)" t nil)
162
163 ;;;***
164
165 ;;;### (autoloads (haskell-doc-show-type haskell-doc-current-info
166 ;;;;;; haskell-doc-mode) "haskell-doc" "haskell-doc.el" (21298 32076
167 ;;;;;; 0 0))
168 ;;; Generated autoloads from haskell-doc.el
169
170 (autoload 'haskell-doc-mode "haskell-doc" "\
171 Enter `haskell-doc-mode' for showing fct types in the echo area.
172 See variable docstring.
173
174 \(fn &optional ARG)" t nil)
175
176 (defalias 'turn-on-haskell-doc-mode 'haskell-doc-mode)
177
178 (defalias 'turn-on-haskell-doc 'haskell-doc-mode)
179
180 (autoload 'haskell-doc-current-info "haskell-doc" "\
181 Return the info about symbol at point.
182 Meant for `eldoc-documentation-function'.
183
184 \(fn)" nil nil)
185
186 (autoload 'haskell-doc-show-type "haskell-doc" "\
187 Show the type of the function near point.
188 For the function under point, show the type in the echo area.
189 This information is extracted from the `haskell-doc-prelude-types' alist
190 of prelude functions and their types, or from the local functions in the
191 current buffer.
192
193 \(fn &optional SYM)" t nil)
194
195 ;;;***
196
197 ;;;### (autoloads (haskell-font-lock-choose-keywords) "haskell-font-lock"
198 ;;;;;; "haskell-font-lock.el" (21298 32076 0 0))
199 ;;; Generated autoloads from haskell-font-lock.el
200
201 (autoload 'haskell-font-lock-choose-keywords "haskell-font-lock" "\
202
203
204 \(fn)" nil nil)
205
206 ;;;***
207
208 ;;;### (autoloads (haskell-indent-mode turn-on-haskell-indent) "haskell-indent"
209 ;;;;;; "haskell-indent.el" (21298 32076 0 0))
210 ;;; Generated autoloads from haskell-indent.el
211
212 (autoload 'turn-on-haskell-indent "haskell-indent" "\
213 Turn on ``intelligent'' Haskell indentation mode.
214
215 \(fn)" nil nil)
216
217 (autoload 'haskell-indent-mode "haskell-indent" "\
218 ``Intelligent'' Haskell indentation mode.
219 This deals with the layout rule of Haskell.
220 \\[haskell-indent-cycle] starts the cycle which proposes new
221 possibilities as long as the TAB key is pressed. Any other key
222 or mouse click terminates the cycle and is interpreted except for
223 RET which merely exits the cycle.
224 Other special keys are:
225 \\[haskell-indent-insert-equal]
226 inserts an =
227 \\[haskell-indent-insert-guard]
228 inserts an |
229 \\[haskell-indent-insert-otherwise]
230 inserts an | otherwise =
231 these functions also align the guards and rhs of the current definition
232 \\[haskell-indent-insert-where]
233 inserts a where keyword
234 \\[haskell-indent-align-guards-and-rhs]
235 aligns the guards and rhs of the region
236 \\[haskell-indent-put-region-in-literate]
237 makes the region a piece of literate code in a literate script
238
239 Invokes `haskell-indent-hook' if not nil.
240
241 \(fn &optional ARG)" t nil)
242
243 ;;;***
244
245 ;;;### (autoloads (turn-on-haskell-indentation haskell-indentation-mode)
246 ;;;;;; "haskell-indentation" "haskell-indentation.el" (21298 32076
247 ;;;;;; 0 0))
248 ;;; Generated autoloads from haskell-indentation.el
249
250 (autoload 'haskell-indentation-mode "haskell-indentation" "\
251 Haskell indentation mode that deals with the layout rule.
252 It rebinds RET, DEL and BACKSPACE, so that indentations can be
253 set and deleted as if they were real tabs. It supports
254 autofill-mode.
255
256 \(fn &optional ARG)" t nil)
257
258 (autoload 'turn-on-haskell-indentation "haskell-indentation" "\
259 Turn on the haskell-indentation minor mode.
260
261 \(fn)" t nil)
262
263 ;;;***
264
265 ;;;### (autoloads (haskell-interactive-mode-reset-error haskell-interactive-mode-echo
266 ;;;;;; haskell-interactive-switch haskell-interactive-bring haskell-interactive-mode)
267 ;;;;;; "haskell-interactive-mode" "haskell-interactive-mode.el"
268 ;;;;;; (21298 32076 0 0))
269 ;;; Generated autoloads from haskell-interactive-mode.el
270
271 (autoload 'haskell-interactive-mode "haskell-interactive-mode" "\
272 Interactive mode for Haskell.
273
274 See Info node `(haskell-mode)haskell-interactive-mode' for more
275 information.
276
277 Key bindings:
278 \\{haskell-interactive-mode-map}
279
280 \(fn)" t nil)
281
282 (autoload 'haskell-interactive-bring "haskell-interactive-mode" "\
283 Bring up the interactive mode for this session.
284
285 \(fn)" t nil)
286
287 (autoload 'haskell-interactive-switch "haskell-interactive-mode" "\
288 Switch to the interactive mode for this session.
289
290 \(fn)" t nil)
291
292 (autoload 'haskell-interactive-mode-echo "haskell-interactive-mode" "\
293 Echo a read only piece of text before the prompt.
294
295 \(fn SESSION MESSAGE &optional MODE)" nil nil)
296
297 (autoload 'haskell-interactive-mode-reset-error "haskell-interactive-mode" "\
298 Reset the error cursor position.
299
300 \(fn SESSION)" t nil)
301
302 ;;;***
303
304 ;;;### (autoloads (haskell-menu) "haskell-menu" "haskell-menu.el"
305 ;;;;;; (21298 32076 0 0))
306 ;;; Generated autoloads from haskell-menu.el
307
308 (autoload 'haskell-menu "haskell-menu" "\
309 Launch the Haskell sessions menu.
310
311 \(fn)" t nil)
312
313 ;;;***
314
315 ;;;### (autoloads (haskell-hayoo haskell-hoogle literate-haskell-mode
316 ;;;;;; haskell-mode haskell-customize haskell-mode-view-news haskell-version)
317 ;;;;;; "haskell-mode" "haskell-mode.el" (21298 32076 0 0))
318 ;;; Generated autoloads from haskell-mode.el
319
320 (autoload 'haskell-version "haskell-mode" "\
321 Show the `haskell-mode` version in the echo area.
322 With prefix argument HERE, insert it at point.
323 When FULL is non-nil, use a verbose version string.
324 When MESSAGE is non-nil, display a message with the version.
325
326 \(fn &optional HERE)" t nil)
327
328 (autoload 'haskell-mode-view-news "haskell-mode" "\
329 Display information on recent changes to haskell-mode.
330
331 \(fn)" t nil)
332
333 (autoload 'haskell-customize "haskell-mode" "\
334 Browse the haskell customize sub-tree.
335 This calls 'customize-browse' with haskell as argument and makes
336 sure all haskell customize definitions have been loaded.
337
338 \(fn)" t nil)
339
340 (defvar haskell-mode-map (let ((map (make-sparse-keymap))) (define-key map [24 4] 'inferior-haskell-send-decl) (define-key map [3 26] 'switch-to-haskell) (define-key map [3 12] 'inferior-haskell-load-file) (define-key map [3 2] 'switch-to-haskell) (define-key map (kbd "C-c C-t") 'inferior-haskell-type) (define-key map (kbd "C-c C-i") 'inferior-haskell-info) (define-key map (kbd "C-c M-.") 'inferior-haskell-find-definition) (define-key map (kbd "C-c C-d") 'inferior-haskell-find-haddock) (define-key map [3 22] 'haskell-check) (define-key map (kbd "C-c C-.") 'haskell-mode-format-imports) (define-key map [remap delete-indentation] 'haskell-delete-indentation) map) "\
341 Keymap used in Haskell mode.")
342
343 (autoload 'haskell-mode "haskell-mode" "\
344 Major mode for editing Haskell programs.
345
346 See also Info node `(haskell-mode)Getting Started' for more
347 information about this mode.
348
349 \\<haskell-mode-map>
350 Literate scripts are supported via `literate-haskell-mode'.
351 The variable `haskell-literate' indicates the style of the script in the
352 current buffer. See the documentation on this variable for more details.
353
354 Use `haskell-version' to find out what version of Haskell mode you are
355 currently using.
356
357 Additional Haskell mode modules can be hooked in via `haskell-mode-hook';
358 see documentation for that variable for more details.
359
360 \(fn)" t nil)
361
362 (autoload 'literate-haskell-mode "haskell-mode" "\
363 As `haskell-mode' but for literate scripts.
364
365 \(fn)" t nil)
366 (add-to-list 'auto-mode-alist '("\\.\\(?:[gh]s\\|hi\\)\\'" . haskell-mode))
367 (add-to-list 'auto-mode-alist '("\\.l[gh]s\\'" . literate-haskell-mode))
368 (add-to-list 'interpreter-mode-alist '("runghc" . haskell-mode))
369 (add-to-list 'interpreter-mode-alist '("runhaskell" . haskell-mode))
370
371 (autoload 'haskell-hoogle "haskell-mode" "\
372 Do a Hoogle search for QUERY.
373
374 \(fn QUERY)" t nil)
375
376 (defalias 'hoogle 'haskell-hoogle)
377
378 (autoload 'haskell-hayoo "haskell-mode" "\
379 Do a Hayoo search for QUERY.
380
381 \(fn QUERY)" t nil)
382
383 (defalias 'hayoo 'haskell-hayoo)
384
385 ;;;***
386
387 ;;;### (autoloads (haskell-move-nested-left haskell-move-nested-right
388 ;;;;;; haskell-move-nested) "haskell-move-nested" "haskell-move-nested.el"
389 ;;;;;; (21298 32076 0 0))
390 ;;; Generated autoloads from haskell-move-nested.el
391
392 (autoload 'haskell-move-nested "haskell-move-nested" "\
393 Shift the nested off-side-rule block adjacent to point by COLS columns to the right.
394
395 In Transient Mark mode, if the mark is active, operate on the contents
396 of the region instead.
397
398 \(fn COLS)" nil nil)
399
400 (autoload 'haskell-move-nested-right "haskell-move-nested" "\
401 Increase indentation of the following off-side-rule block adjacent to point.
402
403 Use a numeric prefix argument to indicate amount of indentation to apply.
404
405 In Transient Mark mode, if the mark is active, operate on the contents
406 of the region instead.
407
408 \(fn COLS)" t nil)
409
410 (autoload 'haskell-move-nested-left "haskell-move-nested" "\
411 Decrease indentation of the following off-side-rule block adjacent to point.
412
413 Use a numeric prefix argument to indicate amount of indentation to apply.
414
415 In Transient Mark mode, if the mark is active, operate on the contents
416 of the region instead.
417
418 \(fn COLS)" t nil)
419
420 ;;;***
421
422 ;;;### (autoloads (haskell-navigate-imports-return haskell-navigate-imports-go
423 ;;;;;; haskell-navigate-imports) "haskell-navigate-imports" "haskell-navigate-imports.el"
424 ;;;;;; (21298 32076 0 0))
425 ;;; Generated autoloads from haskell-navigate-imports.el
426
427 (autoload 'haskell-navigate-imports "haskell-navigate-imports" "\
428 Cycle the Haskell import lines or return to point (with prefix arg).
429
430 \(fn &optional RETURN)" t nil)
431
432 (autoload 'haskell-navigate-imports-go "haskell-navigate-imports" "\
433 Go to the first line of a list of consequtive import lines. Cycles.
434
435 \(fn)" t nil)
436
437 (autoload 'haskell-navigate-imports-return "haskell-navigate-imports" "\
438 Return to the non-import point we were at before going to the module list.
439 If we were originally at an import list, we can just cycle through easily.
440
441 \(fn)" t nil)
442
443 ;;;***
444
445 ;;;### (autoloads (haskell-process haskell-process-start haskell-process-cabal
446 ;;;;;; haskell-process-cabal-build haskell-process-load-or-reload
447 ;;;;;; haskell-process-reload-file haskell-process-load-file haskell-process-do-info
448 ;;;;;; haskell-process-do-type haskell-process-generate-tags) "haskell-process"
449 ;;;;;; "haskell-process.el" (21298 32076 0 0))
450 ;;; Generated autoloads from haskell-process.el
451
452 (autoload 'haskell-process-generate-tags "haskell-process" "\
453 Regenerate the TAGS table.
454
455 \(fn &optional AND-THEN-FIND-THIS-TAG)" t nil)
456
457 (autoload 'haskell-process-do-type "haskell-process" "\
458 Print the type of the given expression.
459
460 \(fn &optional INSERT-VALUE)" t nil)
461
462 (autoload 'haskell-process-do-info "haskell-process" "\
463 Print info on the identifier at point.
464 If PROMPT-VALUE is non-nil, request identifier via mini-buffer.
465
466 \(fn &optional PROMPT-VALUE)" t nil)
467
468 (autoload 'haskell-process-load-file "haskell-process" "\
469 Load the current buffer file.
470
471 \(fn)" t nil)
472
473 (autoload 'haskell-process-reload-file "haskell-process" "\
474 Re-load the current buffer file.
475
476 \(fn)" t nil)
477
478 (autoload 'haskell-process-load-or-reload "haskell-process" "\
479 Load or reload. Universal argument toggles which.
480
481 \(fn &optional TOGGLE)" t nil)
482
483 (autoload 'haskell-process-cabal-build "haskell-process" "\
484 Build the Cabal project.
485
486 \(fn)" t nil)
487
488 (autoload 'haskell-process-cabal "haskell-process" "\
489 Prompts for a Cabal command to run.
490
491 \(fn)" t nil)
492
493 (autoload 'haskell-process-start "haskell-process" "\
494 Start the inferior Haskell process.
495
496 \(fn SESSION)" nil nil)
497
498 (autoload 'haskell-process "haskell-process" "\
499 Get the current process from the current session.
500
501 \(fn)" nil nil)
502
503 ;;;***
504
505 ;;;### (autoloads (haskell-session-process haskell-session haskell-session-maybe
506 ;;;;;; haskell-session-installed-modules haskell-session-all-modules)
507 ;;;;;; "haskell-session" "haskell-session.el" (21298 32076 0 0))
508 ;;; Generated autoloads from haskell-session.el
509
510 (autoload 'haskell-session-all-modules "haskell-session" "\
511 Get all modules -- installed or in the current project.
512 If DONTCREATE is non-nil don't create a new session.
513
514 \(fn &optional DONTCREATE)" nil nil)
515
516 (autoload 'haskell-session-installed-modules "haskell-session" "\
517 Get the modules installed in the current package set.
518 If DONTCREATE is non-nil don't create a new session.
519
520 \(fn &optional DONTCREATE)" nil nil)
521
522 (autoload 'haskell-session-maybe "haskell-session" "\
523 Maybe get the Haskell session, return nil if there isn't one.
524
525 \(fn)" nil nil)
526
527 (autoload 'haskell-session "haskell-session" "\
528 Get the Haskell session, prompt if there isn't one or fail.
529
530 \(fn)" nil nil)
531
532 (autoload 'haskell-session-process "haskell-session" "\
533 Get the session process.
534
535 \(fn S)" nil nil)
536
537 ;;;***
538
539 ;;;### (autoloads (haskell-show-parse haskell-show-parse-and-insert
540 ;;;;;; haskell-show-replace) "haskell-show" "haskell-show.el" (21298
541 ;;;;;; 32076 0 0))
542 ;;; Generated autoloads from haskell-show.el
543
544 (autoload 'haskell-show-replace "haskell-show" "\
545 Replace the given region containing a Show value with a pretty
546 printed collapsible version.
547
548 \(fn START END)" nil nil)
549
550 (autoload 'haskell-show-parse-and-insert "haskell-show" "\
551 Parse a `string' containing a Show instance value and insert
552 it pretty printed into the current buffer.
553
554 \(fn GIVEN)" nil nil)
555
556 (autoload 'haskell-show-parse "haskell-show" "\
557 Parse the given input into a tree.
558
559 \(fn GIVEN)" nil nil)
560
561 ;;;***
562
563 ;;;### (autoloads (turn-on-haskell-simple-indent haskell-simple-indent-mode)
564 ;;;;;; "haskell-simple-indent" "haskell-simple-indent.el" (21298
565 ;;;;;; 32076 0 0))
566 ;;; Generated autoloads from haskell-simple-indent.el
567
568 (autoload 'haskell-simple-indent-mode "haskell-simple-indent" "\
569 Simple Haskell indentation mode that uses simple heuristic.
570 In this minor mode, `indent-for-tab-command' (bound to <tab> by
571 default) will move the cursor to the next indent point in the
572 previous nonblank line, whereas `haskell-simple-indent-backtab'
573 \(bound to <backtab> by default) will move the cursor the
574 previous indent point. An indent point is a non-whitespace
575 character following whitespace.
576
577 Runs `haskell-simple-indent-hook' on activation.
578
579 \(fn &optional ARG)" t nil)
580
581 (autoload 'turn-on-haskell-simple-indent "haskell-simple-indent" "\
582 Turn on function `haskell-simple-indent-mode'.
583
584 \(fn)" t nil)
585
586 ;;;***
587
588 ;;;### (autoloads (haskell-sort-imports) "haskell-sort-imports" "haskell-sort-imports.el"
589 ;;;;;; (21298 32076 0 0))
590 ;;; Generated autoloads from haskell-sort-imports.el
591
592 (autoload 'haskell-sort-imports "haskell-sort-imports" "\
593 Sort the import list at the point.
594
595 \(fn)" t nil)
596
597 ;;;***
598
599 ;;;### (autoloads (haskell-is-prefix-of haskell-string-take haskell-trim)
600 ;;;;;; "haskell-string" "haskell-string.el" (21298 32076 0 0))
601 ;;; Generated autoloads from haskell-string.el
602
603 (autoload 'haskell-trim "haskell-string" "\
604
605
606 \(fn STRING)" nil nil)
607
608 (autoload 'haskell-string-take "haskell-string" "\
609 Take n chars from string.
610
611 \(fn STRING N)" nil nil)
612
613 (autoload 'haskell-is-prefix-of "haskell-string" "\
614 Is x string a prefix of y string?
615
616 \(fn X Y)" nil nil)
617
618 ;;;***
619
620 ;;;### (autoloads (turn-on-haskell-unicode-input-method) "haskell-unicode-input-method"
621 ;;;;;; "haskell-unicode-input-method.el" (21298 32076 0 0))
622 ;;; Generated autoloads from haskell-unicode-input-method.el
623
624 (autoload 'turn-on-haskell-unicode-input-method "haskell-unicode-input-method" "\
625 Set input method `haskell-unicode'.
626 See Info node `Unicode(haskell-mode)' for more details.
627
628 \(fn)" t nil)
629
630 ;;;***
631
632 ;;;### (autoloads (haskell-yas-complete) "haskell-yas" "haskell-yas.el"
633 ;;;;;; (21298 32076 0 0))
634 ;;; Generated autoloads from haskell-yas.el
635
636 (autoload 'haskell-yas-complete "haskell-yas" "\
637
638
639 \(fn &rest ARGS)" nil nil)
640
641 ;;;***
642
643 ;;;### (autoloads (inferior-haskell-find-haddock inferior-haskell-find-definition
644 ;;;;;; inferior-haskell-info inferior-haskell-kind inferior-haskell-type
645 ;;;;;; inferior-haskell-send-decl inferior-haskell-load-and-run
646 ;;;;;; inferior-haskell-load-file switch-to-haskell) "inf-haskell"
647 ;;;;;; "inf-haskell.el" (21298 32076 0 0))
648 ;;; Generated autoloads from inf-haskell.el
649
650 (defalias 'run-haskell 'switch-to-haskell)
651
652 (autoload 'switch-to-haskell "inf-haskell" "\
653 Show the inferior-haskell buffer. Start the process if needed.
654
655 \(fn &optional ARG)" t nil)
656
657 (autoload 'inferior-haskell-load-file "inf-haskell" "\
658 Pass the current buffer's file to the inferior haskell process.
659 If prefix arg \\[universal-argument] is given, just reload the previous file.
660
661 \(fn &optional RELOAD)" t nil)
662
663 (autoload 'inferior-haskell-load-and-run "inf-haskell" "\
664 Pass the current buffer's file to haskell and then run a COMMAND.
665
666 \(fn COMMAND)" t nil)
667
668 (autoload 'inferior-haskell-send-decl "inf-haskell" "\
669 Send current declaration to inferior-haskell process.
670
671 \(fn)" t nil)
672
673 (autoload 'inferior-haskell-type "inf-haskell" "\
674 Query the haskell process for the type of the given expression.
675 If optional argument `insert-value' is non-nil, insert the type above point
676 in the buffer. This can be done interactively with the \\[universal-argument] prefix.
677 The returned info is cached for reuse by `haskell-doc-mode'.
678
679 \(fn EXPR &optional INSERT-VALUE)" t nil)
680
681 (autoload 'inferior-haskell-kind "inf-haskell" "\
682 Query the haskell process for the kind of the given expression.
683
684 \(fn TYPE)" t nil)
685
686 (autoload 'inferior-haskell-info "inf-haskell" "\
687 Query the haskell process for the info of the given expression.
688
689 \(fn SYM)" t nil)
690
691 (autoload 'inferior-haskell-find-definition "inf-haskell" "\
692 Attempt to locate and jump to the definition of the given expression.
693
694 \(fn SYM)" t nil)
695
696 (autoload 'inferior-haskell-find-haddock "inf-haskell" "\
697 Find and open the Haddock documentation of SYM.
698 Make sure to load the file into GHCi or Hugs first by using C-c C-l.
699 Only works for functions in a package installed with ghc-pkg, or
700 whatever the value of `haskell-package-manager-name' is.
701
702 This function needs to find which package a given module belongs
703 to. In order to do this, it computes a module-to-package lookup
704 alist, which is expensive to compute (it takes upwards of five
705 seconds with more than about thirty installed packages). As a
706 result, we cache it across sessions using the cache file
707 referenced by `inferior-haskell-module-alist-file'. We test to
708 see if this is newer than `haskell-package-conf-file' every time
709 we load it.
710
711 \(fn SYM)" t nil)
712
713 ;;;***
714
715 ;;;### (autoloads nil nil ("haskell-bot.el" "haskell-checkers.el"
716 ;;;;;; "haskell-compat.el" "haskell-debug.el" "haskell-package.el"
717 ;;;;;; "haskell-presentation-mode.el" "haskell-str.el" "haskell-utils.el"
718 ;;;;;; "w3m-haddock.el") (21298 32851 395559 0))
719
720 ;;;***
721
722 (provide 'haskell-mode-autoloads)
723 ;; Local Variables:
724 ;; version-control: never
725 ;; no-byte-compile: t
726 ;; no-update-autoloads: t
727 ;; coding: utf-8
728 ;; End:
729 ;;; haskell-mode-autoloads.el ends here