Discussion: sequence discard

[alrz]

Moved from dotnet/roslyn#5811

A sequence discard would allow you to skip a sequence of values (zero or more) in a list pattern. For example, the following would match any array that ends with 1.

if (array is [___, 1]) 

There is no need to have a "one or more" variation since you can use a regular discard to simulate that,

if (array is [___, _, 1]) 

To keep the matching logic simple, we permit the sequence discard only once in a list pattern.

Open issue: would it be useful to allow this also for tuples?

if (tuple is (true, ___)) // matches a tuple of 1+ length with the first element set to true
// instead of
if (tuple is (true, _, _, _, ...))

The compiler uses ITuple interface if the tuple type is not known at compile-time.

[YaakovDavis]

Why not take it to the next level?

if (array is [_*, 1, _+, 2, _?, 3, _*5+, 4, _*6]) 

where
_*: zero or more elements
_+: one or more elements
_?: zero or one elements
_*5+: 5 or more elements
_*6: exactly 6 elements

[vbcodec]

Separated discards are better for readability

[alrz]

@vbcodec

This is not equivalent to a number of discards, as it's indifferent to the "length" of a list (or tuple).

[gulshan]

I think : can be used to indicate start and end of indefinite length discard pattern for tuples and arrays-

if (tuple is (_ : int i))  //Ends with any integer
if(tuple is (1 : _))       //Starts with 1
if(tuple is (0 : _ : 0))   //Starts and ends with 0
if(tuple is (0 , 1 : _ ))  //Starts with 0 then 1

Same goes for lists with [].

[alrz]

@YaakovDavis

I thought about that as a "repeat pattern", e.g. statementList is [ (IfStatement @if)* ] with any variable inside the operand turned into a IEnuemrable<T> but that probably should be filed as its own issue.

[alrz]

@gulshan #221

[gulshan]

#221 has been closed. The pattern part can be reused here for tuples and lists. : also will be used for slicing though.

[MgSam]

• Multiple underscores in a row are extremely difficult to visually parse. Is it one, two, three? Very hard to tell.
• Could you add some use-cases to this proposal? Why would I want to do this? Seems like this is useful for a situation where an array is being used as a DTO rather than defining a full class/struct (or using a tuple). I'd say that's a bad programming practice and we shouldn't make it easier. Seems more at home in JavaScript than C#.

[alrz]

@MgSam

It's a declarative way to match a few elements of an array not the whole thing. Note that "array patterns" must match the whole array so, [ <pat>, <pat> ] only matches an array with length=two, which is not always useful. I'm imagining that this can be used to implement a simple parser for a stream of tokens.