Re: Clause "with and use"

["Robert I. Eachus" <rieachus@comcast.net>]

Gautier Write-only wrote:

> Both "use" you cite are not context clauses -> OT, sorry !

Not off topic.  You can have a use Ascii in a context clause without a 
with for Ascii, in fact you CAN'T have a with clause for Ascii.  (Back 
in 1983 a lot of compilers got tripped up on that special case, but 
those bugs are long gone.)  In Ada 83 a context clause had to contain a 
with clause. But in Ada 95 the syntax has changed, so you should be able 
to compile:

use Ascii;
package Foo is
   Bar: Character := Percent;
end Foo;

If not, complain to your compiler vendor.  (Although I think putting the 
use clause inside Foo looks better.)

> BTW, your mention of ASCII is interesting.
> * Ada 83 (and later) implies a non-written "with Standard; use Standard;"
>   - ASCII is subpackage of Standard.

NO! This is almost as bad as what Russ was saying.  There is no implicit 
with clause for Standard.  Try to create a library unit named Integer. 
You can't.   This is because all library units are explicitly nested 
directly within Standard.  This gives names in Standard a preferential 
visibility.  They can't be hidden by a library unit.  And also there is 
no USE visibility for names in Standard, the visibility is direct.  If 
you have a use clause for a package containing a type named Integer, it 
will not become USE visible due to the direct visibility of the Integer 
in Standard.

> * Ada 95 (and later) implies a non-written "with Ada, Ada.Strings;" when you
>   just write "with Ada.Strings.Maps;". Same for all children 
> -> things are not at all 100% explicit in the present standard.

Ask why, or look at the ARG and Ada 9X DR discussions, etc., and you 
will understand why it was done this way.  First there should be no 
confusion about whether there is a with clause for Ada.Strings. You are 
looking at it.  But consider another case:

package Ada.Strings.Maps is... -- A.4.2(3)

In this case, there is an implicit with of Ada.Strings, and with good 
reason.  To make the language easy to use, we need direct visibility of 
names in Ada.Strings within Ada.Strings.Maps.  That is pretty hard for 
the compiler to do correctly without having Ada.Strings as part of the 
context.  But it is not part of the context clause, because of the 
direct visibility issue, just like Standard.  Ada.Strings.Maps is 
conceptually declared within Ada.Strings, which is within Ada, which is 
within Standard.  Direct visibility all the way, and nary a hint of a 
with or use clause.
> 
> * The "[with and ]use" proposal offers the possibility of writing once
>   the name of a package instead of twice when you use "use" in a context clause.

As I said, not a problem, go ahead and push for "with and use" if you 
like it.  But having a use imply a with breaks things.  That model could 
be fixed, but why even try.  If you currently have a text editor macro 
that maps #wau Foo into "with Foo; use Foo;" you can change it to 
generate "with and use Foo;" if the change is approved.  I don't see it 
as a big deal, but different opinions are allowed and expected.

> -> this feature doesn't reduce from 1 to 0 the appearance of a package name
>    like both mentioned above, but from 2 to 1. When the feature is used, the
>    names remain explicit, but without redundance.
> 
> Clearly the contestation about this proposal is just because this is an evolution.
> Existing elements are by default sacred, improvements are by default suscpicious...

No I look at the "with implies use" proposal and get a splitting 
headache when thinking about how it could be worded.  Answer me just one 
little problem, and I might think about it:

use Foo; use Bar;
package...

Now if there is a package Foo and it contains a package Bar, and there 
is a package Bar in the compilation environment, which one do you get if 
any, and why?  If you don't understand the issue, create the specified 
packages and try it with your current Ada compiler.  Then read RM 8.4(6) 
to see why it works the way it does now, and try to rewrite 8.4(6) to 
match the use implies with proposal.  Now do you see why I have a headache?

This is the reason I often seem to say "Yeah, that's nice, why don't you 
propose it," about some proposals and "Forget it, it won't fly," about 
others.  I can be wrong, if someone finds a way to express things.  Some 
ARG members, especially Tucker, are trying to fit earliest deadline 
first scheduling within a priority based model without 
incompatibilities.  It looks like they are pulling it off.  This is very 
nice because, if it works it will allow some tasks (and priority levels) 
to be used for EDF scheduling and other priority levels for ordinary 
priority based scheduing.  But it is a lot of work that may never be 
visible to most Ada users.  The theory will be there, the few 
implementors who need to will understand it, and enough ARG members will 
understand the model to fix it if it breaks.  For something like that, 
it is worth the pain.  To shorten "with and use" to "use"?  No way!

But in this case, "with and use" is simple and seems to address the 
problem without monkeying with the scope of use clauses.

-- 
                                           Robert I. Eachus

100% Ada, no bugs--the only way to create software.