." hello world!..." 123
  |               ||
  |               |+-- третий разделитель дефолтный
  |               +-- второй разделитель - заявлен командой ." (печать текста)
  +-- первый разделитель дефолтный

К тому же такой подход четко следует духу Oberon’а — избегать любых скрытых механизмов.

MODULE TestBaseType;

TYPE Base = POINTER TO BaseBody;
     BaseBody = RECORD ... END;

(**************************************)

MODULE TestDerivedType;

IMPORT TestBaseType;

TYPE Derived = POINTER TO DerivedBody;
     DerivedBody = RECORD(TestBaseType.BaseBody) ... END;

(**************************************)

MODULE TestBaseMethod;

IMPORT TestBaseType;

PROCEDURE (obj: Base) Method* () BEGIN ... END;

(**************************************)

MODULE TestDerivedMethod;

IMPORT TestDerivedType;

PROCEDURE (obj: Derived) Method* () BEGIN ... END;

(**************************************)

MODULE TestCreateObject;

IMPORT TestBaseType, TestDerivedType;

PROCEDURE Create(): Base BEGIN Create := NEW Derived; END;

(**************************************)

MODULE TestPlayObject;

IMPORT TestBaseType, TestCreateObject;
(* какие из модулей Test???Method нужно импортировать? *)
(* вероятно, TestBaseMethod, ведь мы не знаем здесь о существовании Derived *)
IMPORT TestBaseMethod;

PROCEDURE Play*
VAR obj: TestBaseType.Base;
BEGIN
  obj = TestCreateObject.Create();
  obj.Method();
END;

Invoke: (dynamic_type,method_id) -> implementation

Vmt: {static_type,} dynamic_type -> (method_id->implementation)
Invoke(t,m) = Vmt(t)(m)

Slot: {static_type,} method_id -> (dynamic_type->implementation)
Invoke(t,m) = Slot(m)(t)

Процедуры, привязанные к типу, могут быть объявлены в произвольном порядке. Их можно даже перемежать процедурами, привязанными к другому типу. В языке Object Oberon, где все методы должны быть объявлены внутри соответствующего объявления класса, обнаружилось, что косвенная рекурсия между методами различных классов может поставить в затруднительное положение предварительные описания целых классов.

Мы также отказались от дублирования в самой записи заголовков типизированных процедур, как это сделано в других языках типа C++ и Object Pascal. Это позволяет сохранить записи короткими и избежать избыточности описаний. Ведь изменение в заголовке тогда повлекло бы за собой корректировку в двух разных местах программы, к тому же компилятору пришлось бы еще и проверять идентичность обоих заголовков. Если программист захочет увидеть конкретную запись со всеми связанными с ней процедурами, то он может для получения информации на экране или на листе бумаги воспользоваться специальным инструментом, который называется навигатор модулей (browser).

MODULE SomeMyModule;

(* forward declarations of classes *)
TYPE
  Foo = POINTER TO FooDesc;
  Bar = POINTER TO BarDesc;

(* declaration of class Foo and its methods *)
TYPE
  FooDesc = RECORD ... END;
PROCEDURE^ (this: Foo) foo* ();
PROCEDURE^ (this: Foo) bar* ();

(* declaration of class Bar and its methods *)
TYPE
  BarDesc = RECORD ... END;
PROCEDURE^ (this: Bar) xyz* ();
PROCEDURE^ (this: Bar) tuv* ();

(* declaration of global procedures *)
PROCEDURE^ test* (a: Foo, b: Bar);

(* implementation of procedures *)

(* methods of Foo *)
PROCEDURE (this: Foo) foo* () BEGIN (* TODO: code goes here *) END foo;
PROCEDURE (this: Foo) bar* () BEGIN (* TODO: code goes here *) END bar;

(* methods of Bar *)
PROCEDURE^ (this: Bar) xyz* () BEGIN (* TODO: code goes here *) END xyz;
PROCEDURE^ (this: Bar) tuv* () BEGIN (* TODO: code goes here *) END tuv;

(* global procedures *)
PROCEDURE^ test* (a: Foo, b: Bar) BEGIN (* TODO: code goes here *) END test;

BEGIN
 (* TODO: module startup code goes here *)
END SomeMyModule;

class A
{
    void f1(B b)
    {
        b.f2(this);
    }
    
    void f3() {}
}

class B
{
    void f2(A a)
    {
        a.f3();
    }
}

class A
{
    B _b;
}

class B
{
    A _a;
}

VD>class A
VD>{
VD>    B _b;
VD>}

VD>class B
VD>{
VD>    A _a;
VD>}
VD>

TYPE
  A = POINTER TO RECORD 
    b: B;
  END;

  B = POINTER TO RECORD 
    a: A;
  END;

MODULE M1;

TYPE
  A = POINTER TO RECORD 
    b: B;
  END;

  B = POINTER TO RECORD 
    a: A;
  END;


(* Предварительное "^" объявление процедуры Bbb() связанной с типом B *)
PROCEDURE^ (t: B) Bbb (), NEW;



(* Объявление и Определение процедуры Aaa() связанной с типом A *)
PROCEDURE(t: A) Aaa (), NEW;
BEGIN
  t.b.Bbb(); (* <--- Вызов объявленной выше, но еще не определенной процедуры Bbb() *)
END Aaa;



(* Определение объявленной ранее процедуры Bbb() связанной с типом B *)
PROCEDURE(t: B) Bbb(), NEW;
BEGIN
  t.a.Aaa();
END Bbb;


END M1.

PROCEDURE^ (t: B) Bbb (), NEW;

a * b;

a(b);

ПК>А никто не говорил, что будет легко

for (;;) ;