Stephen Leake <[log in to unmask]> wrote: >So I stand by my statement; deriving new types from user-defined >non-tagged types is rarely useful. Your statement wasn't exactly that. Here is what you wrote Mon, 28 Jan 2002 13:03:42, (Message-ID: <[log in to unmask]>) : >Integer, Float, etc are un-tagged, so we can derive from them, but not >extend them. This form of derivation is of limited use. There was nothing about the derivation from the *user-defined* non-tagged types, since Integer and Float are standard types, and therefore they hardly can be considered as user-defined types. Now to the essense: >This is a "subtype", not a "derived type". A "derived type" uses the >word "new", as in: > >type Derived_Task_Id_Type is new Task_Id_Type; > >Same here; all subtypes, not derived types. > >So I stand by my statement; deriving new types from user-defined >non-tagged types is rarely useful. From the pedantic viepoint, the claim that the derived types and the subtypes are completely different things may be true. Yes, the word "new" is needed for the derivation from the type, in strict sense of the term "derived type", Therefore it would be ok to say: Integer, Float, etc are un-tagged, so we can derive from them, but not extend them. This form of derivation is of limited use. There are other entities in Ada, called "subtypes", which provide a form of differentiation within a type. You might explain what subtypes are, or not, but it occured that you kept silent about them at all, and at the same time provided the "pragma" about limited use of the derivation from the un-tagged types. With that you, intentionally or not, claimed that the power of the type system in Ada95 is roughly and/or practically the same as in C++, etc. In fact, the subtypes have much in common with the derived types, and it isn't a coincidence that the derivation (from the non-tagged types) and subtyping are considered either in neighbouring sections or even together (as in well-known books "Programming in Ada95" by Barnes, and "Ada as Second Language" by Cohen). Practically, the subtypes differ from the distinct type in that a compiler generally permits mixing the different subtypes of the same type in an assignment, but 1) the run-time checks are provided by the same compiler, and 2) the subtype information is available for both a programmer and the custom verification tools, which may perform additional checks. The latter means, in particular, that one may relatively easily create the custom extentions of the type system, that are based on subtypes. Alexander Kopilovitch [log in to unmask] Saint-Petersburg Russia