How to jump to the matching bracket?

[ideasman42]

When reading through the commands I didn't see a way to jump to the matching bracket (% with VIM). Is this possible with meow?

[DogLooksGood]

Use meow-block to select the paired parentheses, then you get the positions of the beginning and the end of brackets.

Or use meow-bounds-of-thing to separately select round, square and curly parentheses.

[ideasman42]

Is it possible to do this without selection? Just to move the cursor to the matching bracket?

I'm trying to do this and can't figure out the steps you describe, what commands exactly would be needed to move the cursor to the matching bracket and clear the selection?

[eshrh]

not sure if you're aware already, but emacs comes with C-M-f and C-M-b (forward-sexp) and (backward-sexp).

maybe you're not interested in my janky config for paren jumping, but i use something like this

(defun jump-matching-pair ()
  (interactive)
  (cond ((looking-at "\\s\(") (forward-sexp) (backward-char 1))
        ((looking-at "\\s\)") (forward-char 1) (backward-sexp))))

(only really looks intuitive with a block cursor imo)

you can bind this to a key, % even: (meow-normal-define-key '("%" . jump-matching-pair)

[ideasman42]

Thanks for the reply, maybe this should be accepted as an answer, I was hoping meow would have this available without having to add support for the feature. While it's not a problem to do this... I'm looking into switching away from evil to other modal editing options, if they don't do things I'd consider basic / fundamental, it makes me question why use them compared to (for example), changing key-bindings for evil-mode or having my own customized configuration.

Of course it's disputable if this should be considered a fundamental feature or not... my assumption was that alternatives might support this, I use it regularly for navigating code.

[eshrh]

Yeah i get it, and that's totally fair. In my opinion, the evil/vi idea is to absolutely pack the keyboard with functions, a subset of which you'll find useful. There's a reason why vi/evil is so well liked, you can get damn efficient because there's just so much. In my opinion, meow is a strongly minimalist system that favors consistency, mnemonic, concision and simplicity over pure efficiency.

I mean, look at how there aren't dedicated keys for first non whitespace char in line and end of line (^ $), imo very fundamental binds. Instead, you've got meow-join and meow-line which double for those functions via a selection (^i in vim is ma in qwerty meow). There's a strong emphasis on the idea that if something might be more efficient or useful but doesn't adhere to this kind of consistency then it should be something that the user adds manually. Swapping between parens is a pretty one-off kind of command, it doesn't compose particularly well. I could list off a few other command in this category (duplication, case modification). I might even mention i found duplication so fundamental that I tried to put it in at one point (#213), so at least in that regard I completely get where you're coming from.

I think I'd agree that paren movement is fairly fundamental. What dlg was trying to say above was this:

(message| "Hello World")

where | is your point (cursor's left edge).

Now, to jump to the beginning of the sexp, from anywhere, you press meow-block (o) and now you have an option of inserting at the beginning or the end (i or a). Your cursor is automatically at the end, but pressing meow-reverse (;) will put your cursor at the beginning without inserting. The fact that your selection is still active probably won't even affect anything you are likely to do there, but you can obviously just cancel it.

Personally, i think this is a pretty bad solution, it's too many keys and too much thinking for a very intuitive action. I don't, and hope you don't settle for this. But, I hope it gets at the kind of consistency that meow aims to maintain. Selection and movement are inherently linked, and each selection is highly multipurpose. The entire program is actually built around this interpretation of the selection, and it defines how almost everything is done. As a direct result of this conscious choice, one-off modification commands will never fit in place, no matter how useful they are.

However, in my opinion the whole ethos of emacs itself is to deeply customize your tools. I'm not even trying to argue that the above consistency is even good, the real reason i like meow is because it's an extraordinarily sane base to hack on. That kind of simplicity and consistency is perfectly ok, because it means that it's trivial to optimize. Find yourself typing .b to select the whole buffer a lot? Just bind a key straight to that: '("&" . (lambda () (interactive) (meow-bounds-of-thing 'buffer))). Have a set of commands that are tightly bundled together (org commands, paredit)? You can even define a whole custom modal state for it! Emacs as a program is only as powerful as it is because lots of people wanted to optimize lots of things and enjoyed that kind of deep optimization.

I get that this is clearly a super opinionated take, and certainly not everyone agrees with it, many people like the vim ethos of "here are your defaults, you will use them and you will like them" batteries-included kinda thing, which is totally fine (if a bit heretic).

basically, this is minimalist and opinionated software that enables and encourages deep customization.

[ideasman42]

not sure if you're aware already, but emacs comes with C-M-f and C-M-b (forward-sexp) and (backward-sexp).

maybe you're not interested in my janky config for paren jumping, but i use something like this

(defun jump-matching-pair ()
  (interactive)
  (cond ((looking-at "\\s\(") (forward-sexp) (backward-char 1))
        ((looking-at "\\s\)") (forward-char 1) (backward-sexp))))

(only really looks intuitive with a block cursor imo)

you can bind this to a key, % even: (meow-normal-define-key '("%" . jump-matching-pair)

Testing this I ran into a problem, (backward-sexp) navigates to before the opening parens (for quoted lisp expressions), so

'(1 2 3) moves the cursor to the ' and not the (.

Using (backward-list) resolves the issue.

This function allows the meow-reverse key to double-up as a jump-to-matching bracket function. As meow-reverse only works with a selection, it fails with an error when there is none - so no functionality is lost. Although it's possible users might want to run this function with a selection, so in that case a separate function would be handy.

(defun my-meow-reverse-or-jump-matching-pair ()
  (interactive)
  (cond
   ((region-active-p)
    (call-interactively 'meow-reverse))
   (t
    (cond
     ((looking-at "\\s\(")
      (forward-sexp))
     ((looking-back "\\s\)")
      (backward-list))))))

[mgraham]

I spent a bunch of time trying to figure out how evil does its matching, but then I realized I was more accustomed to the richer feature set of Evil Matchit. This is mainly because I spend most of my time in ruby-mode and want % to toggle between do...end and case...when...end, etc.

Well it turns out you can use Evil Matchit without Evil!

So this is what I do:

(use-package evil-matchit)
(require 'evil-matchit)

(meow-define-keys 'normal
  '("%" . evilmi-jump-items-native)
  ;; ... other bindings
)