Re: Announce: The Ultimate SI Units Cracker

[Wes Groleau <wesgroleau@despammed.com>]

> Yes - it's run-time consuming since the dimension is an attribute

Since Ada has a 'special' meaning for attribute, perhaps
'component' or 'discriminant' would be better.

Anyway, looks nice.  I once implemented a package with
the 'derived types' approach, and I agree that creating
all the operations is a pain.  I had a generic for each operator,
but it was Ada 83, so the instantiations had to be in the spec,
making the spec over 4,000 lines long.  Someone with a little
authority thought a 4,000 line spec was unacceptable, so he
rewrote it non-generic, reducing the spec down to "only" 3,000
lines (and increasing the body from less than 50 to over 5,000).

I like the discriminant approach, but it does have another
disadvantage in that a lot of numeric operations are lost.

You can't query 'First, 'Last, 'Small, etc.  But maybe when
dealing with physical units those don't really matter much.
And of course the package can provide substitutes.

You also can't provide such a type as a generic formal
where a float or fixed is expected.  (Speaking of which,
perhaps a fixed-point version of SI would be useful to someone.)

Ada 95 extended the concept of attributes being functions
to letting them be procedures ('Write / 'Read), and allowed
programmers to redefine/override 'Write and 'Read.  I am curious
whether overriding/creating other attributes was considered.
Obviously, like operator overloading, it could easily be
used to obfuscate, but it could be very useful to be able
to define 'first and such for things like SI and Rational.

It would also be nice to be able to define a type conversion.

function Float (T : SI) return Float is ....

What I'm getting at is the ability to define a private type
so that it has all the attributes and operations of a numeric
type and can be use as a generic parameter to a numeric package.

I understand that many packages take advantage of the implementation
of a float for efficiency, but there could be an implementation
permission that allows the compiler to reject an instantiation
where this is the case--or issue a warning.


-- 
Wes Groleau
http://freepages.rootsweb.com/~wgroleau