Re: An array of records within an array of records (Still a problem)

Re: An array of records within an array of records (Still a problem)

[tmoran]

> type cd_track_array is array(1..3) of cd_track;
> new_cd_track:cd_track_array;
> ...
>                 id:new_cd_track;
You need          id:cd_track_array;
What you have now is like
  A : Integer;
  B : A;
It's a good idea to pay a lot of attention to naming.  'cd_track_array'
could be a particular array of cd_track's, or it could be, as it is
here, a type - a general description of any set of three cd_track's.
Some people like to put _type or _t or make a plural for a type name to
distinguish it from a variable name, or perhaps use _array for the type
and _list for the variable, or prefix the variable with The_ or A_, or
whatever.  It can be really helpful if you adopt some convention and
then stick to it.  And to the extent your programs are to be read by
others, it's good if you and they share the same conventions.
  Hoping this thread doesn't turn into another war over which
convention is 'right'.    Tom Moran

Re: An array of records within an array of records (Still a problem)

[Stephen Leake]

tmoran@bix.com wrote:

> Some people like to put _type or _t or make a plural for a type name to
> distinguish it from a variable name, or perhaps use _array for the type
> and _list for the variable, or prefix the variable with The_ or A_, or
> whatever.  It can be really helpful if you adopt some convention and
> then stick to it.  And to the extent your programs are to be read by
> others, it's good if you and they share the same conventions.
>   Hoping this thread doesn't turn into another war over which
> convention is 'right'.    Tom Moran

  No war needed; _Type is right :)

Sorry, I couldn't resist. I use _Type, and I just spent the weekend reading
the Ada 95 Booch components, which don't. It was subtly frustrating. It
would be nice if we (the Ada community) could agree on a consensus for this
issue, as we seem to have on the Capitalization_Of_Multi_Word_Names issue.

Maybe if we complete the Ada 95 Booch components, or some equivalent,
widely-useful library, that could serve as a basis for consensus. Hmm, a
quick glance thru some of the GNAT run-time sources indicates they don't
use either _Type or plural for types. Looks like I may end up in the
minority :( .

-- Stephen Leake

Re: An array of records within an array of records (Still a problem)

[Dr Richard A. O'Keefe]

Stephen Leake wrote:
> Sorry, I couldn't resist. I use _Type, and I just spent the weekend
> reading the Ada 95 Booch components, which don't.  It was subtly
> frustrating.  It would be nice if we (the Ada community) could agree
> on a consensus for this issue, as we seem to have on the
> Capitalization_Of_Multi_Word_Names issue.

The rule I was taught is a very simple one.  You should name your
types and your variables so that an object declaration like

    Open_Goal_Set: Goal_Set;

can be read aloud as a TRUE and USEFUL sentence, pronouncing the
colon as "is a".  Hence
    Open_Goal_Set is a Goal_Set
works, but
    Open_Goal_Set is a Goal_Set_Type
doesn't work, and
    Open_Goal_Set is a Goal_Sets
_really_ grates.

Note that this _is_ consistent with the names of the Ada built in
types:
    Space: Character;
NOT
    Space: Character_Type;
or  Space: Characters;

Unlike capitalisation, where the case pattern was _defined_ not to
make any difference to the predefined things in the language, we
_can't_ _consistently_ switch to a *_Type or *s convention.

_Type (was: Re: An array of records within an array of records (Still a problem))

[Norman H. Cohen]

Dr Richard A. O'Keefe wrote:

> The rule I was taught is a very simple one.  You should name your
> types and your variables so that an object declaration like
> 
>     Open_Goal_Set: Goal_Set;
> 
> can be read aloud as a TRUE and USEFUL sentence, pronouncing the
> colon as "is a".

If you end your type names with "_Type", the rule is simply to read the
colon as "is of" instead.  Constructs such as

   for Day in Weekday_Type

read more naturally using the _Type suffix.

-- 
Norman H. Cohen
mailto:ncohen@watson.ibm.com
http://www.research.ibm.com/people/n/ncohen

Re: _Type (was: Re: An array of records within an array of records (Still a problem))

[Michael F Brenner]

   > ... the colon could be read as IS A
   > ... the colon could be read is IS OF

It is commendible that both of these philosophies are attempting
to read the computer statements as English sentences (or French
or Russian or Sanskrit) as well they should.

The readings of IS A and IS OF finally explain why people have
different opinions as to HOW to read them as sentences. 

Of course the original and, IMO, the best philosophy is to read
the colon as IS OF TYPE, which leads types to be either plurals or
classlike words.

It is surprizing and very pleasing that most of those who disagree
with me have good reasons and a rational explanation for their opinions.

The reason I think the plurals is the best is that they ALSO read 
as English sentences in array definitions, array declarations, and
other constructs in which computer science is derived from mathematical
set theory (only finitized in space and time dimensions). That is,
the computer has a finite amount of memory and a finite amount of time
to complete. 

Re: An array of records within an array of records (Still a problem)

[Robert Dewar]

Stephen said

<<> Sorry, I couldn't resist. I use _Type, and I just spent the weekend
> reading the Ada 95 Booch components, which don't.  It was subtly
> frustrating.  It would be nice if we (the Ada community) could agree
> on a consensus for this issue, as we seem to have on the
> Capitalization_Of_Multi_Word_Names issue.
>>

Uniformity might be desirable here, but clearly the rule cannot be
to add _Type to every type (a real noise generator in my opinion),
since clearly this is not the style of the existing language design,
which defines many types.

The style in the RM (which I assume you also find subtly frustating) is
to use nouns as type names, so that something "is a" String or Integer
or Unbounded_String or whatever. Of course there are some cases where
Type is used (File_Type), so I would gather that the consensus from
the RM is to use one of these two styles depending on what is clearer.
Sounds good to me! It's certainly the approach I use.

Of course you have to be tuned in to the criterion of how to make his
this choice. I guess I must be, because I find the RM quite clear and
not frustrating, and I like its decisions on when to use Type and
when not to!