Best way to do keybinds

[slempinen]

Hi! I'm a new emacs user and have been enjoying meow very much. I am however a little confused on what is the recommended way to organize keybindings. I'll give a couple of examples.

Example 1: Accessing projectile command map

Lets say I'm using the projectile package and wish to make a nice and easy button combination to access its command map. Currently my setup looks like this:

(use-package projectile
  :straight t
  :bind (:map projectile-mode-map ("C-c p" . projectile-command-map))
  ...

I can now access projectile commands with SPC c SPC p if C-c C-p is already bound by other modes which it often is. That is to say running projectile-switch-to-buffer requires me to enter SPC c SPC p b which is 5 keys. Way too many for something I do very often. I do not wish to bind the projectile-command-map with meow-normal-define-key as I feel it wouldn't make much sense to bind it to a key directly.

Could I maybe bind it to just SPC b instead? I could do it with meow-leader-define-key but that would maybe cause some issues when projectile mode is not on. Right? Any suggestions with code examples are appreciated :)

Example 2: Binding smartparens commands

Here is my current setup:

(use-package smartparens
  :straight t
  :bind
    (:map smartparens-mode-map
          ("C-c s d" . sp-unwrap-sexp )
          ("C-c s r" . sp-wrap-round)
          ("C-c s c" . sp-wrap-curly)
          ("C-c s s" . sp-wrap-square))
...

Again it works fine but i would like quicker access to C-c s than SPC c SPC s. I found this but honestly I don't get it. Which button combination would allow me to access the custom state as defined in the link? Moreover is this the recommended way to do user defined keybind groupings?

Example 3: Emacs built-in functions

I've bound the S key to C-x C-s with meow-normal-define-key as I like to have saving behind one key. However I would also like to bind stuff like replace-regexp to a quick key combination. It's not part of any third party package so I'm unsure where to put the keybinding code in my init.el. Again I would like to have a key combination like SPC u (or any two key combination) to access a bunch of key bindings set by me but I am unsure of what the best way to go about it is and how to keep it nice and organized.

If you could enlighten me on how you handle your keybindings with code examples I would be very thankful!

[eshrh]

I don't use use-package, so I'm not entirely sure, but I think what you're
doing in example 1 is in general correct. I think the recommended way is to use
:bind-keymap.

I'm not sure what the issue with just binding it to b in the leader (so,
SPC B) is. If projectile mode is not active, and the command is undefined,
then pressing SPC b will just do nothing, which is reasonable. You can also
use some kind of fallback behavior.

I do something like this with projectile also. If projectile is on and I'm in
a project, SPC-f will call projectile-find-file, but if not, then it calls
the normal find-file. Maybe this could be useful? I implement it like this:

(defun find-file-or-projectile ()
  (interactive)
  (if (projectile-project-p)
      (call-interactively #'projectile-find-file)
    (call-interactively #'find-file)))

(meow-leader-define-key '("U" . find-file-or-projectile))

I also don't think there's anything wrong with your second example either. If
you'd like shorter keybinds, there's no real alternative to sacrificing normal
keys. You can treat every key essentially like a prefix, they don't have to be
emacs prefixes like the mode-specific-map (C-c).

(meow-normal-define-key
 '("= r" . sp-wrap-round)
 '("= s" . sp-wrap-square))

is probably the purest way to do it.

I don't think the custom state is what you're looking for. That's meant for
situations where you need to access another keymap for several commands
in a row. For example, moving down (deeper) into a sexp and then raising
it up would normally cost you a lot of keys.

The custom state creates a layer that's toggled by a key (chosen
by you!) and persists until disabled (typically with ESC).

I'll try to improve the documentation in a
little bit, but here's a more complete example:

(setq meow-paren-keymap (make-keymap))
(meow-define-state paren
  "meow state for interacting with smartparens"
  :lighter " [P]"
  :keymap meow-paren-keymap)

;; meow-define-state creates the variable
(setq meow-cursor-type-paren 'hollow)

;; fills in meow-paren-keymap
(meow-define-keys 'paren
  '("<escape>" . meow-normal-mode) ;; disables the paren state
  '("j" . sp-down-sexp)
  '("k" . sp-up-sexp)
  '("r" . sp-raise-sexp)
  '("s s" . sp-wrap-square)
  '("s r" . sp-wrap-round)
  '("s c" . sp-wrap-curly)
  '("s d" . sp-unwrap-sexp))

;; meow-paren-mode is automatically created
(meow-define-keys 'normal
  '("b" . meow-paren-mode))

Now, pressing b in the normal state will take you to the paren
state. Here, j r will move down the sexp and raise. s is a prefix
key, so s r will wrap-round directly with no modifiers. Finally,
pressing ESC will take you back to normal state.

Finally, as for your example 3, as a meow user, I'd tend to put that under some
prefix key or the leader key. A vanilla emacs user would bind it to some shorter
key using global-set-key which is probably the de-facto recommended way.

In any case, my meow keybindings are
here.

I like this article about emacs bindings

[slempinen]

Thank you very much! These were enlightening.

[DogLooksGood]

Yeah, following the convention, your keybinding C-c <letter> is good for user custom keybindings. Meow's KEYPAD mode, has a fallback leader feature. After pressing the first SPC, you will be in KEYPAD mode. And the first letter expect cxmgh can be used for quick access.
For example, a will be the keybinding a in mode-specific-map. This mode-specific-map is the default C-c keymap. So SPC a actually will call the command on C-c a.

This behavior is controlled by meow-leader-dispatch. The default behavior only works for keybinding in mode-specific-map. If you want a general C-c prefix, you can set meow-leader-dispatch to "C-c".

[slempinen]

Thank you! I set meow-keypad-leader-dispatch to "C-c" for now. This seems like something that should be mentioned in documentation. Maybe I'll make a PR if I find the courage 😄