Re: Default value for a record component

["Randy Brukardt" <randy@rrsoftware.com>]

"Maciej Sobczak" <see.my.homepage@gmail.com> wrote in message
news:1185270857.459100.34770@q75g2000hsh.googlegroups.com...
> On 24 Lip, 03:27, "Randy Brukardt" <ra...@rrsoftware.com> wrote:
>
> > This is a rather stupid question, especially given the C++ example that
you
> > give later. The closest analog to a C++ class in Ada is a controlled
type.
>
> What is the analog of C++ struct with a constructor, then?

A function is a constructor for Ada; declare an appropriate function and use
it.

> > Hinestly, I don't see any sane reason for being unwilling to use a
> > controlled type here.
>
> Honestly, me neither. The question is really about the language design
> and its ability to express orthogonal concepts. For me field
> visibility and its initialization are orthogonal. Well, should be.

Everything in Ada is inter-related; often in ways that are not obvious. I
learned this the hard way when we were trying to subset Ada in the early
1980's. It just didn't work very well because there always was something
else that you needed to have a full solution. Eventually we ended up with
95% of the language, and then we might as well finish the whole thing.

I realize that someone relatively new to Ada might not know this, but you
cannot usefully look at single features of Ada in a vacuum. You need to use
many of them...

...
> > In any case, having a type that is visible rather than a private type is
> > almost always a mistake.
>
> Can't you think about examples where it isn't? (the "almost always"
> part has to be complemented by something)

I know of various examples where it wasn't, but those examples are almost
always motivated more by laziness (don't want to write a function call to
access a component) or by missing features in the language (Dmitry's
"virtual components", some way to write aggregates and literals for private
types, etc.). These two reasons are really the same, because if the missing
features were available, one could write an appropriate private type but
still use it as if it was a visible type. The net effect is that I think
that if we had a "perfect" programming language, there would never be a
reason to declare a visible type, but there might be such a reason given the
imperfect nature of real programming languages. (But even then, you are
likely to regret it.)

                                 Randy.