Added: LDM Notes for September 22nd, 2021

[333fred]

https://github.com/dotnet/csharplang/blob/main/meetings/2021/LDM-2021-09-22.md

Agenda

1. Open questions in list patterns
   1. Breaking change confirmation
   2. Positional patterns on ITuple
   3. Slicing rules
   4. Slice syntax recommendations
   5. Other list pattern features
2. Nested members in with and object creation
3. CallerIdentityAttribute
4. Attributes on Main for top level programs

[CyrusNajmabadi]

x is { Length: >0 } // Considered Exhaustive

Should that be >=0. ?

[333fred]

Fixed, thanks.

[DavidArno]

For length patterns, we're not seeing the need. We explored them previously and the exploration seems to have concluded that they might be needed for IEnumerable, but if so we can revisit as we look at IEnumerable again.

Not sure if I'm reading this correctly, but I read it as length patterns for IEnumerable aren't ruled out completely, but aren't being considered yet. I'd really like to see this ruled out completely. There is no length contract to an IEnumerable and therefore there is no requirement for an implementation to have a length as it can keep returning values on demand, ie it can effectively be infinite. As it's ICollection that defines Count, then I feel length patterns should apply to types that implement ICollection, rather than IEnumerable.

[jnm2]

In context, it's often valid to use the existing IEnumerable<T>.Count() and IEnumerable<T>.Count(Func<T, bool>) extension methods.

[CyrusNajmabadi]

and therefore there is no requirement for an implementation to have a length as it can keep returning values on demand

Sure, and such a stream would never match a list pattern. But that doesn't seem like an issue. It anyway exists in .net that there are tons of apis that require a non-infinite stream to work properly. So this would just come with a similar sort of requirement.

[DavidArno]

@jnm2,
Oh, I didn't know there were such extension methods. That rather undermines my argument here in that case as I didn't think the framework supported count on IEnumerable.

@CyrusNajmabadi, if I have eg a Cycle<T> enumerator that endlessly loops over a supplied set of values:

public static IEnumerable<T> Cycle<T>(params T[] collection)
{
    while (true)
    {
        foreach (var item in collection)
        {
            yield return item;
        }
    }
}

then it won't be a case of it not matching a list pattern. It will lock the thread in an endless loop if used with a list pattern.

[jnm2]

It will also hang in an endless loop if such an enumerable is passed to BCL APIs, like new List<T>(IEnumerable<T>).

[DavidArno]

That's a fair point. There are already enough places where an endless enumeration can cause problems and needs to be handled carefully. So one more - length patterns - is just that: one more example to add to the list.

In that case, I retract my concerns as they don't seem so valid now. 😊