From 781360f5507d5e2cfc29e391116ab9943c657d70 Mon Sep 17 00:00:00 2001 From: Luke Hoersten Date: Wed, 4 Feb 2015 11:05:42 -0600 Subject: Big updates to haskell-mode stuff. --- elisp/c-init.el | 49 +++++++++++ elisp/haskell-flycheck.el | 97 +++++++++++++++++++++ elisp/haskell-init.el | 170 +++++++++++++++++++++++++++++++++++++ elisp/hoersten-c-style.el | 36 ++++++++ elisp/javascript-init.el | 16 ++++ elisp/package-require.el | 16 ++++ elisp/shm-init.el | 209 ++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 593 insertions(+) create mode 100644 elisp/c-init.el create mode 100644 elisp/haskell-flycheck.el create mode 100644 elisp/haskell-init.el create mode 100644 elisp/hoersten-c-style.el create mode 100644 elisp/javascript-init.el create mode 100644 elisp/package-require.el create mode 100644 elisp/shm-init.el (limited to 'elisp') diff --git a/elisp/c-init.el b/elisp/c-init.el new file mode 100644 index 0000000..8bcb172 --- /dev/null +++ b/elisp/c-init.el @@ -0,0 +1,49 @@ +;; ~/.emacs.d/c-hook.el +;; Luke Hoersten + +(require 'hoersten-c-style) + +(add-hook + 'c-mode-common-hook + (lambda () + ;; indentation + (setq + tab-width 3 + c-basic-offset 3 + indent-tabs-mode t + standard-indent 3 + whitespace-line-column 120) + + (setq + compile-command "scons " + c-hungry-delete-key t) + + (c-toggle-auto-newline t) ; auto newline + (c-subword-mode t) + + ;; custom keys + (local-set-key (kbd "C-c f") 'ff-find-other-file) ; toggle header/source file + + ;; ;; code folding + ;; (local-set-key (kbd "C-c v") 'hs-toggle-hiding) + ;; (local-set-key (kbd "") 'hs-hide-all) + ;; (local-set-key (kbd "") 'hs-show-all) + ;; (hs-minor-mode t) ; enable hide-show mode + + ;; gdb settings + (setq + gdb-many-windows t ; gdb many windows + gdb-use-separate-io-buffer t ; gdb stdio output + gud-tooltip-mode t) ; mouse hover variables + (local-set-key (kbd "C-c g") 'gdb) ; gdb + + ;; auto-close bracing + (setq parens-require-spaces nil) + (dolist (key '("(" "[")) (define-key (current-local-map) key 'insert-pair)) + )) + +(add-to-list 'auto-mode-alist '("\\.ipp$" . c++-mode)) +(add-to-list 'auto-mode-alist '("\\.inl$" . c++-mode)) + +(message "Loading c-init...done") +(provide 'c-init) diff --git a/elisp/haskell-flycheck.el b/elisp/haskell-flycheck.el new file mode 100644 index 0000000..4248718 --- /dev/null +++ b/elisp/haskell-flycheck.el @@ -0,0 +1,97 @@ +;;; haskell-flycheck.el --- Flychecker using the GHCi process + +;; Copyright (c) 2014 Chris Done. All rights reserved. + +;; This file is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 3, or (at your option) +;; any later version. + +;; This file is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see . + +;;; Code: + +(require 'haskell-process) +(require 'flycheck) + +(defun flycheck-haskell-process-start (checker callback) + "Start a GHCi load with CHECKER. + +CALLBACK is the status callback passed by Flycheck." + (let ((session (haskell-session))) + (haskell-session-current-dir session) + (let ((process (haskell-process))) + (haskell-process-queue-command + process + (make-haskell-command + :state + (list :process process + :session session + :filename (buffer-file-name) + :callback callback + :buffer (current-buffer) + :original (buffer-string)) + :go + (lambda (state) + (with-current-buffer (plist-get state :buffer) + (let* ((filename (plist-get state :filename))) + (write-region (point-min) (point-max) filename) + (clear-visited-file-modtime) + (haskell-process-send-string + (plist-get state :process) + (format ":load \"%s\"" + (replace-regexp-in-string + "\"" + "\\\\\"" + filename)))))) + :live (lambda (state _) + (when (plist-get state :original) + (with-temp-buffer + (insert (plist-get state :original)) + (write-region (point-min) (point-max) (plist-get state :filename)) + (plist-put state :original nil)))) + :complete + (lambda (state response) + (let ((session (plist-get state :session)) + (process (plist-get state :process))) + (haskell-process-set-response-cursor process 0) + (let ((errors (list)) + (next-error t)) + (while next-error + (setq next-error + (haskell-process-errors-warnings + session + process + response + t)) + (when (consp next-error) + (add-to-list 'errors + (flycheck-error-new-at + (plist-get next-error :line) + (plist-get next-error :col) + (plist-get next-error :type) + (plist-get next-error :msg) + :checker 'haskell-process + :buffer (plist-get state :buffer))))) + (funcall (plist-get state :callback) + 'finished + errors))))))))) + + +(flycheck-define-generic-checker 'haskell-process + "A syntax and type checker for Haskell using GHCi (via the +haskell-process Emacs module)." + :start 'flycheck-haskell-process-start + :modes '(haskell-mode) + :next-checkers '((warning . haskell-hlint))) + +;; Register as an auto-selectable checker +(setq flycheck-checkers (cons `haskell-process flycheck-checkers)) + +(provide 'haskell-flycheck) diff --git a/elisp/haskell-init.el b/elisp/haskell-init.el new file mode 100644 index 0000000..0923efd --- /dev/null +++ b/elisp/haskell-init.el @@ -0,0 +1,170 @@ +;; ~/.emacs.d/elisp/haskell-init.el +;; Luke Hoersten + +;; Require packages +(require 'package-require) +(package-require '(haskell-mode hi2 flycheck)) ;; flycheck-haskell hindent shm + +(require 'flycheck) + +;; (eval-after-load 'flycheck +;; '(add-hook 'flycheck-mode-hook #'flycheck-haskell-setup)) +;; (require 'flycheck-haskell) + +(require 'haskell) +(require 'haskell-mode) +(require 'haskell-process) +(require 'haskell-flycheck) +(require 'haskell-interactive-mode) + +(defun haskell-who-calls (&optional prompt) + "Grep the codebase to see who uses the symbol at point." + (interactive "P") + (let ((sym (if prompt + (read-from-minibuffer "Look for: ") + (haskell-ident-at-point)))) + (let ((existing (get-buffer "*who-calls*"))) + (when existing + (kill-buffer existing))) + (let ((buffer + (grep-find (format "cd %s && find . -name '*.hs' -exec grep -inH -e %s {} +" + (haskell-session-current-dir (haskell-session)) + sym)))) + (with-current-buffer buffer + (rename-buffer "*who-calls*") + (switch-to-buffer-other-window buffer))))) + +(defun haskell-process-all-types () + "List all types in a grep-mode buffer." + (interactive) + (let ((session (haskell-session))) + (switch-to-buffer (get-buffer-create (format "*%s:all-types*" + (haskell-session-name (haskell-session))))) + (setq haskell-session session) + (cd (haskell-session-current-dir session)) + (let ((inhibit-read-only t)) + (erase-buffer) + (let ((haskell-process-log nil)) + (insert (haskell-process-queue-sync-request (haskell-process) ":all-types"))) + (unless (eq major-mode 'compilation-mode) + (compilation-mode) + (setq compilation-error-regexp-alist + haskell-compilation-error-regexp-alist))))) + +;;; haskell-mode +(add-hook + 'haskell-mode-hook + (lambda () + (imenu-add-menubar-index) + (flycheck-mode) + (flycheck-disable-checker `haskell-ghc) + (turn-on-hi2) + (interactive-haskell-mode))) + +(custom-set-variables + '(capitalized-words-mode t) + '(haskell-stylish-on-save t) + + '(hi2-layout-offset 4) + '(hi2-left-offset 4) + + '(haskell-process-type 'cabal-repl) + '(haskell-process-args-cabal-repl '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng")) + '(haskell-process-path-ghci "ghci-ng") + '(haskell-process-args-ghci "-ferror-spans") + '(haskell-process-suggest-remove-import-lines t) + '(haskell-process-auto-import-loaded-modules t) + '(haskell-process-log t) + '(haskell-process-reload-with-fbytecode nil) + '(haskell-process-use-presentation-mode t) + '(haskell-process-suggest-haskell-docs-imports t) + '(haskell-process-suggest-hoogle-imports t) + '(haskell-process-generate-tags nil) + '(haskell-process-show-debug-tips nil) + + '(haskell-notify-p t) + '(haskell-align-imports-pad-after-name t) + '(haskell-ask-also-kill-buffers t) + '(haskell-import-mapping t) + + '(haskell-interactive-mode-eval-pretty t) + '(haskell-interactive-mode-scroll-to-bottom t) + '(haskell-interactive-mode-eval-mode 'haskell-mode)) + +;; haskell-interactive-mode keybindings +(define-key interactive-haskell-mode-map (kbd "C-c C-l") 'haskell-process-load-or-reload) +(define-key interactive-haskell-mode-map (kbd "M-,") 'haskell-who-calls) +(define-key interactive-haskell-mode-map (kbd "M-.") 'haskell-mode-goto-loc) +(define-key interactive-haskell-mode-map (kbd "C-?") 'haskell-mode-find-uses) +(define-key interactive-haskell-mode-map (kbd "C-`") 'haskell-interactive-bring) +(define-key interactive-haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear) +(define-key interactive-haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build) +(define-key interactive-haskell-mode-map (kbd "C-c c") 'haskell-process-cabal) +(define-key interactive-haskell-mode-map (kbd "C-c C-t") 'haskell-mode-show-type-at) + +(define-key haskell-interactive-mode-map (kbd "C-c C-i") 'haskell-process-do-info) +(define-key haskell-interactive-mode-map (kbd "C-") 'haskell-interactive-mode-error-backward) +(define-key haskell-interactive-mode-map (kbd "C-") 'haskell-interactive-mode-error-forward) +(define-key haskell-interactive-mode-map (kbd "C-c c") 'haskell-process-cabal) + +(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-d") 'haskell-describe) +(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) +(define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space) + +(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) + +(message "Loading haskell-init...done") +(provide 'haskell-init) + + +;;;; Old haskell stuff +;; ;;; haskell-mode +;; (autoload 'ghc-init "ghc" nil t) +;; (add-hook +;; 'haskell-mode-hook +;; (lambda () +;; (ghc-init) +;; (capitalized-words-mode t) +;; (turn-on-hi2) +;; (imenu-add-menubar-index) +;; (interactive-haskell-mode) +;; (local-set-key (kbd "C-c i") 'haskell-navigate-imports) ; go to imports. prefix to return +;; (local-set-key (kbd "M-p") 'move-line-up) ; need to override default M-p function +;; (local-set-key (kbd "M-n") 'move-line-down) +;; (local-set-key (kbd "C-1") 'ghc-display-errors) +;; (local-set-key (kbd "C-.") 'ghc-goto-next-error) +;; (local-set-key (kbd "C-,") 'ghc-goto-prev-error) + +;; (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) +;; (define-key haskell-mode-map (kbd "SPC") 'haskell-mode-contextual-space) + +;; (setq +;; ghc-ghc-options '("-isrc") +;; haskell-program-name "cabal repl" +;; haskell-stylish-on-save t +;; hi2-layout-offset 4 +;; hi2-left-offset 4 +;; whitespace-line-column 78 +;; ;; haskell-process-type 'cabal-repl +;; haskell-process-suggest-remove-import-lines t +;; haskell-process-auto-import-loaded-modules t +;; haskell-process-log t +;; ))) + +;; ;;; ghci-mode +;; (add-hook 'inferior-haskell-mode-hook 'turn-on-ghci-completion) diff --git a/elisp/hoersten-c-style.el b/elisp/hoersten-c-style.el new file mode 100644 index 0000000..043a499 --- /dev/null +++ b/elisp/hoersten-c-style.el @@ -0,0 +1,36 @@ +;; ~/.emacs.d/hoersten-c-style.el +;; Luke Hoersten + +;; hoersten c++-style +(c-add-style + "hoersten" + '(;; indentation + (indent-tabs-mode . t) + (tab-width . 3) + (c-basic-offset . 3) + + ;; brace cleanups + (c-cleanup-list + brace-else-brace + brace-elseif-brace + brace-catch-brace + empty-defun-braces + defun-close-semi + list-close-comma + scope-operator) + + ;; syntactic symbols + (c-offsets-alist + (substatement-open . 0) + (inline-open . 0) + (case-label . +) + (innamespace . 0) + (arglist-cont-nonempty . +) + (cpp-macro . -)))) + +;; c-like language settings (c, c++, java, etc.) +;;(require 'doxymacs) +(setq-default c-default-style "hoersten") ; load c-style + +(message "Loading hoersten-c-style...done") +(provide 'hoersten-c-style) diff --git a/elisp/javascript-init.el b/elisp/javascript-init.el new file mode 100644 index 0000000..4035870 --- /dev/null +++ b/elisp/javascript-init.el @@ -0,0 +1,16 @@ +;; ~/.emacs.d/elisp/javascript-init.el +;; Luke Hoersten + +;; Require packages +(require 'package-require) +(package-require '(ac-js2 js2-mode json-mode)) + +(require 'auto-complete-config) + +;;; js2-mode +(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode)) +(add-hook 'js2-mode-hook 'ac-js2-mode) +(setq-default ac-js2-evaluate-calls t) + +(message "Loading javascript-init...done") +(provide 'javascript-init) diff --git a/elisp/package-require.el b/elisp/package-require.el new file mode 100644 index 0000000..c44c2d0 --- /dev/null +++ b/elisp/package-require.el @@ -0,0 +1,16 @@ +;; ~/.emacs.d/elisp/package-require.el +;; Luke Hoersten + +(package-initialize) +(add-to-list 'package-archives '("melpa" . "http://melpa.milkbox.net/packages/") t) +(add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/") t) + +(defun package-require (packages) + "Ensure that a given package is installed" + (mapc (lambda (package) + (unless (package-installed-p package) + (package-install package))) + packages)) + +(message "Loading packages...done") +(provide 'package-require) diff --git a/elisp/shm-init.el b/elisp/shm-init.el new file mode 100644 index 0000000..d80a509 --- /dev/null +++ b/elisp/shm-init.el @@ -0,0 +1,209 @@ +;; ~/.emacs.d/elisp/shm-init.el +;; Luke Hoersten + +;; Require packages +(require 'package-require) +(package-require '(haskell-mode shm hindent flymake-haskell-multi)) + +;; Requirements +(require 'shm) +(require 'hindent) +(require 'shm-case-split) +(require 'shm-reformat) +(require 'haskell) +(require 'haskell-mode) +(require 'hindent) +(require 'haskell-process) +(require 'haskell-simple-indent) +(require 'haskell-interactive-mode) +(require 'haskell-font-lock) + +;; Functions +(defun haskell-process-all-types () + "List all types in a grep-mode buffer." + (interactive) + (let ((session (haskell-session))) + (switch-to-buffer (get-buffer-create (format "*%s:all-types*" + (haskell-session-name (haskell-session))))) + (setq haskell-session session) + (cd (haskell-session-current-dir session)) + (let ((inhibit-read-only t)) + (erase-buffer) + (let ((haskell-process-log nil)) + (insert (haskell-process-queue-sync-request (haskell-process) ":all-types"))) + (unless (eq major-mode 'compilation-mode) + (compilation-mode) + (setq compilation-error-regexp-alist + haskell-compilation-error-regexp-alist))))) + +(defun haskell-interactive-toggle-print-mode () + (interactive) + (setq haskell-interactive-mode-eval-mode + (intern + (ido-completing-read "Eval result mode: " + '("fundamental-mode" + "haskell-mode" + "ghc-core-mode"))))) + +(defun haskell-insert-doc () + "Insert the documentation syntax." + (interactive) + (insert "-- | ")) + +(defun haskell-insert-undefined () + "Insert undefined." + (interactive) + (if (and (boundp 'structured-haskell-mode) + structured-haskell-mode) + (shm-insert-string "undefined") + (insert "undefined"))) + +(defun haskell-move-right () + (interactive) + (haskell-move-nested 1)) + +(defun haskell-move-left () + (interactive) + (haskell-move-nested -1)) + +(defun haskell-who-calls (&optional prompt) + "Grep the codebase to see who uses the symbol at point." + (interactive "P") + (let ((sym (if prompt + (read-from-minibuffer "Look for: ") + (haskell-ident-at-point)))) + (let ((existing (get-buffer "*who-calls*"))) + (when existing + (kill-buffer existing))) + (let ((buffer + (grep-find (format "cd %s && find . -name '*.hs' -exec grep -inH -e %s {} +" + (haskell-session-current-dir (haskell-session)) + sym)))) + (with-current-buffer buffer + (rename-buffer "*who-calls*") + (switch-to-buffer-other-window buffer))))) + +(defun haskell-auto-insert-module-template () + "Insert a module template for the newly created buffer." + (interactive) + (when (and (= (point-min) + (point-max)) + (buffer-file-name)) + (insert + "-- | " + "\n" + "\n" + "module " + ) + (let ((name (haskell-guess-module-name))) + (if (string= name "") + (progn (insert "Main") + (shm-evaporate (- (point) 5) + (point))) + (insert name))) + (insert " where" + "\n" + "\n") + (goto-char (point-min)) + (forward-char 4))) + +(defun shm-contextual-space () + "Do contextual space first, and run shm/space if no change in +the cursor position happened." + (interactive) + (if (looking-back "import") + (call-interactively 'haskell-mode-contextual-space) + (progn + (let ((ident (haskell-ident-at-point))) + (when ident + (and interactive-haskell-mode + (haskell-process-do-try-type ident)))) + (call-interactively 'shm/space)))) + +;; Mode settings +(custom-set-variables + '(haskell-process-type 'cabal-repl) + '(haskell-process-args-cabal-repl + '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng")) + '(haskell-notify-p t) + '(haskell-stylish-on-save nil) + '(haskell-tags-on-save nil) + '(haskell-process-suggest-remove-import-lines t) + '(haskell-process-auto-import-loaded-modules t) + '(haskell-process-log t) + '(haskell-process-reload-with-fbytecode nil) + '(haskell-process-use-presentation-mode t) + '(haskell-interactive-mode-include-file-name nil) + '(haskell-interactive-mode-eval-pretty nil) + '(shm-use-presentation-mode t) + '(shm-auto-insert-skeletons t) + '(shm-auto-insert-bangs t) + '(haskell-process-suggest-haskell-docs-imports t) + '(hindent-style "chris-done") + '(haskell-interactive-mode-eval-mode 'haskell-mode) + '(haskell-process-path-ghci "ghci-ng") + '(haskell-process-args-ghci '("-ferror-spans")) + '(haskell-process-args-cabal-repl + '("--ghc-option=-ferror-spans" "--with-ghc=ghci-ng")) + '(haskell-process-generate-tags nil) + '(haskell-complete-module-preferred + '("Data.ByteString" + "Data.ByteString.Lazy" + "Data.List" + "Data.Map" + "Data.Maybe" + "Data.Monoid" + "Data.Ord"))) + +;; Add hook +(add-hook 'haskell-mode-hook 'structured-haskell-mode) +(add-hook 'haskell-mode-hook 'interactive-haskell-mode) +(add-hook 'haskell-interactive-mode-hook 'structured-haskell-repl-mode) +(add-hook 'haskell-mode-hook 'haskell-auto-insert-module-template) + +;; Keybindings +(define-key interactive-haskell-mode-map [f5] 'haskell-process-load-or-reload) +(define-key interactive-haskell-mode-map [f12] 'haskell-process-reload-devel-main) +(define-key interactive-haskell-mode-map (kbd "M-,") 'haskell-who-calls) +(define-key interactive-haskell-mode-map (kbd "C-`") 'haskell-interactive-bring) +(define-key interactive-haskell-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear) +(define-key interactive-haskell-mode-map (kbd "C-c C-c") 'haskell-process-cabal-build) +(define-key interactive-haskell-mode-map (kbd "C-c c") 'haskell-process-cabal) +(define-key interactive-haskell-mode-map (kbd "M-.") 'haskell-mode-goto-loc) +(define-key interactive-haskell-mode-map (kbd "C-?") 'haskell-mode-find-uses) +(define-key interactive-haskell-mode-map (kbd "C-c C-t") 'haskell-mode-show-type-at) + +(define-key haskell-mode-map (kbd "C-c i") 'hindent/reformat-decl) +(define-key haskell-mode-map [f8] 'haskell-navigate-imports) +(define-key haskell-mode-map (kbd "C-c C-u") 'haskell-insert-undefined) +(define-key haskell-mode-map (kbd "C-c C-a") 'haskell-insert-doc) +(define-key haskell-mode-map (kbd "C-") 'haskell-simple-indent-newline-indent) +(define-key haskell-mode-map (kbd "C-") 'haskell-move-right) +(define-key haskell-mode-map (kbd "C-") 'haskell-move-left) +(define-key haskell-mode-map (kbd "") 'haskell-mode-contextual-space) + +(define-key haskell-cabal-mode-map (kbd "C-`") 'haskell-interactive-bring) +(define-key haskell-cabal-mode-map [?\C-c ?\C-z] 'haskell-interactive-switch) +(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) +(define-key haskell-cabal-mode-map (kbd "C-c C-k") 'haskell-interactive-mode-clear) + +(define-key haskell-interactive-mode-map (kbd "C-c C-v") 'haskell-interactive-toggle-print-mode) +(define-key haskell-interactive-mode-map (kbd "C-c C-i") 'haskell-process-do-info) +(define-key haskell-interactive-mode-map [f12] 'haskell-process-reload-devel-main) +(define-key haskell-interactive-mode-map (kbd "C-") 'haskell-interactive-mode-error-backward) +(define-key haskell-interactive-mode-map (kbd "C-") 'haskell-interactive-mode-error-forward) +(define-key haskell-interactive-mode-map (kbd "C-c c") 'haskell-process-cabal) + +(define-key shm-map (kbd "C-c C-p") 'shm/expand-pattern) +(define-key shm-map (kbd "C-c C-s") 'shm/case-split) +(define-key shm-map (kbd "SPC") 'shm-contextual-space) +(define-key shm-map (kbd "C-\\") 'shm/goto-last-point) +(define-key shm-map (kbd "C-c C-f") 'shm-fold-toggle-decl) +(define-key shm-map (kbd "C-c i") 'shm-reformat-decl) + +(turn-on-haskell-simple-indent) +(load "haskell-mode-autoloads.el") + +(message "Loading shm-init...done") +(provide 'shm-init) -- cgit v1.2.3