Added: C# design notes for Jan 16th & 23rd, 2019

[agocke]

LDM Notes for Jan 16th

1. Shadowing in lambdas
2. Pattern-based disposal in await foreach

LDM Notes for Jan 23rd

Function pointers (Updated proposal)

[qrli]

The dynamic check in (1a) is used because in C# 1.0 the non-generic IEnumerable did not implement IDisposable.

Do you mean IEnumerator instead of IEnumerable?

[agocke]

@qrli Yup, thanks, I'll fix that up.

[qrli]

We do not have a non-generic IAsyncEnumerable that doesn't implement IAsyncDisposable, so the dynamic check is unnecessary.

Then this should also be IAsyncEnumerator?

And could you confirm this line?

We will consider extension methods for IAsyncEnumerable and IEnumerable.

[agocke]

Fixed IAsyncEnumerator and that line is correct

[HaloFour]

For "Pattern-based disposal in await foreach" under proposals it looks like there is only one proposal listed with two sub-options. Should there be a second proposal or is that a formatting issue?

Was "pattern-based disposal" for using brought up? I understand the concern regarding allowing pattern-based disposal when using foreach just in case an existing enumerator has a Dispose method but doesn't implement IDisposable (as weird and unlikely as that seems), but I don't see why that necessarily has to prevent pattern-based disposal when using using directly.

[agocke]

Just formatting, we didn't really consider any other options.

Different behavior for the using statement and foreach wasn't really considered.

[tannergooding]

I think that, for function pointers...

IMO, funcptr (from the original proposal) was clearly the "best" syntax, since it indicated the type without needing to worry about the messiness of the other syntaxes.
func* (1), was "worse", but it still had a "cleaner" syntax and clearly indicated that the code was unsafe.

Syntax 5a I think is just bad. Not only is the syntax different from the existing C/C++ syntax, but it is also not clearly better.

[Joe4evr]

I wonder if the *-less option doesn't clearly indicate that they're only usable in unsafe code. 🤔

[ghord]

I think funciton pointer declaration syntax should reflect Func<> syntax or delegate syntax. Introducing third way just makes everything more complicated.

Taking the example from the proposal

delegate int Func1(string s);
delegate Func1 Func2(Func1 f);

Instead of propsed

 func* (func* int(string)) int((func* int(string));

We could have Func<>-like syntax (placement for calling convention to be determined).

 funcptr<funcptr<string, int>, funcptr<string, int>>

Or Delegate-like syntax

funcptr int Func1(string s);
funcptr Func1 Func2(Func1 f);
class MyClass
{
    void MyFunction(Func2 f) { ... }
}