Confusing interaction between opaque types and extension methods

[mpilquist]

Minimized code

opaque type Bytes = Array[Byte]
object Bytes:
  def fromArray(arr: Array[Byte]): Bytes = arr
  extension (self: Bytes):
    def toArray: Array[Byte] = self
    def length: Int = (self: Array[Byte]).length
    def size: Int = (self: Array[Byte]).size

val b = Bytes.fromArray(Array(1, 2, 3))

object Main extends App {
  println("Length: " + b.length)
  println("Size: " + b.size)
}

Output

Length is printed and then an infinite loop is encountered on b.size

Expectation

Array[Byte] doesn't have a size member so (self: Array[Byte]) is lifted to Bytes instead of picking up ArrayOps implicit conversion. This seems like a pretty big gotcha but not sure how to improve.

[odersky]

I don't see what could be done here.

[smarter]

We could print a warning on obviously infinite loops (scala 2 does that for def foo: Int = foo but nothing more I think).

[mpilquist]

Ran in to this limitation again recently:

object Module1:
  opaque type State[S, +A] = S => (S, A)
  object State:
    extension [S, A](self: State[S, A])
      def map[B](f: A => B): State[S, B] =
        s => { val (s2, a) = self(s); (s2, f(a)) }

object Module2:
  import Module1.State
  trait RNG
  opaque type Gen[+A] = State[RNG, A]
  object Gen:
    extension [A](self: Gen[A])
      def map[B](f: A => B): Gen[B] =
        State.map(self)(f)

To implement Gen#map, I had to resort to calling the extension method directly via State.map(self)(f). Is there a better approach to workaround this?

[smarter]

Not that I can think of, instead I would recommend using a plain old class.

[mpilquist]

I don't want to give up on using opaque types that easily. :)

Directly invoking State.map(self)(f) seems like a fine workaround assuming the compiler will always allow such a selection.

[odersky]

Directly invoking State.map(self)(f) seems like a fine workaround assuming the compiler will always allow such a selection.

Yes, that's official syntax, so no worry that it might get outlawed.

[dwijnand]

Perhaps some pinhole linting can be done but otherwise this looks like a candidate FAQ.

[smarter]

Perhaps some pinhole linting can be done

Similar linting is now done for implicit definitions and should be easy to extend to extensions or even all definitions: #13589