Update ref-struct-interfaces.md

[AlekseyTs]

No description provided.

[cston]

Suggested change

	`allows ref strict`, there is no `DisposeAsync` pattern match, and `IAsyncDisposable` is in type parameter's effective interfaces set.
	`allows ref struct`, there is no `DisposeAsync` pattern match, and `IAsyncDisposable` is in type parameter's effective interfaces set.

[cston]

A using statement will recognize and use implementation of IAsyncDisposable interface when resource is a type parameter that
allows ref strict, there is no DisposeAsync pattern match, and IAsyncDisposable is in type parameter's effective interfaces set.

Currently, it looks like we use IAsyncDisposable even if there is a DisposeAsync pattern (available through an interface) - see sharplab.io.

[AlekseyTs]

A using statement will recognize and use implementation of IAsyncDisposable interface when resource is a type parameter that
allows ref strict, there is no DisposeAsync pattern match, and IAsyncDisposable is in type parameter's effective interfaces set.

Currently, it looks like we use IAsyncDisposable even if there is a DisposeAsync pattern (available through an interface) - see sharplab.io.

I can see how this could be confusing, but there is no pattern match in this case due to an ambiguity.

[cston]

My comment here (and below) was about the text rather than the example. The text seems to state we'll use the interface implementation when there is no pattern implementation, which might imply that if there was a pattern implementation, we'd use the pattern implementation instead. But currently it looks like we use the interface implementation regardless of whether there is a pattern implementation.

[AlekseyTs]

there is no DisposeAsync pattern match

The statement doesn't talk about " a pattern implementation" there, it talks about "a pattern match", which doesn't have to exists (and in fact doesn't in some scenarios) when there is a pattern implementation.

[cston]

Suggested change

	`allows ref strict`, there is no `GetEnumerator` pattern match, and ```IEnumerable<T>```/```IEnumerable``` is in type parameter's effective interfaces set.
	`allows ref struct`, there is no `GetEnumerator` pattern match, and ```IEnumerable<T>```/```IEnumerable``` is in type parameter's effective interfaces set.

[cston]

A foreach statement will recognize and use implementation of IEnumerable<T>/IEnumerable interface when collection is a type parameter that
allows ref strict, there is no GetEnumerator pattern match, and IEnumerable<T>/IEnumerable is in type parameter's effective interfaces set.

Currently, it looks like we use IEnumerable<T> even if there is a GetEnumerator pattern (available through an interface) - see sharplab.io.

[AlekseyTs]

A foreach statement will recognize and use implementation of IEnumerable<T>/IEnumerable interface when collection is a type parameter that
allows ref strict, there is no GetEnumerator pattern match, and IEnumerable<T>/IEnumerable is in type parameter's effective interfaces set.

Currently, it looks like we use IEnumerable<T> even if there is a GetEnumerator pattern (available through an interface) - see sharplab.io.

I can see how this could be confusing, but there is no pattern match in this case due to an ambiguity.

[cston]

Suggested change

	`allows ref strict`, there is no `GetAsyncEnumerator` pattern match, and ```IAsyncEnumerable<T>``` is in type parameter's effective interfaces set.
	`allows ref struct`, there is no `GetAsyncEnumerator` pattern match, and ```IAsyncEnumerable<T>``` is in type parameter's effective interfaces set.

[cston]

An await foreach statement will recognize and use implementation of IAsyncEnumerable<T> interface when collection is a type parameter that
allows ref strict, there is no GetAsyncEnumerator pattern match, and IAsyncEnumerable<T> is in type parameter's effective interfaces set.

Currently, IAsyncEnumerable<T> is used even if there is a GetAsyncEnumerator pattern (available through an interface) - see sharplab.io.

[AlekseyTs]

An await foreach statement will recognize and use implementation of IAsyncEnumerable<T> interface when collection is a type parameter that
allows ref strict, there is no GetAsyncEnumerator pattern match, and IAsyncEnumerable<T> is in type parameter's effective interfaces set.

Currently, IAsyncEnumerable<T> is used even if there is a GetAsyncEnumerator pattern (available through an interface) - see sharplab.io.

I can see how this could be confusing, but there is no pattern match in this case due to an ambiguity.