IA = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
END;
IB = INTERFACE (IA)
  PROCEDURE h();
  PROCEDURE k();
END;

IA = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
END;
IB = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
  PROCEDURE h();
  PROCEDURE k();
END;

g(N) = N + N*(N-1)/2! + N*(N-1)*(N-2)/3! + ... = 2^N — 2

Iabc = INTERFACE
   PROCEDURE a();
   PROCEDURE b();
   PROCEDURE c();
  END;

Iab = INTERFACE
   PROCEDURE a();
   PROCEDURE b();
  END;
Iac = INTERFACE
   PROCEDURE a();
   PROCEDURE c();
  END;
Ibc = INTERFACE
   PROCEDURE b();
   PROCEDURE c();
  END;
Ia = INTERFACE
   PROCEDURE a();
  END;
Ib = INTERFACE
   PROCEDURE b();
  END;
Ic = INTERFACE
   PROCEDURE c();
  END;

REAL >= SHORTREAL >= LONGINT >= INTEGER >= SHORTINT >= BYTE

TMyCalculator = CLASS (TInterfacedObject, ICalculate, IStorable, IPaintable, ...)
  //...
END;

Ia = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
END;

Ib = INTERFACE
  FUNCTION  GetA(): Ia; // вот она - агрегация какая
  PROCEDURE h();
  PROCEDURE k();
END;

VAR
  b: Ib;
BEGIN

  //...

  b.GetA.f();

f x = x.method 1 "1"

I1 = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
END;

I2 = INTERFACE
  PROCEDURE f();
  PROCEDURE g();
  PROCEDURE h();
  PROCEDURE k();
END;

VAR a: I1;
    b: I2;

//...

 a := b; // хочу чтобы это было разрешено! Так как "I2" включает в себя все методы "I1"

SYG>I1 = INTERFACE
SYG>  PROCEDURE f();
SYG>  PROCEDURE g();
SYG>END;

SYG>I2 = INTERFACE
SYG>  PROCEDURE f();
SYG>  PROCEDURE g();
SYG>  PROCEDURE h();
SYG>  PROCEDURE k();
SYG>END;

SYG>VAR a: I1;
SYG>    b: I2;

SYG>//...

SYG> a := b; // хочу чтобы это было разрешено! Так как "I2" включает в себя все методы "I1"
SYG>

/* Пример напиан по мативам книги "Как размножаются ёжики". За основу взято предложение: За окном шёл снег и рота краснармейцев. ;-) */
class Рота_Красноармейцев
{
 public:
    void Идёт();
};

class Снег
{
 public:
    void Идёт();
};

Снег obj1;
Рота_Красноармейцев obj2 = obj1; // Постойте, "рота красноармейцев" не то же самое что и "снег"!
obj2.Идёт();      // Да и ходят они по разному!!

        D
 (A)----<----(B)

                         D3
                  (X)----<-----(X)
                 /
                /D2
       D1      /
 (X)----<----(X)
               \
                \
                 \D4
                  \
                   \      D5
                   (X)----<------(X)

                 (X)-........-(X)
                 /
                .
               /
 (X)-.......-(X)
               \
                .
                 .
                  .
                   \      
                   (X)-........-(X)

public interface IList : ICollection, IEnumerable

interface F {
  void f();
}

class A {
  f, g
}

class B {
  f, h
}

void f(F f) {
  f->f();
}

void main() {
  A a;
  B b;
  f((F)A); f((F)B);
}

interface IБоеваяЕдиница
{
 public:
    void Идёт();
};

void ИзменитьДислокацию(IБоеваяЕдиница obj)
{
    obj.Идёт();
}

Снег снег;
ИзменитьДислокацию((IБоеваяЕдиница)снег); // Н-да... вы уверены, что именно это имели в виду?

class Foo : public IFoo, public IBar

    // some Node class
    class Node {
    public:
        void    get( int &value, const char *key );
        void    set( int value, const char *key );
        // ... etc
    };

    // VTFable for INode
    struct INodeVFT {
        bool (*int_get)(void *node, int *v, const char *key, ErrorInfo *e);
        bool (*int_set)(void *node, int v, const char *key, ErrorInfo *e);
        // ... etc
    };

    // отделенный обертывающий интерфейс
    struct INode {
        void            *node; // некий узел не обязательно Node
        const INodeVFT    *vft;  // самодельная в-тейбл.

    public:
        int int_get( const char *key ) // функция хелпер для удобства
        {
            int i;
            ErrorInfo e;
            if ( (vft->int_get)( node, &i, key, &e ) )
                return i;
            throw Error(e);
        }
    };

    // поскольку нет наследования то "оператор" приведения типа прилагается
    void wrap( Node *n, INode &node )
    {
        node.node = n;
        node.vft  = &NodeVFT;
    }

    // a это оборачиватель для ThirdParty Node
    void wrap( ThirdPartyNode *n, INode &node )
    {
        node.node = n;
        node.vft  = &ThirdPartyNodeVFT;
    }

// ==================================================================
// юзалось это так:
// ==================================================================

    void acceptMyNode( Node *n )
    {
        INode node;
        wrap( n, node );
        doNodeWork( node );
    }

    void acceptThirdPartyNode( ThirdPartyNode *n )
    {
        INode node;
        wrap( n, node );
        doNodeWork( node );
    }

    void doNodeWork( INode node )
    {
        int x = node.int_get("FooBar");
    }

interface IWavPlayer // Интерфейс проигрывателя wav-файлов
{
 public:
    void Play();
};
class MainGameObject // Основной объект игры
{
 public:
    void Play();
};

PlayMusic(IWavPlayer player) // некий метод, который проигрывает музыку в фоне.
{
    // запуск нового потока
    player.Play();
}
MainGameObject game;
PlayMusic((IWavPlayer)game); // И?!!

Предположим, у нас есть бизнес кейз такой-то. Мы реализуем его вот так-то и так-то.
Теперь у нас изменился набор требований. Мы меняем вот этот класс вот так-то.
А вот теперь мы вынуждены сделать то-то и то-то, а это тяжелый ручной труд. Я предлагаю сделать так, чтобы работало то-то и то-то. Тогда в случаях, подобных описанному, произойдет то-то и то-то, и все станет работать само.

struct INode 
{
    int get(const char *key);
    void set(int value, const char *key);
};

class NodeWrapper : public INode
{
    private:
        const Node &wrapped;
    public: 
        // type conversion operator
        NodeWrapper(Node &toWrap) : wrapped(toWrap){};
    public: 
      // INode implementation
      int get( const char *key )
        {
          int value;
            wrapped.get(value, key);
            return value;
        }
        void set(int value, const char *key)
        {
          wrapped.set(value, key);
        }
}

...
void acceptMyNode(Node &n)
    {
        doNodeWork(n);
    }

    void acceptThirdPartyNode( ThirdPartyNode &n )
    {
        doNodeWork(n);
    }

    void doNodeWork(INode node )
    {
        int x = node.get("FooBar");
    }

class ThirdPartyNodeWrapper : public ThirdPartyNode, public INode
{
  public ThirdPartyNodeWrapper(&ThirdPartyNode node): ThirdPartyNode(node){};
}

S>struct INode 
S>{
S>    int get(const char *key);
S>    void set(int value, const char *key);
S>};

S>class NodeWrapper : public INode
S>{
// дальше поскипано.
S>

// вспомогательные классцы
struct ErrInfo {
    // поскипан
};

struct Error {
    Error( ErrInfo& ) {}
};

// class MyNode - его будем враппить
struct MyNode {
    int get( const char *key ) { return (int)key; }
};

// ВФ-Тейбл
struct INodeVFT {
    bool    (*int_get)(void*, const char*, int*, ErrInfo*);
    bool    (*int_set)(void*, const char *, int, ErrInfo*);
};

// W-интерфейс
struct INode {
    void              *xp;
    const INodeVFT    *vt;

public:
// хелперы:
    int int_get( const char *key )
    {
        ErrInfo e; int i;
        if ( (*vt->int_get)(xp, key, &i, &e) )
            return i;
        throw Error(e);
    }

    void int_set( const char *key, int value )
    {
        ErrInfo e;
        if ( (*vt->int_set)(xp, key, value, &e) )
            return;
        throw Error(e);
    }
};

// INode wrapper base
template <class This, class T>
struct WNodeImp {
    static const INodeVFT    vt;

// методы по дефлоту:
    static bool    int_get(void*, const char*, int*, ErrInfo*) { return false; }
    static bool    int_set(void*, const char *, int, ErrInfo*) { return false; }

    friend void wrap( T *node, INode &inode )
    {
        inode.xp = node;
        inode.vt = &vt;
    }
};

template <class This, class T>
const INodeVFT WNodeImp<This,T>::vt =
{
    This::int_get,
    This::int_set
};

// INode wrapper for MyNode
struct WMyNode : WNodeImp<WMyNode,MyNode>
{
    static bool int_get( void *x, const char *k, int *rv, ErrInfo* )
    {
        MyNode *n = (MyNode*)x;
        *rv = n->get(k);
        return true;
    }
};

// testing
void work_do( INode node )
{
    int x = node.int_get("ZZz");
    try {
        node.int_set("dgdf", 10); // not implemented
    } catch( Error& )
    {
    }
}

void learn()
{
    MyNode    node;
    INode        inode;
    wrap( &node, inode );

    work_do( inode );

    return;
}

S>class ThirdPartyNodeWrapper : public ThirdPartyNode, public INode
S>{
S>  public ThirdPartyNodeWrapper(&ThirdPartyNode node): ThirdPartyNode(node){};
S>}
S>

UNIT M1;

  TYPE
    IDocument = INTERFACE
      PROCEDURE OpenDocument();
      PROCEDURE CheckDocument();
      PROCEDURE CloseDocument();
    END;

    IDocuments = INTERFACE
      PROCEDURE IncludeDocument(doc: IDocument);
      PROCEDURE ExcludeDocument(doc: IDocument);
      PROCEDURE CheckDocuments();
    END;

  FUNCTION NewDocuments(): IDocuments;

END.

UNIT M2;

  TYPE
    ISuperDocument = INTERFACE
      PROCEDURE OpenDocument();
      PROCEDURE CheckDocument();
      PROCEDURE CloseDocument();
      PROCEDURE GetWriter(OUT Writer: IWriter);
      PROCEDURE GetReader(OUT Reader: IReader);
    END;

  FUNCTION NewSuperDocument(): ISuperDocument;

END.

M2.ISuperDocument >= M1.IDocument;

СГ>UNIT M1;
СГ>UNIT M2;
СГ>

// что-то типа
interface IFoo {
   int  foo();
   void bar();
};

class Some {
   int  dummy();
   void mummy();
};

wrapper Some : IFoo {
   foo = dummy;
   bar = mummy;
};

void test( Some &s )
{
   IFoo &foo = s; // компилер заюзает то что написано во wrapper Some
   foo.foo();
}

K>// что-то типа
K>interface IFoo {
K>   int  foo();
K>   void bar();
K>};

K>class Some {
K>   int  dummy();
K>   void mummy();
K>};

K>wrapper Some : IFoo {
K>   foo = dummy;
K>   bar = mummy;
K>};

K>void test( Some &s )
K>{
K>   IFoo &foo = s; // компилер заюзает то что написано во wrapper Some
K>   foo.foo();
K>}

K>

Node.get(a, b) <-> a=INode.get(b)

S>Node.get(a, b) <-> a=INode.get(b)
S>

S>

TVINSERTSTRUCT args;
args.hParent = ...;
args.hInsertAfter = ...;
args.item.mask = TVIF_IMAGE | TVIF_PARAM ...;
// еще куча всякой инициализации
TreeView_InsertItem(hwnd,&args);

// сигнатура в интерфейсе:
ITreeItem ITree::insert( string name, ITreeItem parent, ITreeItem after );

// сгенеренная враппер функция:
bool MyTreeWrp::insert( MyTree &This, ITreeItem *retval, string name, ITreeItem parent, ITreeItem after, ErrorInfo *e )
{
}

void foo(INode n)
{
   ICoolNode cn = wrapper_cast<ICoolNode>(n);
}