Re: prohibit certain generic instantiations in Ada 2005

["Matthew Heaney" <mheaney@on2.com>]

Ada does have something called "signature packages" that are probably
what you're looking for.

The problem with your previous solutions is that you're trying to use
types to solve your problem, instead of using generics to solve your
problem (which was your original request).

You want to be doing something like:

generic
  type Engine is limited private;
  type Transmission is limited private;
  with procedure Attach (E : in out Engine; T : in out Transmission) is
<>;
  with <other ops req'd by body go here>
package Generic_Cars is ... end;

Don't import generic formal tagged types if you don't need them.  You
only end up overcommitting yourself.  Note that a limited private
generic formal is a superset of tagged (limited), so you're still free
to instantiate Generic_Cars with a tagged generic actual.

You want to prevent attaching an electric engine to a manual
transmission.  That's fine.  If no Attach for binding an electric
engine to a manual transmission exists, then your problem is solved
since you have no generic actual with which to instantiate the package.

Stop trying to import tagged types.  The only reason you'd need to do
that is if the generic package itself needs to extend the formal type.


Now that that's out of the way, I can get to what I mentioned at the
top of my post.  It's possible that the set of operations for engines
and transmissions needed by the generic is large, and so the generic
formal region becomes long since you must declare all the formal
operations.  To simplify things you can declare all the engine
operations in a separate package (and do the same for the transmission
in another package, if necessary), and then import an instantiation of
the engine "signature" package as a generic formal, like this:

generic
  type Engine (<>) is limited private;
  with procedure XXX (E : in out Engine) is <>;
  <lots of other engine ops here>
package Generic_Engines is end;  -- yes, spec is empty

Now you can do this:

generic
  type Engine is limited private;
  type Transmission is limited private;
  with Engines is new Generic_Engines (Engine, others => <>);  --
verify my syntax
  with procedure Attach (E : in out Engine; ...) is <>;
package Generic_Cars is ... end;

That way you can instantiate the Generic_Engines package once for each
interesting engine type (note again that you do NOT need a tagged type
here), and then use that signature package as the generic actual.

Stop using tagged types for everything.  You want signature packages.