opaque traits without type encoding

[vkuncak]

The following program uses no type encoding:

  final class MyFun[A,B](f: A => B):
    def apply(x: A): B = f(x)

  def applyAll(l: List[MyFun[Int,Int]], init: Int): Int = {
    l match {
      case Nil() => init
      case Cons(h, t) => applyAll(t, h(init))
    }
  }

  val t1 = MyFun[Int,Int]((x:Int) => x + 1)

  val t2 = new MyFun[Int,Int]((x: Int) => x - 1)

  val l: List[MyFun[Int,Int]] = List(t2, t1, t2)

  @main @extern
  def f =
    val res: Int = applyAll(l, 100)

If instead we use traits, we end up using type encoding, which can make things much less efficient in large programs.

  trait MyFun[A,B]:
    def apply(x: A): B  

  def applyAll(l: List[MyFun[Int,Int]], init: Int): Int = {
    l match {
      case Nil() => init
      case Cons(h, t) => applyAll(t, h(init))
    }
  }

  val t1 = new MyFun[Int,Int]:
    def apply(x: Int) = x + 1

  val t2 = new MyFun[Int,Int]:
    def apply(x: Int) = x - 1

  val l: List[MyFun[Int,Int]] = List(t2, t1, t2)

  @main @extern
  def f =
    val res: Int = applyAll(l, 100)

I would like that, if we write @opaque trait MyFun then it can only be extended by final and anonymous classes, and we treat it more like the first case class, avoiding the type encoding. Using function types will not work in the presence of mutation, but we should be able to do it by generating extern methods. As with opaque methods, we are purposely giving up on the precision of the underapproximation and the ability to execute the resulting encoding.