Re: using `use' : what is the best practice ?

[stefan-lucks@see-the.signature]

On Tue, 7 Jun 2011, milouz wrote:

> Maybe a not so anecdotic question : when using the 'use' clause ?

I am sure you will get a lot of different answers about this. 

Note that your example below is using "use" in the "context clause" (i.e., 
where the "with" is). 

>    with P1; use P1;
>    with P2; use P2;
> 
>    procedure Main is
>       My_Val : Integer;
>    begin
>       Foo(My_Val);  -- P1 or P2 ?
>    ...

Try out what your program does! If P1 defines 
  procedure Foo(I: Integer); 
and P2 defines only, say, 
  Procedure Foo(S: String);
then the Ada compiler will know that you are calling P1.Foo. You are 
allowed to write P1.Foo(My_Val) to improve the readability of your code. 

On the other hand, if P2 also defines 
  procedure Foo(I: Integer);
you *must* either write P1.Foo(My_Val) or P2.Foo(My_Val). The compiler 
will not try to "guess" which Foo you wanted to call, it will just give 
you the syntax error you deserve. 

> But always avoiding 'use' give some rather obfuscated code, especially
> when using some specific arithmetic operator. For example, playing
> with Address arithmetic without 'use' :

There are alternatives to the use in the syntax clause:
  -> use type;
  -> a renames clause 
  -> a local use 

>    with System;
>    with System.Storage_Elements;
> 
>    procedure Main is
>       A : System.Address;
>       N : Integer;

        use System.Storage_Elements;
        -- locally in any scope -- not very local if in the main procedure
 
        use type System.Address;
        -- alternative: use type

        package SSE renames System.Storage_Elements;
        -- alternative: renames

>    begin
>       A := System.Storage_Elements.To_Address(16#10000#);

        -- A := To_Address(...); -- for local use (or in context clause)
                                 -- but not for use type!

        -- A := SSE.To_Address(...); -- for renames

>       N := 4;
>  
> A := System.Storage_Elements."+"(System.Storage_Elements.Storage_Offset(N), A);

  -- A := SSE."+"(SSE.Storage_Offset(N), A); -- for renames

  -- A := Storage_Offset(N)+ A; -- for local use, context-clause use 
                                -- and use type

>    end Main;
> 
> As I'm very new, I'd like to have your opinion about the way to use
> 'use'.

Always consider the alternatives to the context-clause use!


-- 
------ Stefan Lucks   --  Bauhaus-University Weimar  --   Germany  ------
               Stefan dot Lucks at uni minus weimar dot de
------  I  love  the  taste  of  Cryptanalysis  in  the  morning!  ------