Re: Manifesto against Vector

[Vinzent 'Gadget' Hoefler <nntp-2004-05@t-domaingrabbing.de>]

Dmitry A. Kazakov wrote:

>On Thu, 06 May 2004 11:41:11 +0200, Vinzent 'Gadget' Hoefler
><nntp-2004-05@t-domaingrabbing.de> wrote:
>
>>Dmitry A. Kazakov wrote:
>>
>>>Why that should be told? I'd say that "with" is superfluous.
>>
>>No! If at all then it is "use" which is superfluous. ;-)
>
>How so? "Use" has some semantical sense. It changes visibility. You
>might claim that this is not necessary, but that would be another
>story. On the contrary "with" has no other sense than being just a
>hint to the compiler/linker.

And a idea to me which packages another one is using. This is
especially useful with some of the more "evil" parts of Ada like
Unchecked_Conversion. :)

>It could well be just a pragma, like the
>elaboration control ones.

Yes. Or like the C pragmas that tells the Preprocessor which files it
should include to get all the prototype-declarations. Well, sometimes
it even works without these, yes. Do you really *want* it to work in a
similar way? I don't.

(BTW, for that discussion it might be funny to note that these days
even more and more of the C++-folks consider "using some_namespace;"
to be evil. And now we want to encourage to do exactly the opposite of
that in Ada?)

>>>Maybe, but it should be placed at the beginning of the context. So it
>>>is just one line difference. Not a big issue, IMO.
>>
>>It is more than a single line. Consider this:
>>
>>|with Interfaces;
>> ^^^^
>>|
>>|package body Timer is
>>|
>>[...]
>>|   function Hi_Byte (Value : in Interfaces.Unsigned_16)
>>|     return Interfaces.Unsigned_8 is
>>|      use type Interfaces.Unsigned_16;
>>       ^^^
>>|   begin
>>|      return Interfaces.Unsigned_8 (
>>|          Interfaces.Shift_Right (Value, 8) and 16#FF#);
>>|   end Hi_Byte;
>
>We have no "with type" clause, so this example is incorrect.

Well, then read "use Interfaces;" instead and imagine all the packages
prefixes would go away then.

For me it is still the same principle: Make something as local as you
can. No matter if it is a variable, a procedure, ... or a namespace.

>>>with Foo;
>>>procedure P (<something here needs visibility of Foo>);
>>
>>Simple: Use the full name there. If it's too long for you, I'd say
>>rename it.
>
>It cannot be. P is a unit! (:-))

Hmm, what the heck? I was under the impression that

|subtype Sys_Addr is System.Address;
|
|procedure (foo : Sys_Addr)

would work.

>Then semantics of renaming is inconsitent with one of "use", or better
>to say, simply inconsistent. This is the source of numerous problems:
>
>with Ada.IO_Exceptions;
>package A is
>   End_Error : exception renames Ada.IO_Exceptions.End_Error;
>   X_Error : exception;
>end A;
>--------
>with A;
>package B renames A;
>--------
>with A; use A;
>with B; use B;
>with Ada.IO_Exceptions; use Ada.IO_Exceptions;
>procedure C is
>begin
>   ...
>exception
>   when X_Error =>
>      -- This is OK, multiple views of same thing
>      ...
>   when End_Error =>
>      -- This is illegal, viewing two different views of one thing!
>      ...
>end C;

See. That's a perfect example for a "use"-Problem, which I simply want
to avoid (and which I want to do consistently):

|c.adb:12:09: "End_Error" is not visible
|c.adb:12:09: multiple use clauses cause hiding
                       ^^^^^^^^^^^
|c.adb:12:09: hidden declaration at a.ads:3
|c.adb:12:09: hidden declaration at a-ioexce.ads:26
|gnatmake: "c.adb" compilation error

when you specify:

|   when A.End_Error =>

instead it surprisingly works. And if you always do that, there is
even no inconsistency that you sometimes use the short name and
sometimes the fully specified name "randomly" all over a package, just
depending on which packages you've just had to use and where the
compiler complained about not wanting to know what to do.

I don't know what this has to do with renaming. If you'd declare
End_Error separately in the packages you would run into the same
problem, so in fact it is a "use" problem.

Well, you might argue, just because you renamed it and thus in fact is
exactly the same, the compiler could figure this out by itself. But if
it would really do that, it then would be me to call this behaviour
inconsistent.

>>It's much more simple: Never use "use". :)
>
>Once I will become a rich man, I will buy a LCD with horizontal
>resolution of 10240 pixels, install small fonts, get spectacles ...
>(:-))

Considering I don't use "use" globally[0] and even restrict myself to
72 columns, I don't really understand that part of the problem. :)


Vinzent.

[0] And even locally I use "use" in relatively seldom circumstances,
the above "use type" is just because I consider the line
  | return Interfaces.Unsigned_8 (
  |   Interfaces."and" (Interfaces.Shift_Right (Value, 8), 16#FF#));
a little bit to much overkill even for my attitude to not using "use"
as much as I can't. Especially because this whole messy line just
compiles to a single "shrw $8, %ax". :)