In the course of exercising abstract hierarchies I frequently find myself wanting to specify a type in terms of the methods it must implement without wanting to impose the additional requirement of implementing a specific interface. One can do this but the penalty for doing so is severe and, it appears to me, unnecessary.

Consider:

trait Trait {
  type Foo <: { def bar(x: Int): Int }
  
  def foobar(foo: Foo) = foo.bar(10)
}

class Concrete1 extends Trait {
  class Foo() { def bar(x: Int) = 1 }
}

class Concrete2 extends Trait {
  class Foo() { def bar(x: Int) = 1 }
  
  override def foobar(foo: Foo) = foo.bar(10)
}

In Concrete2 we override the method with a syntactically identical version of the inherited method. The impact is profound.

In Concrete1: a call to foobar forwards the target object and argument to Trait.foobar, where the integer is boxed and placed in an array, the method handle is looked up, the reflective call is issued, the result is unboxed, and it is returned to the calling class.

In Concrete2: a call to foobar results in a direct unboxed call to foo.bar.

But surely if manually overriding each method with an exact copy achieves this, the compiler could assume the responsibility.