Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Dictionary expressions: add resolutions for open questions from LDM-2024-03-11 #8074

Merged
merged 2 commits into from
Apr 26, 2024
Merged

Dictionary expressions: add resolutions for open questions from LDM-2024-03-11 #8074

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4a8fcc5
Dictionary expressions: open question resolutions from LDM
cston Apr 24, 2024
2a3b3f8
Add open question
cston Apr 24, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 15 additions & 0 deletions proposals/dictionary-expressions.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,6 +76,8 @@ Dictionary<string, int> nameToAge = ["mads": 21, existingKvp]; // A user would h
Dictionary<string, int> nameToAge = ["mads": 21, existingKvp.Key: existingKvp.Value];
```

**Resolution:** *Expression elements* of key-value pairs will be supported in dictionary expressions. [LDM-2024-03-11](https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-03-11.md#conclusions)

### Open question 2

Having spreads in a *dictionary expression* only be concerned with element types (and not the collection type being spread itself), matches the equivalent case in the collection-expression case:
Expand All @@ -96,6 +98,8 @@ Note: this seems particularly restrictive given that people may commonly use thi
Dictionary<string, int> nameToAge = ["mads": 21, .. existingDict.Where(kvp => kvp.Value >= 21)];
```

**Resolution:** *Spread elements* of key-value pair collections will be supported in dictionary expressions. [LDM-2024-03-11](https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-03-11.md#conclusions)

### Open question 3

How far do we want to take this KeyValuePair representation of things? Do we allow *dictionary elements* when producing normal collections? For example, should the following be allowed:
Expand All @@ -112,6 +116,8 @@ Importantly, we do not believe it wise to *require* the presence of a `k:v` elem
Dictionary<string, int> everyone = [.. students, .. teachers];
```

**Resolution:** *Dictionary elements* will be supported in collection expressions for collection types that have a key-value pair element type. [LDM-2024-03-11](https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-03-11.md#conclusions)

### Open question 4

Should we take a very restrictive view of `KeyValuePair<,>`? Specifically, should we allow only that exact type? Or should we allow any types with an implicit conversion to that type? For example:
Expand Down Expand Up @@ -149,6 +155,15 @@ Which approach should we go with with our dictionary expressions? Options includ
2. Purely permissive. All elements are added using the indexer. Perhaps with compiler warnings if the exact same key is given the same constant value twice.
3. Perhaps a hybrid model. `.Add` if only using `k:v` and switching to indexers if using spread elements. There is deep potential for confusion here.

**Resolution:** Use *indexer* as the lowering form. [LDM-2024-03-11](https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-03-11.md#conclusions)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

How should we handle the contradiction between this and the resolution to open question 3:

Dictionary elements will be supported in collection expressions for collection types that have a key-value pair element type.

Which used this example, for which list["mads"] = 21 will not work:

List<KeyValuePair<string, int>> list = ["mads": 21];

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Good catch. Added an open question.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

godo question. my preference is '3'. normal pre-dictionary collection initializable types have 'Add' semantics for their elements. I would prefer to stick with that for sanity/consistency.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Credit to Fred :)


### Open question 6

From [Open Question 3](#open-question-3), we will support *dictionary elements* for C#12 collection expression target types. Which approach should we use for initialization for those types? Options include:

1. Use applicable instance indexer if available; otherwise use C#12 initialization.
2. Use applicable instance indexer if available; otherwise report an error during construction (or conversion?).
3. Use C#12 initialization always.

## Conversions

Expand Down