RE: (elementary question) Test on type ?

["Beard, Frank" <beardf@spawar.navy.mil>]

I agree with what John's saying about "Generics are the place to do
identical stuff ...", but I don't think you need to pass overloaded
subprograms and some enumeration types to do specifics.  The generic
formal subprograms are for the specific stuff.  So, I think all you
would need is the following (from his original post):

-- specification :
generic
  type T is (<>);
  with procedure Do_Something (Item : in out T);
  with function Specific_Stuff (Item : T) return Float;
function F(X : T) return Float;
 
--body :
 
function F(X : T) return Float is
begin
 
--<Replace this>
--if Type(X) = Integer then  ??????
--   something...
-- 
--I := integer(X) ????

--<with this>
  Do_Something(X);

  -- if you really need to convert to integer here.
  I := integer(Specific_Stuff(X));

  return Specific_Stuff(X);
 
 
end;
 
--application prog:

procedure Do_Something (to_The_Integer : in out integer);

function To_Float(from_Integer : integer) return Float;

function F1 is new F(T              => Integer,
                     Do_Something   => Do_Something,
                     Specific_Stuff => To_Float);

The decisions are already made in the subprograms being used
to instantiate the generic, so it is unnecessary to do it again
internally in the generic.  Whatever specific things you want to
do based on the types should be abstracted out to the actual
subprograms that are supplied for the generic formal parameters.

Frank

-----Original Message-----
From: john.mccabe@emrad.com.nospam [mailto:john.mccabe@emrad.com.nospam]

Generics are the place to do identical stuff independent of the types.
If you want to do different stuff depending on the type, then you
should use overloaded function. I'm not sure whether this is possible
(and I can't check at the moment as I don't use Ada any more), but you
may be able to pass overloaded functions as generic actual parameters
and then just make a call where the compiler will handle the types.

e.g.

generic
   type MyType is (<>);
   with procedure Test (InParm : in Integer);
   with procedure Test (InParm : in SomeOtherDiscreteType);
package X
   :

Then call Test when you want. I guess what you could do was define a
type somewhere e.g: type PossibleTypes is (Int, Flt, Enum); then use
declare the Test operations as functions that returned that type.

Hope this helps.



Best Regards
John McCabe
_______________________________________________
comp.lang.ada mailing list
comp.lang.ada@ada.eu.org
http://ada.eu.org/mailman/listinfo/comp.lang.ada