mini.cycle idea for next and previous operation

[Sreinumder]

Current Workflow with dial.nvim

I currently use dial.nvim for my advanced needs.
I myself like to think and group the patterns for cycling into group like alphabets, numbers, dates, time, words, logical etc.
and assign a letter for each and follow the general pattern of
<leader>+i+(character) for incrementing
<leader>+u+(character) for decrementing

Showcase

Feature request that are not present currently in dial.nvim

Operator for changing next or previous pattern

<c-a> equivalent

          cursor here
               V
  (x           |y           z)
   |            |           |
   v            |           v
 `<leader>ila]`    v      `[<leader>ina`
          `<leader>ia`

1. <leader>ia increments this or closest next alpha (alphabet): y->z
2. <leader>ila increments last alpha : x->y
3. <leader>ina increments next alpha : z->a

similarly, <leader>ua decrements this or closest next alpha.

Count Handling:
(c)<leader>i(n)na
increment the nth next pattern c times

example:
2<leader>i7nu

before: 1 |1 1 1  1 1 1 1  1 1 1 1
after:  1 1 1 1  1 1 1 3|  1 1 1 1

g<c-a> equivalent

How count is handled for:
(c)g<leader>i(n)na
increments every pattern until nth next pattern c times

example:
g<leader>i7nu

before: 1 |1 1 1  1 1 1 1  1 1 1 1
after:  1 2 3 4  5 6 7 8|  1 1 1 1

2g<leader>i7nu

before: 1 |1 1 1  1 1 1 1  1 1 1 1
after:  1 3 5 7  9 11 13 15|  1 1 1 1

Operator for finding or selecting next or previous pattern

<leader>Inu finds and selects next number pattern
<leader>I2na finds and selects 2nd next alphabet pattern
<leader>Ill finds and selects last logical pattern
<leader>I3ld finds and selects 3rd last date/day pattern

Use it as textobject

Additonally we can now treat these cycleable patterns as an textobject.
and combine them with operators like:
d<leader>Inu to delete next number group pattern
d<leader>Iu to delete current or next number group pattern
c<leader>Ilw to delete next word group pattern

[echasnovski]

Huge thanks for detailed suggestion! I haven't thought deeply about 'mini.cycle' yet, so this is valuable.

My initial thoughts were something along these lines:

• Extend <C-a> and <C-x> to apply on customizable Lua patterns. So that user can configure array of patterns with their replacements and those will be searched in order (similar to how 'cover_or_next' search method works in 'mini.ai').
• OR provide custom operators (like g< / g> or g- / g+) that would "increase" and "decrease" explicit target (textobject or motion) based on pre-defined set of rules. So it would try rules one by one and apply the transform if target matches some Lua pattern.

The second approach is cleaner but lacks the usability of "cycle at cursor" type of workflow when it automatches cycleable object at cursor.

---

The idea in this suggestion is a bit more involved and closer resembles 'mini.surround' / 'mini.ai' in a sense of providing the interface for custom "cycleable" objects (with maybe a set of predefined ones). This is not necessarily a bad thing (as there are two modules with same workflow which can reuse some code), but I am not yet sure if I want to follow that path, as the code is quite complex.
But the following interface does indeed look interesting (I am just rewording for my future self here):

• Type g< or g> followed by a cycleable identifier (l for logic, t for time, etc.). This will search like 'cover_or_next' (probably only at current line) for patterns in that cycleable identifier and then apply transform.
• Type g<< / g>> to apply the same search and replace but search all identifiers for covering match first and then all identifiers for "next" match. These are <C-x> and <C-a> alternatives.
• [count] can be used to adjust how many times "match and replace" is done.
• Not sure how to fit here alternatives for g<C-x> and g<C-a>.
• Using "next" and "last" seems to be both overcomplicating things and not working well with l and n identifiers for "logic" and "number".