Make loading faster by eliminating require blocks

early-init.el

@@ -17,4 +17,13 @@
 ;; Log garbage collection.
 (setq garbage-collection-messages nil)
 
+;; Monitor startup time
+(add-hook 'emacs-startup-hook
+          (lambda ()
+            (message "Emacs ready in %s with %d garbage collections."
+                     (format "%.2f seconds"
+                             (float-time
+                              (time-subtract after-init-time before-init-time)))
+                     gcs-done)))
+
 ;;; early-init.el ends here

lisp/icejam-avy.el

@@ -9,8 +9,6 @@
 ;; Avy is a navigation manager.
 
 ;;; Code:
-(require 'icejam-keys-mode)
-
 (use-package avy :ensure t :defer t
   :config
   (setopt avy-timeout-seconds 1.0) ;; Wait for 1 second for candidates

lisp/icejam-base.el

@@ -9,11 +9,8 @@
 ;; pkg/base defines basic packages and environment.
 
 ;;; Code:
-(require 'icejam-keys-mode)
 
-;;;;;;;; Other optimizations ;;;;;;;;;;;;;;;;;
 ;;;;;;;; Stolen from Doom Emacs. ;;;;;;;;;;;;;
-
 ;; Update emacs less often
 (setopt idle-update-delay 1.0)
 
@@ -34,8 +31,9 @@
 (setopt fast-but-imprecise-scrolling t)
 
 ;;;;;;;;; TRAMP configuration ;;;;;;;;;;;;;;;;
-(require 'tramp)
+(use-package tramp :ensure nil :defer 3
-(setopt tramp-default-method "ssh")
+  :config
+  (setopt tramp-default-method "ssh"))
 
 ;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
 (global-set-key (kbd "RET") 'newline)
@@ -123,6 +121,8 @@
         indicate-empty-lines nil)
 
 ;;;;;;;;;;;;;;;;; Treemacs
+(eval-when-compile (defvar icejam-keys-mode-map))
+
 (use-package treemacs :ensure t :defer t
   :hook ((elpaca-after-init . treemacs-follow-mode)
          (elpaca-after-init . treemacs-project-follow-mode))

lisp/icejam-complete-at-point.el

@@ -20,7 +20,7 @@
   (setopt corfu-cycle t
           corfu-count 20 ;; Show 20 completion candidates
 
-          corfu-max-width 120 ;; Max width of the corfu frame
+          corfu-max-width 100 ;; Max width of the corfu frame
           corfu-right-margin-width 0.5
           corfu-left-margin-width 0.5
           corfu-bar-width 0.5
@@ -31,8 +31,7 @@
           corfu-on-exact-match 'nil
           corfu-popupinfo-delay '(0.4 . 0.2)
           corfu-auto t
-          corfu-quit-no-match 'separator
+          corfu-quit-no-match 'separator))
-          ))
 
 ;; Allow corfu to work in terminal
 (use-package corfu-terminal :ensure t :defer t
@@ -45,6 +44,8 @@
   (declare-function cape-dabbrev 'cape)
   (declare-function cape-file 'cape)
   (declare-function cape-keyword 'cape)
+  (declare-function cape-elisp-symbol 'cape)
+  (declare-function cape-capf-super 'cape)
 
   ;; Set default completion values:
   (set-default 'completion-at-point-functions
@@ -57,6 +58,7 @@
 
 (defun icejam-set-lsp-capfs ()
   "Set `completion-at-point-function` to list where LSP is supported."
+  (declare-function lsp-completion-at-point 'lsp-mode)
   (setq-local completion-at-point-functions
               (list (cape-capf-super #'lsp-completion-at-point
                                      #'yasnippet-capf)
@@ -72,10 +74,12 @@
                     #'cape-file
                     #'cape-elisp-symbol)))
 
-(use-package yasnippet-capf :ensure t :after corfu
+(use-package yasnippet-capf :ensure t :after corfu :defer 1
-  :config (setopt yasnippet-capf-lookup-by 'name))
+  :config
+  (declare-function yasnippet-capf 'yasnippet)
+  (setopt yasnippet-capf-lookup-by 'name))
 
-(use-package nerd-icons-corfu :ensure t
+(use-package nerd-icons-corfu :ensure t :defer 2
   :after corfu
   :config
   (declare-function nerd-icons-corfu-formatter 'nerd-icons-corfu)

lisp/icejam-completing-read.el

@@ -6,8 +6,7 @@
 ;;; helpful.
 ;;;
 ;;; Code:
-
+(eval-when-compile (defvar icejam-keys-mode-map))
-(require 'icejam-keys-mode)
 
 ;; Preparations for using Vertico/Orderless
 (setopt

lisp/icejam-custom-init.el

@@ -12,7 +12,12 @@
 
 ;; Set GC at 500 MB for startup
 (setopt gc-cons-threshold 500000000)
-(setopt gc-cons-percentage 0.6)
+(setopt gc-cons-percentage 5.0)
+
+(add-hook 'after-init-hook (lambda ()
+                             ;; Restore GC to normal, but still high
+                             (setopt gc-cons-threshold 204800000)
+                             (setopt gc-cons-percentage 0.2)))
 
 ;; Allow for deeper stacktraces / recursion
 ;; (setopt max-lisp-eval-depth 10000)
@@ -138,9 +143,5 @@
 ;; Diminish modeline litter
 (use-package icejam-diminish :ensure nil)
 
-;; Restore GC to normal, but still high
-(setopt gc-cons-threshold 204800000)
-(setopt gc-cons-percentage 0.2)
-
 (provide 'icejam-custom-init)
 ;;; icejam-custom-init.el ends here

lisp/icejam-deft.el

@@ -3,9 +3,6 @@
 ;;; Notational velocity, backed by OneDrive.
 ;;; Code:
 
-(require 'icejam-keys-mode)
-(require 'icejam-transient)
-
 (use-package deft :ensure t :defer t
   :config
   (setopt deft-directory (substitute-in-file-name "$DEFT_PATH")

lisp/icejam-ispell.el

@@ -3,7 +3,7 @@
 ;;; Highlight misspelled words
 ;;; Code:
 
-(use-package ispell :ensure nil :defer t
+(use-package ispell :ensure nil :defer 2
   :config
   (setopt ispell-program-name "aspell")
   (setopt ispell-extra-args '("--run-together" "--run-together-limit=5" "--run-together-min=2")))

lisp/icejam-keys-mode.el

@@ -19,43 +19,39 @@
 ;; Globally enable my minor mode
 (icejam-keys-mode)
 
-;;; Helpful key bindings
-(define-key icejam-keys-mode-map (kbd "C-c \\") 'split-window-right) ;; Split window to the right
-(define-key icejam-keys-mode-map (kbd "C-c /") 'split-window-below) ;; Split window to the bottom
-
-;; Move between windows key bindings
-(define-key icejam-keys-mode-map (kbd "C-c <left>") 'windmove-left)
-(define-key icejam-keys-mode-map (kbd "C-c <right>") 'windmove-right)
-(define-key icejam-keys-mode-map (kbd "C-c <up>") 'windmove-up)
-(define-key icejam-keys-mode-map (kbd "C-c <down>") 'windmove-down)
-
-;; The same, but without using arrow keys
-(define-key icejam-keys-mode-map (kbd "C-c [") 'windmove-left)
-(define-key icejam-keys-mode-map (kbd "C-c ]") 'windmove-right)
-(define-key icejam-keys-mode-map (kbd "C-c {") 'windmove-up)
-(define-key icejam-keys-mode-map (kbd "C-c }") 'windmove-down)
-
-;; Kill current buffer and window
-(define-key icejam-keys-mode-map (kbd "C-c q") 'kill-buffer-and-window)
-
-;; List buffers
-(define-key icejam-keys-mode-map (kbd "C-c b") 'ibuffer)
-
-;; Revert without asking
 (defun icejam-revert-buffer-no-confirm ()
   "Revert buffer without confirmation."
   (interactive) (revert-buffer t t))
 
-(define-key icejam-keys-mode-map (kbd "C-c r") 'icejam-revert-buffer-no-confirm)
+;; Splitting window
+(keymap-set icejam-keys-mode-map "C-c \\" #'split-window-right)
+(keymap-set icejam-keys-mode-map "C-c /" #'split-window-below)
 
-;;;;;;;;; Emacs bindings ;;;;;;;;;;;;;;;;;;;;;
+;; Move between windows
-(define-key icejam-keys-mode-map [home] 'beginning-of-line)
+(keymap-set icejam-keys-mode-map "C-c <left>" #'windmove-left)
-(define-key icejam-keys-mode-map [end] 'end-of-line)
+(keymap-set icejam-keys-mode-map "C-c <right>" #'windmove-right)
+(keymap-set icejam-keys-mode-map "C-c <up>" #'windmove-up)
+(keymap-set icejam-keys-mode-map "C-c <down>" #'windmove-down)
+
+;; History of buffers
+(keymap-set icejam-keys-mode-map "C-c s [" #'previous-buffer)
+(keymap-set icejam-keys-mode-map "C-c s ]" #'next-buffer)
+
+;; List of buffers buffer
+(keymap-set icejam-keys-mode-map "C-c b" #'ibuffer)
+
+;; Manipulate buffers (kill or revert)
+(keymap-set icejam-keys-mode-map "C-c q" #'kill-buffer-and-window)
+(keymap-set icejam-keys-mode-map "C-c r" #'icejam-revert-buffer-no-confirm)
+
+;; Make emacs behave like a normal editor from 21st century.
+(keymap-set icejam-keys-mode-map "<home>" 'beginning-of-line)
+(keymap-set icejam-keys-mode-map "<end>" 'end-of-line)
 
 ;;;;;;;;; Translate keys ;;;;;;;;;;;;;;;;;;;;;
-(define-key key-translation-map (kbd "<f6>") (kbd "C-c l")) ;; On F6, send C-c l
+(keymap-set key-translation-map "<f6>" "C-c l") ;; On F6, send C-c l
-(define-key key-translation-map (kbd "<f7>") (kbd "C-c c")) ;; On F7, send C-c c
+(keymap-set key-translation-map "<f7>" "C-c c") ;; On F7, send C-c c
-(define-key key-translation-map (kbd "<f8>") (kbd "C-c p")) ;; On F8, send C-c p
+(keymap-set key-translation-map "<f8>" "C-c p") ;; On F8, send C-c p
 
 (provide 'icejam-keys-mode)
 ;;; icejam-keys-mode.el ends here

lisp/icejam-magit.el

@@ -2,7 +2,7 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))
 
 (use-package magit
   :ensure t

lisp/icejam-prog-mode.el

@@ -80,10 +80,11 @@
     (column-enforce-n 98)))
 
 ;; PCRE to Emacs regex translations
-(use-package pcre2el :ensure t :defer t)
+(use-package pcre2el :ensure t :defer 3)
 
 ;; Visual regexp
-(use-package visual-regexp-steroids :ensure t :after (pcre2el)
+(use-package visual-regexp-steroids :ensure t
+  :after (pcre2el)
   :config
   ;; Use pcre2el for regexes - so that I can use brackets more naturally with
   ;; regexp.

lisp/icejam-sys-specific.el

@@ -7,7 +7,7 @@
 (defconst IS-BSD (eq system-type 'berkeley-unix))
 (defconst IS-GNU (eq system-type 'gnu/linux))
 
-(require 'icejam-keys-mode)
+(eval-when-compile (defvar icejam-keys-mode-map))
 
 (defun icejam-function-delete-window ()
   "Kill a window."
@@ -31,24 +31,24 @@
             (setq mac-command-modifier 'meta))))
 
       ;; Mac binding (fix)
-      (define-key icejam-keys-mode-map (kbd "H-<right>") #'end-of-line)
+      (keymap-set icejam-keys-mode-map "H-<right>" #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<left>") #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map "H-<left>" #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "H-<up>") #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map "H-<up>" #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "H-<down>") #'scroll-up)
+      (keymap-set icejam-keys-mode-map "H-<down>" #'scroll-up)
 
       ;; Use CMD bindings that you know from the operating system
-      (define-key icejam-keys-mode-map [(hyper a)] #'mark-whole-buffer) ;; Select all
+      (keymap-set icejam-keys-mode-map "H-a" #'mark-whole-buffer) ;; Select all
-      (define-key icejam-keys-mode-map [(hyper v)] #'yank) ;; Paste
+      (keymap-set icejam-keys-mode-map "H-v" #'yank) ;; Paste
-      (define-key icejam-keys-mode-map [(hyper x)] #'kill-region) ;; Cut
+      (keymap-set icejam-keys-mode-map "H-x" #'kill-region) ;; Cut
-      (define-key icejam-keys-mode-map [(hyper c)] #'kill-ring-save) ;; Copy
+      (keymap-set icejam-keys-mode-map "H-c" #'kill-ring-save) ;; Copy
-      (define-key icejam-keys-mode-map [(hyper s)] #'save-buffer) ;; Save
+      (keymap-set icejam-keys-mode-map "H-s" #'save-buffer) ;; Save
-      (define-key icejam-keys-mode-map [(hyper z)] #'undo) ;; Undo
+      (keymap-set icejam-keys-mode-map "H-z" #'undo) ;; Undo
-      (define-key icejam-keys-mode-map [(hyper Z)] #'undo-redo) ;; Redo
+      (keymap-set icejam-keys-mode-map "H-Z" #'undo-redo) ;; Redo
-      (define-key icejam-keys-mode-map [(hyper q)] #'kill-emacs) ;; Close emacs
+      (keymap-set icejam-keys-mode-map "H-q" #'kill-emacs) ;; Close emacs
-      (define-key icejam-keys-mode-map [(hyper w)] #'icejam-function-delete-window) ;; Close window
+      (keymap-set icejam-keys-mode-map "H-w" #'icejam-function-delete-window) ;; Close window
 
       ;; And then some extras
-      (define-key icejam-keys-mode-map [(hyper l)] #'goto-line) ;; Goto Line
+      (keymap-set icejam-keys-mode-map "H-l" #'goto-line) ;; Goto Line
       ;; Disable meta on right alt (useful for Polish characters)
       ;; (setq mac-right-option-modifier nil)
 
@@ -70,39 +70,39 @@
 (if IS-GNU
     (progn
       ;; Save and undo
-      (define-key icejam-keys-mode-map (kbd "s-s") #'save-buffer)
+      (keymap-set icejam-keys-mode-map (kbd "s-s") #'save-buffer)
-      (define-key icejam-keys-mode-map (kbd "s-z") #'undo)
+      (keymap-set icejam-keys-mode-map (kbd "s-z") #'undo)
-      (define-key icejam-keys-mode-map (kbd "s-Z") #'undo-redo)
+      (keymap-set icejam-keys-mode-map (kbd "s-Z") #'undo-redo)
-      (define-key icejam-keys-mode-map (kbd "s-a") #'mark-whole-buffer)
+      (keymap-set icejam-keys-mode-map (kbd "s-a") #'mark-whole-buffer)
 
       ;; Copy and paste bindings
-      (define-key icejam-keys-mode-map (kbd "s-x") #'kill-region)
+      (keymap-set icejam-keys-mode-map (kbd "s-x") #'kill-region)
-      (define-key icejam-keys-mode-map (kbd "s-v") #'yank)
+      (keymap-set icejam-keys-mode-map (kbd "s-v") #'yank)
-      (define-key icejam-keys-mode-map (kbd "s-c") #'kill-ring-save)
+      (keymap-set icejam-keys-mode-map (kbd "s-c") #'kill-ring-save)
 
       ;; Linux Ergo bindings (fix)
-      (define-key icejam-keys-mode-map (kbd "C-<right>") #'end-of-line)
+      (keymap-set icejam-keys-mode-map (kbd "C-<right>") #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<left>") #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map (kbd "C-<left>") #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "C-<up>") #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map (kbd "C-<up>") #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "C-<down>") #'scroll-up)))
+      (keymap-set icejam-keys-mode-map (kbd "C-<down>") #'scroll-up)))
 
 ;; BSD-specific config
 (if IS-BSD
     (progn
-      (define-key icejam-keys-mode-map (kbd "A-<right>") #'end-of-line)
+      (keymap-set icejam-keys-mode-map (kbd "A-<right>") #'end-of-line)
-      (define-key icejam-keys-mode-map (kbd "A-<left>") #'beginning-of-line)
+      (keymap-set icejam-keys-mode-map (kbd "A-<left>") #'beginning-of-line)
-      (define-key icejam-keys-mode-map (kbd "A-<up>") #'scroll-down) ; WTF is this reverse, I dunno
+      (keymap-set icejam-keys-mode-map (kbd "A-<up>") #'scroll-down) ; WTF is this reverse, I dunno
-      (define-key icejam-keys-mode-map (kbd "A-<down>") #'scroll-up)
+      (keymap-set icejam-keys-mode-map (kbd "A-<down>") #'scroll-up)
 
-      (define-key icejam-keys-mode-map (kbd "A-a") #'mark-whole-buffer)
+      (keymap-set icejam-keys-mode-map (kbd "A-a") #'mark-whole-buffer)
-      (define-key icejam-keys-mode-map (kbd "A-v") #'yank)
+      (keymap-set icejam-keys-mode-map (kbd "A-v") #'yank)
-      (define-key icejam-keys-mode-map (kbd "A-x") #'kill-region)
+      (keymap-set icejam-keys-mode-map (kbd "A-x") #'kill-region)
-      (define-key icejam-keys-mode-map (kbd "A-c") #'kill-ring-save)
+      (keymap-set icejam-keys-mode-map (kbd "A-c") #'kill-ring-save)
-      (define-key icejam-keys-mode-map (kbd "A-s") #'save-buffer)
+      (keymap-set icejam-keys-mode-map (kbd "A-s") #'save-buffer)
-      (define-key icejam-keys-mode-map (kbd "A-l") #'goto-line)
+      (keymap-set icejam-keys-mode-map (kbd "A-l") #'goto-line)
-      (define-key icejam-keys-mode-map (kbd "A-w") #'icejam-function-delete-window)
+      (keymap-set icejam-keys-mode-map (kbd "A-w") #'icejam-function-delete-window)
-      (define-key icejam-keys-mode-map (kbd "A-z") #'undo)
+      (keymap-set icejam-keys-mode-map (kbd "A-z") #'undo)
-      (define-key icejam-keys-mode-map (kbd "A-q") #'kill-emacs)))
+      (keymap-set icejam-keys-mode-map (kbd "A-q") #'kill-emacs)))
 
 (provide 'icejam-sys-specific)
 ;;; icejam-sys-specific.el ends here

lisp/icejam-transient.el

@@ -2,9 +2,7 @@
 ;;; Commentary:
 ;;; Global Transient definitions.
 ;;; Code:
-
+(eval-when-compile (defvar icejam-keys-mode-map))
-(require 'icejam-avy)
-(require 'icejam-keys-mode)
 
 (use-package transient :ensure (:wait t))
 
@@ -16,22 +14,22 @@
 (transient-define-prefix icejam-project-menu ()
   "Project Commands."
   [["Project"
-    ("s" "Switch project"       project-switch-project)
+    ("s" "Switch project" project-switch-project)
     ("f" "Find file in project" project-find-file)
-    ("g" "Grep in project"      consult-ripgrep)
+    ("g" "Grep in project" consult-ripgrep)
-    ("t" "Find file"            find-file)]
+    ("t" "Find file anywhere" find-file)]
    ["Magit"
-    ("m" "Git status"           magit-status)
+    ("m" "Git status" magit-status)
-    ("C" "Git checkout"         magit-checkout)
+    ("C" "Git checkout" magit-checkout)
-    ("M" "Git blame"            magit-blame)]
+    ("M" "Git blame" magit-blame)]
    ["Completions"
-    ("a" "Grep in buffer"       consult-line)
+    ("a" "Find line by contents" consult-line)
-    ("b" "Find Buffer"          consult-buffer)]]
+    ("b" "Find buffer by name" consult-buffer)]]
   [["LISP"
     ("i" "IELM"                 ielm)
     ("B" "iBuffer"              ibuffer)
-    ("e" "eval-region"          eval-region)]]
+    ("e" "eval-region"          eval-region)]
-  [["Other"
+   ["Other"
     ("d" "deft"                 deft)
     ("T" "Speed Type"           speed-type-text)]]
   [[""
@@ -137,7 +135,7 @@ You can pass MAYBE-MODE to find mode explicitly."
 
 (transient-define-prefix icejam-command-palette ()
   "All transient menus in one place."
-  ["All my stuff in one place\n"
+  ["Command palette\n"
    ["The thing you are editing"
     ("p" "Project" icejam-project-menu)
     ("c" "Code" icejam-code-menu)
@@ -147,11 +145,11 @@ You can pass MAYBE-MODE to find mode explicitly."
     ("b" "iBuffer" ibuffer)
     ("w" "Window" icejam-buffer-menu)]])
 
-(define-key icejam-keys-mode-map (kbd "C-c p") 'icejam-project-menu)
+(keymap-set icejam-keys-mode-map "C-c p" #'icejam-project-menu)
-(define-key icejam-keys-mode-map (kbd "C-c c") 'icejam-code-menu)
+(keymap-set icejam-keys-mode-map "C-c c" #'icejam-code-menu)
-(define-key icejam-keys-mode-map (kbd "C-c w") 'icejam-buffer-menu)
+(keymap-set icejam-keys-mode-map "C-c w" #'icejam-buffer-menu)
-(define-key icejam-keys-mode-map (kbd "C-c l") 'icejam-transient-for-lang)
+(keymap-set icejam-keys-mode-map "C-c l" #'icejam-transient-for-lang)
-(define-key icejam-keys-mode-map (kbd "H-p") 'icejam-command-palette)
+(keymap-set icejam-keys-mode-map "H-p" #'icejam-command-palette)
 
 (provide 'icejam-transient)
 ;;; icejam-transient.el ends here

lisp/icejam-tree-sitter.el

@@ -10,7 +10,6 @@
 ;; community.
 
 ;;; Code:
-
 (use-package tree-sitter-langs :ensure t :defer t
   :commands tree-sitter-langs--bin-dir
   :hook

lisp/langs/icejam-lang-clang.el

@@ -2,8 +2,6 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))
 
 (defun icejam-lang-activate-clang-mode ()

lisp/langs/icejam-lang-clojure.el

@@ -2,16 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
 (use-package clojure-mode :defer t :ensure t)
 
 (use-package cider
   :requires clojure-mode
-  :commands cider-jack-in
+  :commands (cider-mode cider-jack-in)
   :defer t
   :ensure t
   :config (setq cider-annotate-completion-function t))

lisp/langs/icejam-lang-dart.el

@@ -1,8 +1,7 @@
 ;;; dart -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function lsp 'lsp-mode)
-(require 'icejam-prog-mode)
 
 (use-package dart-mode :ensure t :defer t)
 (use-package lsp-dart :defer t :ensure t :requires (dart-mode lsp))

lisp/langs/icejam-lang-dhall.el

@@ -1,9 +1,7 @@
 ;;; dhall -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function lsp 'lsp-mode)
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
 
 (use-package dhall-mode :ensure t :defer t :requires (lsp))
 

lisp/langs/icejam-lang-elisp.el

@@ -1,13 +1,13 @@
 ;;; languages/elisp -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-transient)
+(declare-function icejam-set-elisp-capfs 'icejam-complete-at-point)
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
-(declare-function column-enforce-n "column-enforce-mode" (number))
 (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
 
-(use-package lispy :ensure t :defer t)
+(use-package lispy :ensure t :defer t :commands (lispy-mode))
 
 (defun icejam-activate-emacs-lisp-mode ()
   "Goodies for editing Emacs files."
@@ -15,13 +15,7 @@
   (icejam-set-indent 2) ;; Default indentation of 2 characters
   (column-enforce-n 80) ;; Use 80 char limit.
   (lispy-mode t)        ;; Modal editing for Lisp
-
+  (icejam-set-elisp-capfs))
-  (setq-local completion-at-point-functions
-              (list (cape-capf-super #'elisp-completion-at-point
-                                     #'yasnippet-capf)
-                    #'cape-dabbrev
-                    #'cape-file
-                    #'cape-elisp-symbol)))
 
 (add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
 (add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)

lisp/langs/icejam-lang-elixir.el

@@ -2,16 +2,22 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-flycheck)
+(declare-function -> 'dash)
-(require 'icejam-transient)
+(declare-function lsp 'lsp-mode)
+(declare-function yas--table-get-create 'yasnippet)
+(declare-function yas--remove-template-by-uuid 'yasnippet)
 
-(declare-function lsp "lsp-mode" nil)
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 ;; Only load the elixir-format from elixir mode.
 (use-package elixir-format :defer t
-  :ensure (:type git :host github :repo "elixir-editors/emacs-elixir" :files ("elixir-format.el")))
+  :ensure (:type git
+                 :host github
+                 :repo "elixir-editors/emacs-elixir"
+                 :files ("elixir-format.el")))
 
 (use-package elixir-ts-mode :ensure t :defer t :after (elixir-format lsp-mode lsp-ui))
 
@@ -21,12 +27,12 @@
       (concat (propertize "Code actions for " 'face 'transient-heading)
               (propertize (format "%s" major-mode) 'face 'transient-key)
               (propertize ":\n" 'face 'transient-heading)))
-    ("m" "LSP iMenu"                           lsp-ui-imenu)
+    ("m" "LSP iMenu" lsp-ui-imenu)
-    ("r" "Reload buffer"                       icejam-revert-buffer-no-confirm)
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
     ("f" "Format buffer with Elixir formatter" elixir-format)
-    ("e" "Show errors"                         flymake-show-buffer-diagnostics)]]
+
-  [""
+    ("q" "Quit" keyboard-quit)]])
-   ("q" "Quit"                                 keyboard-quit)])
 
 (defun icejam-delete-elixir-snippets ()
   "This function deletes Elixir snippets I don't use."

lisp/langs/icejam-lang-erlang.el

@@ -2,11 +2,10 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode)
-
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function lsp "lsp-mode" nil)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
-(declare-function column-enforce-n "column-enforce-mode" (number))
 
 (use-package erlang
   :defer t
@@ -14,6 +13,7 @@
   :after (lsp lsp-ui))
 
 (defun icejam-activate-erlang-mode ()
+  "Start Erlang related editing process."
   (icejam-set-indent 4)
   (column-enforce-n 80)
 

lisp/langs/icejam-lang-fsharp.el

@@ -10,8 +10,10 @@
 
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function lsp-deferred 'lsp-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package fsharp-mode
   :requires (lsp-mode lsp-ui)

lisp/langs/icejam-lang-gleam.el

@@ -9,9 +9,10 @@
 ;; Gleam language support
 
 ;;; Code:
-
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package gleam-ts-mode :defer t :after (lsp)
   :ensure (:type git
@@ -25,7 +26,8 @@
   "All things Gleam."
   (icejam-set-indent 2)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'gleam-mode-hook 'icejam-lang-activate-gleam-mode)
 

lisp/langs/icejam-lang-golang.el

@@ -9,8 +9,10 @@
 ;; golang mode stuff
 
 ;;; Code:
-
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package go-mode
   :requires (lsp-mode lsp-ui)
@@ -21,9 +23,10 @@
   "Activate my own Golang mode settings."
   (icejam-set-indent 8)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
-(add-hook 'go-mode-hook 'icejam-activate-golang-mode)
+(add-hook 'go-mode-hook #'icejam-activate-golang-mode)
 
 (provide 'icejam-lang-golang)
 ;;; icejam-lang-golang.el ends here

lisp/langs/icejam-lang-haskell.el

@@ -10,8 +10,10 @@
 
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-lsp)
+(declare-function lsp-deferred 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package haskell-mode
   :ensure t

lisp/langs/icejam-lang-javascript.el

@@ -2,9 +2,10 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-flycheck)
+(declare-function lsp-deferred 'lsp-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package js2-mode :ensure t :defer t
   :after (web-mode lsp-mode lsp-ui))

lisp/langs/icejam-lang-kotlin.el

@@ -9,10 +9,10 @@
 ;; kotlin does a thing.
 
 ;;; Code:
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
-
+(declare-function lsp 'lsp-mode)
-(declare-function lsp "lsp-mode" nil)
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package kotlin-ts-mode
   :ensure t
@@ -28,7 +28,8 @@
   "All things Kotlin."
   (icejam-set-indent 2)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
 

lisp/langs/icejam-lang-lean.el

@@ -2,15 +2,15 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function lsp-deferred 'lsp-mode)
-(require 'icejam-lsp)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package lean4-mode
   :ensure (lean4-mode
-	   :type git
+           :type git
-	   :host github
+           :host github
-	   :repo "leanprover/lean4-mode"
+           :repo "leanprover/lean4-mode"
-	   :files ("*.el" "data"))
+           :files ("*.el" "data"))
   :requires (lsp)
   :defer t)
 
@@ -24,7 +24,7 @@
   ;; Capf override
   (icejam-set-lsp-capfs))
 
-(add-hook 'lean4-mode-hook 'icejam-activate-lean-mode)
+(add-hook 'lean4-mode-hook #'icejam-activate-lean-mode)
 
 (provide 'icejam-lang-lean)
 ;;; icejam-lang-lean.el ends here

lisp/langs/icejam-lang-markdown.el

@@ -2,7 +2,8 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
 ;; Markdown is a dependency of LSP mode. By wrapping it in unless we silence
 ;; a warning from the byte compiler.
@@ -14,6 +15,7 @@
   (setq-default markdown-command "pandoc"))
 
 (declare-function rxt--re-builder-switch-pcre-mode "pcre2el")
+(declare-function markdown-preview 'markdown-mode)
 
 (defun icejam-lang-activate-markdown-mode ()
   "Reconfigure markdown mode for your own purposes."
@@ -21,11 +23,11 @@
   (column-enforce-n 10000)
 
   ;; Markdown mode reuses my bindings, remove them.
-  (define-key markdown-mode-map (kbd "C-c <left>") nil)
+  (keymap-set markdown-mode-map "C-c <left>" nil)
-  (define-key markdown-mode-map (kbd "C-c <right>") nil)
+  (keymap-set markdown-mode-map "C-c <right>" nil)
-  (define-key markdown-mode-map (kbd "C-c <up>") nil)
+  (keymap-set markdown-mode-map "C-c <up>" nil)
-  (define-key markdown-mode-map (kbd "C-c <down>") nil)
+  (keymap-set markdown-mode-map "C-c <down>" nil)
-  (define-key markdown-mode-map (kbd "C-c C-v") 'markdown-preview))
+  (keymap-set markdown-mode-map "C-c C-v" #'markdown-preview))
 
 (add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
 (add-hook 'markdown-mode-hook 'display-line-numbers-mode)

lisp/langs/icejam-lang-ocaml.el

@@ -2,12 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-transient)
-(require 'icejam-prog-mode)
 (declare-function lsp "lsp-mode" nil)
 
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
+
 (use-package merlin :defer t :ensure t)
-(use-package opam-switch-mode :defer t :ensure t)
+(use-package opam-switch-mode :defer t :ensure t :commands (opam-switch-mode))
 (use-package dune :defer t :ensure t)
 (use-package tuareg :defer t :ensure t)
 
@@ -48,7 +50,8 @@
   (icejam-set-indent 2)
   (opam-switch-mode t)
   (icejam-load-ocaml-site-packages)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)
 

lisp/langs/icejam-lang-php.el

@@ -9,15 +9,15 @@
 ;; php related settings
 
 ;;; Code:
-
+(declare-function column-enforce-n 'column-enforce-mode (number))
-(require 'icejam-prog-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
-(require 'icejam-flycheck)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
-(require 'icejam-transient)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 (use-package php-mode :ensure t :defer t
   :requires (lsp-mode lsp-ui))
 
-(transient-define-prefix icejam-lang-php/context-menu ()
+(transient-define-prefix icejam-lang-php-context-menu ()
   "PHP Buffer Commands."
   [""
    ["LSP"
@@ -36,7 +36,7 @@
   (icejam-set-indent 4)
   (column-enforce-n 80)
 
-  (define-key php-mode-map (kbd "C-c l") 'icejam-lang-php/context-menu)
+  (keymap-set php-mode-map "C-c l" #'icejam-lang-php-context-menu)
 
   ;; Capf override
   (icejam-set-lsp-capfs))

lisp/langs/icejam-lang-purescript.el

@@ -9,7 +9,10 @@
 ;; Configuration for purescript.
 
 ;;; Code:
-(require 'icejam-prog-mode)
+
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package purescript-mode :ensure t :defer t
   :after (lsp-mode lsp-ui))

lisp/langs/icejam-lang-python.el

@@ -1,12 +1,10 @@
 ;;; python -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
-(require 'icejam-transient)
-
-(declare-function lsp nil)
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 (transient-define-prefix icejam-python-lang-menu ()
   "Python Buffer Commands."

lisp/langs/icejam-lang-ruby.el

@@ -2,9 +2,12 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
-(use-package rspec-mode :ensure t :defer t)
+(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
 (use-package ruby-end :ensure t :defer t)
 (use-package rbs-mode :ensure t :defer t)
 

lisp/langs/icejam-lang-rust.el

@@ -2,7 +2,11 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp-deferred 'lsp-mode)
+
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package rust-mode
   :ensure t
@@ -22,7 +26,8 @@
   (column-enforce-n 99)
 
   ;; Run LSP
-  (lsp-deferred))
+  (lsp-deferred)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
 (add-hook 'rust-mode-hook 'flycheck-rust-setup)

lisp/langs/icejam-lang-web.el

@@ -2,8 +2,7 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-lsp)
+(declare-function lsp 'lsp-mode)
-(require 'icejam-flycheck)
 
 (use-package web-mode :after (lsp flycheck) :ensure t :defer t)
 

lisp/langs/icejam-lang-ziglang.el

@@ -9,7 +9,10 @@
 ;; ziglang does a thing.
 
 ;;; Code:
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package zig-mode :ensure t :defer t :requires (lsp))
 
@@ -21,7 +24,8 @@
 
   ;; Set indentation to 4 chars
   (icejam-set-indent 4)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'zig-mode-hook 'icejam-activate-zig-mode)