Использование дженериков для обеспечения корректной структуры во время компиляции

Злоупотребляя системой типов в c #, я могу создать код, в котором компилятор будет применять правило, гарантирующее, что невозможная операция не будет выполнена. В приведенном ниже коде он специфичен для умножения матриц.

Очевидно, что приведенное ниже совершенно непрактично/неправильно, но есть ли причины, по которым мы не можем иметь что-то подобное в c #в будущем, где я мог бы определить тип Matrix<2,2> и обеспечить безопасность компилятором?

Кроме того, существует ли что-либо подобное в каких-либо основных языках? Я подозреваю, что что-то подобное возможно с метапрограммированием на C++??

public abstract class MatrixDimension { }

public class One : MatrixDimension { }
public class Two : MatrixDimension { }
public class Three : MatrixDimension { }

public class Matrix<TRow, TCol>
    where TRow : MatrixDimension
    where TCol : MatrixDimension
{

// matrix mult. rule. N×M * M×P  = N×P 
    public Matrix<TRow, T_RHSCol> Mult<T_RHSCol>(Matrix<TCol, T_RHSCol> rhs)
        where T_RHSCol : MatrixDimension
    { return null;}
}

public class TwoByTwo : Matrix<Two, Two> { }

public void Main()
{
    var twoByTwo = new Matrix<Two, Two>();
    var oneByTwo = new Matrix<One, Two>();
    var twoByThree = new Matrix<Two, Three>();
    var threeByTwo = new Matrix<Three, Two>();
    var _twoByTwo = new TwoByTwo();

    var _2x2 = twoByTwo.Mult(twoByTwo);
    var _1x2 = oneByTwo.Mult(twoByTwo);
    var _3x3 = twoByThree.Mult(threeByTwo);

    var _2x2_ = _twoByTwo.Mult(twoByTwo);

    var invalid = twoByThree.Mult(twoByThree); // compile fails, as expected
}