# C# Language Design Meeting for August 24th, 2022

## Agenda

1. [C# feature triage](#c-feature-triage)

## Quote of the Day

- "There will also be a debate about whether the next one will be 13 or 14"

## Disclaimer

Hi all, your friendly C# note taker here. [This time last year](https://github.com/dotnet/csharplang/blob/main/meetings/2021/LDM-2021-08-30.md#discussion), when we did
our initial C# 11 triage, I mentioned that readers should not try to use the meeting to "read the tea leaves" for what would be in C# 11. Most of our readers didn't, and
for that we are appreciative. However, a few blog posts did crop up on what features were going to be in C# 11, and they contained information about features the did not
make C# 11 (and missed some features that did make it). We'd ask, again, that you please not use these notes as a way of saying what will be in the next version of C#.
We are looking through our backlogs, user feedback, and other such areas to decide what areas we want to be focusing on, but we are not committing to anything just yet.
We are merely trying to get an understanding of our priorities, and any of these features could make C# next, make it in preview form, or not make it at all. Thanks.

## Discussion

### C# feature triage

Today, we started our future C# feature triage. This is the first of at least 2-3 meetings where we will be looking at the big and small ticket items and feature areas
to determine where our design focus will be for the next year. This year, we started the process by collecting topics from all members of the LDT. The recurring themes
of these topics are:

1. Discriminated unions and working with un/less-structured data. Nearly everyone brought up a topic in this broad area, be it looking at closed-type-hierarchy-style
tagged unions or unstructured anonymous inline unions of data. We think there's a lot of potential here, and in particular potential for a holistic exploration of the
space in the same style as we did for pattern matching, where we used a broad internal vision to deliver 4+ releases of features to build out the space. We would like
to spend time in the next cycles coming up with a similar vision for this space, and start delivering on features in it that will fit into this broader vision of making
data easier to work with in the language.
2. Roles/extension everything. This is another big feature space that includes things both large and small that users have been asking about for years. Unlike DUs, we
have a better understanding of the specific areas this feature is trying to address, and an internal working group on roles has been persistently chipping away at a
design for breaking up the larger feature into smaller components that can be shipped without breaking our future ability to innovate in this space. We hope to have
results from this group to share soon.
3. Tooling improvements. A rarer suggestion from this group, but there is interest in investing more in the "C#-adjacent" tooling experience, and seeing what can be
done to further improve the polyglot notebooks and interactive scenarios and bring them to parity with regular C# projects. We'd also like to look at the experiences
that other languages bring in their tooling (specifically via language features) and see what lessons we can learn to make our own experiences better.
4. Expression trees. As last year, discussions on how to modernize this experience have been continuing in the background, and we would like to address them. It's not
a small amount of work, but it needs to start somewhere.
5. Community-driven features. We've been successful in the past few releases of having community members design and implement C# features, and we'd like to continue this
trend. `field` is an example of this we hope to see soon (there are outstanding design questions that need to be answered after implementation hit issues), but other
features in the Any Time bucket that receive community interest should also get some of our attention.
6. Smaller nits, such as block expressions. We've talked about rounding off some smaller corners that have usability impacts, such as expanding our set of expressions
in C# (making switch expressions have less of a cutoff, allowing returns in new places, etc). We are generally aligned on the idea, but there are some serious syntax
battles that need to be fought.

When we look at the sets of features we're interested in, we see large emerging themes, and opportunities to break up the features into smaller things working groups
can investigate and bring back to the larger group. We've had good success with this approach in both `required` members and in the ongoing group working on roles, and
we think it's a strategy we should adopt more. Next time, we'll discuss these themes further, and see if we can break them up further into more concrete areas for
investigation.
