Re: Modular types inside records

["Nick Roberts" <nickroberts@callnetuk.com>]

Totally off-base, Pawel!

One of the things you must learn, if you are going to become a professional
Ada programmer, is what is grandly called 'decoupling'. This means, in
essence, making the interfaces between modules as simple as reasonably
possible. In the case of bottom-up programming (which includes your
example), this generally means making the interface as simple as
(reasonably) possible for 'users' of your package.

Does adding the 'mod_n_max' generic parameter make things easier for users
of your package? It surely does not.

Trust me, something like:

   if Front = Buffer'Last then
      Front := Buffer'First;
   else
      Front := Buffer_Index'Succ(Front);
   end if;

is a terrifically simple piece of code, as code goes. In your time, you will
come across multi-KSLOC Gorgons that will make you have to change your
underpants. You will come to eat the kind of fragmentette above in one gulp.

Oh harken ye to the words of the old and grizzled: it's not the car that has
the fanciest gadgets that wins the race, it's the one that manages to
actually finish the race.

Another way to think of it is like this: programming is not an art, it's
just a way of getting a job done. And, believe me, this comes from a man who
deeply believes that programming is an art.

Or, another way is this: you have to know a lot in order to know a little.

Okay, so how do we 'pros' do it, then? By declaring a 'Cyclic_Succ' function
of course:

generic
   type Element_Type is (<>);
function Cyclic_Succ (Item: in Element_Type) return Element_Type;

Neat huh? I'll leave the implementation and use of this function to you.

All the best,

--
Nick Roberts
http://www.AdaOS.org

PS: If you need to remove Constraint_Error checks, for speed, you can use
pragma Suppress (after testing).