Re: Ripple effect

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

"Jeffrey R. Carter" <spam.not.jrcarter@acm.not.spam.org> writes:

> Robert A Duff wrote:
> > Not sure about "use" but "use type" is a bad idea -- should be the
> > default.
> 
> OK. In the discussion, your language used "use" in context clauses as
> equivalent to Ada's "with" (which sounds like a good idea), and you
> didn't show any equivalent to Ada's "use". I thought I recalled you
> saying that the language didn't have one, but I guess IDRC.

I think I want something like Ada's "use".  Pascal calls it "with" (for
records, as opposed to packages).  It has nasty Beaujolais-like effects,
but that's not necessary.  One of the brilliant things Ichbiah did was
to eliminate Beaujolais effects.  Well, almost -- Ada 9X finished the
job.  And Ichbiah didn't go far enough in that regard -- I would
eliminate hiding entirely.

But I think perhaps the "use"-like thing belongs on the package, rather
than on the clients of the package, because the person who writes the
package needs to use naming conventions that make sense for use or
not-use.

I've considered calling it "open" -- it opens up the scope for
visibility.  An "open" module provides direct visibility of its contents
to clients.  And perhaps an "open" statement in addition, to be used by
clients.

> If you do have an equivalent to Ada's "use", maybe it should be called
> "see".

Perhaps.  But if it goes on the package/module, it should be an
adjective.

> > Yes.  Do you think it should be otherwise? [transitive context clauses]
> 
> It seems awkward. We're working on a project. I create package B, which
> has "with A;" on it. I thought B would need it, but I was wrong, and
> forgot to remove it. You're developing C and need to use B, so you have
> "with B;" on C. Then you realize you need to use A and write some code
> that references A. You forget to put "with A;" on C, but it compiles OK
> because B references A. Then I clean up B and remove the reference to A
> from it. Now C doesn't compile. That seems undesirable.

It does not bother me that a change to the visible part of A affects
clients, transitively.  That has to be true, in general.

My thinking is that if B uses A in a visible way, C pretty-much has to
know about A.  E.g.:

    with A;
    package B is
        procedue Mumble(X: A.T);
    end B;

If C uses B.Mumble, it most likely needs to declare objects of type A.T.
C certainly knows about type A.T!  So non-transitive with's cause a lot
of clutter -- C needs to 'with' everything it uses, plus everything
those things are (visibly) based on, transitively.  So high-level
packages tend to have so many with_clauses that nobody wants to read
them, largely defeating the purpose.

OTOH, if B uses A only for implementation, that's a different story.
Then the import of A belongs on the body of B, and C shouldn't know
about it.  (My language doesn't have private parts.)

By the way, the issue of bogus with_clauses is a real maintenance
problem -- nobody ever deletes a with_clause, so they tend to
accumulate.  This problem is easily solved.  The compiler should give an
error message.  An error that can be suppressed, so that you can
temporarily have bogus with_clauses during development.  That's
essentially what GNAT does, with appropriate warning switches.

- Bob