Re: Convention for naming of packages

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

Le Thu, 09 Feb 2012 22:39:51 +0100, Jeffrey Carter  
<spam.jrcarter.not@spam.not.acm.org> a écrit:
> The plural is used a lot in the standard library (Ada.Strings,  
> Ada.Containers).
I had this in minde, though this was not common enough. After I read you  
yesterday, I changed my mind and feel at rest with the plural now.

> The present participle is sometimes useful (Widget_Handling,  
> Town_Marshalling).
Noted.

> I've also seen instances where _Management was meaningful and solved  
> this kind of conflict.
Idem.


Will go for plural so.


Now I am seeking for something even more difficult: conflict between  
function names and object names. This can be solved using prefixed  
notation, but I want to avoid it to not bloat source too much. A too long  
full name is not readable and can just make people think Ada is  
definitively over‑wordy (as J.P. Rosen explained in a paper, people tends  
to keep in mind bad points first about Ada).

To be honest, this conflict typically occurs when I want a local constant  
to hold the value returned by a function, to avoid invocation of this  
function multiple time. That's a common idiom, although I feel this may be  
based on wrong assumptions about compiler efficiency, while not the only  
one reason. I feel it's often good to substitute a single name to a whole  
expression.

A quick example.


    function Object (Param : Param_Type) return Object_Type;

    procedure Scan is
       Object : constant Object_Type := Object (Param);
       -- Or alternatively: “Object : constant Object_Type renames Object  
(Param);”
    begin
       for I in Index_Type loop
          ... Object ...
          -- Instead of ... Object (Param) ...
       end loop;
    end;

Object conflict with Object. I can use prefix and have

    Object : constant Object_Type := Repository_Package.Object (Param);

instead of

    Object : constant Object_Type := Object (Param);


But I would like to avoid the Repository_Package prefix for the previously  
given reasons. I remember I knew a language (cannot remember which one)  
which was fine with this, as this language considered Object to not  
already be defined when it was encountering Object (Param).

Thus

    Object : constant Object_Type := Object (Param);

was defining Object with an initial value and right after hiding the  
Object function.

The problem does not occurs with either record type (as members are all  
prefixed) and subprogram parameters, as these are assigned by the caller.  
The latter may be an idea, so this could be a solution:


    procedure Scan is
       procedure Scan (Object : in Object_Type) is
       begin
          for I in Index_Type loop
             ... Object ...
             -- Instead of ... Object (Param) ...
          end loop;
       end,
    begin
       Scan (Object (Param));
    end;

I don't know what to think about it, looks too much like a big trick in  
Ada source and this is even much longer than using the previous prefix  
notation along with a local constant.

What do you feel about this?


-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University