- "If you have a ref struct as a synchronization primitive that's pretty useless" "Hey, we were discussing readonly setters today, just because it's useless doesn't mean we shouldn't do it"
Today we continued with triage of championed issues without a milestone.
We continue to work on this, but it was filed after our last triage session so it didn't have a milestone.
Conclusion: Added to the working set.
We've determined this is a duplicate of #7429. Closing out.
Conclusion: Closed as a duplicate.
.NET 8 has mostly addressed this request with some JIT work to make TryWriteUtf8 extremely efficient. The remaining work here would be allowing usage outside of that
API, and we're unsure whether the existing are addressed with this new work. We'll wait to see if the new work has sufficiently addressed requests here before proceeding
with more design work.
Conclusion: To the backlog.
Some initial discussion revealed that there are some split opinions in the LDM on whether we think lock should natively support this new type, or if a new language feature
should be used (or if it should be done via using). However, what's clear is that we do need to have more discussions on this in the .NET 9 timeframe, or our ability to
address this request without potential breaking changes will slip us by.
Conclusion: Into the working set for .NET 9 discussions.
This is one of the smallest possible language features that could possibly exist, and we're generally fine with the idea, especially as there is prior art in other languages
for \e as an escape (regex, for example, uses \e for \u001b as well). We think the existing issue is sufficiently well-specified to proceed to put this into the needs
implementation bucket of any time, open for community contribution.
Conclusion: Into Any Time, needing an implementation.
We think this request is better served by library functions. There's a large number of potential follow-on requests here: requests for floored division, requests for
other types of remainder operations, and we don't think that adding increasing numbers of % or / characters to other operators is a sustainable path forward for these
requests, either for human understanding of the operators or for the language to continue designing. We think that extension methods are probably the best path forward for
getting an infix-style calling pattern for these operations.
Conclusion: Likely never.