fiddlerwoaroof/dotfiles - Change O3777TK2IVZ6LQATEWWIICGJY3GXO4MOUHZ73ENZFSY3VW4Q2DQAC

emacs: rename configurations to config-conf.el

Created by Ed Langley on August 3, 2019

O3777TK2IVZ6LQATEWWIICGJY3GXO4MOUHZ73ENZFSY3VW4Q2DQAC

Dependencies

In channels

main

Change contents

File deletion: dependencies, dependencies
BFD:BFD[3.1] → [4.129:152]
BFD:BFD[3.1] → [4.129:152]
BFD:BFD[4.152] → [4.128:128]

File deletion: slime.el

BF:BFD[5.4163] → [5.7035:7067]

BF:BFD[5.7067] → [5.4191:4191]

B:BD[5.4191] → [5.4192:4272]

∅:D[6.376] → [5.4322:4339]

∅:D[7.1323] → [5.4322:4339]

B:BD[5.4322] → [5.4322:4339]

∅:D[7.1387] → [5.4339:4340]

B:BD[5.4339] → [5.4339:4340]

∅:D[7.2167] → [5.4380:4699]

B:BD[5.4380] → [5.4380:4699]

∅:D[8.235] → [5.5070:5071]

B:BD[5.5070] → [5.5070:5071]

∅:D[8.825] → [5.5209:5210]

B:BD[5.5209] → [5.5209:5210]

∅:D[9.2772] → [5.5210:6151]

B:BD[5.5210] → [5.5210:6151]

B:BD[5.6151] → [10.9142:9359]

∅:D[10.9359] → [5.6151:6451]

B:BD[5.6151] → [5.6151:6451]

∅:D[11.514] → [5.6451:6452]

B:BD[5.6451] → [5.6451:6452]

∅:D[11.552] → [5.6770:6906]

B:BD[5.6770] → [5.6770:6906]

∅:D[9.2933] → [5.6966:7019]

B:BD[5.6966] → [5.6966:7019]

∅:D[8.1846] → [5.7019:7021]

B:BD[5.7019] → [5.7019:7021]

∅:D[7.2229] → [8.1906:1907]

B:BD[8.1906] → [8.1906:1907]

B:BD[12.606] → [12.606:616]

∅:D[12.616] → [5.7022:7023]

∅:D[8.2060] → [5.7022:7023]

B:BD[5.7022] → [5.7022:7023]

∅:D[13.685] → [14.16511:16512]

∅:D[12.1396] → [14.16511:16512]

B:BD[5.7034] → [14.16511:16512]

B:BD[14.16512] → [13.686:1350]

∅:D[15.510] → [11.553:669]

B:BD[13.1350] → [11.553:669]

∅:D[16.224] → [11.716:1260]

B:BD[11.716] → [11.716:1260]

∅:D[16.288] → [11.1316:1779]

B:BD[11.1316] → [11.1316:1779]

B:BD[11.1260] → [16.225:288]

B:BD[11.669] → [16.170:224]

B:BD[13.1350] → [15.171:510]

B:BD[12.1027] → [12.1027:1028]

B:BD[13.483] → [13.483:685]

B:BD[5.7021] → [7.2168:2229]

B:BD[5.7019] → [8.826:863]

∅:D[12.278] → [8.902:955]

B:BD[8.902] → [8.902:955]

∅:D[12.361] → [8.996:1048]

B:BD[8.996] → [8.996:1048]

∅:D[12.443] → [8.1088:1139]

B:BD[8.1088] → [8.1088:1139]

∅:D[12.524] → [8.1178:1846]

B:BD[8.1178] → [8.1178:1846]

B:BD[8.1139] → [12.444:524]

B:BD[8.1048] → [12.362:443]

B:BD[8.955] → [12.279:361]

B:BD[8.863] → [12.198:278]

B:BD[5.6906] → [9.2879:2933]

B:BD[5.6452] → [9.2773:2878]

B:BD[9.2878] → [11.515:552]

B:BD[5.6451] → [11.169:514]

B:BD[5.5210] → [9.2704:2772]

B:BD[5.5071] → [8.236:262]

B:BD[8.374] → [8.374:603]

B:BD[8.699] → [8.699:825]

B:BD[5.4699] → [8.187:235]

B:BD[5.4340] → [7.1388:2167]

∅:D[2.211] → [7.1324:1387]

B:BD[5.4339] → [7.1324:1387]

B:BD[5.4339] → [2.171:211]

B:BD[5.4272] → [6.171:376]

;;;; SLIME SETUP {{{
;; (load (expand-file-name "~/quicklisp/slime-helper.el"))
(require 'slime)
(global-set-key (kbd "C-c x") 'slime-export-symbol-at-point)
(when (and (boundp 'common-lisp-hyperspec-root)
           (string-prefix-p "/" common-lisp-hyperspec-root))
  (setq common-lisp-hyperspec-root
        (concat "file://" common-lisp-hyperspec-root)))
;; Replace "sbcl" with the path to your implementation
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry 91 "(" lisp-mode-syntax-table)
(modify-syntax-entry 93 ")" lisp-mode-syntax-table)
;;(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?\[ "(]" lisp-mode-syntax-table)
(modify-syntax-entry ?\] ")[" lisp-mode-syntax-table)
(modify-syntax-entry ?\{ "(}" lisp-mode-syntax-table)
(modify-syntax-entry ?\} "){" lisp-mode-syntax-table)
(setq shr-inhibit-images t
      shr-use-fonts nil)
(defun fwoar--clhs-lookup (&rest args)
  (let ((browse-url-browser-function 'eww-browse-url))
    (hyperspec-lookup (word-at-point))))
(pushnew (list ?h "Check hyperspec" #'fwoar--clhs-lookup)
         slime-selector-methods
         :key #'car)
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
         slime-selector-methods
         :key #'car)
;;;;; }}}
With ARG positive N, absorb that many expressions.
Examples:
  (do-stuff 1)         (save-excursion
  (save-excursion  ->   |(do-stuff 1)
   |(do-stuff 2))        (do-stuff 2))
  foo bar (concat |baz quux) -> (concat |foo bar baz quux) ;; 2"
  (interactive "p")
  (sp-forward-whitespace)
  (let* ((old (point))
         (raise (progn
                  (sp-end-of-sexp)
                  (buffer-substring (point) old))))
    (delete-region old (point))
    (sp-forward-slurp-sexp arg)
    (sp-backward-whitespace)
    (sp-end-of-sexp)
    (insert raise)
    (save-excursion
      (sp-backward-up-sexp)
      (indent-sexp)))
  (sp-backward-whitespace))
(defslime-repl-shortcut fwoar--slime-repl-load-asd ("load-asd")
  (:handler (lambda ()
              (interactive)
                (slime-eval-async (cons 'cl:progn
                                        (mapcar (lambda (it)
                                                  `(cl:progn (asdf:load-asd ,it) ,it))
                                                system-files))
                  (lambda (r)
                    (message "Loading ASDs done: %s" r))))))
  (:one-liner "Load asd for current project"))
(comment (defslime-repl-shortcut fwoar--slime-repl-quickload ("quickload")
           (:handler (lambda ()
                       (interactive)
                         (slime-eval-async (cons 'cl:progn
                                                 (mapcar (lambda (it)
                                                           `(cl:progn (asdf:load-asd ,it) ,it))
                                                         system-files))
                           (lambda (r)
                             (message "Loading ASDs done: %s" r))))))
           (:one-liner "Load asd for current project")))
                       (let ((system-files (fwoar--get-asds)))
              (let ((system-files (fwoar--get-asds)))
(setq slime-contribs '(slime-fancy
                       slime-company
                       slime-macrostep
                       slime-trace-dialog
                       slime-mdot-fu
                       slime-buffer-streams
                       slime-indentation)
      slime-export-save-file t)
(slime-setup slime-contribs)
(defun sp-absorb-forward-sexp (&optional arg)
  "Absorb previous expression.
Save the expressions preceding point and delete them.  Then slurp
an expression backward and insert the saved expressions.
;;(message (format "s-c-c is: %s" slime-company-completion))
(defun slime-ecl ()
  (interactive)
    (slime)))
(defun slime-cmucl ()
  (interactive)
    (slime)))
(defun slime-sbcl ()
  (interactive)
    (slime)))
(defun slime-ccl ()
  (interactive)
    (slime)))
(defun find-use-clause (current-form)
  (when current-form
    (destructuring-bind (discriminator . packages) current-form
      (case discriminator
        (:use (remove-if (op (or (eql :cl _)))
                         (cdr current-form)))
        (defpackage (find-use-clause
                     (find-if (lambda (f)
                                (and (listp f)
                                     (eql (car f) :use)))
                              '(defpackage :tracking-sim (:use :cl :alexandria :serapeum) (:export)))))))))
(defun load-package-uses ()
  (interactive)
  (slime-eval-async `(ql:quickload ',(find-use-clause (list-at-point)))))
  (let ((inferior-lisp-program "ccl")
        (slime-lisp-implementations nil))
  (let ((inferior-lisp-program "sbcl")
        (slime-lisp-implementations nil))
  (let ((inferior-lisp-program "cmucl")
        (slime-lisp-implementations nil))
  (let ((inferior-lisp-program "ecl")
        (slime-lisp-implementations nil))
(pushnew (list ?S "Goto System" #'fwoar--find-system)
(cl-defgeneric fwoar--find-system ())
(cl-defmethod fwoar--find-system (&context (major-mode lisp-mode))
  (let ((systems (fwoar--get-asds)))
(defun fwoar--get-asds ()
  (let ((dir-of-asd (locate-dominating-file default-directory
                                            (lambda (n)
                                              (directory-files n nil "^[^.#][^#]*[.]asd$")))))
    (when dir-of-asd
      (directory-files dir-of-asd
                       t "^[^.#][^#]*[.]asd$"))))
(evil-define-key 'normal lisp-mode-map "gd" 'slime-edit-definition)
(defun setup-lisp-mode ()
  (unless (string= "*slime-scratch*" (buffer-name))
    (smartparens-strict-mode 1)
    (evil-smartparens-mode 1)
    (aggressive-indent-mode 1))
  (define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
  (rainbow-delimiters-mode))
(add-hook 'lisp-mode-hook 'setup-lisp-mode) 
(add-hook 'emacs-lisp-mode-hook 'setup-lisp-mode) 
(setq inferior-lisp-program "~/sbcl/bin/sbcl") 
(defmacro define-lisp-implementations (&rest decl)
  `(progn
     ,@(cl-loop for (symbol . args) in decl
                collect `(progn
                           (defun ,symbol ()
                             (interactive)
                             (slime ',symbol))
                           (cl-pushnew '(,symbol ,@args) slime-lisp-implementations
                                       :key 'car)))))
(with-eval-after-load "slime"
  (when (or (eq system-type 'gnu/linux)
            (eq system-type 'darwin))
    (define-lisp-implementations
      (abcl  ("abcl"))
      (ccl ("ccl"))
      (clisp ("clisp"))
      (cmucl ("cmucl" "-quiet"))
      (ecl   ("ecl"))
      ;;(mkcl  ("mkcl"))
      ;;(xcl   ("xcl"))
      (sbcl  ("sbcl" "--dynamic-space-size" "8192")))))
;; put slime-company in load-path
;; (require 'slime-company)
(use-package slime-company
  :ensure t)
(add-to-list 'load-path (fwoar-git-repo "3dp/slime/"
                                        "git@github.com:slime/slime.git"
                                        "https://github.com/slime/slime.git"))

File deletion: evil.el

BF:BFD[5.4163] → [5.10196:10227]

BF:BFD[5.10227] → [5.7069:7069]

B:BD[5.7069] → [14.16514:16607]

∅:D[17.269] → [14.16607:16608]

B:BD[14.16607] → [14.16607:16608]

B:BD[14.16608] → [7.2571:2670]

B:BD[14.16607] → [17.171:269]

∅:D[7.2670] → [5.7070:7110]

∅:D[14.16608] → [5.7070:7110]

B:BD[5.7069] → [5.7070:7110]

∅:D[18.369] → [5.7110:7231]

B:BD[5.7110] → [5.7110:7231]

B:BD[5.7294] → [5.7294:7392]

∅:D[19.431] → [5.7713:7714]

B:BD[5.7713] → [5.7713:7714]

B:BD[5.9324] → [5.9324:9734]

∅:D[17.274] → [5.9734:9735]

∅:D[18.1219] → [5.9734:9735]

B:BD[5.9734] → [5.9734:9735]

∅:D[17.557] → [5.9849:9850]

B:BD[5.9849] → [5.9849:9850]

∅:D[20.310] → [5.9850:9851]

∅:D[17.762] → [5.9850:9851]

B:BD[5.9850] → [5.9850:9851]

∅:D[20.543] → [5.10034:10035]

∅:D[17.1009] → [5.10034:10035]

B:BD[5.10034] → [5.10034:10035]

∅:D[17.1716] → [5.10123:10124]

B:BD[5.10123] → [5.10123:10124]

∅:D[17.3856] → [21.196:197]

B:BD[5.10195] → [21.196:197]

B:BD[21.197] → [17.3857:4187]

∅:D[17.4187] → [21.197:235]

B:BD[21.197] → [21.197:235]

B:BD[21.235] → [17.4188:4202]

∅:D[17.4202] → [21.235:245]

B:BD[21.235] → [21.235:245]

B:BD[21.245] → [17.4203:4337]

∅:D[17.4337] → [21.245:313]

B:BD[21.245] → [21.245:313]

B:BD[21.313] → [17.4338:4487]

∅:D[17.4487] → [21.313:382]

B:BD[21.313] → [21.313:382]

B:BD[21.382] → [17.4488:4642]

B:BD[17.4642] → [7.2750:2753]

B:BD[5.10124] → [17.1717:3856]

B:BD[5.10035] → [17.1010:1077]

∅:D[20.619] → [17.1078:1198]

B:BD[17.1078] → [17.1078:1198]

∅:D[20.970] → [17.1324:1447]

B:BD[17.1324] → [17.1324:1447]

∅:D[20.1332] → [17.1575:1716]

B:BD[17.1575] → [17.1575:1716]

B:BD[17.1447] → [20.971:1332]

B:BD[17.1198] → [20.620:970]

B:BD[17.1077] → [20.544:619]

B:BD[5.9851] → [17.763:883]

B:BD[17.883] → [20.311:543]

B:BD[5.9850] → [17.558:638]

B:BD[17.638] → [20.172:310]

B:BD[5.9735] → [17.275:395]

∅:D[2.225] → [17.395:557]

B:BD[17.395] → [17.395:557]

B:BD[17.395] → [2.213:225]

B:BD[5.9734] → [18.370:658]

∅:D[22.564] → [18.946:1219]

B:BD[18.946] → [18.946:1219]

B:BD[18.1219] → [17.270:274]

B:BD[18.658] → [22.170:564]

B:BD[19.299] → [19.299:300]

B:BD[5.7110] → [18.170:171]

∅:D[7.2749] → [18.243:369]

B:BD[18.243] → [18.243:369]

B:BD[18.171] → [7.2671:2749]

(defun wrap-with-doublequote (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "\""))
(defun fwoar-delete-mru-window ()
  (interactive)
  (delete-window
   (get-mru-window nil nil t)))
(defun wrap-in-dollar-brace
    (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "${"))
(use-package evil
  :ensure t
  :config
  (advice-add 'evil-delete-marks :after
              (lambda (&rest args)
                (evil-visual-mark-render)))
  (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common)
  (evil-mode)
  (progn ;; navigation
    (define-key evil-normal-state-map " f" 'helm-projectile)
    (define-key evil-normal-state-map " j" 'helm-buffers-list)
    (define-key evil-normal-state-map " u" 'undo-tree-visualize))
  (progn ;; completion
    (define-key evil-normal-state-map (kbd "TAB") 'company-indent-or-complete-common)
    (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common))
  (progn ;; narrowing
    (define-key evil-normal-state-map " n(" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " n)" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " nn" 'narrow-to-defun)
    (define-key evil-normal-state-map " nr" 'narrow-to-region)
    (define-key evil-normal-state-map " nw" 'widen)))
(use-package centaur-tabs
  :ensure t
  :after evil
  :config
  (setq centaur-tabs-adjust-buffer-order t
        centaur-tabs-adjust-buffer-order 'left)
  (centaur-tabs-enable-buffer-reordering)
  (define-key evil-normal-state-map "gt" 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "<header-line> <wheel-up>") 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "s-}") 'centaur-tabs-forward-tab)
  (define-key evil-normal-state-map "gT" 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "<header-line> <wheel-down>") 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "s-{") 'centaur-tabs-backward-tab))
 
  (progn ;; splicing
    (define-key evil-normal-state-map ",S" 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, S") 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, C-S") 'sp-splice-sexp)
    (define-key evil-normal-state-map ",A" 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, A") 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, C-A") 'sp-splice-sexp-killing-backward)
    (define-key evil-normal-state-map ",D" 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, D") 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, C-D") 'sp-splice-sexp-killing-forward)
    (define-key evil-normal-state-map ",F" 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, F") 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, C-F") 'sp-splice-sexp-killing-around))
  (progn ;; barf/slurp
    (define-key evil-normal-state-map ",," 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, ,") 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-,") 'sp-backward-barf-sexp)
    (define-key evil-normal-state-map ",." 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, .") 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-.") 'sp-forward-barf-sexp)
    (define-key evil-normal-state-map ",<" 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, <") 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C-<") 'sp-backward-slurp-sexp)
    (define-key evil-normal-state-map ",>" 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, >") 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C->") 'sp-forward-slurp-sexp))
  (progn ;; misc
    (define-key evil-normal-state-map ",~" 'sp-convolute-sexp)
    (define-key evil-normal-state-map ",a" 'sp-absorb-sexp)
    (define-key evil-normal-state-map ",e" 'sp-emit-sexp)
    (define-key evil-normal-state-map ",`" 'sp-clone-sexp)
    (define-key evil-normal-state-map ",J" 'sp-join-sexp)
    (define-key evil-normal-state-map ",|" 'sp-split-sexp))
    (define-key evil-normal-state-map ",w$" 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map ",w{" 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w}" 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w[" 'sp-wrap-square)
    (define-key evil-normal-state-map ",w]" 'sp-wrap-square)
    (define-key evil-normal-state-map ",w\"" 'wrap-with-doublequote)
    (define-key cider-mode-map (kbd "C-, w \"") 'sp-wrap-doublequote))
    (define-key global-map (kbd "C-, w [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, <escape>") 'sp-wrap-square)
    (define-key global-map (kbd "C-, [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, w ]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, C-]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, ]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-{") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, }") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-}") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w }") 'sp-wrap-curly)
    (define-key evil-normal-state-map (kbd "C-, $") 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map ",w(" 'sp-wrap-round)
    (define-key evil-normal-state-map ",w)" 'sp-wrap-round)
    (define-key global-map (kbd "C-, (") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-(") 'sp-wrap-round)
    (define-key global-map (kbd "C-, )") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-)") 'sp-wrap-round)
  (progn ;; wrapping
    (define-key evil-normal-state-map ",W" 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, W") 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, C-W") 'sp-wrap-round)
(use-package evil-surround
  :ensure t
  :after evil
  :config
  (global-evil-surround-mode))
(use-package evil-leader
  :after evil
  :config (evil-leader/set-leader "ß"))
(use-package evil-smartparens
  :ensure t
  :after evil smartparens
  :config
  (evil-smartparens-mode 1)
  :ensure t
  (progn ;; workaround until this fixed: https://github.com/emacs-evil/evil/issues/1129
    ;;                          or this: https://github.com/emacs-evil/evil/pull/1130
    (defun config/fix-evil-window-move (orig-fun &rest args)
      "Close Treemacs while moving windows around."
    (dolist (func '(evil-window-move-far-left
                    evil-window-move-far-right
                    evil-window-move-very-top
                    evil-window-move-very-bottom))
      (advice-add func
                  :around #'config/fix-evil-window-move)))
  )
      (if (fboundp 'treemacs-get-local-window)
          (let* ((treemacs-window (treemacs-get-local-window))
                 (is-active (and treemacs-window (window-live-p treemacs-window))))
            (when is-active (treemacs))
            (apply orig-fun args)
            (when is-active
              (save-selected-window
                (treemacs))))
        (apply orig-fun args)))
  (define-key evil-motion-state-map (kbd "C-w C-w") 'evil-window-mru)
  (define-key evil-normal-state-map "ZZ" 'save-buffer)
  (define-key evil-motion-state-map (kbd "C-w C-o") 'fwoar-delete-mru-window)

File deletion: slime.el

BF:BFD[5.4163] → [5.15842:15874]

BF:BFD[5.15874] → [5.12998:12998]

B:BD[5.12998] → [5.12999:15841]

;;;; SLIME SETUP {{{
;; (load (expand-file-name "~/quicklisp/slime-helper.el"))
(add-to-list 'load-path "~/git_repos/3dp/slime/")
(require 'slime)
(use-package slime-company
  :ensure t)
(global-set-key (kbd "C-c x") 'slime-export-symbol-at-point)
(when (and (boundp 'common-lisp-hyperspec-root)
           (string-prefix-p "/" common-lisp-hyperspec-root))
  (setq common-lisp-hyperspec-root
        (concat "file://" common-lisp-hyperspec-root)))
;; Replace "sbcl" with the path to your implementation
(setq inferior-lisp-program "~/sbcl/bin/sbcl")
(add-hook 'lisp-mode-hook
          '(lambda ()
             ;;(define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
             ;; (unless (string= "*slime-scratch*" (buffer-name))
             ;;   (paredit-mode)
             ;;   (evil-paredit-mode))
             (rainbow-delimiters-mode))) 
(setq slime-contribs
      '(slime-fancy
        slime-company
        slime-macrostep
        slime-trace-dialog
        slime-mdot-fu))
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry 91 "(" lisp-mode-syntax-table)
(modify-syntax-entry 93 ")" lisp-mode-syntax-table)
;;(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(setq shr-inhibit-images t
      shr-use-fonts nil)
(defun fwoar--clhs-lookup (&rest args)
  (let ((browse-url-browser-function 'eww-browse-url))
    (hyperspec-lookup (word-at-point))))
(pushnew (list ?h "Check hyperspec" #'fwoar--clhs-lookup)
         slime-selector-methods
         :key #'car)
(defun fwoar--slime-find-system ()
  (let ((systems (directory-files
                  (locate-dominating-file default-directory
                                          (lambda (n)
                                            (directory-files n nil "^[^.#][^#]*[.]asd$")))
                  t "^[^.#][^#]*[.]asd$")))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
(pushnew (list ?S "Goto System" #'fwoar--slime-find-system)
         slime-selector-methods
         :key #'car)
 ;;;;; }}}

File deletion: evil.el

BF:BFD[5.4163] → [5.19003:19034]

BF:BFD[5.19034] → [5.15876:15876]

B:BD[5.15876] → [5.15877:19002]

(use-package evil
  :ensure t
  :config
  (advice-add 'evil-delete-marks :after
              (lambda (&rest args)
                (evil-visual-mark-render)))
  (evil-define-key 'normal lisp-mode-map " o" 'slime-selector)
  (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common)
  (evil-mode)
  (use-package evil-smartparens
    :ensure t
    :after smartparens
    :config
    (evil-smartparens-mode 1)
    (progn ;; wrapping
      (define-key evil-normal-state-map ",W" 'sp-wrap-round)
      (define-key evil-normal-state-map ",w(" 'sp-wrap-round)
      (define-key evil-normal-state-map ",w)" 'sp-wrap-round)
      (define-key evil-normal-state-map ",w{" 'sp-wrap-curly)
      (define-key evil-normal-state-map ",w}" 'sp-wrap-curly)
      (define-key evil-normal-state-map ",w[" 'sp-wrap-square)
      (define-key evil-normal-state-map ",w]" 'sp-wrap-square))
    (progn ;; splicing
      (define-key evil-normal-state-map ",S" 'sp-splice-sexp)
      (define-key evil-normal-state-map ",A" 'sp-splice-sexp-killing-backward)
      (define-key evil-normal-state-map ",D" 'sp-splice-sexp-killing-forward)
      (define-key evil-normal-state-map ",F" 'sp-splice-sexp-killing-around))
    (progn ;; barf/slurp
      (define-key evil-normal-state-map ",," 'sp-backward-barf-sexp)
      (define-key evil-normal-state-map ",." 'sp-forward-barf-sexp)
      (define-key evil-normal-state-map ",<" 'sp-backward-slurp-sexp)
      (define-key evil-normal-state-map ",>" 'sp-forward-slurp-sexp))
    (progn ;; misc
      (define-key evil-normal-state-map ",~" 'sp-convolute-sexp)
      (define-key evil-normal-state-map ",a" 'sp-absorb-sexp)
      (define-key evil-normal-state-map ",e" 'sp-emit-sexp)
      (define-key evil-normal-state-map ",`" 'sp-clone-sexp)
      (define-key evil-normal-state-map ",J" 'sp-join-sexp)
      (define-key evil-normal-state-map ",|" 'sp-split-sexp))
    (progn ;; narrowing
      (define-key evil-normal-state-map " n(" 'sp-narrow-to-sexp)
      (define-key evil-normal-state-map " n)" 'sp-narrow-to-sexp)
      (define-key evil-normal-state-map " nn" 'narrow-to-defun)
      (define-key evil-normal-state-map " nr" 'narrow-to-region)
      (define-key evil-normal-state-map " nw" 'widen)))
  (progn ;; navigation
    (define-key evil-normal-state-map " f" 'helm-projectile)
    (define-key evil-normal-state-map " j" 'helm-buffers-list)
    (define-key evil-normal-state-map " u" 'undo-tree-visualize))
  (progn ;; completion
    (define-key evil-normal-state-map (kbd "TAB") 'company-indent-or-complete-common)
    (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common))
  ;; (use-package  evil-paredit
  ;;   :ensure t
  ;;   :after paredit
  ;;   :config
  ;;   (evil-paredit-mode))
  ;;(use-package evil-numbers
  ;;  :ensure t
  ;;  :config
  ;;  (global-set-key (kbd "C-c +") 'evil-numbers/inc-at-pt)
  ;;  (global-set-key (kbd "C-c -") 'evil-numbers/dec-at-pt))
  (use-package evil-surround
    :ensure t
    :config
    (global-evil-surround-mode))
  (use-package evil-leader
    :config (evil-leader/set-leader "ß")))

File addition: slime-conf.el (----------)

[5.4163]

;;;; SLIME SETUP {{{
;; (load (expand-file-name "~/quicklisp/slime-helper.el"))
(add-to-list 'load-path (fwoar-git-repo "3dp/slime/"
                                        "git@github.com:slime/slime.git"
                                        "https://github.com/slime/slime.git"))
(require 'slime)
(use-package slime-company
  :ensure t)
;; put slime-company in load-path
;; (require 'slime-company)
(defmacro define-lisp-implementations (&rest decl)
  `(progn
     ,@(cl-loop for (symbol . args) in decl
                collect `(progn
                           (defun ,symbol ()
                             (interactive)
                             (slime ',symbol))
                           (cl-pushnew '(,symbol ,@args) slime-lisp-implementations
                                       :key 'car)))))
(with-eval-after-load "slime"
  (when (or (eq system-type 'gnu/linux)
            (eq system-type 'darwin))
    (define-lisp-implementations
      (abcl  ("abcl"))
      (ccl ("ccl"))
      (clisp ("clisp"))
      (cmucl ("cmucl" "-quiet"))
      (ecl   ("ecl"))
      ;;(mkcl  ("mkcl"))
      ;;(xcl   ("xcl"))
      (sbcl  ("sbcl" "--dynamic-space-size" "8192")))))
(global-set-key (kbd "C-c x") 'slime-export-symbol-at-point)
(when (and (boundp 'common-lisp-hyperspec-root)
           (string-prefix-p "/" common-lisp-hyperspec-root))
  (setq common-lisp-hyperspec-root
        (concat "file://" common-lisp-hyperspec-root)))
;; Replace "sbcl" with the path to your implementation
(setq inferior-lisp-program "~/sbcl/bin/sbcl") 
(defun setup-lisp-mode ()
  (unless (string= "*slime-scratch*" (buffer-name))
    (smartparens-strict-mode 1)
    (evil-smartparens-mode 1)
    (aggressive-indent-mode 1))
  (define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
  (rainbow-delimiters-mode))
(add-hook 'lisp-mode-hook 'setup-lisp-mode) 
(add-hook 'emacs-lisp-mode-hook 'setup-lisp-mode) 
(evil-define-key 'normal lisp-mode-map "gd" 'slime-edit-definition)
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry 91 "(" lisp-mode-syntax-table)
(modify-syntax-entry 93 ")" lisp-mode-syntax-table)
;;(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?\[ "(]" lisp-mode-syntax-table)
(modify-syntax-entry ?\] ")[" lisp-mode-syntax-table)
(modify-syntax-entry ?\{ "(}" lisp-mode-syntax-table)
(modify-syntax-entry ?\} "){" lisp-mode-syntax-table)
(setq shr-inhibit-images t
      shr-use-fonts nil)
(defun fwoar--clhs-lookup (&rest args)
  (let ((browse-url-browser-function 'eww-browse-url))
    (hyperspec-lookup (word-at-point))))
(pushnew (list ?h "Check hyperspec" #'fwoar--clhs-lookup)
         slime-selector-methods
         :key #'car)
(defun fwoar--get-asds ()
  (let ((dir-of-asd (locate-dominating-file default-directory
                                            (lambda (n)
                                              (directory-files n nil "^[^.#][^#]*[.]asd$")))))
    (when dir-of-asd
      (directory-files dir-of-asd
                       t "^[^.#][^#]*[.]asd$"))))
(cl-defgeneric fwoar--find-system ())
(cl-defmethod fwoar--find-system (&context (major-mode lisp-mode))
  (let ((systems (fwoar--get-asds)))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
(pushnew (list ?S "Goto System" #'fwoar--find-system)
         slime-selector-methods
         :key #'car)
(defun slime-ecl ()
  (interactive)
  (let ((inferior-lisp-program "ecl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-cmucl ()
  (interactive)
  (let ((inferior-lisp-program "cmucl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-sbcl ()
  (interactive)
  (let ((inferior-lisp-program "sbcl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-ccl ()
  (interactive)
  (let ((inferior-lisp-program "ccl")
        (slime-lisp-implementations nil))
    (slime)))
(defun find-use-clause (current-form)
  (when current-form
    (destructuring-bind (discriminator . packages) current-form
      (case discriminator
        (:use (remove-if (op (or (eql :cl _)))
                         (cdr current-form)))
        (defpackage (find-use-clause
                     (find-if (lambda (f)
                                (and (listp f)
                                     (eql (car f) :use)))
                              '(defpackage :tracking-sim (:use :cl :alexandria :serapeum) (:export)))))))))
(defun load-package-uses ()
  (interactive)
  (slime-eval-async `(ql:quickload ',(find-use-clause (list-at-point)))))
;;(message (format "s-c-c is: %s" slime-company-completion))
;;;;; }}}
(defun sp-absorb-forward-sexp (&optional arg)
  "Absorb previous expression.
Save the expressions preceding point and delete them.  Then slurp
an expression backward and insert the saved expressions.
With ARG positive N, absorb that many expressions.
Examples:
  (do-stuff 1)         (save-excursion
  (save-excursion  ->   |(do-stuff 1)
   |(do-stuff 2))        (do-stuff 2))
  foo bar (concat |baz quux) -> (concat |foo bar baz quux) ;; 2"
  (interactive "p")
  (sp-forward-whitespace)
  (let* ((old (point))
         (raise (progn
                  (sp-end-of-sexp)
                  (buffer-substring (point) old))))
    (delete-region old (point))
    (sp-forward-slurp-sexp arg)
    (sp-backward-whitespace)
    (sp-end-of-sexp)
    (insert raise)
    (save-excursion
      (sp-backward-up-sexp)
      (indent-sexp)))
  (sp-backward-whitespace))
(setq slime-contribs '(slime-fancy
                       slime-company
                       slime-macrostep
                       slime-trace-dialog
                       slime-mdot-fu
                       slime-buffer-streams
                       slime-indentation)
      slime-export-save-file t)
(slime-setup slime-contribs)
(defslime-repl-shortcut fwoar--slime-repl-load-asd ("load-asd")
  (:handler (lambda ()
              (interactive)
              (let ((system-files (fwoar--get-asds)))
                (slime-eval-async (cons 'cl:progn
                                        (mapcar (lambda (it)
                                                  `(cl:progn (asdf:load-asd ,it) ,it))
                                                system-files))
                  (lambda (r)
                    (message "Loading ASDs done: %s" r))))))
  (:one-liner "Load asd for current project"))
(comment (defslime-repl-shortcut fwoar--slime-repl-quickload ("quickload")
           (:handler (lambda ()
                       (interactive)
                       (let ((system-files (fwoar--get-asds)))
                         (slime-eval-async (cons 'cl:progn
                                                 (mapcar (lambda (it)
                                                           `(cl:progn (asdf:load-asd ,it) ,it))
                                                         system-files))
                           (lambda (r)
                             (message "Loading ASDs done: %s" r))))))
           (:one-liner "Load asd for current project")))

File addition: evil-conf.el (----------)

[5.4163]

(defun wrap-with-doublequote (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "\""))
(defun wrap-in-dollar-brace
    (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "${"))
(defun fwoar-delete-mru-window ()
  (interactive)
  (delete-window
   (get-mru-window nil nil t)))
(use-package evil
  :ensure t
  :config
  (define-key evil-motion-state-map (kbd "C-w C-o") 'fwoar-delete-mru-window)
  (define-key evil-motion-state-map (kbd "C-w C-w") 'evil-window-mru)
  (define-key evil-normal-state-map "ZZ" 'save-buffer)
  (advice-add 'evil-delete-marks :after
              (lambda (&rest args)
                (evil-visual-mark-render)))
  (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common)
  (evil-mode)
  (progn ;; navigation
    (define-key evil-normal-state-map " f" 'helm-projectile)
    (define-key evil-normal-state-map " j" 'helm-buffers-list)
    (define-key evil-normal-state-map " u" 'undo-tree-visualize))
  (progn ;; completion
    (define-key evil-normal-state-map (kbd "TAB") 'company-indent-or-complete-common)
    (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common))
  (progn ;; workaround until this fixed: https://github.com/emacs-evil/evil/issues/1129
    ;;                          or this: https://github.com/emacs-evil/evil/pull/1130
    (defun config/fix-evil-window-move (orig-fun &rest args)
      "Close Treemacs while moving windows around."
      (if (fboundp 'treemacs-get-local-window)
          (let* ((treemacs-window (treemacs-get-local-window))
                 (is-active (and treemacs-window (window-live-p treemacs-window))))
            (when is-active (treemacs))
            (apply orig-fun args)
            (when is-active
              (save-selected-window
                (treemacs))))
        (apply orig-fun args)))
    (dolist (func '(evil-window-move-far-left
                    evil-window-move-far-right
                    evil-window-move-very-top
                    evil-window-move-very-bottom))
      (advice-add func
                  :around #'config/fix-evil-window-move)))
  )
(use-package evil-surround
  :ensure t
  :after evil
  :config
  (global-evil-surround-mode))
(use-package evil-leader
  :ensure t
  :after evil
  :config (evil-leader/set-leader "ß"))
(use-package evil-smartparens
  :ensure t
  :after evil smartparens
  :config
  (evil-smartparens-mode 1)
  (progn ;; wrapping
    (define-key evil-normal-state-map ",W" 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, W") 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, C-W") 'sp-wrap-round)
    (define-key evil-normal-state-map ",w(" 'sp-wrap-round)
    (define-key evil-normal-state-map ",w)" 'sp-wrap-round)
    (define-key global-map (kbd "C-, (") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-(") 'sp-wrap-round)
    (define-key global-map (kbd "C-, )") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-)") 'sp-wrap-round)
    (define-key evil-normal-state-map ",w$" 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map (kbd "C-, $") 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map ",w{" 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w}" 'sp-wrap-curly)
    (define-key global-map (kbd "C-, {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-{") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, }") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-}") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w }") 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w[" 'sp-wrap-square)
    (define-key evil-normal-state-map ",w]" 'sp-wrap-square)
    (define-key global-map (kbd "C-, w [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, <escape>") 'sp-wrap-square)
    (define-key global-map (kbd "C-, [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, w ]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, C-]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, ]") 'sp-wrap-square)
    (define-key evil-normal-state-map ",w\"" 'wrap-with-doublequote)
    (define-key cider-mode-map (kbd "C-, w \"") 'sp-wrap-doublequote))
  (progn ;; splicing
    (define-key evil-normal-state-map ",S" 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, S") 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, C-S") 'sp-splice-sexp)
    (define-key evil-normal-state-map ",A" 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, A") 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, C-A") 'sp-splice-sexp-killing-backward)
    (define-key evil-normal-state-map ",D" 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, D") 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, C-D") 'sp-splice-sexp-killing-forward)
    (define-key evil-normal-state-map ",F" 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, F") 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, C-F") 'sp-splice-sexp-killing-around))
  (progn ;; barf/slurp
    (define-key evil-normal-state-map ",," 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, ,") 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-,") 'sp-backward-barf-sexp)
    (define-key evil-normal-state-map ",." 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, .") 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-.") 'sp-forward-barf-sexp)
    (define-key evil-normal-state-map ",<" 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, <") 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C-<") 'sp-backward-slurp-sexp)
    (define-key evil-normal-state-map ",>" 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, >") 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C->") 'sp-forward-slurp-sexp))
  (progn ;; misc
    (define-key evil-normal-state-map ",~" 'sp-convolute-sexp)
    (define-key evil-normal-state-map ",a" 'sp-absorb-sexp)
    (define-key evil-normal-state-map ",e" 'sp-emit-sexp)
    (define-key evil-normal-state-map ",`" 'sp-clone-sexp)
    (define-key evil-normal-state-map ",J" 'sp-join-sexp)
    (define-key evil-normal-state-map ",|" 'sp-split-sexp))
  (progn ;; narrowing
    (define-key evil-normal-state-map " n(" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " n)" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " nn" 'narrow-to-defun)
    (define-key evil-normal-state-map " nr" 'narrow-to-region)
    (define-key evil-normal-state-map " nw" 'widen)))
(use-package centaur-tabs
  :ensure t
  :after evil
  :config
  (setq centaur-tabs-adjust-buffer-order t
        centaur-tabs-adjust-buffer-order 'left)
  (centaur-tabs-enable-buffer-reordering)
  (define-key evil-normal-state-map "gt" 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "<header-line> <wheel-up>") 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "s-}") 'centaur-tabs-forward-tab)
  (define-key evil-normal-state-map "gT" 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "<header-line> <wheel-down>") 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "s-{") 'centaur-tabs-backward-tab))

File addition: slime-conf.el (----------)

[5.4163]

;;;; SLIME SETUP {{{
;; (load (expand-file-name "~/quicklisp/slime-helper.el"))
(add-to-list 'load-path (fwoar-git-repo "3dp/slime/"
                                        "git@github.com:slime/slime.git"
                                        "https://github.com/slime/slime.git"))
(require 'slime)
(use-package slime-company
  :ensure t)
;; put slime-company in load-path
;; (require 'slime-company)
(defmacro define-lisp-implementations (&rest decl)
  `(progn
     ,@(cl-loop for (symbol . args) in decl
                collect `(progn
                           (defun ,symbol ()
                             (interactive)
                             (slime ',symbol))
                           (cl-pushnew '(,symbol ,@args) slime-lisp-implementations
                                       :key 'car)))))
(with-eval-after-load "slime"
  (when (or (eq system-type 'gnu/linux)
            (eq system-type 'darwin))
    (define-lisp-implementations
      (abcl  ("abcl"))
      (ccl ("ccl"))
      (clisp ("clisp"))
      (cmucl ("cmucl" "-quiet"))
      (ecl   ("ecl"))
      ;;(mkcl  ("mkcl"))
      ;;(xcl   ("xcl"))
      (sbcl  ("sbcl" "--dynamic-space-size" "8192")))))
(global-set-key (kbd "C-c x") 'slime-export-symbol-at-point)
(when (and (boundp 'common-lisp-hyperspec-root)
           (string-prefix-p "/" common-lisp-hyperspec-root))
  (setq common-lisp-hyperspec-root
        (concat "file://" common-lisp-hyperspec-root)))
;; Replace "sbcl" with the path to your implementation
(setq inferior-lisp-program "~/sbcl/bin/sbcl") 
(defun setup-lisp-mode ()
  (unless (string= "*slime-scratch*" (buffer-name))
    (smartparens-strict-mode 1)
    (evil-smartparens-mode 1)
    (aggressive-indent-mode 1))
  (define-key evil-insert-state-map "^N" 'slime-fuzzy-indent-and-complete-symbol)
  (rainbow-delimiters-mode))
(add-hook 'lisp-mode-hook 'setup-lisp-mode) 
(add-hook 'emacs-lisp-mode-hook 'setup-lisp-mode) 
(evil-define-key 'normal lisp-mode-map "gd" 'slime-edit-definition)
(modify-syntax-entry ?- "w" lisp-mode-syntax-table)
(modify-syntax-entry ?* "w" lisp-mode-syntax-table)
(modify-syntax-entry ?+ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?! "w" lisp-mode-syntax-table)
(modify-syntax-entry ?$ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?& "w" lisp-mode-syntax-table)
(modify-syntax-entry ?% "w" lisp-mode-syntax-table)
(modify-syntax-entry ?= "w" lisp-mode-syntax-table)
(modify-syntax-entry ?< "w" lisp-mode-syntax-table)
(modify-syntax-entry ?> "w" lisp-mode-syntax-table)
(modify-syntax-entry 91 "(" lisp-mode-syntax-table)
(modify-syntax-entry 93 ")" lisp-mode-syntax-table)
;;(modify-syntax-entry ?@ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?^ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?_ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?~ "w" lisp-mode-syntax-table)
(modify-syntax-entry ?. "w" lisp-mode-syntax-table)
(modify-syntax-entry ?\[ "(]" lisp-mode-syntax-table)
(modify-syntax-entry ?\] ")[" lisp-mode-syntax-table)
(modify-syntax-entry ?\{ "(}" lisp-mode-syntax-table)
(modify-syntax-entry ?\} "){" lisp-mode-syntax-table)
(setq shr-inhibit-images t
      shr-use-fonts nil)
(defun fwoar--clhs-lookup (&rest args)
  (let ((browse-url-browser-function 'eww-browse-url))
    (hyperspec-lookup (word-at-point))))
(pushnew (list ?h "Check hyperspec" #'fwoar--clhs-lookup)
         slime-selector-methods
         :key #'car)
(defun fwoar--get-asds ()
  (let ((dir-of-asd (locate-dominating-file default-directory
                                            (lambda (n)
                                              (directory-files n nil "^[^.#][^#]*[.]asd$")))))
    (when dir-of-asd
      (directory-files dir-of-asd
                       t "^[^.#][^#]*[.]asd$"))))
(cl-defgeneric fwoar--find-system ())
(cl-defmethod fwoar--find-system (&context (major-mode lisp-mode))
  (let ((systems (fwoar--get-asds)))
    (find-file (if (not (null (cdr systems)))
                   (helm-comp-read "system:" systems)
                 (car systems)))))
(pushnew (list ?S "Goto System" #'fwoar--find-system)
         slime-selector-methods
         :key #'car)
(defun slime-ecl ()
  (interactive)
  (let ((inferior-lisp-program "ecl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-cmucl ()
  (interactive)
  (let ((inferior-lisp-program "cmucl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-sbcl ()
  (interactive)
  (let ((inferior-lisp-program "sbcl")
        (slime-lisp-implementations nil))
    (slime)))
(defun slime-ccl ()
  (interactive)
  (let ((inferior-lisp-program "ccl")
        (slime-lisp-implementations nil))
    (slime)))
(defun find-use-clause (current-form)
  (when current-form
    (destructuring-bind (discriminator . packages) current-form
      (case discriminator
        (:use (remove-if (op (or (eql :cl _)))
                         (cdr current-form)))
        (defpackage (find-use-clause
                     (find-if (lambda (f)
                                (and (listp f)
                                     (eql (car f) :use)))
                              '(defpackage :tracking-sim (:use :cl :alexandria :serapeum) (:export)))))))))
(defun load-package-uses ()
  (interactive)
  (slime-eval-async `(ql:quickload ',(find-use-clause (list-at-point)))))
;;(message (format "s-c-c is: %s" slime-company-completion))
;;;;; }}}
(defun sp-absorb-forward-sexp (&optional arg)
  "Absorb previous expression.
Save the expressions preceding point and delete them.  Then slurp
an expression backward and insert the saved expressions.
With ARG positive N, absorb that many expressions.
Examples:
  (do-stuff 1)         (save-excursion
  (save-excursion  ->   |(do-stuff 1)
   |(do-stuff 2))        (do-stuff 2))
  foo bar (concat |baz quux) -> (concat |foo bar baz quux) ;; 2"
  (interactive "p")
  (sp-forward-whitespace)
  (let* ((old (point))
         (raise (progn
                  (sp-end-of-sexp)
                  (buffer-substring (point) old))))
    (delete-region old (point))
    (sp-forward-slurp-sexp arg)
    (sp-backward-whitespace)
    (sp-end-of-sexp)
    (insert raise)
    (save-excursion
      (sp-backward-up-sexp)
      (indent-sexp)))
  (sp-backward-whitespace))
(setq slime-contribs '(slime-fancy
                       slime-company
                       slime-macrostep
                       slime-trace-dialog
                       slime-mdot-fu
                       slime-buffer-streams
                       slime-indentation)
      slime-export-save-file t)
(slime-setup slime-contribs)
(defslime-repl-shortcut fwoar--slime-repl-load-asd ("load-asd")
  (:handler (lambda ()
              (interactive)
              (let ((system-files (fwoar--get-asds)))
                (slime-eval-async (cons 'cl:progn
                                        (mapcar (lambda (it)
                                                  `(cl:progn (asdf:load-asd ,it) ,it))
                                                system-files))
                  (lambda (r)
                    (message "Loading ASDs done: %s" r))))))
  (:one-liner "Load asd for current project"))
(comment (defslime-repl-shortcut fwoar--slime-repl-quickload ("quickload")
           (:handler (lambda ()
                       (interactive)
                       (let ((system-files (fwoar--get-asds)))
                         (slime-eval-async (cons 'cl:progn
                                                 (mapcar (lambda (it)
                                                           `(cl:progn (asdf:load-asd ,it) ,it))
                                                         system-files))
                           (lambda (r)
                             (message "Loading ASDs done: %s" r))))))
           (:one-liner "Load asd for current project")))

File addition: evil-conf.el (----------)

[5.4163]

(defun wrap-with-doublequote (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "\""))
(defun wrap-in-dollar-brace
    (&optional arg)
  (interactive "P")
  (sp-wrap-with-pair "${"))
(defun fwoar-delete-mru-window ()
  (interactive)
  (delete-window
   (get-mru-window nil nil t)))
(use-package evil
  :ensure t
  :config
  (define-key evil-motion-state-map (kbd "C-w C-o") 'fwoar-delete-mru-window)
  (define-key evil-motion-state-map (kbd "C-w C-w") 'evil-window-mru)
  (define-key evil-normal-state-map "ZZ" 'save-buffer)
  (advice-add 'evil-delete-marks :after
              (lambda (&rest args)
                (evil-visual-mark-render)))
  (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common)
  (evil-mode)
  (progn ;; navigation
    (define-key evil-normal-state-map " f" 'helm-projectile)
    (define-key evil-normal-state-map " j" 'helm-buffers-list)
    (define-key evil-normal-state-map " u" 'undo-tree-visualize))
  (progn ;; completion
    (define-key evil-normal-state-map (kbd "TAB") 'company-indent-or-complete-common)
    (define-key evil-insert-state-map (kbd "TAB") 'company-indent-or-complete-common))
  (progn ;; workaround until this fixed: https://github.com/emacs-evil/evil/issues/1129
    ;;                          or this: https://github.com/emacs-evil/evil/pull/1130
    (defun config/fix-evil-window-move (orig-fun &rest args)
      "Close Treemacs while moving windows around."
      (if (fboundp 'treemacs-get-local-window)
          (let* ((treemacs-window (treemacs-get-local-window))
                 (is-active (and treemacs-window (window-live-p treemacs-window))))
            (when is-active (treemacs))
            (apply orig-fun args)
            (when is-active
              (save-selected-window
                (treemacs))))
        (apply orig-fun args)))
    (dolist (func '(evil-window-move-far-left
                    evil-window-move-far-right
                    evil-window-move-very-top
                    evil-window-move-very-bottom))
      (advice-add func
                  :around #'config/fix-evil-window-move)))
  )
(use-package evil-surround
  :ensure t
  :after evil
  :config
  (global-evil-surround-mode))
(use-package evil-leader
  :ensure t
  :after evil
  :config (evil-leader/set-leader "ß"))
(use-package evil-smartparens
  :ensure t
  :after evil smartparens
  :config
  (evil-smartparens-mode 1)
  (progn ;; wrapping
    (define-key evil-normal-state-map ",W" 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, W") 'sp-wrap-round)
    (define-key evil-normal-state-map (kbd "C-, C-W") 'sp-wrap-round)
    (define-key evil-normal-state-map ",w(" 'sp-wrap-round)
    (define-key evil-normal-state-map ",w)" 'sp-wrap-round)
    (define-key global-map (kbd "C-, (") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-(") 'sp-wrap-round)
    (define-key global-map (kbd "C-, )") 'sp-wrap-round)
    (define-key global-map (kbd "C-, C-)") 'sp-wrap-round)
    (define-key evil-normal-state-map ",w$" 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map (kbd "C-, $") 'wrap-in-dollar-brace)
    (define-key evil-normal-state-map ",w{" 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w}" 'sp-wrap-curly)
    (define-key global-map (kbd "C-, {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-{") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, }") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, C-}") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w {") 'sp-wrap-curly)
    (define-key global-map (kbd "C-, w }") 'sp-wrap-curly)
    (define-key evil-normal-state-map ",w[" 'sp-wrap-square)
    (define-key evil-normal-state-map ",w]" 'sp-wrap-square)
    (define-key global-map (kbd "C-, w [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, <escape>") 'sp-wrap-square)
    (define-key global-map (kbd "C-, [") 'sp-wrap-square)
    (define-key global-map (kbd "C-, w ]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, C-]") 'sp-wrap-square)
    (define-key global-map (kbd "C-, ]") 'sp-wrap-square)
    (define-key evil-normal-state-map ",w\"" 'wrap-with-doublequote)
    (define-key cider-mode-map (kbd "C-, w \"") 'sp-wrap-doublequote))
  (progn ;; splicing
    (define-key evil-normal-state-map ",S" 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, S") 'sp-splice-sexp)
    (define-key cider-mode-map (kbd "C-, C-S") 'sp-splice-sexp)
    (define-key evil-normal-state-map ",A" 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, A") 'sp-splice-sexp-killing-backward)
    (define-key cider-mode-map (kbd "C-, C-A") 'sp-splice-sexp-killing-backward)
    (define-key evil-normal-state-map ",D" 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, D") 'sp-splice-sexp-killing-forward)
    (define-key cider-mode-map (kbd "C-, C-D") 'sp-splice-sexp-killing-forward)
    (define-key evil-normal-state-map ",F" 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, F") 'sp-splice-sexp-killing-around)
    (define-key cider-mode-map (kbd "C-, C-F") 'sp-splice-sexp-killing-around))
  (progn ;; barf/slurp
    (define-key evil-normal-state-map ",," 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, ,") 'sp-backward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-,") 'sp-backward-barf-sexp)
    (define-key evil-normal-state-map ",." 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, .") 'sp-forward-barf-sexp)
    (define-key cider-mode-map (kbd "C-, C-.") 'sp-forward-barf-sexp)
    (define-key evil-normal-state-map ",<" 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, <") 'sp-backward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C-<") 'sp-backward-slurp-sexp)
    (define-key evil-normal-state-map ",>" 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, >") 'sp-forward-slurp-sexp)
    (define-key cider-mode-map (kbd "C-, C->") 'sp-forward-slurp-sexp))
  (progn ;; misc
    (define-key evil-normal-state-map ",~" 'sp-convolute-sexp)
    (define-key evil-normal-state-map ",a" 'sp-absorb-sexp)
    (define-key evil-normal-state-map ",e" 'sp-emit-sexp)
    (define-key evil-normal-state-map ",`" 'sp-clone-sexp)
    (define-key evil-normal-state-map ",J" 'sp-join-sexp)
    (define-key evil-normal-state-map ",|" 'sp-split-sexp))
  (progn ;; narrowing
    (define-key evil-normal-state-map " n(" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " n)" 'sp-narrow-to-sexp)
    (define-key evil-normal-state-map " nn" 'narrow-to-defun)
    (define-key evil-normal-state-map " nr" 'narrow-to-region)
    (define-key evil-normal-state-map " nw" 'widen)))
(use-package centaur-tabs
  :ensure t
  :after evil
  :config
  (setq centaur-tabs-adjust-buffer-order t
        centaur-tabs-adjust-buffer-order 'left)
  (centaur-tabs-enable-buffer-reordering)
  (define-key evil-normal-state-map "gt" 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "<header-line> <wheel-up>") 'centaur-tabs-forward-tab)
  (define-key global-map (kbd "s-}") 'centaur-tabs-forward-tab)
  (define-key evil-normal-state-map "gT" 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "<header-line> <wheel-down>") 'centaur-tabs-backward-tab)
  (define-key global-map (kbd "s-{") 'centaur-tabs-backward-tab))

emacs: rename configurations to config-conf.el

Dependencies

In channels

Change contents

File deletion: dependencies, dependencies

File deletion: slime.el

File deletion: evil.el

File deletion: slime.el

File deletion: evil.el

File addition: slime-conf.el (----------)

File addition: evil-conf.el (----------)

File addition: slime-conf.el (----------)

File addition: evil-conf.el (----------)