John Reid answered Aleksandar Donev's question:

> Fortran 95 says that two or more part references with nonzero rank must
> not be specified in a structure component.

   Unfortunately, it is not permissible for more than one {part-ref} to be
   an array; for example, it is not permitted to write

      tar%du   ! Illegal

  for the array tar of Section 6.12.  The reason for this is that if
  tar%du were considered to be an array, its element (1,2,3,4) would
  correspond to

     tar(2,3,4)%du(1)

  which would be too confusing a notation.

We already have this situation with characters.  The only difference is
that the last (i.e., most rapidly varying) "subscript" is allowed only
to be a section with stride 1.  Consider a rank-3 array of characters

  character(len=10) :: C(5,6,7)

Then the (/ 1,2,3,4 /) "element" of this array is c(2,3,4)(1:1), which
is equally as confusing as John's example above.

In the next edition of Fortran (i.e. after Fortran 2000), to regularize
things, we should do at least two things:

1.  Treat the "substring" selector of a character as an ordinary subscript,
    allowing a single value, a pair of values separated by a colon,
    denoting a stride-1 section, or a triplet, denoting a section with a
    stride other than 1.  Doing only this would make characters more
    parallel to ordinary arrays.  The last "subscript," being the most
    rapidly varying, would properly be in the "row major" position, and
    enclosed in parentheses instead of delimited by commas, which is
    _exactly_ the notation used in many languages that have arrays of
    arrays.

2.  Allow nonzero rank for several parts of a structure reference, subject
    to the requirement that a pointer part with nonzero rank is the last
    part with nonzero rank.

Observing that these are essentially arrays with subscripts in row-major
positions, i.e., the most rapidly varying subscript is last, a possible
third regularization is to allow specifying row-major subscripts, e.g.

  real :: A(10)(20)

has the same storage layout as

  real :: B(20,10)

but the subscripts are in the reverse order:  A(3)(4) is in the same
subscript position as B(4,3).  As I noted above, we already allow this
for characters, with the constraint that the row-major "subscript" has
to be a section.  Notice the similarity of the declaration of A and

  character :: C(10)*20

The declaration

  character :: C(10)(20)

would be allowed (indeed, some might say preferred), and would be _exactly_
the same as

  character(len=20) :: C(10)

This would imply that we allow ranks up to at least 8, so why not go
further to, say, a total rank of 15?

There are obvious generalizations of this.  For example, in

  real :: R(10,20)(30,40)

the third subscript varies most rapidly, then the fourth, then the first,
then the second.  We would, of course, for reasons of symmetry, allow such
things as

  real :: R(10)(20)(30)(40)
  character(len=40) :: C(10)(20)(30)

which would be totally row-major, not partly row-major and partly column-
major, as character arrays of rank > 1 are now.

Adding the third element to this proposition makes the treatment of
arrays entirely symmetric between numeric types, characters, and structure
designators with more than one part having nonzero rank.

BTW, I proposed most of this in my second public comment on Fortran 90 --
the one that X3J3 didn't answer (perhaps because it was too big, and too
radical for its time), and on page 19 (section 12) of 97-114.

--
What fraction of Americans believe   |  Van Snyder
Wrestling is real and NASA is fake?  |  [log in to unmask]
Any alleged opinions are my own and have not been approved or disapproved
by JPL, CalTech, NASA, Sean O'Keefe, George Bush, the Pope, or anybody else.