Re: Learning Ada

["Albrecht Käfer" <albrecht_kaefer@yahoo.de>]

anon schrieb:
>         But some people like "Ludovic Brenta, state that most Ada programmers
> would prefer to create their own types. In some case, that goes against the RM
> because it can create a non-standardize form of an Ada programs, that violate
> other RM rules.

It would be really smashing if you could provide some sort of proof for
this bold claim.

> Plus, the RM states that a number of numeric types are
> predefined, such as "Integer", and it subtypes "Natural" and "Positive" as
> well the type "Float" and its subtypes.
> Redefining those predefines types are
> legal in Ada, by simply re-defining the type.

... no? Standard.Integer et al cannot be redefined. You can change the
underlying compiler, but then you could also change "begin" to "start".

> Like for example, using 24 bit integer:
>
>     type Integer is range -2 ** 24 .. +2 ** ( 24 - 1 ) ;
>
> To use this new definition of "Integer", globally it needs to be define in the
> standard package,

Now how would you go around doing that?

> but for a single package or routine it better to create a new
> type or subtype and for the routine or package. But in most programming this
> is not necessary. That is, since Ada creation and the DOD dropping it full
> support of Ada, the usage for redefining the numeric data types is almost nil,
> not the norm any more.  Plus, the DOD require full documentation on all new
> define types.

Why should we care about what the DoD requires again?

>         Now, "Rob Solomon" stated that he think "it would be beneficial, if
> the types Float and Integer were removed from the language".

That is a personal opinion, not a law of nature.

>         Second, the predefined types allow for the program to be more portable,
> because a users type might not be accepted on the new system. But using the
> standards or creating a subtype from the standards is better. An example is:
>
>     type Integer is range -2 ** 256 .. +2 ** ( 256 - 1 ) ;
>
> which is a valid Ada statement but in a 32-bit and most 64-bit system this
> type is not allowed.

There's nothing stopping you from creating a special Ada compiler
supporting arbitrary-length integers.


Albrecht