Robert I. Eachus wrote:
> At 06:16 AM 11/17/98 GMT, Simon Wright wrote:
> > From: Samuel Mize <[log in to unmask]>
> > Perhaps a "class" package would also require that all the subprograms
> > in the package have the controlling operand as the first parameter
> > (the return value, for functions).  This would help out the people who
> > find the syntax "object.message" to be more readable.
>    This is starting to get silly.

Sorry, I thought this list was (among other things) a place to toss
out and develop ideas that might help make Ada more saleable to others.

> function Message (Text: in Clever_Ideas) return Better_Ideas is...

The name of the function is "team-ada" and I was calling it.

- - - - -

>Ada is a very rich language, and while I
> can understand having a tool to detect some departures from local coding
> standards and software engineering practices, putting on a straight-jacket
> is not all that good an idea.

I don't see why marking some packages, and putting limits on those
marked packages, would be "putting on a straight-jacket."  If a
given package needs to exceed those limits, you don't use the
marker, just as you don't use "positive" for counting from zero.

But I was just tossing out a thought about "class" packages.  If
you're saying I defined too tight a limit on parameter lists, I'd
like to understand what you mean.  Someone else (I think it was Simon)
pointed out that we need selector functions.

Did you perhaps think I was saying that all packages should be
classes?  Good grief, no.

Perhaps a "class" pragma would have a parameter that states whether
the package's parameter lists are limited to object-first order.
Perhaps the pragma's parameters would let you specify several types
of object-oriented coding limits -- another advantage of marking
packages as "classes" with a pragma.

To some extent I was reacting to the typical comment that you can
do classes in Ada, it's just a tagged type in a package.  No.  That
isn't a language-defined class.  There are semantic constraints
behind the concept "class" that are not checked by putting a tagged
type in a package.

If you do a tagged-type-in-a-package combo right, you wind up with
something equivalent to a class.

But if you do integer codes right, you wind up with something
equivalent to an enumeration.  Guess we don't need those.  If you
do assembly coding right, you wind up with something equivalent to
a tasking run-time.

In all these cases, I'd rather the compiler was helping me check my
code, and your code, and especially the code we have to use from that
guy over there who thinks C is just too kewl.

I think it's interesting and exciting that such methodology checking
could be integrated into an Ada compilation system with pragmas, if
we want to, without some kludgy thing like a pre-processor.

You could use a pre-processor or stand-alone tool too, of course.  But
it would have to do some semantic analysis -- may as well use the
compiler if you can.

I don't know much about ASIS -- might it allow class-checking to be
integrated into a tool suite WITHOUT being integrated into a specific
compiler?  Kewl, d00d!

- - - - -

> For example:
>     type Set is...
>     function "+"(L,R: Set) return Set;
>     function "-"(L: Set, R: Element) return Set;
>     -- and so on.

Can you explain what you are trying to communicate with your example?
I don't understand your point.

- - - - -

>     In addition if you really prefer the class.method(parameters) notation,

Nobody wants that.  Some people want object.method(parameters) .

> Ada has it all over the place:
>     Protected_Object.Method(Parameters);
>     Task.Entry(Parameters);
>     Type'Attribute_Function(Parameters)
> and of course, and most important:
>     Package.Operation(Parameters);

Yep, lots of places except for tagged types, which is how Ada
implements object-oriented programming, which is the context in
which people are carping about not having it.

>[explains how to get object.method notation with generic packages]

> Generic instance as object is not a good model if you
> have many objects of the class, or if the number of objects is highly
> dynamic.  But it is great when you have objects with no particular
> hierarchy, and many different types of state variables.

So as long as you don't want to define a class hierarchy, or do
programming by extension, or have polymorphism, and you have a
very limited number of instances, you can use that technique.  I
don't think you'll win a lot of converts from C++ or Smalltalk
with that sales pitch.

I'm not arguing for or against object.method notation.  Some people
think it's important for clarity, a desideratum I would think we can
all respect.  I was trying to think up something that might help
such people transition to Ada.

"Look," we could say, "you can require that a particular tagged
type's operations start their parameter list with the controlling
object.  It makes the receiving object just as obvious as
object.method notation does.  But if you're just doing programming
by extension, not object-oriented programming, you don't have to
live with that limit."

By the way, perhaps such a "class" package's type should only be
extensible through other, similarly-limited "class" packages, to
ensure that all its operations follow the parameter-ordering rule.

Sam Mize

Samuel Mize -- [log in to unmask] (home email) -- Team Ada
Fight Spam: see \\\ Smert Spamonam