Re: Rational for not making cursor tagged in Containers

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Fri, 20 Apr 2007 16:42:27 +0200, Georg Bauhaus wrote:

> On Fri, 2007-04-20 at 12:39 +0200, Dmitry A. Kazakov wrote:

>> BTW, Ada has private types from the day one.
> 
> If the type in question is private, there is nothing
> to argue about.

It is private.

> To emphasize: I don't want to loose
> comparatively simple building blocks (records) just because
> some smart programmers can build similar things (implementing
> record interfaces) with more effects. I'm not forced to provide
> get {} and set {} in C#, and neither assigners in Eiffel.

This is confused. Are you talking about composition of types or about usage
of?

If it is the latter, then you already lost, because prefix notation is used
in Ada for gazillion unrelated things. You cannot tell what X.A means
without the context. And this is right.
 
If you are talking about the former, then what is lost? You still can use
plain records as an abbreviation to: this implements a record interface and
surprisingly is also built-it record.

> This is where it becomes dangerous, I think. Suggesting that programmers
> can implement "linguistic interfaces" forces programmers to be language
> designers, profiting from decades of language research, compilation
> technology, etc. etc..

Honestly, I don't see what is so especially dangerous in X.A as compared to
A(X).

>>> Not every programming team consists of real or even wannabe
>>> language designers. But who else has even got a chance of knowing
>>> what they are doing to a larger program when implementing the
>>> concept of record?
>> 
>> Why they are allowed to implement a concept of task,
> 
> Uh, what do you mean?

I mean they are allowed to write

   task type X is

but not

   record type X is

(as opposed to type Y is record [X])

IMO, task is far more conceptually complex than a container of fixed number
of elements indexed by statically known strings.

>>  Where do you draw the line?
> 
> For a general purpose language, I draw the line where the
> programmers would otherwise be forced to fiddle with
> the tiny bits usually done by compilers. The operations
> of private types are not tiny bits, but forcing plain record
> component assignments to be full subprograms should not be
> the default in Ada.

Uhm, default of what? I wish to have record interfaces, nothing more. I
don't see nothing special in record containers. I cannot understand why a
record view should enforce anything on the implementation of, beyond that
view. Also I fail to understand why polymorphic objects has to be records
and not arrays or access types. Why array or number cannot have
discriminants, but records can? Why array element cannot be extracted using
X."Foo", and why record item cannot be using X("Foo"). etc.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de