# C# Language Design Meeting for August 31st, 2022

## Agenda

1. [Short term work triage](#short-term-work-triage)
    1. [Partial properties](#partial-properties)
    2. [Using aliases for any type](#using-aliases-for-any-type)
    3. [Null-conditional assignment](#null-conditional-assignment)
    4. [`await?`](#await)
    5. [`params IEnumerable`](#params-ienumerable)
    6. [Discriminated Unions](#discriminated-unions)
    7. [Roles](#roles)
    8. [`pragma warning enable`](#pragma-warning-enable)
    9. [Ignored directives support](#ignored-directives-support)
    10. [Primary constructors](#primary-constructors)
    11. [Switch expression as a statement](#switch-expression-as-a-statement)

## Quote of the Day

- "Features ready to eat"

## Discussion

### Short term work triage

The LDM is going on break for 3 weeks due to member absences, and the compiler team is starting to wrap up on C# 11 bugs. We therefore took today to triage through smaller features
and prototyping work we'd like to start on as we wrap up. The former should be simple features that don't need further design work, and the latter should be features where a prototype
would serve to further the design.

**Important note**: This list is longer than the compiler team will be able to look at in the next few weeks. Think of it as a shortlist, nothing more.

#### Partial properties

https://github.com/dotnet/csharplang/issues/6420

This feature has not been looked at much by the full LDM, but the proposal seems straightforward, follows our existing rules for partial methods, and avoids complicated questions on
what to do for fully-auto properties. We'll put it on the list.

#### Using aliases for any type

https://github.com/dotnet/csharplang/issues/4284

We originally wanted to look at this in conjunction with `global using`s, but didn't get to it. It's on the list.

#### Null-conditional assignment

https://github.com/dotnet/csharplang/issues/6045

Another one we wanted to get to during 11, but ran out of time. It's on the list.

#### `await?`

https://github.com/dotnet/csharplang/issues/35

This is our second-highest upvoted `Any Time` milestone issue, and continues C#'s operator monad over nulls (along with the previous issue). It's on the list.

#### `params IEnumerable`

https://github.com/dotnet/csharplang/issues/179

This issue is specifically for `params IEnumerable` parameters, not including `Span<T>` or other possible variations. And we think that's part of the problem with trying to approach
this right now: there's too many questions about what exactly to support. We think this has too many questions to be on the shortlist.

#### Discriminated Unions

https://github.com/dotnet/csharplang/issues/113

Obviously, this is not in the "go implement in the next few weeks" category. However, we think that starting to prototype will help inform our design choices in this space, and this is
feature is (by a large margin) the most up-voted issue on csharplang. Protoyping is on the list.

#### Roles

https://github.com/dotnet/csharplang/issues/5497

This is another area where we think prototypes will help drive the conversation, especially since our current questions are around feasibility of implementation. Prototyping/initial
implementation is on the list.

#### `pragma warning enable`

https://github.com/dotnet/csharplang/issues/3986

This is fairly simple and non-complicated. However, very rarely for a csharplang issue, this issue has no upvotes or activity of any kind, and some members of the LDT are conflicted on
whether the feature is worth it. Not on the list.

#### Ignored directives support

https://github.com/dotnet/csharplang/issues/3507

Would be nice to have, but only in conjunction with the rest of the simple programs feature. Implementation might be one of the simplest ever features in the compiler, but without the
tooling to accompany it we don't know that this is the right design. Not on the list.

#### Primary constructors

https://github.com/dotnet/csharplang/issues/2691

The last time these were brought up, we blocked on what exactly the primary constructor parameters _are_: fields, captures, or something else? We think a prototype to play around with might
help us make progress, so this is on the prototyping shortlist.

#### Switch expression as a statement

https://github.com/dotnet/csharplang/issues/2860
https://github.com/dotnet/csharplang/issues/3038

There are a few different directions we could take this space. We could take this approach, or look at modernizing switch statement syntax, or some other form. This space needs more design,
so this is not on the list.
