LDM Notes for March 5th, 2025

[MadsTorgersen]

https://github.com/dotnet/csharplang/blob/main/meetings/2025/LDM-2025-03-05.md

Agenda

• Dictionary expressions
• Target-typed static member lookup

[huoyaoyuan]

At the same time there's also a lot of resistance to having a sigil instead of just a name. It feels like users may have difficulty realizing when they could choose to use this feature. Without the dot it would feel like the compiler just knows what you mean.

Perhaps there is a path we can take that allows us to get feedback from the ecosystem on this question?

Can this be helped with IDE suggestion? Like how IDE suggests EnumType.Member as a whole completion item.

The conversion rules pertain to how we decide that a given type is a dictionary type.

Not directly related, but I'd like to see more IDE hint about whether (and how) a type qualifies for a language feature, like the "awaitable" hint.

[jnm2]

It feels like users may have difficulty realizing when they could choose to use this feature.

As I see it, no more difficult than knowing when they could choose to use new() or null, which are other constructs which require target typing, in which you omit the type in just the same way.

[RikkiGibson]

M1(Red);
M2(Red);
var item = Red;

When I think about these various Reds, it concerns me a bit that they could be all referring to different symbols. Compare with:

M1(.Red);
M2(.Red);
var item = Red; // .Red is invalid here
M2(item);
M2(Red); // uses the same Red as 'var item'

IMO, a sigil accomplishes two important tasks here:

1. it signals that the meaning of the name is dependent on the target.
2. it offers a way to use either a member of the target, or a name which is simply in scope, without requiring qualification.

BTW, it seems like for members which cannot be qualified, there is a need for them to be "more prominent" in lookup, than members which can be qualified. So, even if we were working from scratch, it would not be realistic or desirable for Red from the target type, to be better than Red the local variable in scope, for example.

I'm interested in learning more about how different languages are solving this, including Swift, F#, and Rust, and probably more, and why they made the choices they made regarding inference.

[colejohnson66]

I originally disliked the idea of a sigil, but I've come around. I think .Member is the correct way.