Add ordinal scope types

[pokey]

So could say "take next dollar fine" to select the first $ after the given token. Could also say "<ordinal> <symbol>", eg "second dollar".

In addition, could support "next line fine", "third line fine", etc, as well as "next funk fine", etc

For convenience, potentially "down <number>" could be alias for "<ordinal> line".

Would need to support other direction as well, eg "take last dollar fine", or "take second to last dollar fine", tho the latter is a bit verbose

Use "prior" for opposite of "next"

We should also figure out compact grammar for the following:

• Support simple relative and absolute ordinal scope modifiers #982
• Scope and next scope
• Scope and next two scopes
• Every scope from scope through end of iteration scope
• Every scope from scope through start of iteration scope
• Scope and previous scope
• Scope and previous two scopes
• Target past next scope
• This past next scope
• Target past previous scope
• This past previous scope
• Target past next two scopes (might not need to be compact)
• How to make these work with "next <symbol>" eg "next comma"
• How to make these work with "next instance <target>" for selecting next occurrence of a target
  • Does this work for any target or just mark?
  • Where does it start searching? At <target> or cursor or able to search from a different target?

"next <mark>"

It should always be next instance of given mark's text relative to input. So eg if there is a token "hello" with a hat over the h, then "next harp" will select the next instance of hello after the cursor

Should support "every", "first", etc for these as well

Note that for things like :, ,, ), etc, we don't really care about the token that has the hat because it will always just be the one character, so it will behave like we want anyway. For failure modes of this assumption (eg < and <=), we can add something like glyph modifier or something in the future if that becomes a problem

Plurals

Where plurals make sense (eg "three funks"), vendor in the following sections of inflection:

• https://github.com/jpvanhal/inflection/blob/master/inflection/__init__.py#L1-L141
• https://github.com/jpvanhal/inflection/blob/master/inflection/__init__.py#L284-L306
• https://github.com/jpvanhal/inflection/blob/master/inflection/__init__.py#L419-L426

And have csv overrides code generate a list called foo_plural if you pass in a flag asking for plurals

Some proposed spoken forms:

[AndreasArvidsson]

I would really like the down 3 aproach as well. Then we could do stuff like:

take up 5
chuck down 5
take up 5 past down 2
take up 5 past blue air
move funk blue air to down 5

[pokey]

@AndreasArvidsson Yes and given it's a transformation rather than a mark we can also say "take fine up 5 past down 2"

[AndreasArvidsson]

@auscompgeek Had a really interesting idea "take every third funk"

[pokey]

@auscompgeek Had a really interesting idea "take every third funk"

What would that do?

[pokey]

Proposed shape: let's use the thing we have today with modifications; see #13 (comment)

interface OrdinalScope {
    type: "ordinalScope"

    scopeType: ScopeType; 

    /* The start of the range.  If negative, go backwards from selection if {@link isRelative} is `true`, or start from end of iteration scope if not. */
    start: number;

    /* The number of scopes to include.  Will always be positive.  If greater than 1, will include scopes after {@link start} */
    length: number;

    /* Whether to be relative to target or relative to iteration scope */
    isRelative: boolean;

    /** Indicates that the range should have anchor and active reversed.  If `undefined`, inherit direction from input to this modifier */
    isReversed?: boolean;
}

[pokey]

Fwiw this is the version of the type today:

cursorless/src/typings/targetDescriptor.types.ts

Lines 179 to 186 in da757c2

	export interface OrdinalRangeModifier {
	type: "ordinalRange";
	scopeType: ScopeType;
	anchor: number;
	active: number;
	excludeAnchor?: boolean;
	excludeActive?: boolean;
	}

Maybe we just add isRelative to that and be done with it?

Keep in mind that if it is absolute, we need to look at whether input has explicit range to decide whether it's iteration scope vs input range