feat(core): add +add-hook! & +remove-hook! from Doom

Author: abougouffa

core/me-loaddefs.el

@@ -397,6 +397,31 @@ Hook BODY in HOOK, it runs only once.
 
 (fn HOOK &rest BODY)" nil t)
 (function-put '+hook-once! 'lisp-indent-function 1)
+(autoload '+add-hook! "../elisp/+minemacs" "\
+A convenience macro for adding N functions to M hooks.
+
+This macro accepts, in order:
+
+  1. The mode(s) or hook(s) to add to. This is either an unquoted mode, an
+     unquoted list of modes, a quoted hook variable or a quoted list of hook
+     variables.
+  2. Optional properties :local, :append, and/or :depth [N], which will make the
+     hook buffer-local or append to the list of hooks (respectively),
+  3. The function(s) to be added: this can be a quoted function, a quoted list
+     thereof, a list of `defun' or `cl-defun' forms, or arbitrary forms (will
+     implicitly be wrapped in a lambda).
+
+(fn HOOKS [:append :local [:depth N]] FUNCTIONS-OR-FORMS...)" nil t)
+(function-put '+add-hook! 'lisp-indent-function '(lambda (indent-point state) (goto-char indent-point) (when (looking-at-p "\\s-*(") (lisp-indent-defform state indent-point))))
+(autoload '+remove-hook! "../elisp/+minemacs" "\
+A convenience macro for removing N functions from M hooks.
+
+Takes the same arguments as `add-hook!'.
+
+If N and M = 1, there's no benefit to using this macro over `remove-hook'.
+
+(fn HOOKS [:append :local] FUNCTIONS)" nil t)
+(function-put '+remove-hook! 'lisp-indent-function 'defun)
 (autoload '+compile-functions "../elisp/+minemacs" "\
 Queue FNS to be byte/natively-compiled after a brief delay.
 
@@ -421,7 +446,7 @@ Run all build functions registered with `+register-build-function!'.
 (fn &optional DONT-ASK-P)" t)
 (autoload 'minemacs-update "../elisp/+minemacs" "\
 Update MinEmacs packages." t)
-(register-definition-prefixes "../elisp/+minemacs" '("+eval-when-idle-" "+hook-once-num" "minemacs--build-functions"))
+(register-definition-prefixes "../elisp/+minemacs" '("+add-hook!" "+eval-when-idle-" "+hook-once-num" "+resolve-hook-forms" "minemacs--build-functions"))
 
 
 ;;; Generated autoloads from ../elisp/+primitives.el

elisp/+minemacs.el

@@ -248,6 +248,92 @@ DEPTH and LOCAL are passed as is to `add-hook'."
        ,(macroexp-progn body)
        (remove-hook ',hook ',fn-name)))))
 
+;; From Doom Emacs
+(defun +resolve-hook-forms (hooks)
+  "Converts a list of modes into a list of hook symbols.
+
+If a mode is quoted, it is left as is. If the entire HOOKS list is quoted, the
+list is returned as-is."
+  (declare (pure t) (side-effect-free t))
+  (let ((hook-list (ensure-list (+unquote hooks))))
+    (if (eq (car-safe hooks) 'quote)
+        hook-list
+      (cl-loop for hook in hook-list
+               if (eq (car-safe hook) 'quote)
+               collect (cadr hook)
+               else collect (intern (format "%s-hook" (symbol-name hook)))))))
+
+;; From Doom Emacs
+;;;###autoload
+(defmacro +add-hook! (hooks &rest rest)
+  "A convenience macro for adding N functions to M hooks.
+
+This macro accepts, in order:
+
+  1. The mode(s) or hook(s) to add to. This is either an unquoted mode, an
+     unquoted list of modes, a quoted hook variable or a quoted list of hook
+     variables.
+  2. Optional properties :local, :append, and/or :depth [N], which will make the
+     hook buffer-local or append to the list of hooks (respectively),
+  3. The function(s) to be added: this can be a quoted function, a quoted list
+     thereof, a list of `defun' or `cl-defun' forms, or arbitrary forms (will
+     implicitly be wrapped in a lambda).
+
+\(fn HOOKS [:append :local [:depth N]] FUNCTIONS-OR-FORMS...)"
+  (declare (indent (lambda (indent-point state)
+                     (goto-char indent-point)
+                     (when (looking-at-p "\\s-*(")
+                       (lisp-indent-defform state indent-point))))
+           (debug t))
+  (let* ((hook-forms (+resolve-hook-forms hooks))
+         (func-forms ())
+         (defn-forms ())
+         append-p local-p remove-p depth)
+    (while (keywordp (car rest))
+      (pcase (pop rest)
+        (:append (setq append-p t))
+        (:depth  (setq depth (pop rest)))
+        (:local  (setq local-p t))
+        (:remove (setq remove-p t))))
+    (while rest
+      (let* ((next (pop rest))
+             (first (car-safe next)))
+        (push (cond ((memq first '(function nil))
+                     next)
+                    ((eq first 'quote)
+                     (let ((quoted (cadr next)))
+                       (if (atom quoted)
+                           next
+                         (when (cdr quoted)
+                           (setq rest (cons (list first (cdr quoted)) rest)))
+                         (list first (car quoted)))))
+                    ((memq first '(defun cl-defun))
+                     (push next defn-forms)
+                     (list 'function (cadr next)))
+                    ((prog1 `(lambda (&rest _) ,@(cons next rest))
+                       (setq rest nil))))
+              func-forms)))
+    `(progn
+       ,@defn-forms
+       (dolist (hook (nreverse ',hook-forms))
+        (dolist (func (list ,@func-forms))
+         ,(if remove-p
+              `(remove-hook hook func ,local-p)
+            `(add-hook hook func ,(or depth append-p) ,local-p)))))))
+
+;; From Doom Emacs
+;;;###autoload
+(defmacro +remove-hook! (hooks &rest rest)
+  "A convenience macro for removing N functions from M hooks.
+
+Takes the same arguments as `add-hook!'.
+
+If N and M = 1, there's no benefit to using this macro over `remove-hook'.
+
+\(fn HOOKS [:append :local] FUNCTIONS)"
+  (declare (indent defun) (debug t))
+  `(+add-hook! ,hooks :remove ,@rest))
+
 ;; Adapted from: Doom Emacs
 ;;;###autoload
 (defun +compile-functions (&rest fns)