Add LDM notes for June 22, 2020

meetings/2020/LDM-2020-06-22.md

@@ -0,0 +1,104 @@
+
+# C# Language Design Meeting for June 22, 2020
+
+## Agenda
+
+1. Data properties
+
+1. Clarifying what's supported in records for C# 9
+
+    - Structs
+
+    - Inheritance with records and classes
+
+## Discussion
+
+### `data` properties
+
+We've been working on an implementation for data properties and have some questions about
+modifiers, which are currently not allowed.
+
+There are some modifiers that could be legal, like `new`, `abstract`, `virtual`, and `override`.
+Some of these, especially `new` and `override` would probably prevent `data` properties from
+being used at all, since a warning would be generated if there's a matching member in the base
+that requires either `override` or `new`.
+
+However, the point of data properties was to be brief. Adding modifiers would potentially cloud
+the purpose of the feature. The syntactical abbreviation isn't strictly required because the
+equivalent property can always be written explicitly:
+
+```C#
+data int X;
+
+// versus
+
+public int X { get; init; }
+```
+
+
+**Conclusion**
+
+Based on where we are in the schedule for C# 9, we probably will not have time to respond to feedback.
+Therefore, we're planning on putting this feature into preview and not shipping it with C# 9. For now,
+let's allow the following modifiers: `public`, `new`, `abstract`, `virtual`, and `override`. This will
+provide an option for allowing `data` properties to interact more smoothly with other constructs in C#,
+while maintaining some of the simplicity. We'll see how it feels in prototypes to gauge whether we went
+too far, or not far enough.
+
+### Struct records
+
+We're not sure how much space we have for structs in C# 9, but we do think structs are an
+interesting design point. We previously proposed that structs could support a variety of record
+behaviors without being a record. One idea would be to automatically implement `IEquatable<T>`
+for all structs, but this has a lot of potential negative impact for the runtime and the
+ecosystem: effectively every struct would add a large number of members which could seriously
+bloat metadata.
+
+An alternative would be to work with the runtime to try to provide a runtime-generated form of
+`IEquatable<T>`. If it's cheap enough, we may be able to provide `IEquatable<T>` for structs as
+a as-necessary addition to all structs. However, this is a potentially very large change. Even
+small costs could add up, and even small semantic changes could impact someone.
+
+Overall, the modification of arbitrary struct semantics just seems too risky. Something as simple
+as testing a struct for an implementation of `IEquatable<T>` could be a breaking change, and with
+a change this big, it's almost certain to be breaking for someone.
+
+**Conclusion**
+
+Altering the semantics of all structs as-is is out. We're leaning towards a real "record struct"
+declaration.
+
+### Inheritance between records and classes
+
+We currently have a restriction that records cannot inherit from classes and classes cannot
+inherit from records. We should confirm that this restriction is acceptable for C# 9.
+
+**Conclusion**
+
+We definitely see scenarios for expanding this, but we think the restriction is fine for the
+first version of records. Based on feedback and example scenarios, we can reconsider these
+restrictions and also the expected semantics.
+
+### `with` expressions on non-records
+
+This encompasses:
+
+    1. Finding some way to define a compatible `Clone` for user-defined classes
+
+    1. Anonymous types
+
+    1. Tuples
+
+Compatibility for `Clone` in user-defined classes is the most difficult of these items because it
+relies on a new language feature for requiring that a new object is returned from the Clone
+method.
+
+Anonymous types are very simple, we can retroactively define them as record types.
+
+Tuples would be simple to special-case in the language, but it's probably more consistent to
+decide the semantics for struct records first, and then update the definition of
+System.ValueTuple to support them.
+
+**Conclusion**
+
+Anonymous types can be updated at any time, everything else should wait until after C# 9.