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.
This commit is contained in:
Henrik Lissner 2017-06-08 11:47:56 +02:00
parent 64a142b3fc
commit c7254e7bdc
No known key found for this signature in database
GPG key ID: 5F6C0EA160557395
154 changed files with 1101 additions and 1118 deletions

View file

@ -1,8 +1,8 @@
;;; core-keybinds.el
;;; core-keybinds.el -*- lexical-binding: t; -*-
;; A centralized keybinds system, integrated with `which-key' to preview
;; available keys, and `evil', if it's enabled. All built into one powerful
;; macro: `map!'.
;; available keybindings. All built into one powerful macro: `map!'. If evil is
;; never loaded, then evil bindings set with `map!' will be ignored.
(defvar doom-leader-key "SPC"
"The leader prefix key, for global commands.")
@ -11,13 +11,13 @@
"The localleader prefix key, for major-mode specific commands.")
(defvar doom-evil-state-alist
'(("n" . normal)
("v" . visual)
("i" . insert)
("e" . emacs)
("o" . operator)
("m" . motion)
("r" . replace))
'((?n . normal)
(?v . visual)
(?i . insert)
(?e . emacs)
(?o . operator)
(?m . motion)
(?r . replace))
"A list of cons cells that map a letter to a evil state symbol.")
@ -33,7 +33,7 @@
;; embolden local bindings
(set-face-attribute 'which-key-local-map-description-face nil :weight 'bold)
(which-key-setup-side-window-bottom)
(which-key-mode +1))
(add-hook 'window-setup-hook #'which-key-mode))
;;
@ -56,14 +56,11 @@ IGNORE is a list of keyword letters that should be ignored.
For example, :nvi will map to (list 'normal 'visual 'insert). See
`doom-evil-state-alist' to customize this."
(delq nil
(mapcar (lambda (l)
(let ((state (cdr (assoc l doom-evil-state-alist))))
(unless state
(unless (or (eq ignore t) (member l ignore))
(error "not a valid state: %s" l)))
state))
(split-string (substring (symbol-name keyword) 1) "" t))))
(cl-loop for l across (substring (symbol-name keyword) 1)
if (cdr (assq l doom-evil-state-alist))
collect it
else if (not (or (eq ignore t) (member l ignore)))
do (error "not a valid state: %s" l)))
;; Register keywords for proper indentation (see `map!')
@ -79,6 +76,11 @@ For example, :nvi will map to (list 'normal 'visual 'insert). See
(put ':localleader 'lisp-indent-function 'defun)
(put ':textobj 'lisp-indent-function 'defun)
;; specials
(defvar doom--keymaps nil)
(defvar doom--prefix nil)
(defvar doom--defer nil)
(defmacro map! (&rest rest)
"A nightmare of a key-binding macro that will use `evil-define-key*',
`define-key', `local-set-key' and `global-set-key' depending on context and
@ -130,9 +132,9 @@ Example
(:when IS-MAC
:n \"M-s\" 'some-fn
:i \"M-o\" (lambda (interactive) (message \"Hi\"))))"
(let ((keymaps (if (boundp 'keymaps) keymaps))
(prefix (if (boundp 'prefix) prefix))
(defer (if (boundp 'defer) defer))
(let ((doom--keymaps doom--keymaps)
(doom--prefix doom--prefix)
(doom--defer doom--defer)
local key def states forms desc modes)
(while rest
(setq key (pop rest))
@ -156,19 +158,19 @@ Example
(:unless (push `(if (not ,(pop rest)) ,(macroexpand `(map! ,@rest))) forms) (setq rest '()))
(:after (push `(after! ,(pop rest) ,(macroexpand `(map! ,@rest))) forms) (setq rest '()))
(:desc (setq desc (pop rest)))
(:map* (setq defer t) (push :map rest))
(:map* (setq doom--defer t) (push :map rest))
(:map
(setq keymaps
(setq doom--keymaps
(let ((car (pop rest)))
(if (listp car) car (list car)))))
(:mode
(setq modes
(let ((car (pop rest)))
(if (listp car) car (list car))))
(unless keymaps
(setq keymaps
(mapcar (lambda (m) (intern (format "%s-map" (symbol-name m))))
modes))))
(unless doom--keymaps
(setq doom--keymaps
(cl-loop for m in modes
collect (intern (format "%s-map" (symbol-name m)))))))
(:textobj
(let* ((key (pop rest))
(inner (pop rest))
@ -178,20 +180,20 @@ Example
forms)))
(:prefix
(let ((def (pop rest)))
(setq prefix `(vconcat ,prefix (kbd ,def)))
(setq doom--prefix `(vconcat ,doom--prefix (kbd ,def)))
(when desc
(push `(doom--keybind-register ,(key-description (eval prefix))
(push `(doom--keybind-register ,(key-description (eval doom--prefix))
,desc ',modes)
forms)
(setq desc nil))))
(otherwise ; might be a state prefix
(_ ; might be a state doom--prefix
(setq states (doom--keyword-to-states key '("L")))
(let (case-fold-search)
(when (string-match-p "L" (symbol-name key))
(setq local t)
(cond ((= (length states) 0)
(user-error "local keybinding for %s must accompany another state" key))
((> (length keymaps) 0)
((> (length doom--keymaps) 0)
(user-error "local keybinding for %s cannot accompany a keymap" key))))))))
;; It's a key-def pair
@ -205,8 +207,8 @@ Example
(setq key `(kbd ,key)))
((stringp key)
(setq key (kbd key))))
(when prefix
(setq key (append prefix (list key))))
(when doom--prefix
(setq key (append doom--prefix (list key))))
(unless (> (length rest) 0)
(user-error "map! has no definition for %s key" key))
(setq def (pop rest))
@ -214,10 +216,10 @@ Example
(push `(doom--keybind-register ,(key-description (eval key))
,desc ',modes)
forms))
(cond ((and keymaps states)
(cond ((and doom--keymaps states)
(unless (featurep 'evil) (throw 'skip 'evil))
(dolist (keymap keymaps)
(push `(,(if defer 'evil-define-key 'evil-define-key*)
(dolist (keymap doom--keymaps)
(push `(,(if doom--defer 'evil-define-key 'evil-define-key*)
',states ,keymap ,key ,def)
forms)))
(states
@ -227,8 +229,8 @@ Example
,(intern (format "evil-%s-state-%smap" state (if local "local-" "")))
,key ,def)
forms)))
(keymaps
(dolist (keymap keymaps)
(doom--keymaps
(dolist (keymap doom--keymaps)
(push `(define-key ,keymap ,key ,def) forms)))
(t (push `(,(if local 'local-set-key 'global-set-key) ,key ,def)
forms))))