Fix #10087 : Change syntax of given instances in patterns

[odersky]

See the reference doc pages in this PR for details

[nicolasstucki]

How would we re-write the following pattern to make x, y and z givens?

case x @ (y: Y, z @ Z()) =>

[nicolasstucki]

We should have tests with nested given patterns.

[odersky]

you can't make x a given here. for x and y it would simply be:

case (x as given Y, y as given Z)

We already have a test like this.

[nicolasstucki]

This seems to be a core limitation of the syntax.

The given statement syntax is

given X
given x as X

What if we used the same in patterns?

case given X =>
case given x as X =>

Then we could extend it to

case given x @ X(y, z) =>

[nicolasstucki]

Interesting. This allows for a given to be bound to a val which we could not do with given y as Ordering[T] = x

val (y as given Ordering[T]) = x

[smarter]

If I understand this correctly, the y is not implicit here (hence the error on next line), and the given Ordering is not visible outside of the pattern its part of, so while this syntax is permitted because any pattern can be used in a val, it's useless.

[odersky]

@smarter: correct. implicits in patterns behave the same way.

[nicolasstucki]

Does this one work as a val definition in class?

[odersky]

yes, it should work

[nicolasstucki]

Then we should have some tests

[odersky]

Since it is a syntax change it would be good to merge this before M1. I don't think we need more tests for this at this point.

[nicolasstucki]

Implementation-wise it LGTM. Though I have some concerns about it being the right syntax due to limitations in expressivity and it not being aligned with statement given syntax.

[nicolasstucki]

This syntax improvement is clearly the right one

inline def setFor[T]: Set[T] = summonFrom {
-  case given _: Ordering[T] => new TreeSet[T]
+  case given Ordering[T] => new TreeSet[T]
  case _                 => new HashSet[T]
}

But this other change is not so clear

inline def setFor[T]: Set[T] = summonFrom {
-  case given t: Ordering[T] => new TreeSet[T]
+  case t as given Ordering[T] => new TreeSet[T]
  case _                 => new HashSet[T]
}

The following would be clearer if we compare with given statements

inline def setFor[T]: Set[T] = summonFrom {
-  case given t: Ordering[T] => new TreeSet[T]
+  case given t as Ordering[T] => new TreeSet[T]
  case _                 => new HashSet[T]
}

[smarter]

case t as given Ordering[T] => new TreeSet[T]

This syntax always has to be supported (assuming #9837 stays in)

case given t as Ordering[T] => new TreeSet[T]

Because the previous syntax already exists, this one doesn't add anything, so it's not clear if it should be supported.

[smarter]

I think we should get this in M1 since it's a net improvement and we can discuss if we want more changes later.