Quotes of the day:
"Let's support most operators, but not equal and not-equal"
"We'll rename the next version to C# l'eight"
- User-defined operators in interfaces
- return/break/continue as expressions
Let's not allow conversion operators in interfaces, since they are not allowed on interfaces today, even when defined elsewhere.
There'd be no way to override Equals
and GetHashCode
, so you couldn't do ==
and !=
in a recommended way. That's an argument for disallowing. What if we did allow Equals
and GetHashCode
to be overridden in interfaces? That would be a major undertaking, for what seems like modest gains.
However, if we allow <=
and >=
you can get the effect of ==
anyway, through &
. This may or may not be an argument for disallowing more - or maybe all - operators.
Some options:
- Drop operators across the board
- Let's not allow
==
and!=
and see what feedback we get - Let's allow
==
and!=
and see what people use it for
Let's stick with option 2 for now. We'll see from prototype use whether this is an intolerable limitation, but we believe it is a decent place to land.
Conversion and equality are the most useful operators, in that they apply to any domain, whereas most of the other operators are for more specific, often math-related, purposes. If we don't allow them, is it worth allowing the rest?
Let's assume that it is. Those specific domains are likely still important to express in interfaces.
We only even look for operator implementations in interfaces if one of the operands has a type that is an interface or a type parameter with a non-empty effective base interface list.
The applicable operators from classes/structs shadow those in interfaces. This matters for constrained type parameters: the effective base class can shadow operators from effective base interfaces.
Here there could be operators declared in interfaces that are more specific than ones implemented in classes.
We should look at operators from classes first, in order to avoid breaking changes. Only if there are no applicable user-defined operators from classes will we look in interfaces. If there aren't any there either, we go to built-ins.
We hypothesize that there's no case (outside of equality and conversion) where user-defined operators in interfaces shadow predefined operators, but we may be wrong. So that needs to be investigated a bit.
If we find an applicable candidate in an interface, that candidate shadows all applicable operators in base interfaces: we stop looking. This is a bit more complicated than in classes, where it's linear, but we can express it right.
It's been proposed to allow return
, break
and continue
as expressions, the same way we now allow throw
expressions.
There's a bigger discussion of whether we should seek to make C# more expression-oriented, adding a "value" (or at least a classification) for each statement kind, and allowing all or most statements in an expression context. However, this specific proposal does not need to be part of that discussion: we already have throw
expressions, and the potential value of adding these other jump-statements can be evaluated in that narrower context.
There are clearly scenarios that can be expressed more concisely with this feature, but the really compelling ones involve the use of ??
on nullable value types (and presumably on nullable reference types in the future). It provides an elegant way to get at the underlying type without having to more explicitly unpack it:
int z = x + y ?? return null; // where x and y are of type int?
//as opposed to something like
if (x is null || y is null) return null;
int z = (x + y).Value; // explicit unpacking
// or
int? nz = x + y;
if (nz is null) return null;
int z = nz ?? 0; // dummy unpacking
// or using patterns
if (!(x + y is int z)) return null;
The scenarios involving the ternary conditional operator seem less compelling, as they are more easily replaced by a "bouncer" if-statement:
accumulator += (y != 0) ? x/y : continue;
// as opposed to
if (y == 0) continue;
accumulator += x/y;
Yes, it's more concise, but is it more clear?
break
and continue
differ from throw
in that the latter just gets out of there, whereas these affect definite assignment more subtly and locally.
return
feels more like throw
, in that it leaves the whole call context. However, unlike throw
it is normal control flow.
There's something unfortunate about calls like these:
M(Foo1(), Foo2() ?? break, int.TryParse(s, out int x) ? x * 10 : continue);
You start computing arguments and then you decide not to do the call. Wouldn't it have been better (at least more efficient) to decide before starting to compute the arguments? Maybe, but that also leads to more ceremony and less locality of the code.
We are somewhat compelled by the ??
examples. They really do read better than using patterns for nullable things.
Let's have someone champion it, and keep it on the radar.