Added: LDM notes for Dec 3, 2018

[agocke]

C# Language Design Notes for Dec 3, 2018

1. using declaration open issues
2. Return type of Range indexer on array and framework types

[dsaf]

Deconstruction

Q: Do we want to allow a deconstruction in the declaration e.g., using var (x, y) = GetResources()?

We noted that this could mean two different things: the outer tuple is disposed, then deconstructed, or the elements are deconstructed, then each is disposed.

Conclusion

This seems too complicated for the marginal benefit. Rejected.

Maybe there should be a symmetrical method Construct for the existing Deconstruct. This way you could create a custom disposable "tuple" which will look like a syntactic ValueTuple but be a custom type.

[dsaf]

On the other hand default interface implementation could solve this as well?

[jnm2]

using var _ = ...;

Today we have using (var x = expr) { } and using (expr) { }.

Why wouldn't we have using var x = expr; and using expr;, since it's in an executable block and neither the developer or the compiler can mistake that for a using declaration?

[AlgorithmsAreCool]

Why wouldn't we have using var x = expr; and using expr;

Idk, isn't the whole point of using declarations to make disposable declarations nicer? If there is no declaration it is more like a disposable expression and that is kind of odd. I like the idea of using an explicit discard to imply the variable is what is being disposed and it's scope is the same as other variables.

[alrz]

Why wouldn't we have using var x = expr; and using expr;

This'll be ambiguous:

using (expr);

is it a regular using statement on expr with ; as the body or a using declaration on (expr)?

[jnm2]

@alrz Perfect, thanks!

Now since var foo is typically replaced with _ in order to discard, not var _, why is using var _ = expr; better than using _ = expr;?

[AlgorithmsAreCool]

Is var foo actually replaced with _?

The spec says that discards still need a type.

https://github.com/dotnet/roslyn/blob/master/docs/features/discards.md

Reading comprehension is important 😅

[Joe4evr]

@AlgorithmsAreCool As per the doc you linked yourself:

The second representation of discards is using the expression _ as a short-hand for var _, when no variable named _ is in scope.

It also works in SharpLab.

[alrz]

using _ = expr;

@jnm2 the syntax doesn't allow it. var is a part of declaration which is not optional. note: _ = e; is an assignment rather than declaration. Underscore is usually a special identifier in existing syntax forms.

[scalablecory]

We could allow jumping "out" of a using var, but we're concerned it may be confusing, since there may not be a syntactical indication that the disposal is executed.

Am I reading this correctly that this code will be be illegal?

{
using var foo = bar();
goto baz;
}
baz:

This is valid with the current using statement, where there is just as little syntactical indication that a dispose will occur. I would prefer consistency to avoid needing to remember corner-cases that depend on how using is used.

[gafter]

No, @scalablecory, you are not reading that correctly. The only error condition is when the label and the using declaration appear directly in the same statement list (which is not the case here) and the goto crosses the using (which is also not the case here).