IIndexable<T>

[CaseyHofland]

I'm doing some work on creating generic heatmaps and one thing I need to do is transform a Vector (float) to a Point (integer).

In making my solution generic, I was really surprised that the only thing I needed for my Points to implement this:

    /// <summary>Indexer provider for value types of immutable length.</summary>
    public interface IIndexable<T> : IEnumerable<T>
    {
        static abstract int Count { get; }
        T this[int index] { get; set; }
    }
    
    public struct Point2 : IIndexable<int>
    {
        public int X;
        public int Y;
        
        public static int Count => 2;
        
        public IEnumerator<int> GetEnumerator()
        {
            yield return X;
            yield return Y;
        }
    }
    
    public struct Point3 : IIndexable<int>
    {
        // ...
    }

@tannergooding I think this could benefit generic vectors (floating or integer) a lot, since it abstracts the IVector<TSelf> implementation from the underlying numeric value. It could also be used on matrices and quaternions.

[huoyaoyuan]

The API itself is very similar to IList<T>. However, for primitive types like points, such interface usage would be very inefficient. Instead, the common approach is to cast the point into Span<T>.

[CaseyHofland]

You got me there, I'm still new to Span<T>. Nevermind, thanks for teaching me 🙏

[CaseyHofland]

I am wondering if there is some kindof interface for getting a Span, something like ISpanable<T>. I have looked around but nothing shows up.

Even if IIndexer<T> is inefficient I still think there's a huge benefit of having some common interface exposing a static abstract int Count. Right now I need to write an implementation that manipulates points and vectors and it shouldn't care about what point or vector it is, just what Count it has. Generic math was a great first step, but generic vector math would need this, whether you would use it to look up indices or create a Span<T> out of.

[huoyaoyuan]

It sounds related to the const generics proposal and fixed size arrays. There's no convenience at present.