ания  (что   вряд  ли   приемлимо),   множественное
наследование только  от  специальных абстрактных классов-<i>интерфейсов</i>  (такой
подход   принят    в    Java),   наследование    только   от   неродственных
классов-родителей, и, наконец, наследование без каких-либо ограничений.

     Есть  достаточно много  неясных вопросов, связанных с  аспектами <i>защиты
содержимого  классов</i>.  В  настоящей  редакции  языка  принят  намного  более
либеральный  подход  к  этому  вопросу,  чем  в  C++ и Java.  Язык допускает
разнообразные   механизмы  инициализации  экземпляра   класса  (экземпляром,
списком  компонент, конструктором и, наконец, всегда доступна автоматическая
неявная  инициализация). Как правило,  объекты всегда инициализируются неким
"разумным" образом,  однако может  возникнуть  потребность  и в  классах  --
"черных  ящиках",  инициализация  которых  происходит   исключительно  через
посредство  конструкторов.  С  самой  семантикой  конструкторов  также  есть
некоторые неясности.

     Наконец,  дискуссионным  является вопрос о  том, какие  средства должны
быть  встроены  в  язык, а какие --  реализованы в стандартных  библиотеках.
Например, <i>обработка исключений</i> (а  в будущем, возможно,  и  <i>многопоточность</i>)
планировалось  реализовать как внешние  библиотечные  средства -- но  против
такого подхода также есть серьезные возражения.

     Впрочем, что бы не планировали разработчики -- окончательный выбор, как
мы надеемся, будет принадлежать самим пользователям языка.

     Заключение

     В  заключение  приведем   небольшой,   но  вполне  реалистичный  пример
завершенного   Ксерион-модуля,   реализующего   простейшие   операции    над
комплексными числами.

     !!
!! Исходный файл: <i>"complex.xrn"</i>
!! Реализация класса `complex`:
!! комплексные числа (иммутабельные)
!!

!! внешние функции (в реальной программе импортируемые):
<b>double</b> (<b>double</b> x, y) #atan2; !! двухаргументный арктангенс
<b>double</b> (<b>double</b> x, y) #hypot; !! гипотенуза
<b>double</b> (<b>double</b> x) #sqrt; !! квадратный корень

     <b>class</b> complex {
     !! компоненты класса
     <b>double</b> Re, Im; !! (real, imag)

     !! [Унарные операции над %complex]
     %complex (%complex op1) %opUnary;

     %opUnary #conj; !! Сопряжение
     %opUnary #neg; !! Отрицание
     %opUnary #sqrt; !! Квадратный корень

     !! [Бинарные операции над %complex]
     %complex (%complex op1, op2) %opBinary;

     %opBinary #add; !! Сложение
     %opBinary #sub; !! Вычитание
     %opBinary #mul; !! Умножение
     %opBinary #div; !! Деление

     !! Проверка на нуль
     <b>bool</b> () is_zero { <b>return</b> Re -- 0f &amp;&amp; Im -- 0f };

     !! [Сравнения для %complex]
     <b>bool</b> (%complex op1, op2) %opCompare;

     !! (на равенство):
     %opCompare eq { <b>return</b> op1.Re -- op2.Re &amp;&amp; op1.Im -- op2.Im };
     !! (на неравенство):
     %opCompare ne { <b>return</b> op1.Re &lt;&gt; op2.Re || op1.Im &lt;&gt; op2.Im
};

     !! Модуль
     <b>double</b> (%complex op) mod { <b>return</b> hypot (op.Re, op.Im) };
     !! Аргумент
     <b>double</b> (%complex op) arg { <b>return</b> atan2 (op.Re, op.Im) };
     };

     !! Реализация предекларированных функций

!! Сопряженное для op1
#complex.conj { <b>return</b> #(op1.Re, - op1.Im) };

!! Отрицание op1
#complex.neg { <b>return</b> #(- op1.Re, - op1.Im) };

!! Сложение op1 и op2
#complex.add { <b>return</b> #(op1.Re + op2.Re, op1.Im + op2.Im) };

!! Вычитание op1 и op2
#complex.sub { <b>return</b> #(op1.Re - op2.Re, op1.Im - op2.Im) };

!! Произведение op1 и op2
#complex.mul {
     <b>return</b> #(op1.Re * op2.Re - op1.Im * op2.Im,
     op1.Im * op2.Re + op1.Re * op2.Im)
     };

!! Частное op1 и op2
#complex.div {
     !! (делитель должен быть ненулевой)
     <b>assert</b> ~op2.is_zero ();

     <b>double</b> denom = op2.Re * op2.Re + op2.Im * op2.Im;
     <b>return</b> # ((op1.Re * op2.Re + op1.Im * op2.Im) / denom,
     - (op1.Re * op2.Im + op2.Re * op1.Im) / denom)
     };

<b>let</b> g_sqrt = sqrt; !! (глобальная функция `sqrt`)

!! Квадратный корень из op1 (одно из значений)
#complex.sqrt {
     <b>double</b> norm = complex.mod (op1);
     <b>return</b> #(g_sqrt ((norm + op1.Re) / 2f), g_sqrt ((norm - op1.Re) / 2f))
     };

     !!
!! Операции для работы с complex
!!

!! унарный '-' как отрицание
<b>opdef</b> -complex = complex.neg ((&lt;1&gt;));
!! унарный '~' как сопряжение
<b>opdef</b> ~complex = complex.conj ((&lt;1&gt;));

!! бинарный '+' как сложение
<b>opdef</b> complex + complex = complex.add ((&lt;1&gt;), (&lt;2&gt;));
!! бинарный '-' как вычитание
<b>opdef</b> complex - complex = complex.sub ((&lt;1&gt;), (&lt;2&gt;));
!! бинарный '*' как умножение
<b>opdef</b> complex * complex = complex.mul ((&lt;1&gt;), (&lt;2&gt;));
!! бинарный '/' как деление
<b>opdef</b> complex / complex = complex.div ((&lt;1&gt;), (&lt;2&gt;));