Skip to content

Latest commit

 

History

History
148 lines (86 loc) · 5.77 KB

LDM-2017-02-21.md

File metadata and controls

148 lines (86 loc) · 5.77 KB
Raw

C# Language Design Notes for Feb 21, 2017

Agenda

We triaged some of the championed features, to give them a tentative milestone and ensure they had a champion.

As part of this we revisited potential 7.1 features and pushed several out.

  1. Implicit interface implementation in Visual Basic (VB 16)
  2. Delegate and enum constraints (C# X.X)
  3. Generic attributes (C# X.0 if even practical)
  4. Replace/original (C# X.0 if and when relevant)
  5. Bestest betterness (C# 7.X)
  6. Null-coalescing assignments and awaits (C# 7.X)
  7. Deconstruction in from and let clauses (C# 7.X)
  8. Target-typed new expressions (C# 7.X)
  9. Mixing fresh and existing variables in deconstruction (C# 7.1)
  10. Implementing == and != on tuple types (C# 7.X)
  11. Declarations in embedded statements (No)
  12. Field targeted attributes on auto-properties (C# 7.1)

Implicit interface implementation in Visual Basic

Champion "Implicit interface implementation"

This long-requested feature in VB would also help deal with problems related to default implementations of interface members.

Conclusion

Candidate for VB 16.

Delegate and enum constraints

Champion "Generic constraint delegate (or allow System.Delegate as a constraint)"

Champion "Generic constraint enum (or allow System.Enum as a constraint)"

This is a common request. Could

  • semantically require an actual delegate/enum or just allow the base class
  • syntactically show up as either the base class or the keyword

For delegates we need to consider how to deal with MulticastDelegate.

Conclusion

Candidates for a minor C# version.

Generic attributes

Champion "Allow Generic Attributes"

Even though this would work in principle, there are bugs in most versions of the runtime so that it wouldn't work correctly (it was never exercised).

We need a mechanism to understand which target runtime it works on. We need that for many things, and are currently looking at that. Until then, we can't take it.

Conclusion

Candidate for a major C# version, if we can make a sufficient number of runtime versions deal with it.

Replace/original

Champion "Replace/original and code generation extensions"

If there's renewed investment in source generators, we'll add this, but this is not driven from the language end.

Conclusion

Candidate for a major C# version, if and when source generators or similar efforts take place.

Bestest betterness

Champion "Bestest Betterness"

We want to do it, but not low-hanging enough for C# 7.1 time frame.

Conclusion

Candidate for a minor C# release in the 7.X wave.

Null-coalescing assignments and awaits

Champion "Null-coalescing assignments"

Champion "Null-conditional await"

These need a little more design work and general bake time than what 7.1 allows.

await? is an odd kind of keyword, but changing await to not throw on null may also be an issue. Thought needed.

Conclusion

Candidate for a minor C# release in the 7.X wave.

Deconstruction in from and let clauses

Champion "deconstruction in from and let"

Too many worms in the can for 7.1.

Conclusion

Candidate for a minor C# release in the 7.X wave.

Target-typed new expressions

Champion "Target-typed new expression"

Links well with target typed default expressions, but too much design and potential fallout for 7.1. Interaction with anonymous objects as well.

Conclusion

Candidate for a minor C# release in the 7.X wave.

Mixing fresh and existing variables in deconstruction

Champion "Mix Declarations and Variables in Deconstruction"

This rounds out the C# 7.0 experience, and was a late design change we didn't get to implementing.

May lead to occasional confusion, as in M((int x, y) = e) (declaring y)? We are OK with that.

Conclusion

Candidate for C# 7.1.

Implementing == and != on tuple types

Champion "Support for == and != on tuple types"

There's design work. It's not just call .Equals recursively.

== today works between int and byte, for instance. We should probably make (i1, i2) == (b1, b2) work with that same equality.

Also for generics, for a type parameter T and a t of that type, we should allow (t, i) == (null, 0) by recursively applying the special "compare to null" semantics of equality over type parameters of C# today.

Too big for 7.1.

Conclusion

Candidate for a minor C# release in the 7.X wave.

Declarations in embedded statements

Now that you can declare expression variables in an embedded statement, it's odd that old-fashioned declaration statements are forbidden in an embedded position (such as an if-branch, for instance). However, now that you can use a discard instead of a dummy variable declaration, the motivating scenario also goes away.

Conclusion

Let's not do it.

Field targeted attributes on auto-properties

Champion "Auto-Implemented Property Field-Targeted Attributes"

Technically a breaking change, since the field target is already permitted today, but ignored. We don't expect anyone to be relying on this, though!

Conclusion

Candidate for 7.1.