Text object for a symbol and its sub- and superscripts

[rsekman]

Is your feature request related to a problem? Please describe it.

Anyone who's used TeX for some time will have used sub- and superscripts like $ Cx_0^{1/2} y $. Since the whole of x_0^{1/2} is semantically one object, it would be extremely convenient to have a text object corresponding to it, say ax. (The exact binding is immaterial, of course.)

Describe the solution you'd like

With the cursor anywhere between x and }, inclusive, in the example above, vax selects x_0^{1/2}.

For nested su*scripts, say, e^{ a x^3} with the cursor anywhere in x^3, vax selects x^3, on e^ it selects e^{ a x^3}, and with the cursor inside the {}, va{ax also selects everything.

For something like \sin^2 x, vax could be used to select \sin^2.

Describe alternatives you've considered

For me, this would mostly replace various mashing of a{WB fF etc.

The vim-textobj-user plugin can probably be used to implement this, but since it is such a common task when editing TeX, I think it makes sense for it to be provided in vimtex. We already have ac, a$ etc.
One possibility would be an optional dependency on vim-textobj-user.

[lervag]

Thanks, this is an interesting suggestion. First, is there a similar (well defined!) ix variant?

So, the main problem here is to properly define the relevant "atoms". The *script is "easy", I think, because it should suffice to either match e.g. ^a, ^\symbol, ^\cmd{...}, or ^{...}. That is, I don't think there are more than four cases here. However, it is slightly more challenging for the "main" atom. I think these are the possible cases:

1. a^
2. \symbol^
3. \cmd{...}^
4. (parens)^ (preceeding whitespace)
5. func(parens)^ (here func can be a letter or a \symbol)
6. perhaps also variants with {...}^ and [...]^?

Do you agree, am I missing something?

[lervag]

Oh, and of course, the "main" atom could also already have a sub or superscript. So, the algorithm would match like this:

1. detect "main" atom
2. detect subscript or superscript; if matched go to 3.
3. detect superscript or subscript

[rsekman]

Thanks, this is an interesting suggestion.

I'm glad you like it, I was a little worried this would be a "why don't you just [horribly complicated thing]" suggestion because of edge cases.

First, is there a similar (well defined!) ix variant?

I don't really know. It could be the su*scripts themselves. If you want the kernel letter or symbol that's usually covered by ac, aw, or even just l. I can see situations where you would want to yank a su*script on its own, say you were editing something like:

$a = b+c$ therefore $a^{1 + 3x} = (b+c)^{1 + 3x}$

With the cursor on 3, vax would select ^{1 + 3x}. In a_k^{1/3}, we would select _k^{1/3}. In many cases this would be almost synonymous to a{, but that's not necessarily a problem.

5. `func(parens)^` (here `func` can be a letter or a `\symbol`)

Distinguishing between f(x + a) (the function f evaluated at x + a) and f(x+a) (f multiplying (x + a) is something humans can do from context, but Vim can't. I think it's best to not include f in the selection in this case. If that's what the user wants, they can ob.

6. perhaps also variants with `{...}^` and `[...]^`?

Do you agree, am I missing something?

I think anything ad selects should fall under 6., for example \left( 1 + \frac{a}{b} \right)^3

[lervag]

First, is there a similar (well defined!) ix variant?

I don't really know. It could be the suscripts themselves. If you want the kernel letter or symbol that's usually covered by ac, aw, or even just l. I can see situations where you would want to yank a suscript on its own, say you were editing something like:

Hmm, yes, I guess ix would typically be very similar to something like a} or a}oh, and so it might be redundant. In any case, let's focus on the ax idea first.

$a = b+c$ therefore $a^{1 + 3x} = (b+c)^{1 + 3x}$

With the cursor on 3, vax would select ^{1 + 3x}. In a_k^{1/3}, we would select _k^{1/3}. In many cases this would be almost synonymous to a{, but that's not necessarily a problem.

Huh, then I've misunderstood. I thought you wanted vax to match a^{1 + 3x}? I.e.,

Since the whole of x_0^{1/2} is semantically one object, it would be extremely convenient to have a text object corresponding to it, say ax

Or did you mean to write vix as a continued argument here?

5. `func(parens)^` (here `func` can be a letter or a `\symbol`)

Distinguishing between f(x + a) (the function f evaluated at x + a) and f(x+a) (f multiplying (x + a) is something humans can do from context, but Vim can't. I think it's best to not include f in the selection in this case. If that's what the user wants, they can ob.

Agreed. Good point.

6. perhaps also variants with `{...}^` and `[...]^`?

Do you agree, am I missing something?

I think anything ad selects should fall under 6., for example \left( 1 + \frac{a}{b} \right)^3

Yes, agreed. But, this does make the matching difficult. Consider

\left( 1 + a^{1 + x} \right)^{1 - x}

Here vax should match a^{1 + x} as long as the cursor is within this part, and it should match the entire string if it is anywhere else within the nested part.

\left( 1 + a^{1 + x} \right)

The same applies here.

a^{\left( 1 + b \right)}

With cursor on 1, vax would match the same as vad. This seems inconvenient, or is it just a natural consequence of the definitions?

[rsekman]

With the cursor on 3, vax would select ^{1 + 3x}. In a_k^{1/3}, we would select _k^{1/3}. In many cases this would be almost synonymous to a{, but that's not necessarily a problem.

Huh, then I've misunderstood. I thought you wanted vax to match a^{1 + 3x}? I.e.,

Ah, yes, I meant vix.

Yes, agreed. But, this does make the matching difficult. Consider

\left( 1 + a^{1 + x} \right)^{1 - x}

Here vax should match a^{1 + x} as long as the cursor is within this part, and it should match the entire string if it is anywhere else within the nested part.

\left( 1 + a^{1 + x} \right)

The same applies here.

I think if the cursor is on 1 we should only match 1: 1 is an atom with empty sub- and superscripts. What we should do when the cursor is on whitespace is more ambiguous, but I think your idea is correct: match the whole string in these examples.

a^{\left( 1 + b \right)}

With cursor on 1, vax would match the same as vad. This seems inconvenient, or is it just a natural consequence of the definitions?

I think it's a natural consequence of what we're aiming at. It's not that uncommon that the same selection can be described by several text objects, say {1/3} can be selected by all of a{, aW, ad.

[lervag]

I'm sorry about the lack of progress here. I've tried to summarize things for myself, but I would appreciate a comment from you. Does the following sounds sensible?

Let's first focus on the ax variant only, we can consider to look into ix at a later time.

To make it easier both for testing and to understand where we want to go, I've made a map of objects and how they respond to dax when the cursor is on top of the character before the | symbol:

C|x_0^{1/2} y             -> x_0^{1/2} y
Cx|_0^{1/2} y             -> C y
Cx_0^{|1/2} y             -> C y
e|^{a x^3}                ->
e^{a| x^3}                -> e^{ x^3}
e^{a x|^3}                -> e^{a }
\si|n_k^{a x^3}           ->
\sin_k^{a| x^3}           -> \sin_k^{ x^3}
\sin_k^{a x|^3}           -> \sin_k^{a }
( as|d )^{...}            -> ( ad )^{...}
( asd )^{...|}            ->
\left( as|d \right)^{...} -> \left( ad \right)^{...}
\left( asd \rig|ht)^{...} ->
\left( asd \right)^{|...} ->

A pseudo algorithm:

0. Check if cursor is in math mode: abort if not.
1. First detect the current word or command (e.g. asd or \sin). This should look back to the previous word boundary or \.
2. Look forward to capture possible _ and ^ groups.
3. If the detected atom contains the original cursor position: success.
4. If not, then move active cursor position to the position before the boundary detected in step 1 and repeat from step 0.

[rsekman]

No worries about the lack of progress, I've enjoyed vimtex plenty in the meantime without this.

These all seem reasonable to me. If and when this is implemented, it would be a good idea to include these examples in the documentation.

[lervag]

These all seem reasonable to me. If and when this is implemented, it would be a good idea to include these examples in the documentation.

Agreed!

[lervag]

I'm looking at this thing again. I've tried to summarize it, yet another time. We are looking for constructs like this:

    a^{...}_{...}
 \cmd^{...}_{...}

Algorithm:

0. Stop if we are not in math region
1. Find the start: command (preceding ) or single character symbol preceded by another word character or whitespace
2. Look forward for attached ^ or _ groups
3. The resulting region from symbol or command start to last group is a candidate region
4. If candidate region does not contain the cursor position or is "trivial" (only a single character): move active cursor position to the position before the candidate region and repeat from step 0.

I've added the "trivial" condition, because I think it will help make this more useful. Else it will typically match single symbols when what you really wanted was to match the "parent" symbol. E.g., for e^{2kn/N}_0, if the cursor is within the braces, we want ax to match the entire e^..., not only k or n, and so on.

What do you think?

[lervag]

I've made the skeleton part and added some tests and docs. The hard work remains, but I think I have some good ideas.

[lervag]

The PR #2025 is opened, but note that it is not ready for testing yet. I'll let you know.

[rsekman]

E.g., for e^{2kn/N}_0, if the cursor is within the braces, we want ax to match the entire e^..., not only k or n, and so on.

Yes, this is very reasonable. If we wanted 2kn/N or {2kn/N}, we would use i} or a{. Is there any work I can do to make #2025 ready for testing?