To Van Snyder <[log in to unmask]>
 Thank you for your indication.

I look at ftp://ftp.j3-fortran.org/j3/doc/standing/007 but,
if I have correctly understood, the  ASSOCIATE construct is,
from some points of view,  LESS powerful than Pascal's and
(this is for me more important) JavaScript's WITH.

Whith the ASSOCIATE construct I must specify ALL the
associated components. I would like instead to IMPLICITLY
specify to the compiler that a lot of variables belongs to
the same object.

With the WITH construct I can look at any  Fortran 77
old instruction sequence, create a service derived utility_type whose
components are all the instruction sequence variables
and then, using a simple WITH, perform the
sequence instructions with the data of the created utility_object.
Without any modification of the old instruction sequence
and without a long list of all the instruction sequence variables !!!!

If the same calculation must be performed with different
data, a parallelization procedure (using the Unix pthread_create(...)
or the Windows CreateThread(...)) can be set up where
each thread works on a different element of a vector whose elements
are of the type of the utility_object.

A NEW PROPOSAL for the ASSOCIATE instruction: If I could write:

ASSOCIATE ( *=> myobj%* )
   a=b+c+d+...+z
END ASSOCIATE

that is if all the components would match to their own names (*=>myobj%*),
the ASSOCIATE instruction could work exactly as the WITH !!!
Now, instead, I must write:

ASSOCIATE (a =>myobj%a, b=>myobj%b ,..., z=myobj%z)

a very hard and tiring work if I have hundred of components!


To Alekandar Donev <[log in to unmask]>

O.K. Life is hectic but decades (not years) are elapsing before
enhancements of interest for scientific programmers are introduced
in the Fortran standard.
How many years I have been waiting for the IF THEN ELSE and how
long I have to wait for someting really similar to the WITH of
Pascal ?
And I don't speak about the Template proposal...


To A.J.Giles <[log in to unmask]>

The TEMPLATE instruction purpose is not the replacement
of the OOP instructions but the proposal of some new ways.
If a function performing the rotation of the three components
Point%x, Point%y Point%z is available, why
I can't use that function for ALL the objects with
the three conponents x, y and z ?
Without the OOP complication ?
The number of arguments could be reduced passing to Rotation(Point)
not only points but even some other object provided with ... a
barycentre (that is with x,y and z components).
It is better to write Rotation(Point) than
Rotation(Point%x,Point%y,Point%z) !!!

Anyway, in almost a point my written was'nt clear: my proposals
are intended for the f3k Fortran, not the f2k one ! ;-)

Joking aside, do you think that my proposed enancement ( *=> xxx%* )
can be accepted ?
Best regards

           G.B.
           [log in to unmask]