Added: LDM Notes for September 19th, 2018

[agocke]

C# Language Design Notes for September 19, 2018

Agenda

Triage:

1. XML doc comment features
2. New foreach pattern using Length and indexer
3. Object initializers for readonly members
4. readonly struct methods
5. params Span
6. Nullable reference type features on Nullable

[ufcpp]

I'd like #145 is also considered.

[qrli]

Is it an option to split the doc comments out of the language?
Or, make the language only define the container of the doc comments (/// as of now) and leave all tags to doc tool chain?

[Thaina]

New foreach pattern using Length and indexer

Should be generalized to ref foreach with IRefEnumerator

[tannergooding]

@agocke or @jaredpar, could you clarify on a comment given to the readonly functions on structs section?

First concern is ordering restrictions of the "readonly" modifier. It can also indicate a "readonly ref" return type, so we need to make sure it's not ambiguous.

The current proposal was (well before the LDM meeting) updated such that the readonly method modifier would appear after the argument list, so that it would not be ambiguous (I believe this was @jaredpar's suggestion).

[jaredpar]

Yep and LDM loved that suggestion. And by love I mean they made faces at me. 😄

[gafter]

I'd like #145 is also considered.

@ufcpp would be considered if some member of the LDM championed it.

[Thaina]

If we need to extend IEnumerator and foreach could we also have continue accept parameter and yield that provide parameter?

A MoveNext with variable like in javascript

IEnumerator<T,V>
{
     T Current;
     bool MoveNext(V value);
}

IEnumerable<T,V>
{
    IEnumerator<T,V> GetEnumerator();
}

////

IEnumerable<object,(bool,int)> GetItems()
{
    foreach(var item in items)
    {
        (var stop,int count) = yield return item; // yield will return value it got from MoveNext
        if(stop)
        {
            // Do some cleanup logic
            yield break;
        }
    }
}

////

foreach(var item in GetItems()) // IEnumerable<object,(bool,int)>
{
    //DoSomething with item
    continue (false,0); // MoveNext with parameter must continue with that parameter
}

It not directly related but I think if we extend feature relate to this anyway it would be easier to do it all in one go

[svick]

@Thaina I find that code confusing, because it changes what IEnumerable, foreach, continue and yield return mean to the point where they're almost unrecognisable. Also, you have not provided any justification or use case for that feature. I think that if you want it considered seriously, you should create a new issue for it, explain what its use cases are and also explain why alternative solutions using existing language features are not good enough.

C# does tend to add features in groups which share a theme, but each of those features should still be properly considered on its own merits.

[Thaina]

@svick I have seen this feature from javascript iterator system that it could send the state of the iteration back to iterator to decide more logic to do work. Most of the time it used to send the state to let iterator decide that should it continue iteration, as oppose to letting the iterating side decide when to stop, and iterator only stop when it iterate to the last. It could also use to switching logic of iteration on the fly

I think it useful in some situation