When to use formal discrete type?

When to use formal discrete type?

[Victor Porton]

I am creating a generic package which accepts as a formal argument a type 
which is expected to be an enumeration type.

Should for this enumeration argument I use formal private type (is private) 
or formal discrete type (is (<>))?

I do not use features specific to discrete types such as 'First or 'Range 
attributes.

Because it easily generalizes from discrete types to arbitrary private 
types, should I do generalization?

What of (generalizing for all private types or not) the two is better:

a. for clarity of code;

b. for performance?

It there a noticeable difference in performance if I generalize?

-- 
Victor Porton - http://portonvictor.org

Re: When to use formal discrete type?

[Shark8]

On Wednesday, November 29, 2017 at 12:04:35 PM UTC-7, Victor Porton wrote:
> 
> Because it easily generalizes from discrete types to arbitrary private 
> types, should I do generalization?
> 
> What of (generalizing for all private types or not) the two is better:
> 
> a. for clarity of code;
> 
> b. for performance?
> 
> It there a noticeable difference in performance if I generalize?

My rule of thumb is use the most general type as reasonably possible -- so, if you aren't using things like X'First and X'Succ(Value) go ahead and make the parameter private. (On the other hand, if you do find yourself using a value for first/last and/or functions for previous/next consider using more restrictive generic formal parameter; of course, your design might make it impossible to use a discrete-formal [like, say, modeling integrals (for certain models)].)

As for performance, I would recommend that you first benchmark and hotspot-analyze your code: it's typically dumb to spend hours and hours super-optimizing something from O(n**4) to O(n) if n always <= 3. -- Chances are that your intuition as to what's a /real/ performance hit is going to be wrong.

Re: When to use formal discrete type?

[Dmitry A. Kazakov]

On 2017-11-29 20:43, Shark8 wrote:

> My rule of thumb is use the most general type as reasonably possible

BTW, that's the principle of weakening preconditions [and strengthening 
post-conditions]

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

Re: When to use formal discrete type?

[Randy Brukardt]

"Victor Porton" <porton@narod.ru> wrote in message 
news:ovn0bv$1rto$1@gioia.aioe.org...
...
> It there a noticeable difference in performance if I generalize?

That clearly is compiler specific, and also specific to how the type is 
used.

Janus/Ada, for example, uses generic sharing, so the code generated for a 
formal discrete type and a formal private type are very different. (In most 
cases, the formal private type will win, but not if there are a lot of 
components of that type).

OTOH, GNAT generally uses template expansion. In such a case, the final code 
isn't much different than if you had written it yourself without using the 
generic. So it probably doesn't matter much.

The main difference is the promise given to the instantator. A private type 
implies that any non-limited type will work (assuming that it has the 
operations given in the generic spec). So you may want to consider what 
happens if someone instantiates your generic with some record type. If that 
would be a real problem, then the formal discrete type would be better (as 
it better documents what actually works).

                                   Randy.