[Proposal] where expression

[fawdlstty]

It is recommended to add a WHERE expression. The purpose of the new expression is to allow an expression in the constraint operator to be evaluated as a value.Like the usual operator (+-*/%)

public class Foo {
    public static T add<T> (T a, T b) where [T + T] {
        return a + b;
    }
}
public class Foo1 {
    public static T opera<T> (T a, T b) where [T + T], [T - T], [T * T, [T / T], [T % T] {
        return a + b;
    }
}



Foo.add (1, 2); // compile success
Foo.add (1.2, 2.6); // compile success
Foo.add (new object (), new object ()); // compile failure

public class Bar {
    public int val = 5;
    public static Bar operator + (Bar a, Bar b) {
        return new Bar { val = a.val + b.val };
    }
}
Foo.add (new Bar (), new Bar ()); // compile success

public class Bar1 {
    public int val = 5;
    public static Bar1 operator - (Bar1 a, Bar1 b) {
        return new Bar1 { val = a.val - b.val };
    }
}
Foo1.opera (new Bar1 (), new Bar1 ()); // compile success
Foo.add (new Bar1 (), new Bar1 ()); // compile failure

Existing problem: There is no constraint that can directly make T type do mathematical operation, so it must be cast to dynamic, but cast or method directly accept dynamic type, which may make the type that cannot do mathematical operation can also be passed as a parameter, unable to check the code statically

the proposal can fix this problem

[yaakov-h]

Seems like something better solved by Shapes (#164).

[juliusfriedman]

How about a little something different here cause I sorta like this...

public class Foo {
    public static T add<T> (T a, T b) where T : [virtual] operator(+, -, *, /, %)
        return a + b;
    }
}
public class Foo1 {
    public static T opera<T> (T a, T b) where  [virtual] operator(+, -, *, /, %)
        return a + b;
    }
}

(the virtual can be committed and indicated derives is allowed, in or out would probably be used for that.)

public class Foo {
    public static T add<out T> (T a, T b) where T :  operator(+, -, *, /, %)
        return a + b;
    }
}
public class Foo1 {
    public static T opera<in T> (T a, T b) where T : operator(+, -, *, /, %)
        return a + b;
    }
}

Beats something liek this maybe:

Number

[juliusfriedman]

Seems like something better solved by Shapes (#164).

Or Roles right? Definitely note Records :P

[fawdlstty]

where T : [virtual] operator(+, -, *, /, %)

@juliusfriedman how to recognition i++ or ++i？

[333fred]

#1711 is the current issue for static interface members and roles, which is what we're looking at for this space. This issue itself is mostly a duplicate of #3333, so I'm going to close it out and direct discussion to one of those two.