Major optimization refactor, across the board

+ enable lexical-scope everywhere (lexical-binding = t): ~5-10% faster
  startup; ~5-20% general boost
+ reduce consing, function calls & garbage collection by preferring
  cl-loop & dolist over lambda closures (for mapc[ar], add-hook, and
  various cl-lib filter/map/reduce functions) -- where possible
+ prefer functions with dedicated opcodes, like assq (see byte-defop's
  in bytecomp.el for more)
+ prefer pcase & cond (faster) over cl-case
+ general refactor for code readability
+ ensure naming & style conventions are adhered to
+ appease byte-compiler by marking unused variables with underscore
+ defer minor mode activation to after-init, emacs-startup or
  window-setup hooks; a customization opportunity for users + ensures
  custom functionality won't interfere with startup.

modules/feature/jump/autoload/evil.el

@@ -1,4 +1,4 @@
-;;; feature/jump/autoload/evil.el
+;;; feature/jump/autoload/evil.el -*- lexical-binding: t; -*-
 
 ;;;###autoload (autoload '+jump:online "feature/jump/autoload/evil" nil t)
 (evil-define-command +jump:online (query &optional bang)
@@ -6,11 +6,12 @@
 reuse it on consecutive uses of this command. If BANG, always prompt for search
 engine."
   (interactive "<a><!>")
-  (setq query (or query (thing-at-point 'symbol t)))
-  (unless query
-    (user-error "The search query is empty"))
-  (let ((engine (or (and (not bang) (bound-and-true-p +jump--online-last))
-                    (completing-read (format "Search on (%s): " query)
-                                     (mapcar #'car +jump-search-url-alist)
-                                     nil t))))
-    (+jump/online engine query)))
+  (let ((query (or query (thing-at-point 'symbol t))))
+    (unless query
+      (user-error "The search query is empty"))
+    (+jump/online
+     (or (and (not bang) (bound-and-true-p +jump--online-last))
+         (completing-read (format "Search on (%s): " query)
+                          (mapcar #'car +jump-search-url-alist)
+                          nil t))
+     query)))

modules/feature/jump/autoload/jump.el

@@ -1,4 +1,4 @@
-;;; feature/jump/autoload.el
+;;; feature/jump/autoload.el -*- lexical-binding: t; -*-
 
 (defvar +jump--rg-installed-p (executable-find "rg"))
 (defvar +jump--ag-installed-p (executable-find "ag"))
@@ -42,12 +42,11 @@ Tries xref and falls back to `dumb-jump', then rg/ag, then
 
           ((and (featurep 'evil)
                 evil-mode
-                (let ((bounds (bounds-of-thing-at-point 'symbol))
-                      (orig-pt (point)))
+                (destructuring-bind (beg end) (bounds-of-thing-at-point 'symbol)
                   (evil-goto-definition)
                   (let ((pt (point)))
-                    (not (and (>= pt (car bounds))
-                              (<  pt (cdr bounds))))))))
+                    (not (and (>= pt beg)
+                              (<  pt end)))))))
 
           (t (user-error "Couldn't find '%s'" sym)))))
 
@@ -58,9 +57,8 @@ Tries xref and falls back to `dumb-jump', then rg/ag, then
 Tries `xref-find-references' and falls back to rg/ag."
   (interactive)
   (let ((sym (thing-at-point 'symbol t)))
-    (cond ((progn
-             (ignore-errors (xref-find-references sym)
-                            t)))
+    (cond ((ignore-errors (xref-find-references sym)
+                          t))
 
           ((and sym
                 (featurep 'counsel)
@@ -87,7 +85,7 @@ Interactively, you are prompted to choose a source from
                               (mapcar #'car +jump-search-url-alist)
                               nil t))
          (thing-at-point 'symbol t)))
-  (condition-case ex
+  (condition-case _ex
       (let ((url (cdr (assoc where +jump-search-url-alist))))
         (unless url
           (error "'%s' is an invalid search engine" where))