Re: Imitation is the sincerest form of flattery

["Frank J. Lhota" <NOSPAM.lhota.adarose@verizon.net>]

"Amir Yantimirov" <amir@iae.nsk.su> wrote in message
news:5115eb96.0303242148.57027600@posting.google.com...

> Not that. I propose something alike this:
>
> type TFoo = record ... end record;
>
> procedure Bar ( Baz : in out TFoo);
>   with TFoo:
>     'First = 1;
>     'Last = 32;
>     [].Read = ReadBits;
>     [].Write = WriteBits;
>   end with;
> begin
>   Baz[40] := 0; -- compile error!

I'm a little confused by this pseudo-code. Is Bar a derived type? Is it some
sort of constructor? And what does the "[].Write = WriteBits;" statement do?
You may very well have a quite valuable idea here, but this code sample does
not convey it. Now that you have piqued our curiousity, please clarify.

> Different levels of abstraction needs different solutions. So I argue
> only that ALL types should be tagged.

In a sense, you're absolutely right. The most consistent way to do OOP is to
allow a type hierarchy to be based on any type, including built-in scalar
types. An example of this is the Smalltalk language. Everything in Smalltalk
is part of a class hierarchy, including boolean values, integers,
characters, and even blocks of code. Smalltalk's consistent "everything is
an object" approach is elegant and provides unparalleled ability to apply
OOP techniques.

There is only one good reason, why Ada, C++, C# and Java have not adapted
the Smalltalk philosophy of having everything tagged: efficiency. Smalltalk,
for all of its virtues, has been terribly slow due to its need to use
indirection for nearly everything. Consider this:

    type My_Integer is new Integer;
    function "+" ( Left, Right : in My_Integer ) return My_Integer;
    function "*" ( Left, Right : in My_Integer ) return My_Integer;
    -- ...

    -- Currently not valid Ada, but this would be valid if Integer is
tagged.
    procedure Compute( A, B : in Integer'Class ) is
    begin
        -- ...
    end Compute;

Within Compute, arithmetic with A and B will depend on whether they are
Integer or My_Integer. As desirable as this may be, this certainly rules out
using the implicit versions of "+" and "*". A call to Compute would require
that, somehow, tags be attached to A and B. This requirement is why we have
the annoying boxing and unboxing stuff in C#.

If there is a way to get the effect of tagged scalar types without a big hit
on efficiency, however, it would certainly be helpful. Perhaps there is some
happy compromise between Smalltalk and C#.