[Proposal]: Allow struct to return instance members by reference (avoid CS8170)

[Thaina]

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Introduce new syntax to have ref return function and property and indexer possible to return field of struct

Motivation

Main motivation is to allow access to reference of struct member by function and indexer

Take Matrix for example. It would be convenient to access matrix with index like so

public struct Vector4
{
    public float X,Y,Z,W;
    public in float this[int i]
    {
        get
        {
                if(i == 0)
                    return ref X;
                if(i == 1)
                    return ref Y;
                if(i == 2)
                    return ref Z;
                if(i == 3)
                    return ref W;

                throw new ArgumentOutOfRangeException("i");
        }
    }
}

public struct Matrix4x4
{
    public Vector4 Row0,Row1,Row2,Row3;
    public in Vector3 this[int i] // return vector by ref
    {
            if(i == 0)
                return ref Row0;
            if(i == 1)
                return ref Row1;
            if(i == 2)
                return ref Row2;
            if(i == 3)
                return ref Row3;

            throw new ArgumentOutOfRangeException("i");
    }

    public in float this[int i,int j] => this[i][j]; // vector by ref and access with its ref indexer
}

////

Matrix4x4 m;
foreach(var i in 0..4)
    m[i,3] = 5; // set M14,M24,M34,M44 to 5

Detailed design

As the example above. I think it should be possible to use some keyword, in in this case, as a replacement of ref. It actually just normal ref return but with a difference marker to let the stack know that, the returned reference will be a reference of that struct instance field itself, so it still return error CS8170 if trying to return it over the stack that instantiate it

For example, with the same Matrix4x4 above

public static class SomeClass
{
    public static ref float Get(int i,int j)
    {
        var m = Matrix4x4.Identity;
        return ref m[i,j]; // still error CS8170 because this reference is came from `in` function
    }
}

This would also allow interface member to be defined as the reference of the field

public interface IMatrix<T>
{
    int Width { get; }
    int Height { get; }
    in T this[int i,int j];
}

public static class MatrixExt
{
    public static float? Determinant<M>(in this M matrix,int i,int j) where M : struct,IMatrix<float>
    {
        if(matrix.Width != matrix.Height)
            return null; // no determinant

        // implement formula to calculate determinant of arbitrary matrix
        
    }
}

public struct Matrix2x2 : IMatrix<float>
{
    public Vector2 Row0,Row1;
    public in Vector3 this[int i] // return vector by ref
    {
            if(i == 0)
                return ref Row0;
            if(i == 1)
                return ref Row1;

            throw new ArgumentOutOfRangeException("i");
    }

    // implement interface
    public int Width => 2;
    public int Height => 2;
    public in float this[int i,int j] => this[i][j];
}

public struct Matrix3x3 : IMatrix<float>
{
    public Vector3 Row0,Row1,Row2;
    public in Vector3 this[int i] // return vector by ref
    {
            if(i == 0)
                return ref Row0;
            if(i == 1)
                return ref Row1;
            if(i == 2)
                return ref Row2;

            throw new ArgumentOutOfRangeException("i");
    }

    // implement interface
    public int Width => 3;
    public int Height => 3;
    public in float this[int i,int j] => this[i][j];
}

public struct Matrix4x4 : IMatrix<float>
{
    public Vector4 Row0,Row1,Row2,Row3;
    public in Vector4 this[int i] // return vector by ref
    {
            if(i == 0)
                return ref Row0;
            if(i == 1)
                return ref Row1;
            if(i == 2)
                return ref Row2;
            if(i == 3)
                return ref Row3;

            throw new ArgumentOutOfRangeException("i");
    }

    // implement interface
    public int Width => 4;
    public int Height => 4;
    public in float this[int i,int j] => this[i][j];
}

// and so on for any matrix with arbitrary size

////

Matrix2x2 m2x2;
Matrix3x3 m3x3;
Matrix4x4 m4x4;

var m2d = m2x2.Determinant(); // same implementation of determinant function
var m3d = m3x3.Determinant();
var m4d = m4x4.Determinant();

Drawbacks

I don't think there is any?

Alternatives

Extension method is the closest possible solution but it not as flexible as it not allow implementing for interface, maybe unless something like trait also exist too?

Unresolved questions

If the in keyword would be confused then what could be?

Design meetings

Also related to #2107

[huoyaoyuan]

This already of a part of #3936.
Struct lifetime must be dealed very carefully.

[Thaina]

@huoyaoyuan That's why I propose an alternative that we should keep the same behaviour of ref return as is but using another keyword to be used in this case

In the presense of difference keyword, the compiler would be able to distinguish that it need to treat any value returned from that function in the same way as reference to the field value directly. And deal with it in the same lifetime of ref of the field of struct itself

And as I present in the issue, with this we could declare interface in the same way, so we could write generic method with this constraint, for arbitrary operation and access with struct

[huoyaoyuan]

In the presense of difference keyword, the compiler would be able to distinguish

There's no difference with adding a new attribute. Abusing keyword is strictly avoided.

[Thaina]

@huoyaoyuan If the attribute could enforce compiler if specified on interface and also force the struct to implement this function to also declare the same attribute then I would be satisfied, will it though?

[YairHalberstadt]

Why would it be useful for an interface to be able to constrain the method in this way?

[Thaina]

@YairHalberstadt The major use case of this feature I would like to have is as the sample above. The ability to declare an arbitrary size vector and matrix struct, then I could write one generic extension method for every of them

I could made a struct that could act like 34 dimension float vector. And a struct that act like 34x11 dimension float matrix

And then I could write a dot product as extension method that constraint with IVector and IMatrix, that dot product generic function could take any struct. Also anythings that a vector could do, I then could have my struct do vector and matrix algebra directly

In my opinion this is the major use case of generic constraint in general. We can have interface as contract for struct to implement, then we can write any generic function to act on any struct with the same contract and same pattern efficiently. The current hindrance to efficiency of this method is that, we can't have struct return ref of its field from the generic constraint function

[CyrusNajmabadi]

Could you link to a gist showing what you would like to write here?

[Thaina]

@YairHalberstadt Or did you mean, why interface should also declare that its function is return the ref of the struct field?

Then it was also because this exact use case, generic constraint with where T : struct,Interface. If we don't have something to constraint method then isn't it allow leakage of ref struct?

public static ref float GetRef<T>() where T : IVector
{
    var v = new T();
    return ref v[0]; // is this fine?
}

[Thaina]

@CyrusNajmabadi Do you mean my Dot function?

I would like to reuse all of my IMatrix and IVector struct above then

public static class VectorExt
{
    public static float Dot<V>(in this V l,in V r) where V : struct,IVector
    {
        float sum = 0;
        int i = 0;
        while(i < l.Size)
        {
            sum += l[i] * r[i];
            i++;
        }

        return sum;
    }

    public static float Dot<V0,V1>(in this V0 l,in V1 r)
        where V0 : struct,IVector
        where V1 : struct,IVector
    {
        if(l.Size != r.Size)
            throw new ArgumentOutOfRangeException("vector Size");

        float sum = 0;
        int i = 0;
        while(i < l.Size)
        {
            sum += l[i] * r[i];
            i++;
        }

        return sum;
    }

    public static void Dot<V,M,R>(in this V vector,in M matrix,out R result)
        where V : struct,IVector
        where M : struct,IMatrix
        where R : struct,IVector
    {
        if(vector.Size != matrix.Width)
            throw new ArgumentOutOfRangeException("vector Width");
        if(result.Size != matrix.Height)
            throw new ArgumentOutOfRangeException("result Height");

        result = new R();
        int i = 0;
        while(i < r.Size)
        {
            result[i] = vector.Dot(matrix[i]); // vector dot vector using above extension method
            i++;
        }
    }
}

////

struct MyInputVector : IVector
{
    // 34 float
}

struct MyMatrix : IMatrix
{
    // 34x11 float
}

struct MyOutputVector : IVector
{
    // 11 float
}

////

var input = new MyInputVector();
var matrix = new MyMatrix();

input.Dot(matrix,out MyOutputVector output); // Dot<V,M,R> => Dot<MyInputVector,MyMatrix,MyOutputVector>

something like this

[CodingMadness]

Anything new about this topic, since it was not closed since then?

[333fred]

There is nothing new on this topic. As per our README, I'm converting this to a discussion topic.

[RikkiGibson]

[UnscopedRef] permits returning this by reference.

[sgf]

[UnscopedRef] permits returning this by reference.

Yes, agreed, the issue has been implemented.

provide-unscoped
Adding the [UnscopedRef] attribute will solve this problem.