Ada_Ru форум

Обсуждение языка Ада

Ada2005 & Gnat 2007

Оставить новое сообщение

Сообщения

Alexey Veselovsky
Ada2005 & Gnat 2007
2008-07-02 07:37:50

Что-то у меня примерчик не получается с новой нотацией вызовов

примитивных функция/процедур для теговых типов...

 

-- Спецификация пакета

package Objects is

 

type Obj is tagged record

I : Integer;

end record;

 

procedure Foo (Self : Obj);

 

end Objects;

 

-- Тело пакета

package body Objects is

 

procedure Foo (Self : in out Obj) is

begin

null;

end Foo;

 

begin

null;

end Objects;

 

-- Главная процедура

with Objects; use Objects;

 

procedure Test is

O : Obj;

begin

O.I := 10;

O.Foo; -- ошибка тут

null;

end Test;

 

---------------------

 

Компилятор ругается следующими словами:

test.adb:7:05: no selector "Foo" for type "Obj" defined at objects.ads:3

Что я делаю не так?

On Wed, 2 Jul 2008 11:37:50 +0400, you wrote:

 

Что-то у меня примерчик не получается с новой нотацией вызовов

примитивных функция/процедур для теговых типов...

[...]

Что я делаю не так?

 

Скорее всего, забыли ключ -gnat05. За исключением несовместимости описания и реализации подпрограммы Foo, Ваша программа законна.

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

$B'9'd'`(B $B'q(B $B'U'V']'Q'p(B $B'_'V(B $B'd'Q'\(B?

 

$B'3'\'`'b'V'V(B $B'S'c'V'T'`(B, $B'Y'Q'R'm']'Z(B $B'\']'p'i(B -gnat05. $B')'Q(B $B'Z'c'\']'p'i'V'_'Z'V'^(B $B'_'V'c'`'S'^'V'c'd'Z'^'`'c'd'Z(B $B'`'a'Z'c'Q'_'Z'q(B

$B'Z(B $B'b'V'Q']'Z'Y'Q'h'Z'Z(B $B'a'`'U'a'b'`'T'b'Q'^'^'m(B Foo, $B'#'Q'j'Q(B $B'a'b'`'T'b'Q'^'^'Q(B $B'Y'Q'\'`'_'_'Q(B.

 

$B'2'Q'Y'`'R'b'Q']'c'q(B. $B'5(B $B'^'V'_'q(B $B'_'Q(B $B'c'Q'^'`'^(B $B'U'V']'V(B $B'c'd'`'Z'd(B $B'U'S'Q(B MinGW -- $B'`'U'Z'_(B $B'`'R'm'i'_'m'[(B, $B'U']'q(B

$B'a']'p'c'`'S(B, $B'U'b'e'T'`'[(B -- $B'd'`'d(B $B'i'd'`(B GNAT GPL $B'c(B $B'c'`'R'`'[(B $B'd'q'_'V'd(B $B'S(B $B'S'Z'_'U'e(B. $B'#(B $B'a'e'd'q'g(B $B'_'Q(B

$B'a'V'b'S'`'^(B $B'^'V'c'd'V(B $B'c'd'`'Z'd(B MinGW $B'`'R'm'i'_'m'[(B (gcc 3.4) $B'S(B $B'c'`'c'd'Q'S(B $B'\'`'d'`'b'`'T'`(B, $B'\'Q'\(B

$B'`'\'Q'Y'Q']'`'c'n(B $B'd'`'X'V(B $B'S'g'`'U'Z'](B gnat. $B'1'b'Z'i'V'^(B $B'T'_'Q'd(B $B'U'b'V'S'_'Z'[(B, 2004 $B'T'`'U'Q(B $B'b'`'X'U'V'_'Z'q(B.

GPS $B'c'`'`'d'S'V'd'c'd'S'V'_'_'`(B $B'a'`'U'g'S'Q'd'm'S'Q']'`(B $B'd'`'d(B $B'c'Q'^'m'[(B, $B'U'b'V'S'_'Z'[(B $B'T'_'Q'd(B. $B'*(B $B'_'Q(B $B'\']'p'i'Z'\(B

-gnat2005 $B'b'e'T'Q']'`'c'n(B $B'a']'`'g'Z'^'Z(B $B'c']'`'S'Q'^'Z(B.

$B'1'`'a'b'Q'S'Z'](B $B'a'e'd'Z(B. $B'4'V'a'V'b'n(B $B'c'`'R'Z'b'Q'V'd'c'q(B.

 

PS. $B'!(B $B'\']'p'i'Z'\(B -gnat05 $B'_'V(B $B'_'e'X'V'_(B. $B'0'_'`(B $B'Z(B $B'd'Q'\(B $B'a'`(B $B'e'^'`']'i'Q'_'Z'p(B.

PPS. $B'!(B $B'a'`'i'V'^'e(B $B'o'd'Q(B $B'_'`'d'Q'h'Z'q(B ($B'i'V'b'V'Y(B $B'd'`'i'\'e(B) $B'S'S'V'U'V'_'Q(B $B'd'`']'n'\'`(B $B'U']'q(B $B'd'o'T'`'S'm'g(B

$B'd'Z'a'`'S(B? $B'#(B $B'3(B++ $B'_'Q'a'b'Z'^'V'b(B, $B'o'd'Q(B $B'_'`'d'Q'h'Z'q(B $B'a'b'Z'^'V'_'q'd'c'q(B $B'\'`(B $B'S'c'V'^(B $B'd'Z'a'Q'^(B ($B'\'b'`'^'V(B

$B'a'b'Z'^'Z'd'Z'S'_'m'g(B $B'Q'\'Q(B int $B'Z(B $B'd(B.$B'a(B.)...

$B'/'e(B, $B'Z(B $B'U'`(B $B'\'e'i'Z(B, $B'a'`'i'V'^'e(B $B'S(B $B'!'U'V(B $B'_'V'd(B $B'^'V'd'`'U'`'S(B-$B'b'Q'c'j'Z'b'V'_'Z'[(B ($B'\'Q'\(B $B'_'Q'a'b'Z'^'V'b(B $B'V'c'd'n(B

$B'S(B C#) -- $B'd(B.$B'V(B. $B'S'`'Y'^'`'X'_'`'c'd'n(B $B'U'`'R'Q'S'Z'd'n(B $B'a'b'Z'^'Z'd'Z'S'_'e'p(B $B'`'a'V'b'Q'h'Z'p(B $B'\(B

$B'\']'Q'c'c'e(B/$B'd'o'T'`'S'`'^'e(B $B'd'Z'a'e(B $B'S(B $B'U'b'e'T'`'^(B $B'a'Q'\'V'd'V(B. IMHO, $B'o'd'`(B $B'R'm(B $B'c'^'`'d'b'V']'`'c'n(B $B'S(B $B'!'U'V(B

$B'R'`']'V'V(B $B'`'b'T'Q'_'Z'i'_'`(B $B'_'V'X'V']'Z(B $B'S(B $B'3(B#.

 

---

$B'.'V'd'`'U'm(B-$B'b'Q'c'j'Z'b'V'_'Z'q(B $B!=(B $B'U'`'R'Q'S']'V'_'Z'V(B $B'^'V'd'`'U'Q(B $B'S(B $B'c'e'k'V'c'd'S'e'p'k'Z'[(B $B'\']'Q'c'c(B $B'c(B $B'a'`'^'`'k'n'p(B

$B'\']'p'i'V'S'`'T'`(B $B'c']'`'S'Q(B this $B'a'b'Z(B $B'a'V'b'S'`'^(B $B'a'Q'b'Q'^'V'd'b'V(B $B'c'd'Q'd'Z'i'V'c'\'`'[(B $B'f'e'_'\'h'Z'Z(B.

---

On Wed, 2 Jul 2008 12:51:20 +0400, you wrote:

 

PS. А ключик -gnat05 не нужен. Оно и так по умолчанию.

 

Вообще-то нет. По крайней мере не в GNAT Pro 6.2w

 

PPS. А почему эта нотация (через точку) введена только для тэговых типов?

 

Не только. Она присутствует в task- и protected-типах. Она-же используется для членов записей и указателей. Но, да, она задумана и реализована как заплатка, ну и выглядит соответствующе... (:-))

 

В С++ например, эта нотация применятся ко всем типам (кроме

примитивных ака int и т.п.)...

 

Классы С++, которые Вы имеете ввиду, приблизительно соответствуют tagged в Аде. Все остальное - "примитив". (:-))

 

Ну, и до кучи, почему в Аде нет методов-расширений (как например есть в C#) -- т.е. возможность добавить примитивную операцию к

классу/тэговому типу в другом пакете. IMHO, это бы смотрелось в Аде более органично нежели в С#.

 

Это было бы ужасно. Если тип можно латать на лету, то ни о каких

контрактах, тем более проверяемых статически, и речи быть не может.

Другой вопрос в том, можно ли было переносить т.н. "freezing point" типа из одного пакета в другой. Дело это сложное, но с "limited with" можно было бы поиграть. Есть случай, когда это было бы просто необходимо - multiple dispatch. Но пока никто не собирается эти вопросы даже рассматривать. Аду 2005 понесло совсем в другом направлении.

 

Методы-расширения ― добавление метода в существующий класс с помощью ключевого слова this при первом параметре статической функции.

 

Ради Бога, выводите новый тип, и он будет и в классе, и иметь новые операции, из своего *нового* класса.

 

Принципиальная разница заключается в допущении мутации объектов. В Аде это нельзя. И правильно что нельзя. Эффекта мутации можно добиться и без разрушения системы типов, через делегацию, например. К сожалению, эти средства в Аде в зачаточном состоянии.

 

P.S. А нотация это плохая, вредная. Зря ее ввели. Следовало бы ее вообще везде удалить (она существовала еще в Аде 83), и ввести абстрактные типы записей. Хочется делегировать член X.A методу A(X) (а может и любому другому)? Добавляйте абстрактную компоненту и реализуйте ее вызовом A. Для пользователя это выглядело бы как rename. Все дела.

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

PS. А ключик -gnat05 не нужен. Оно и так по умолчанию.

 

Вообще-то нет. По крайней мере не в GNAT Pro 6.2w

 

GNAT GPL 2007 -- ключик не нужен. Собралось всё корректно и без него.

В С++ например, эта нотация применятся ко всем типам (кроме

примитивных ака int и т.п.)...

 

Классы С++, которые Вы имеете ввиду, приблизительно соответствуют tagged в Аде. Все остальное - "примитив". (:-))

 

 

Гм. Ну положим такой класс:

 

class A {

public:

int i;

void foo(){}

};

 

ну, или, что то же самое:

struct A {

int i;

void foo(){}

}

 

Насколько я понимаю, это соответствует не таггированым записям в Аде. Тут нет vptr. rtti тут тоже нет. Т.е. dynamic_cast не сработает.

Тагированым записям соответствует вот такое:

struct A {

int i;

void foo(){}

virtual ~A(){}

};

 

Ну, и до кучи, почему в Аде нет методов-расширений (как например есть в C#) -- т.е. возможность добавить примитивную операцию к

классу/тэговому типу в другом пакете. IMHO, это бы смотрелось в Аде более органично нежели в С#.

 

Это было бы ужасно. Если тип можно латать на лету, то ни о каких контрактах, тем более проверяемых статически, и речи быть не может.

 

Ну, не латать, а просто расширять. Причем только доп. методами. Причем только в compile-time.

 

Другой вопрос в том, можно ли было переносить т.н. "freezing point" типа из одного пакета в другой. Дело это сложное, но с "limited with" можно было бы поиграть. Есть случай, когда это было бы просто необходимо - multiple dispatch. Но пока никто не собирается эти вопросы даже рассматривать. Аду 2005 понесло совсем в другом направлении.

 

А в каком направлении её понесло? ;-)

 

Принципиальная разница заключается в допущении мутации объектов. В Аде это нельзя. И правильно что нельзя. Эффекта мутации можно добиться и без разрушения системы типов, через делегацию, например. К сожалению, эти средства в Аде в зачаточном состоянии.

Можно подробней? Чего не хватает и чего хотелось бы, где это уже есть?

P.S. А нотация это плохая, вредная. Зря ее ввели. Следовало бы ее вообще

Нотация -- доступ к функциям через точку?

 

везде удалить (она существовала еще в Аде 83),

Для задачных типов?

 

и ввести абстрактные типы

записей. Хочется делегировать член X.A методу A(X) (а может и любому другому)? Добавляйте абстрактную компоненту и реализуйте ее вызовом A. Для пользователя это выглядело бы как rename. Все дела.

Гм. Вроде бы есть какие-то абстрактные записи/рекорды в Аде... Или это не то? Можно примерчик в (псевдо)коде?

 

Вообще, было бы возможно логичным сделать так как предложил Евгений Зуев -- почему бы не сделать класс пакетом? Ведь функция может быть пакетом, задача тоже может быть, так почему класс не может быть

пакетом? Тогда и точка эта бы смотрелась бы вполне себе органично. А сейчас -- видишь точку и думаешь, это мы к функции какого-то пакета лезем, или же вызываем метод какого-то объекта? В С++ в этом плане лучше -- там доступ к потрохам неймспейса осуществляется через :: а вызов метода/доступ к полю, через точку.

PS. А ключик -gnat05 не нужен. Оно и так по умолчанию.

Вообще-то нет. По крайней мере не в GNAT Pro 6.2w

 

Да, это фактически главное отличие в функциональности между версией GPL и версией вэйвфранта Pro на котором она собрана - версия языка по умолчанию разная, 95 на Pro и 05 на GPL. Это в рамках популяризации нового стандарта сделано было.

On Wed, 2 Jul 2008 14:46:51 +0400, you wrote:

 

PS. А ключик -gnat05 не нужен. Оно и так по умолчанию.

 

Классы С++, которые Вы имеете ввиду, приблизительно соответствуют tagged в Аде. Все остальное - "примитив". (:-))

 

Тагированым записям соответствует вот такое:

struct A {

int i;

void foo(){}

virtual ~A(){}

};

 

Возможно, по реализации, но не по контракту. В С++ просто нет отдельного контракта на классы. Это, между прочим, правильно. Классы должны иметь все типы. В Аде контракт "имею класс" это - tagged, ну и заплатка интерфейсов.

Ну, и до кучи, почему в Аде нет методов-расширений (как например есть в C#) -- т.е. возможность добавить примитивную операцию к

классу/тэговому типу в другом пакете. IMHO, это бы смотрелось в Аде более органично нежели в С#.

 

Это было бы ужасно. Если тип можно латать на лету, то ни о каких контрактах, тем более проверяемых статически, и речи быть не может.

 

Ну, не латать, а просто расширять. Причем только доп. методами. Причем только в compile-time.

 

Отлично, но вот вопрос, это может быть видимым легально? Т.е. возможна ли программа которая не видит расширения? Если да, то каков статус, того, чье расширение еще не видно? Это не тип, т.к. тип, он с расширением. Что ЭТО? И зачем это вводить, если уже есть типы. Далее то, что расширения не видит, оно может тем не менее его достать окольными путями? Все это исключительно неприятно. И опять таки, непонятно зачем, если алгебра типов это уже делает. Ну, а если видеть этого нельзя, то и расширять было нечего...

Другой вопрос в том, можно ли было переносить т.н. "freezing point" типа из одного пакета в другой. Дело это сложное, но с "limited with" можно было бы поиграть. Есть случай, когда это было бы просто необходимо - multiple dispatch. Но пока никто не собирается эти вопросы даже рассматривать. Аду 2005 понесло совсем в другом направлении.

 

А в каком направлении её понесло? ;-)

 

Повторять чужие ошибки...

 

Принципиальная разница заключается в допущении мутации объектов. В Аде это нельзя. И правильно что нельзя. Эффекта мутации можно добиться и без разрушения системы типов, через делегацию, например. К сожалению, эти средства в Аде в зачаточном состоянии.

 

Можно подробней? Чего не хватает и чего хотелось бы, где это уже есть?

 

Есть переименование, есть view-conversions, есть прозрачность указателей. Не хватает наследования интерфейсов (выбрасывая реализацию представления), и простых способов сказать "это идет туда, переименуй все оттуда здесь, он

- как я, только без хвоста...", и т.п..

 

P.S. А нотация это плохая, вредная. Зря ее ввели. Следовало бы ее вообще

Нотация -- доступ к функциям через точку?

 

Да. Метод - не член объекта и не член класса. Это просто не отношение принадлежности. Представлять его синтаксически таковым опасно. Люди начинают в это верить, и писать программы, соответствующим образом.

везде удалить (она существовала еще в Аде 83),

Для задачных типов?

 

Да. Всегда хотел иметь многозадачные рандеву...

 

и ввести абстрактные типы

записей. Хочется делегировать член X.A методу A(X) (а может и любому другому)? Добавляйте абстрактную компоненту и реализуйте ее вызовом A. Для пользователя это выглядело бы как rename. Все дела.

 

Гм. Вроде бы есть какие-то абстрактные записи/рекорды в Аде... Или это не то? Можно примерчик в (псевдо)коде?

 

type Publicly_Record is private record

X : Integer;

Y : Float;

end record;

 

private

type Publicly_Record is access Remote_Device_Type'Class;

-- Getters

function "X" (Device : Publicly_Record) return Integer;

function "Y" (Device : Publicly_Record) return Float;

-- Setters

procedure "X" (Device : in out Publicly_Record; Value : Integer); procedure "Y" (Device : in out Publicly_Record; Value : Float);

Абстрактную запись можно реализовать любым типом. Для каждого абстрактного члена не абстрактная реализация должна предоставить getter/setter-пару.

Вообще, было бы возможно логичным сделать так как предложил Евгений Зуев -- почему бы не сделать класс пакетом?

 

Это же предлагал Матт Веббер, сравнительно давно

 

http://mats.weber.org/thesis/Ada-Extensions.pdf

 

Я - против. Видимость к типам никакого отношения иметь не должна.

Ведь функция может быть пакетом,

 

Не пакетом, а единицей компиляции. Это совсем другой коленкор.

 

задача тоже может быть, так почему класс не может быть

пакетом?

 

Класс - замыкание открытого множества типов в типе. Его вообще

скомпилировать нельзя, в том смысле, что исполнять-то нечего. Тип это просто аннотация кода, чистая абстракция. С этой точки зрения, тип вообще "не нужен", т.к. можно иметь Тьюринг-полную систему без типов.

 

Тогда и точка эта бы смотрелась бы вполне себе органично. А

сейчас -- видишь точку и думаешь, это мы к функции какого-то пакета лезем, или же вызываем метод какого-то объекта?

 

Точка перегружена еще с Ады 83:

 

1. Расширенное имя

2. Компонента записи

3. Разыменование указателя

4. Вызов точки входа

 

И вообще, это - важный момент идеологии Ады. Например глядя на имя нельзя сказать это вызов функции или значение. Ответ Ады - "зачем тебе это знать?"

В С++ в этом плане

лучше -- там доступ к потрохам неймспейса осуществляется через :: а вызов метода/доступ к полю, через точку.

 

Не вижу особого преимущества. Это так же как () и [], почему не

перегрузить, если нет конфликта? И вообще, см. выше, точки зрения абстрактных типов это - все равно. Не нравиться точка, можно объявить "/" или "+", как душе угодно. Дебаты 70-х годов...

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

sve

Это было бы ужасно. Если тип можно латать на лету, то ни о каких

контрактах, тем более проверяемых статически, и речи быть не может.

 

 

речь очевидно идет о syntax sugar применительно к операциям над типом, не не являющихся элементарными по отношению к этому типу. например вместо того, чтобы звать Op(T) зовете T.Op() где Op - некая функция (вообще не фигурирующая в интерфейсе типа), принимающая T первым параметром.

On Thu, 3 Jul 2008 12:18:06 +0400, you wrote:

 

>Это было бы ужасно. Если тип можно латать на лету, то ни о каких >контрактах, тем более проверяемых статически, и речи быть не может.

 

речь очевидно идет о syntax sugar применительно к операциям над типом, не не являющихся элементарными по отношению к этому типу.

 

Есть предположение, что не примитивных операций вообще быть не должно. Все, что не "примитивно" идет на весь класс:

 

procedure Foo (X : Integer); -- Ошибка, если вне Standard

procedure Foo (X : Integer'Class); -- OK

 

Но это так, к слову.

 

например вместо того,

чтобы звать Op(T) зовете T.Op()

 

T.Op, очевидно

 

где Op - некая функция (вообще не

фигурирующая в интерфейсе типа), принимающая T первым параметром.

 

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

 

procedure Foo (X : T);

procedure "Foo" renames Foo;

 

X.Foo = Foo (X)

 

procedure Bar (Y : S; X : T; Z : U);

procedure "Bar" renames Bar;

for "Bar"'Self use X;

 

X.Bar (Y, Z) = Bar (Y, X, Z)

 

function Baz (Y : S) return T;

procedure "Baz" renames Baz;

 

X.Baz (Y) = X := Baz (Y)

 

Совершенно не очевидно почему именно первый параметр заслуживает этой чести, а остальные - нет.

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

sve

Есть предположение, что не примитивных операций вообще быть не должно. Все,

что не "примитивно" идет на весь класс:

 

позднее связывание - лишние накладные расходы и проседание в производительности.

 

procedure Foo (X : Integer); -- Ошибка, если вне Standard

procedure Foo (X : Integer'Class); -- OK

 

 

Возражений нет, кроме автоматизма, конечно. Во всех случаях программист

должен бы явно переименовать:

 

согласен например это легко приводит в частности к тому, что весь интерфейс типа не локализован в одном месте, а разбросан по куче пакетов.

 

Совершенно не очевидно почему именно первый параметр заслуживает этой

чести, а остальные - нет.

 

потому что параметров всегда не меньше одного, а если один, то всегда первый?

потому что параметров всегда не меньше одного,

параметров может и не быть

 

а если один, то всегда первый?

и последний ;-)

sve

параметров может и не быть

 

неявный 'this' ( любое другое имя для указателя на instance ) есть всегда. речь ведь о методах и "расширениях" ( или как там в С# ? )

On Thu, 3 Jul 2008 13:36:27 +0400, you wrote:

 

>Есть предположение, что не примитивных операций вообще быть не должно. Все, >что не "примитивно" идет на весь класс:

 

позднее связывание - лишние накладные расходы и проседание в

производительности.

 

procedure Foo (X : Integer); -- Ошибка, если вне Standard

procedure Foo (X : Integer'Class); -- OK

 

Речь идет о случае, когда Foo не примитивен. Следовательно, его параметры должны быть статически известны (Integer или Integer'Class). Т.е. Foo связывается в период компиляции и никаких накладных расходов ее вызов не имеет [кроме передачи тэга]. Внутри Foo, там да, примитивные операции Integer будут связаны динамически. В принципе, если Foo inline, компилятор должен убрать все динамическое связывание, когда аргумент Foo - Integer.

Но ход мысли тот, что так не должно быть! В Аде считается плохим тоном использовать встроенные типы. Т.е. код будет другим:

 

type Counter is range 1..250;

procedure Foo (X : Counter); -- примитивна, дальше некуда...

 

Но если товарищ объявляет Foo уже после заморозки типа, значит, или что-то не так, или речь идет о всем классе.

 

>Совершенно не очевидно почему именно первый параметр заслуживает этой >чести, а остальные - нет.

 

потому что параметров всегда не меньше одного, а если один, то всегда первый?

 

Но функция-то имеет два, - один аргумент, и один результат. Почему именно аргумент? Кстати о функциях, агрегат - типичный пример, когда управляющим параметром является результат. В Ада агрегаты определять нельзя. А зря. И вообще, если мы С++ симулируем, так в нем параметров может быть много. Что такого особого в подпрограммах с одним параметром?

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

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

Какая радость от агрегатов?

 

И

вообще, если мы С++ симулируем, так в нем параметров может быть много. Что такого особого в подпрограммах с одним параметром?

 

А в Аде с параметрами(относительно их числа) как-то по другому?

On Thu, 3 Jul 2008 15:00:37 +0400, you wrote:

 

Но функция-то имеет два, - один аргумент, и один результат. Почему именно

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

 

Какая радость от агрегатов?

 

Когда более или менее сложному типу требуются "литералы" и прочие "значения".

 

Для доступа к предопределенным агрегатам в Аде требуется экспонировать потроха типа, и, кроме того, они должны быть именно тем, чем являются в публичной части. Не утомляет писать в программах белый шум типа

(Ada.Finalization.Controlled with ...)? А как насчет инициализации списка строк агрегатом ("A", "ABC", "DEFGH")? Если список и запись, то совсем не такая!

 

И

вообще, если мы С++ симулируем, так в нем параметров может быть много. Что такого особого в подпрограммах с одним параметром?

 

А в Аде с параметрами(относительно их числа) как-то по другому?

 

В отношении префиксной нотации, да. Причем варианты, самые разные. Короче, бардак, и там, и здесь

 

--

Regards,

Dmitry A. Kazakov

http://www.dmitry-kazakov.de

Новое сообщение:
Страницы: 1

Чтобы оставить новое сообщение необходимо Зарегистрироваться и Войти