Add implicit conversion from IArray to immutable.ArraySeq

[nicolasstucki]

Based on #11320
Part of #11298

[nicolasstucki]

Based on https://github.com/scala/scala/blob/2.13.x/src/library/scala/Predef.scala#L544

Not sure if this is the best location for this conversion. We could also move it to Predef.

[nicolasstucki]

Strange, it seems that implicit conversions have higher priority than extension methods. @odersky, is that the intended behaviour?

[nicolasstucki]

I had to add a DummyImplicit to make it work

[odersky]

Should there be a conversion from IArray to Seq? I see three alternatives:

1. No conversion, but add all Seq methods (including toSeq) as extension methods to IArray. The methods can be overloaded to specialize for primitive element types, just like the wrapArray conversions are specialized.
2. An old style implicit conversion
3. A new style Conversion instance.

I think I would go with (1). It's better not to introduce implicit conversions for new types. (2) is better than (3) since new style conversions warn at the use site which is definitely not what we want here. So new style conversions should not be used for extension methods.

I experimented with the idea of overloaded toSeq. It seems to be possible to do it if we use @targetName:

import annotation.targetName
case class IA[+X](xs: X*)

extension (x: IA[Int])
  @targetName("toIntSeq")
  def toSeqq: Seq[Int] = List(1, 2, 3, 4)
extension [T](x: IA[T])
  def toSeqq: Seq[T] = List()

def f[T](as: IA[T]) =
  val xs = IA(1, 2, 3)
  println(xs.toSeqq)
  println(as.toSeqq)

@main def Test =
  f(IA("a"))

Adding all the Seq methods as extension methods is a bit tedious. I have a branch that is already half way there.

I have another idea how we can avoid the repetition in the future: Allow export in extension blocks. But that is for after 3.0.

[sjrd]

Why would we specialize all the extension methods of IArray when we don't do that for Array?

[odersky]

Why would we specialize all the extension methods of IArray when we don't do that for Array?

We only specialize toSeq which corresponds to the specialized implicit conversions from Array to ArraySeq. I.e. the Seq wrapper should not have to use reflection to access the array elements.

[nicolasstucki]

I experimented with the idea of overloaded toSeq. It seems to be possible to do it if we use @TargetNAME:

We do not need to use @TargetNAME as the extension methods have the arrays in their signature and those be resolved as they are just arrays for the JVM. We already do that with apply and length.