retrofit polymorphism : Heron does not require a class to explicitly state which interfaces it implements, interface implementation is determined by whether the function signatures match

types {
    class Dog {
      MakeSound() : String {
        return "woof";
      }
      GetNumLegs() : Int {
        return 4;
      }
      GoFetch() {
        // ...
      }
    }

    class Duck {
      GetNumLegs() : Int {
        return 2;
      }
      MakeSound() : String {
        return "quack";
      }
      FlySouth() {
        // ...
      }
    }

    interface IAnimal {
      MakeSound() : String;
      GetNumOfLegs() : Int;
    }  }
  functions {
    _main() {
      IAnimal& animal;
      Dog dog;
      Duck duck;
      animal = @dog;
      P(animal.MakeSound()); // outputs woof
      animal = @duck;
      P(animal.MakeSound()); // outputs quack
    }
  }

template<typename T>
  void foo(T& t) { t.bar(); }

ISomething ismt = (ISomething)obj;

animal = @dog;

CS>ISomething ismt = (ISomething)obj;
CS>

class X : IX
{}

...

X x = new X();
IX ix = (IX)x;

CS>animal = @dog;
CS>

CS>>ISomething ismt = (ISomething)obj;
CS>>

CS>>animal = @dog;
CS>>

IAnimal animal;

class Base {}

class C : Base, IA {}

interface IA {}

...

Base b = new C();
IA ia = (IA)b; // здесь компилятор отрезолвить интерфейс не может

CS>IAnimal animal;
CS>

AVK>class Base {}
AVK>class C : Base, IA {}
AVK>interface IA {}
AVK>...
AVK>Base b = new C();
AVK>IA ia = (IA)b; // здесь компилятор отрезолвить интерфейс не может
AVK>

CS>>IAnimal animal;
CS>>

Polymorphism without Space Overhead
Because polymorphism is provided externally to a class, it means that any class can be used polymorphically and also that there is no overhead of vtable pointers within a class. Most OOP languages, if not all, require a significant overhead to provide polymorphic behaviour.

The only caveat is that the interface references are typically twice the width of an an ordinary reference ( technically this is not neccessarily the case, as I will explain below ). On the other hand the overhead of multiple interface implementation in other languages is considerably more significant.

Polymorphism only when Needed
Another advantage of the Heron interfaces approach, is that you don't need to incur any of the cost of run-time polymorphism, until when and if you explicitly require it. That cost includes the inability to inline functions, the performance hit of dynamic dispatch and the space overhead of function dispatch tables.