Re: advice on package design

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> 3. You can rename parts of contents of Baz in Foo:
> 
> package Foo is
>    type Word is ...
>    package Baz is new Bar (Word, ...);
> 
>    subtype Linked_List is Baz.Linked_List; -- "renaming" of a type
>    procedure Insert (...) renames Baz.Insert; -- renaming of a procedure
>    ...
> end Foo;

One variation on that is to declare a derived type:

    type Linked_List is new Baz.Linked_List;

This causes all of the primitive subprograms of Baz.Linked_List to be
inherited -- implicitly declared in Foo.  But for anything that's not a
primitive subprograms, you have to write some wrapper code by hand.

If I were [re]designing Ada, I would make 'use' transitive.  That is,
if Foo says "use Linked_List" that would make the contents of
Linked_List directly visible in Foo, and anything that says "use Foo;"
would have direct visibility on everything directly visible in Foo --
not just the things *declared* in Foo.  Or something like that.

It really is a flaw in Ada that you can't easily re-export stuff.
The renaming solution is bad because it is verbose, and therefore
error prone.  I still remember a bug I fixed many years ago:

    function "and"(...) return ... renames Something."and";
    function "or"(...) return ... renames Something."or";
    function "xor"(...) return ... renames Something."or";

The problem is that renaming is *not* usually used to rename things --
it is used to import them (with the *same* name) into a different
scope.  Given that mindset, it took me a *long* time to notice the bug
in the above.  The symptom was that xor was behaving strangely in some
faraway place.

That was Ada 83.  In Ada 95, "use type" would have prevented the
problem.

- Bob