maxmustermann/csharplang
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Add notes for July 17th, 2020

Browse source
This commit is contained in:
Fredric Silberberg 2020-07-13 14:52:25 -07:00
parent 9cf2f66647
commit e4429f399f
No known key found for this signature in database
GPG key ID: BB6144C8A0CEC8EE
2 changed files with 210 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

201
meetings/2020/LDM-2020-07-13.md Normal file
View file

@ -0,0 +1,201 @@
# C# Language Design Meeting for July 6th, 2020
## Agenda
1. [Generics and generic type parameters in aliases](#Generics-and-generic-type-parameters-in-aliases)
2. ["closed" enum types](#"closed"-enum-types)
3. [Allow `ref` assignment for switch expressions](#Allow-`ref`-assignment-for-switch-expressions)
4. [Null suppressions nested under propagation operators](#Null-suppressions-nested-under-propagation-operators)
5. [Relax rules for trailing whitespaces in format specifier](#Relax-rules-for-trailing-whitespaces-in-format-specifier)
6. [Private field consideration in structs during definite assignment analysis](#Private-field-consideration-in-structs-during-definite-assignment-analysis)
7. [List patterns](#list-patterns)
8. [Property-scoped fields and the `field` keyword](#Property-scoped-fields-and-the-field-keyword)
9. [File-scoped namespaces](#file-scoped-namespaces)
10. [Allowing `ref`/`out` on lambda parameters without explicit type](#Allowing-ref/out-on-lambda-parameters-without-explicit-type)
11. [Using declarations with a discard](#Using-declarations-with-a-discard)
12. [Top level statements and functions](#Top-level-statements-and-functions)
13. [Implicit usings](#implicit-usings)
## Quote of the day
"It does actually seem like this pattern is the 98% case..."
"I just want to disagree with something [redacted] said... [they] said [they] thought it was the 98% case that this would apply to, and I think it's 99..."
"Not fair, I was going to say that."
## Discussion
This meeting was issue triage. There will not be much detail on any particular issue, just a general summary
of the LDM's feeling and the milestone that we triaged to.
### Generics and generic type parameters in aliases
https://github.com/dotnet/csharplang/issues/1239
In general, we want to make improvements in this area. We should also be open to making other enhancements
in this space, such as allowing tuple syntax on the right side, or allowing C# keywords like `int`. There's
also a set of features that we should investigate in parallel, such as globally-visible aliases or publicly-
exported aliases.
#### Conclusion
Triaged for C# 10 for now so that we can look at the space hollistically in the near term.
### "closed" enum types
https://github.com/dotnet/csharplang/issues/3179
This is a solution to the very common complaints around enum usage, particularly in switch expressions and other
exhaustiveness scenarios. It will also work well with DUs, and we should make sure that whatever syntax we use
there works well with closed or sealed enum types as well.
#### Conclusion
Triaged for C# 10 to look at in coordination with DUs.
### Allow `ref` assignment for switch expressions
https://github.com/dotnet/csharplang/issues/3326
We like this proposal. You can already do this with ternaries, and it's odd that you can't do this with switch
expressions as well. It's not high priority, but we'd be happy to see it in the language. Like ternaries, the
ref version would not be target-typed.
#### Conclusion
Triaged for Any Time.
### Null suppressions nested under propagation operators
https://github.com/dotnet/csharplang/issues/3393
This will be a breaking change, so we need to get it in as soon as possible.
#### Conclusion
C# 9 timeframe. We need to make a syntax proposal and approve it.
### Relax rules for trailing whitespaces in format specifier
https://github.com/dotnet/csharplang/issues/3414
In reading this proposal, we're unsure whether the request was for _ignoring_ trailing spaces in format specifiers,
or allowing them and including them in the format specifier. We think that either way this is interpreted, it will
be confusing: trailing spaces are allowed in front of an interpolated expression and mean nothing, but for things
like `DateTime`, spaces are valid parts of a format specifier and will be respected in the output. We think that
either behavior here would be confusing, with no clear indication on which the user wants.
#### Conclusion
Rejected.
### Private field consideration in structs during definite assignment analysis
https://github.com/dotnet/csharplang/issues/3431
This is a bug from the native compiler that had to be reimplemented in Roslyn for compat, but it's always been
one of the prime candidates for a warning wave (and is already supported as an error in the compiler via the strict
feature flag). There is some contention whether it should be a warning or an error in this wave. There is also a
concern that this will combine with the `SkipLocalsInit` feature in C# 9 to expose an uninitialized memory hole in
C# with no use of `unsafe` or `System.Unsafe` required.
#### Conclusion
We need to look at this ASAP to make sure that we don't unintentionally expose unsafety in the language without
user intention. We'll schedule this for next week.
### Remove restriction that optional parameters must be trailing
https://github.com/dotnet/csharplang/issues/3434
It's possible to define such methods in metadata with the correct attribute usage _and_ call them from C# today.
This would just be about removing the restriction from _defining_ them in C#.
#### Conclusion
Triaged for Any Time.
### List patterns
https://github.com/dotnet/csharplang/issues/3435
We have an open proposal that with a prototype. We like the general direction it takes, but we need to have more
detailed design review of it and possibly make a few different decisions. This is a direction we want to take
pattern matching in future releases, so we'll continue iterating on this.
#### Conclusion
Triaged into C# 10 for design work.
### Property-scoped fields and the `field` keyword
* https://github.com/dotnet/csharplang/issues/133
* https://github.com/dotnet/csharplang/issues/140
We've started doing design work around both of these issues. We should continue doing that.
#### Conclusion
Triaged into C# 10.
### File-scoped namespaces
https://github.com/dotnet/csharplang/issues/137
This has been a large request for a long time that reflects the default of almost every single C# file written.
There's still some design work to do, particularly in how that will affect `using` statements, but it's work
that we should take on.
#### Conclusion
Triaged into C# 10.
### Allowing `ref`/`out` on lambda parameters without explicit type
https://github.com/dotnet/csharplang/issues/338
We've heard this request a few times, and while we don't see any particular issue with this, it's not a priority
for the team at this point. If a spec/implementation was provided we'd likely accept it but won't go out of our
way to add it unless something else changes here.
#### Conclusion
Triaged to Any Time.
### Using declarations with a discard
https://github.com/dotnet/csharplang/issues/2235
There's still some open design questions here, particularly around possibly ambiguous syntaxes. We need to keep
iterating on this to find a design that we like.
#### Conclusion
Triaged for X.X, pending a new proposal.
### Top level statements and functions
https://github.com/dotnet/csharplang/issues/3117
This is part 2 of the work we started in C# 9 with top-level statements: designing free-floating functions that
can sit on the top level without any containing type. We need to continue examining this context of scripting
unification, which we plan to continue doing on an ongoing basis.
#### Conclusion
Triage into C# 10 for ongoing discussion.
### Implicit usings
https://github.com/dotnet/csharplang/issues/3428
This is another issue arising of discussions on top-level statements and using C# as a scripting language:
attempting to make the language more brief by specifying common imports on the command line or as part of
the project file is certainly one way to remove boilerplate. However, it's a controversial feature that often
draws visceral reactions. We need to discuss this more and figure out if it's a feature we want to have in C#,
taking into account our increased focus on scripting-like scenarios. It's worth noting that CSX has a limited
form of this support already, and implementing this in C# proper would bring us one step closer to unifying the
two dialects.
#### Conclusion
Triage to C# 10 for discussion.

14
meetings/2020/README.md
View file

@ -19,9 +19,7 @@
## Jul 20, 2020
## Jul 13, 2020
- Triage [championed features](https://github.com/dotnet/csharplang/issues?q=is%3Aopen+is%3Aissue+label%3A%22Proposal+champion%22+no%3Amilestone)
- [struct private fields in definite assignment](https://github.com/dotnet/csharplang/issues/3431) (Neal/Julien)
## Jun 3, 2020
@ -54,11 +52,17 @@
# C# Language Design Notes for 2020
Overview of meetings and agendas for 2020
[Overview of meetings and agendas for 2020](https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-07-13.md)
- Triage open issues
## Jul 13, 2020
[C# Language Design Notes for July 13th, 2020]
## Jul 6, 2020
[C# Language Design Notes for July 1, 2020](https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-07-06.md)
[C# Language Design Notes for July 6, 2020](https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-07-06.md)
- [Repeat Attributes in Partial Members](https://github.com/RikkiGibson/csharplang/blob/repeated-attributes/proposals/repeat-attributes.md) (Rikki)
- `sealed` on `data` members