Sorry for the long post, I don't know how to make it more concise.
Let me see if I can explain what I'm trying to do... Consider a
subroutine to minimize a function of n variables,

subroutine minimize(Func, x)
real, dimension(:), intent(inout):: x
interface
real function Func(z)
real, dimension(:), intent(in):: z
end function Func
end interface
!
! Start calling Func(x) and use some clever
! algorithm to modify x until Func(x)
! reaches a minimum
end subroutine minimize

So I write the body of the minimizer, place it in a module, and
people can USE the module and minimize their own objective functions,

X= initial_guess
call minimize(my_function, X)

Pierre Asselin wrote:

Pierre Asselin wrote:

...

[good summary of the usual suggestions elided]

There are multiple ways to do in in f2003. The class stuff is one.
Another way is "hidden" in the C interop stuff, although it has good
application completely unrelated to C. That way is to use the C_PTR
type. It is a C void pointer and can point to pretty much anything. (I
think it might be limitted to interoperable types, but that's not a
horrible restriction).

Part of why I mention it is that this might even be a candidate for f95,
in either of 2 ways.

1. Some f95 compilers implement the C interop stuff as an f95 extension.
Thus you might have that now.

Pierre Asselin wrote:
| Sorry for the long post, I don't know how to make it more concise.
| Let me see if I can explain what I'm trying to do... Consider a
| subroutine to minimize a function of n variables,

I suggested enhancing the language with a special type called
e.g. WHATEVER which would be type-compatible with pretty much
anything for the purpose of such data passing (kind of equivalent
of C void*). Obviously, that is pretty much emulable in F2003 with
derived classes, but there are no compilers...

Apart from the clumsy TRANSFER solution, I will offer a
non-standard one, but hopefully fairly portable. It relies on the
following assumptions:

* the varying-type argument you need is always a scalar
* compiler's internal representation of any scalar POINTER is
the same (and equivalent to C void*).

Jugoslav Dujic wrote:
| Pierre Asselin wrote:
|| Sorry for the long post, I don't know how to make it more concise.
|| Let me see if I can explain what I'm trying to do... Consider a
|| subroutine to minimize a function of n variables,
|
| I suggested enhancing the language with a special type called
...

Sorry, the previous post went erroneously off my "Drafts" folder;
it (obviously) isn't completed. Later...

--
Jugoslav
___________
www.xeffort.com

Please reply to the newsgroup.
You can find my real e-mail on my home page above.

I'll reply to my own post and consolidate here.

Richard Maine wrote:

Hmf. The standard says yes in two specific cases, neither of which
is the one I need. Otherwise, the standard says that the TRANSFER(...)
above has the same physical representation as A, whatever that
means. The term "physical representation" isn't defined anywhere
and the promise seems hollow to me.

Pierre Asselin wrote: