General pair manipulation discussion thread

[eshrh]

I think it's maybe reasonable to say that pair/surround manipulation is a commonly missed feature in meow. I've been thinking about this for some time now, and I'd like some community feedback. Please feel free to post any of your thoughts, ideas or opinions.

1. Should meow implement some pair manipulation code, or should this be left to other packages (embrace, smartparens, paredit)?
2. What kind of features should we have? Embrace/vim-surround style add/change/delete are probably an the table, but anything else?
   a. Any idea about how to handle more arbitrary selection manipulation? Embrace lets you turn a selection into a function and further prompts you for what the function name is. Same idea with html tags. Should this arbitrary text prompt be built into meow, or should we offer a function interface where you can write your own manipulation function and register it kind of like a hook?
3. How should the idea of pairs be integrated with the existing things table (which, for the most part, are defined by a beginning and end regex)
4. How can any feature be made to integrate better with other parts of meow (any ideas about how this can work with the beacon?)

[eshrh]

tagging #224, #267, #205 where this was also discussed

[fbergroth]

1. Yes!
3. Things can get re-used if we consider the delta between bounds and inner to be the pairs content. POC:

(defun meow-surround-delete ()
  (interactive)
  (let* ((ch (meow-thing-prompt "Delete thing: "))
         (inner (meow--parse-inner-of-thing-char ch))
         (outer (meow--parse-bounds-of-thing-char ch)))
    (delete-region (cdr inner) (cdr outer))
    (delete-region (car outer) (car inner))))

Some things are not meaningful here (probably those where bounds equals inner), so we should rather let the user choose from some list of pair-thingies.
4. Hmm, how do you mean? Create a cursor for every pair?

[DogLooksGood]

I don't think we should add pair manipulation into Meow. Pair manipulation can be really complex, even more than Meow itself.

Instead, we should let Meow playing well with these pair manipulation packages.

[DogLooksGood]

Another idea is we support some easy selection recover. For example, you select a symbol, then insert something, then back to normal, recover the selection, then append something.
I also think it's better to use different keys for cancel-selection and cancel-grab. Then cancel-selection can be used to recover old selections.

[mclearc]

For what it is worth, as I've mentioned before, embrace does pair manipulation well, and is easy to use with meow. Perhaps it is best to just point this out in the docs? I'm not sure I see why it should be part of meow itself. Here's my setup for it if that is useful:

(use-package embrace
  :straight (:type git :host github :repo "cute-jumper/embrace.el")
  :bind (("C-M-s-#" . embrace-commander))
  :config
  (add-hook 'org-mode-hook 'embrace-org-mode-hook)
  (defun embrace-markdown-mode-hook ()
    (dolist (lst '((?* "*" . "*")
                   (?\ "\\" . "\\")
                   (?$ "$" . "$")
                   (?/ "/" . "/")))
      (embrace-add-pair (car lst) (cadr lst) (cddr lst))))
  (add-hook 'markdown-mode-hook 'embrace-markdown-mode-hook))

I then add '("S" . embrace-commander) to meow-normal-define-key.

[mmarshall540]

Old thread, but I feel like Meow's "select-thing" commands provide the missing link that makes Emacs's built-in electric-pair-mode a complete pair-manipulation solution.

For example, using the respective suggested mappings...

"Ma|ry had a little lamb." (where "|" is the location of point)
delete the quotes: in Dvorak , g k DEL y, or in QWERTY , g s DEL p
replace the quotes with parens: in Dvorak , g k DEL SPC ( y, or in QWERTY , g s DEL SPC ( p

surround the next 4 words with parens: in Dvorak w 3 SPC (, or in QWERTY e 3 SPC (

Maybe not as featureful as packages like smartparens or embrace, but it works just fine.

It's also probably not as succinct, but a couple of keyboard macros could easily fix that.

Here are the settings I use for electric-pair-mode.

(electric-pair-mode)
(setq electric-pair-inhibit-predicate 'ignore)
(setq electric-pair-skip-self t)

That's it! Maybe someone will find this useful.

[jgarte]

This works nicely.

[Haxxflaxx]

I just stumbled onto this post and this is a fantastic solution for solving surrounding in meow.

Some additional things:
With meow-keypad-execute-on-beacons enabled, the surround will also be applied to beacons in the grabbed region.

Sometimes I want to be able to surround things with other characters for example in org- or markdown-mode, but I don't want to always treat those characters as surrounding.

  (setq meow-normal-electric-extra-pairs '((?| . ?|) (?/ . ?/) (?- . ?-) (?+ . ?+) (?* . ?*) (?= . ?=)
                                           (?# . ?#) (?< . ?>) (?% . ?%) (?: . ?:) (?~ . ?~)))
  (defun meow-around-electric-pair-advice (orig-fun &rest args)
    (let ((electric-pair-pairs (append electric-pair-pairs (if (meow-normal-mode-p)
                                                               meow-normal-electric-extra-pairs
                                                             nil))))
      (apply orig-fun args)))
  (advice-add 'electric-pair-post-self-insert-function :around #'meow-around-electric-pair-advice)

This snippet adds a bunch of extra pairs only in normal state.

Before using this I used embrace and this really only replaces the case where you add surrounding characters, not deleting or replacing which would need to be handled with normal editing commands.

[zetashift]

Before using this I used embrace and this really only replaces the case where you add surrounding characters, not deleting or replacing which would need to be handled with normal editing commands.

As a current embrace user, do you have a snippet/config for easily deleting and replacing pairs?

[Haxxflaxx]

I don't per se. For deleting I use normal meow commands e.g. ", r d o r". This selects in parens, kill selection, select the parens and replace with the previous kill.
I don't find myself changing the surrounding that often so I haven't thought much about it. Maybe something like ", r d { p" so similar to the one before but backspace to remove the previous pair, self insert to provide a new one, then paste the kill like before.

Like I said, these aren't really operations that I do very often, so I don't mind that there are a lot of key presses.
I have been thinking about creating something like a trim function, so you could do something like select bounds of pairs, trim which would delete the outermost characters in the selection but keep the selection active, then wrap with new once.

[zetashift]

Ah I see, thank you! I think I'll keep using embrace for now. But it's nice to see what people can do with this!

[DogLooksGood]

Maybe it's not so convenient. This is what we can do without using an external package:

pair-manipulation.mp4