Почему scala использует метод отражения для вызова по структурному типу?

Если функция принимает структурный тип, ее можно определить как:

def doTheThings(duck: { def walk; def quack }) { duck.quack }

или

type DuckType = { def walk; def quack  }
def doTheThings(duck: DuckType) { duck.quack }

Затем вы можете использовать эту функцию следующим образом:

class Dog {
    def walk { println("Dog walk") }
    def quack { println("Dog quacks") }
}

def main(args: Array[String]) {
    doTheThings(new Dog);
}

Если вы декомпилируете (для Java) классы, сгенерированные scalac для моего примера, вы можете видеть, что аргумент doTheThings имеет тип Object, и реализация использует отражение для вызова методов в аргументе (т.е. duck.quack)

Мой вопрос - почему размышление? Не возможно ли использовать анонимный и invokevirtual вместо отражения?

Вот способ перевести (реализовать) структурный вызов типа для моего примера (синтаксис Java, но точка - это байт-код):

class DuckyDogTest {
  interface DuckType {
    void walk();
    void quack();
  }

  static void doTheThing(DuckType d) {
    d.quack();
  }

  static class Dog {
    public void walk() { System.out.println("Dog walk"); }
    public void quack() { System.out.println("Dog quack"); }
  }

  public static void main(String[] args) {
    final Dog d = new Dog();
    doTheThing(new DuckType() {
      public final void walk() { d.walk(); }
      public final void quack() { d.quack();}
    });
  }
}

Ответы

type T = { def quack(): Unit; def walk(): Unit }
def f(a: T, b: T) = 
  if (a eq b) println("They are the same duck!")
  else        println("Different ducks")

f(x, x) // x is a duck