Macro wrappers on meow define keys

[Inc0n]

Macro definition

(defmacro meow-define-key (states &rest key-binds)
  (if (listp states)
      `(progn
         ,@(mapcar 
            (lambda (state)
              (let ((meow-keymap (intern (format "meow-%s-keymap" state))))
                `(progn
                   ,@(cl-loop
                      for (key def) on key-binds by #'cddr
                      do (message "%s %s" meow-keymap (intern (format "meow-%s-keymap" state)))
                      collect
                      `(define-key ,meow-keymap
                         (kbd ,key)
                         (meow--parse-def ,def))))))
            states))
    `(meow-define-key
      (,states)
      ,@key-binds)))

This is similar to evil-define-key.
This would transforms the following:

(meow-define-key (leader)
                 "j" "H-j"
                 "k" "H-k")

Into:

(progn
  (progn
    (define-key meow-leader-keymap
      (kbd "j")
      (meow--parse-def "H-j"))
    (define-key meow-leader-keymap
      (kbd "k")
      (meow--parse-def "H-k"))))

You can either pass in a list of states or a single state.
There are some optimization that can be done, ish. If constraints are established.
Such as allow the evaluation of kbd at read time (macro).

[DogLooksGood]

Is it a drop-in replacement helper for migration from evil?

[Inc0n]

What I am trying to say that to if someone wanted to migrate from evil, the existing meow-leader-define-key, meow-normal-define-key, etc, would suffice.
This is more of a syntactic sugar, which IMO would be more readable.

[Inc0n]

They look like this in emacs:

[Inc0n]

I just found out some limitations to this macro, that this cannot be used for both leader and states keymaps key definition.
Since leader keymap variable name: meow-leader-keymap,
whereas states keymap variable name: meow-<state>-state-keymap.

[Inc0n]

This can be worked around for states definition, user need to specify insert-state, motion-state. Leader can be passed in as leader.
The added benefit is user can define a key definition for multiple states, for example for me,

  (meow-define-key (normal-state insert-state)
    [?\C-r] 'undo-redo)

[DogLooksGood]

There are few scenarios where the same commands are bound in multiple states. In my case, just one, a global ' for repeat.

You can have a alist ((:leader . meow-leader-keymap) (:motion . meow-motion-state-keymap) ...) to map from the keyword to keymap symbol in the macro.

[Inc0n]

With meow-keymap-alist it could now be written as a function also.

(defun meow-define-key (states &rest key-binds)
  (dolist (state states)
    (if-let* ((pair (assq state meow-keymap-alist))
	      (keymap (cdr pair)))
	(cl-loop
	 for (key def) on key-binds by #'cddr
	 do (define-key keymap key def))
      (user-error "undefined meow state %s" state))))

This version as a function would require quotation of the states:

(meow-define-key '(leader) 
  "1" meow-digit-argument
  "2" meow-digit-argument
  "3" meow-digit-argument)

Note: meow--parse-def has been removed from the definition.