Re: Generics vs. O-O?

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Fri, 2 Aug 2013 11:06:33 -0700 (PDT), Alan Jump wrote:

> On Friday, August 2, 2013 10:51:03 AM UTC-7, Dmitry A. Kazakov wrote:
>> Reasons to deploy this pattern in Ada are questionable at best.
>> Ada offers support of singletons where appropriate. Here is the list, maybe
>> incomplete:
>> 1. Anonymous arrays are singletons
>> 2. Procedures and functions are singletons
>> 3. Protected objects are singletons
>> 4. Tasks objects are singletons
> 
> You are stipulating that procedures, functions, protected objects and task
> objects are singletons, but at the same time, stating there are only
> questionable reasons to make use of them?

Not them, but the singleton pattern. You don't need any pattern to make a
procedure singleton. You just define it and here you are, it is a
singleton. Let me elaborate a bit:

1. Anonymous arrays are declared as:

   A : array (1..10) of Character; -- This is a singleton

Compare:

   type Multitude is array (1..10) of Character; -- Not a singleton
   A : Multitude; -- One instance
   B : Multitude; -- Another instance

2. Procedures and functions:

   procedure Foo (I : Integer); -- This a singleton

Ada does not have named procedural types. Thus subroutines are always
singletons.

3. protected Singleton is ...; -- This is a singleton

Compare

   protected type Multitude is ..;
   A : Multitude;
   B : Multitude;

4. task Singleton is ...; -- This is a singleton

Compare;

   task type Multitude is ...;
   A : Multitude;
   B : Multitude;

> Semantically, you have just
> eliminated the core raison d'etre for the existence of Ada as a
> language...specifically, strong typing.

Why? The type of a procedure is not weak. Strong typing is about relation
between objects and types, such that an object has a type (plus some other
requirements). It does not imply that a type has an object (singleton).
Normally the latter is considered a design artifact. Unless trivial cases
like I listed above, more elaborated abstract types are better designed not
to be singletons. Relying on single instance is fragile design.
Notwithstanding that sometimes it is what you need.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de