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
    }
  }

AVK>А для меня есть. Видимо потому что написание серверов накладывает свой отпечаток на мировоззрение

Пристегните ремни! А то после последней катастрофы всех непристёгнутых по стенкам размазало, а все, кто был пристёгнут — сидели как живые...

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

class X : IX
{}

...

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

CS>animal = @dog;
CS>

class Base {}

interface IA
{
    void Foo();
}

class X : Base, IA
{
    void Bar1(); // адрес метода в памяти 0001
    void Foo(); // адрес метода в памяти 0002
}

class Y : Base, IA
{
    void Foo(); // адрес метода в памяти 0003
    void Bar2(); // адрес метода в памяти 0004
}

...

Base[] bs = new Base[]{new X(). new Y()};
(IA)bs[0].Foo(); // здесь должен быть вызов по адресу 0002
(IA)bs[1].Foo(); // а здесь должен быть вызов по адресу 0003

VD>Вот такую антиобъектную ересь я от тебя не ждал. Всю жизнь хорошие архитекторы закладывались на абстракцию и считали любые звсисимости не нее вредом. А тут оказывается, что это зло.

Вот хот-дог — это когда плескают в морду коньяком. Фрирайдеры это тоже делают, но они не знают, что когда они плескают в морду коньяком, они становятся хот-догерами. Понимаешь? Вот в чем разница. Во фрирайде можно все. Но есть ограничения. А в хот-доге ограничений просто нет. Потому что по определению их быть не может. Понимаешь?

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>

The most prominent difference is that they do not require declarations within a class of intention to implement an interface

any class can be used polymorphically

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 <...> space overhead of function dispatch tables.

virtual functions can lead to complex code, and violate object oriented principles such as information/implementation hiding. Virtual functions often lead to situiations where the objects are not tested properly for all possible inheritance scenarios.

Function pointers can be effectively implemented as intefaces with only one function. This helps simplify the language significantly when compared to C++ for instance.

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

ISomething ismt = (ISomething)obj;

animal = @dog;

class Base {}

interface IA
{
    void Foo();
}

class X : Base, IA
{
    void Bar1();
}

CS>IRef<typename A> 
CS>{
CS>  A *pa;
CS>  void* methods[] = {   
CS>    void (*A::Foo)();
CS>    int  (*A::Bar1)();
CS>    int  (*A::Bar2)(int);
CS>    ....
CS>  };
CS>}

А, кстати, что произойдет в C# в описанной ситуации (у класса X удалили void Foo())?

AVK>

AVK>class Base {}

AVK>interface IA
AVK>{
AVK>    void Foo();
AVK>}

AVK>class X : Base, IA
AVK>{
AVK>    void Bar1(); // адрес метода в памяти 0001
AVK>    void Foo(); // адрес метода в памяти 0002
AVK>}

AVK>class Y : Base, IA
AVK>{
AVK>    void Foo(); // адрес метода в памяти 0003
AVK>    void Bar2(); // адрес метода в памяти 0004
AVK>}

AVK>...

AVK>Base[] bs = new Base[]{new X(). new Y()};
AVK>(IA)bs[0].Foo(); // здесь должен быть вызов по адресу 0002
AVK>(IA)bs[1].Foo(); // а здесь должен быть вызов по адресу 0003

Я начал завидовать рабам. Они все знают заранее. У них тверррдые убеждения. Наверное потому, что у них нет выбора. А рыцарь — он всегда на растутье дорог.

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.

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

Generics and templates have a minor overlap in functionality. They both make it possible to create parameterized types which make it possible to create type safe collections. That’s where the similarity stops. First, let’s look at some features templates allow and how they are interpreted. I’ll assume that you know the syntax for templates.

Templates are instantiated at compile-time with the source code.
Templates are type safe.
Templates allow user-defined specialization.
Templates allow non-type parameters.
Templates use “lazy structural constraints”.
Templates support mix-ins.
Templates are instantiated at compile-time. This is huge. Anyone who really wants to understand the limitations of either generics or templates needs to know this.

AVK>class Base {}
AVK>interface IA
AVK>{
AVK>    void Foo();
AVK>}
AVK>class X : Base, IA
AVK>{
AVK>    void Bar1(); // адрес метода в памяти 0001
AVK>    void Foo(); // адрес метода в памяти 0002
AVK>}
AVK>class Y : Base, IA
AVK>{
AVK>    void Foo(); // адрес метода в памяти 0003
AVK>    void Bar2(); // адрес метода в памяти 0004
AVK>}
AVK>...
AVK>Base[] bs = new Base[]{new X(). new Y()};
AVK>(IA)bs[0].Foo(); // здесь должен быть вызов по адресу 0002
AVK>(IA)bs[1].Foo(); // а здесь должен быть вызов по адресу 0003
AVK>

class X {
  void Bar1(); 
  void Foo(); 
}
class Y {
  void Bar2(); 
  void Foo(); 
}

interface IFoo
{
   void Foo();
}

IFoo foos[] = { new X(), new Y() } 
/* в этой строке произойдет построение локальных интерфейсных
таблиц IFoo для классов X и Y и ссылки на них сохранятся в экземлярах IFoo */

foos[0].Foo();
foos[1].Foo();

interface ISupportInitialize
{
    void Initialize();
}

class Control {}

class SomeCustomControl : Control, ISupportInitialize
{
    public void Initialize();
}

...

foreach (ControlDescription cd in ControlDescriptions)
{
    Control c = CreateControl(cd);
    ISupportInitialize isi = c as ISupportInitialize;
    if (isi != null)
        isi.Initialize();
}

AVK>Какой ты хитрый. Я тебя не спрашиваю как мне полиморфный код сделать неполиморфным. Для примера делать это бессмысленно, поскольку это игрушечный код. Убери к примеру из одного из классов метод Foo () (и вызов его соотв.), а в контейнере класс оставь, и все, приехали.

IFoo foos[] = { new X(), new Y() }

MS>IFoo foos[] = { new X(), new Y() } 
MS>

template<typename T>
  void Bar(T& t) {  
   t.Foo(); // здесь проблема - какую Foo подставлять.
}

interface IW 
{
  int Foo();
}

void Bar(IW t) 
{  
   t.Foo(); // здесь проблемы нет
}

class Base {}

interface IA
{
    void Foo();
}

class X : Base, IA
{
    void Bar1(); // адрес метода в памяти 0001
    void Foo(); // адрес метода в памяти 0002
}

class Y : Base, IA
{
    void Foo(); // адрес метода в памяти 0003
    void Bar2(); // адрес метода в памяти 0004
}

...

Base[] bs = new Base[]{new X(). new Y()};
(IA)bs[0].Foo(); // здесь должен быть вызов по адресу 0002
(IA)bs[1].Foo(); // а здесь должен быть вызов по адресу 0003

interface IOnClick {
  void onclick();
}

class Observable 
{
  IOnClick onclick;
}

class Observer
{
  void onclick() { printf("Gotcha!"); }
}

Observable observable;
Observer   observer;

observable.onclick = @observer;

А какие от этого бенефиты, кроме повышения зависимости от опечаток?

Бросай ружье, да всплывай...

   class Base {}
   interface IA
   {
      void Foo();
   }
   class X : Base//, IA
   {
      public void Bar1(){}
      //public void Foo(){}
   }
   class Y : Base, IA
   {
      public void Foo(){}
      public void Bar2(){}
   }
   . . .
   Base[] bs = new Base[]{new X(), new Y()};
   ((IA)bs[0]).Foo(); // здесь должен быть вызов по адресу 0002
   ((IA)bs[1]).Foo(); // а здесь должен быть

Убери к примеру из одного из классов метод Foo () (и вызов его соотв.), а в контейнере класс оставь, и все, приехали.

using System;

class Program
{
    static void Main(string[] args)
    {
        Base[] bs = new Base[]{new X(), new Y()};
        ((IA)bs[0]).Foo(); // 0002
        ((IA)bs[1]).Foo(); // 0003
    }
}

class Base {}

interface IA
{
    void Foo();
}

class X : Base, IA
{
    public void Bar1() { } // 0001
    public void Foo() { } // 0002
}

class Y : Base//, IA
{
    //public void Foo() { } // 0003
    public void Bar2() { } // 0004
}

class C
 {
  public:
  
   int method1();
   double method2();
 };

struct MethodMap
 {
  int (::*method1)();
  double (::*method2)();
  
  template <class T>
  explicit MethodMap(T &x)
   {
    method1 = x .* &T::method1 ;
    method2 = x .* &T::method2 ;
   }
 };

/* main() */ 

int main()
 {
  C c;
  
  MethodMap map(c);
  
  int x=map.method1();
  double y=map.method2();
 
  return 0;
 }

I believe I could write macros to allow you to generate baz with:

DECLARE_INTERFACE(
baz,
((int)(foo)(int))
((int)(bar)(char const*))
);

If I get a few minutes maybe I'll hack them up for fun.

  BOOST_INTERFACE_BEGIN(IShape)
    BOOST_INTERFACE_CONST_FUNCTION0(GetX, int)
    BOOST_INTERFACE_CONST_FUNCTION0(GetY, int)
    BOOST_INTERFACE_CONST_FUNCTION0(GetArea, double)
    BOOST_INTERFACE_FUNCTION2(SetXY, void, (int, x), (int, y))
    BOOST_INTERFACE_FUNCTION2(OffSetXY, void, (int, x), (int, y))
    BOOST_INTERFACE_CONST_FUNCTION0(GetName, const char*)
  BOOST_INTERFACE_END(IShape)