Proposal to Extend C# Array Indexing for Relative Access

[cosmix-pics]

Overview:

This proposal suggests adding a new indexing syntax to C# arrays that allows developers to access array elements relative to the array's length. The primary aim is to enhance readability and reduce common off-by-one errors, especially when working with dynamic arrays whose length might change.

Syntax:

The proposed syntax introduces the / symbol before a number inside the array index, which will act as a shorthand to access elements relative to the array's length.

array[/n]

Where n is the nth part of the array's length.

Examples:

1. Accessing the middle of an array:

int[] values = new int[3];
Console.WriteLine(values[/2]); // Equivalent to values[1]

2. Accessing the third of an array:

int[] values = new int[9];
Console.WriteLine(values[/3]); // Equivalent to values[2]

Benefits:

1. Readability: It provides a clear intention that you're accessing an element relative to the array's length.
2. Avoids Off-by-One Errors: Often, developers make mistakes like accessing the midpoint of an array using length/2 - 1. This syntax would help reduce such errors.
3. Dynamic Length Adaptation: In cases where the array's length may change, using this relative access ensures that the desired position is always accessed without manual recalculations.

Potential Issues and Concerns:

1. Learning Curve: Introducing a new syntax can be confusing to beginners and might take time for seasoned developers to adopt.
2. Backward Compatibility: The new syntax should not break existing code or introduce ambiguous cases.
3. Performance: There should not be any performance penalty for using this shorthand.

Implementation Details:

The C# compiler will be responsible for translating this new syntax into the standard array indexing. It will calculate the actual index at compile-time (for static lengths) or runtime (for dynamic lengths) and replace the new syntax with standard indexing.

For example:

values[/2]

Will be translated to:

values[values.Length / 2]

Conclusion:

By introducing this new array indexing syntax, C# can offer a more expressive and error-reducing way to access array elements relative to its length. This is just a proposal that aims to gather feedback and iterate on any concerns or suggestions.

[cosmix-pics]

In addition to the previously proposed relative array indexing using the / symbol, we suggest extending this feature to work seamlessly with the ^ operator. This would allow developers to access elements from the end of the array in a relative manner.

Proposed Syntax:

array[^/n]

Where n represents the nth part of the array's length from the end.

Example:

int[] values = new int[9];
Console.WriteLine(values[^/3]);  // This would be equivalent to values[6]

[svick]

I don't understand the use cases. When would you want to do this? And what makes you think those use cases are common enough to justify a dedicated language syntax? Especially considering that you can very easily write an extension method that does the same thing, if it's a common operation in your domain.

[cosmix-pics]

Thanks for the feedback! I understand your reservations. Here's a brief rundown:

Readability:

values[/2] or values[^/3] are concise and immediately show intent, like accessing the midpoint or a third from the end.

Error Prevention:

This syntax inherently reduces common off-by-one errors.

Consistency:

C# introduced the ^ operator for end-based indexing. This proposal aligns with that, adding more flexibility.

Performance:

Native syntax can be optimized at the compiler level, potentially outpacing extension methods.

Discoverability:

Language features are more easily discovered and adopted than library-specific methods.
While extension methods are great, native syntax can make common patterns more intuitive.

This has potential use cases in several fields.

Example Working with Date Data analytics:

Suppose you have an array representing stock prices recorded every day for a month.
A month varies in length static indexing is not advised.

double[] stockPrices = GetMonthlyStockPrices();
double midMonthPrice = stockPrices[/2]; //get the price in the middle of the month
double QuarterlyAvgPrice = (stockPrices[/4] + stockPrices[/2] + stockPrices[^/4] + stockPrices[^]) / 4;

Image Manipulation:

Imagine cropping an image to remove the outer thirds:

texture[/3..^/3 , /3..^/3]

This immediately showcases a central cropped region, making the code expressive and self-documenting. This syntax would be especially handy in domains like image processing, graphics, and gaming where dynamic cropping is frequent.
Integrating relative indexing with ranges can make such tasks concise and error-free.

Let me know your thoughts.

[Faolan-Rad]

Ranges aren't supported by multi dimensional array which is a problem in the texture example. Currently from what I know which would be nice cuz It could be used with matrix arrays you can pull the underlying matrix like pulling a 3x3 from a 4x4. From what I know data analytics is used in almost every field like for performance analytics and stuff and I've personally had to use it cuz when you come to monitoring 1% lows in game I was keeping track of the last 100 frame times would have another array as the sorted version and would need to know what the 10th section is of the sorted one or 100th section I do understand that this is not a completely accurate representation of 1% but in game dev it provides I quick way to put a number to lag spikes

[huoyaoyuan]

I don't understand how it's readable. I can't map array[/n] to array[array.Length/n-1] with my mind.

What will be the result if Length isn't divisible by n?

How to represent the positions at 2/n, 3/n, 4/n? 1/n isn't special.

[cosmix-pics]

Not sure where you are getting array.Length/n-1 it would be floor(array.Length/n) Due to casting to an index.