Deconstructing into index

[dsaf]

Not sure if this is already on the map or if it's just not a good fit for the language:

var grid = new object?[10, 10];

var point = new Point(5, 5);

var cell = grid[point];  // Instead of grid[point.X, point.Y]

public struct Point(int x, int y)
{
    public int X = x;
    public int Y = y;

    public void Deconstruct(out int x, out int y)
    {
        x = X;
        y = Y;
    }
}

Also, some errors of today:

//CS0022	Wrong number of indices inside []; expected 2
var cell = grid[point];

//CS0029	Cannot implicitly convert type 'Point' to 'System.Index'
var cell = grid[..point];

//CS0030	Cannot convert type 'Point' to 'System.Index'
var cell = grid[..(Index)point];

//CS0022	Wrong number of indices inside []; expected 2
var cell = grid[new Index(5)];

//CS0029	Cannot implicitly convert type 'Index' to 'int'
var cell = grid[new Index(5), new Index(5)];

https://learn.microsoft.com/en-us/dotnet/api/system.index

Index is used by the C# compiler...

If, as a language user, I cannot use Index type, then why are you notifying me of it's existence?

[HaloFour]

Sounds like this Grid class should be declared with an indexer that accepts a Point?

There is a discussion on splatting, and this sounds like it would fall under that category: #424

Otherwise it could be a use case for extension indexers.

[dsaf]

Sounds like this Grid class should be declared with an indexer that accepts a Point?

Technically 'yes', but in a way that all syntax sugar is redundant.

There is a discussion on splatting, and this sounds like it would fall under that category: #424

It's probably an extra feature. Like splatting into non-collection method arguments.

Otherwise it could be a use case for extension indexers.

Most likely!

[FaustVX]

👍 for the extension, you can do that: sharplab.io and it will work for every 2D array.

[dsaf]

Most of language syntax sugar can be approximated by (extension) methods and OOP. But we still want syntax sugar.
And the language consistency too - should context matter in how 1, 2, 3, 4, 5 behaves or should it work same way irrespective of context?

[HaloFour]

It's probably an extra feature. Like splatting into non-collection method arguments.

The splatting discussed in that discussion is specifically being able to take a tuple and apply it as the parameters to a method:

int Add(int x, int y) => x + y;

var tuple = (1, 2);
var result = Add(tuple); // splat the tuple as the arguments to the method

That could potentially extend to types that have positional deconstruct methods. Although, in 8 years there hasn't been any interest in this space by the language team, so I think extensions would be the best bet.