Can I mimic multiple passed-object dummy arguments without adding dependencies? - fortran

Question

I previously asked Can I mimic multiple passed-object dummy arguments in Fortran?
I over-simplified my problem for that question, and a better example of the code I would like to write is
module m_Parent
type, abstract :: Parent
contains
procedure(f_Parent), deferred :: f
end type
abstract interface
subroutine f_Parent(foo,bar)
import Parent
implicit none
class(Parent), intent(in) :: foo
class(Parent), intent(in) :: bar
end subroutine
end interface
end module
module m_Child
use m_Parent
type, extends(Parent) :: Child
contains
procedure, public :: f => f_Child
end type
contains
subroutine f_Child(foo,bar)
implicit none
class(Child), intent(in) :: foo
class(Child), intent(in) :: bar
end subroutine
end module
with the constraint that m_Parent may not have dependencies on m_Child, to avoid circular dependencies and to allow for many Child classes without having to update m_Parent with the details of each.
As before:
the code presented here is forbidden by the Fortran standard.
the select type construct is too slow.
Can I mimic the behaviour that the above code would produce if multiple passed-object dummy arguments were allowed by the Fortran standard?

Answer 1

The standard forbids multiple passed-object dummy arguments, along with passed-object dummy arguments which are arrays or pointers. The standard does not forbid passed-object dummy arguments which are classes containing arrays or pointers.
This can be implemented as
module m_Parent
type, abstract :: Parent
end type
type, abstract :: ParentPair
contains
procedure(f_ParentPair), deferred :: f
end type
abstract interface
subroutine f_ParentPair(foobar)
import ParentPair
implicit none
class(ParentPair), intent(in) :: foobar
end subroutine
end interface
end module
module m_Child
use m_Parent
type, extends(Parent) :: Child
contains
procedure, public :: f => f_Child
end type
type, extends(ParentPair) :: ChildPair
type(Child) :: foo
type(Child) :: bar
contains
procedure, public :: f => f_ChildPair
end type
contains
subroutine f_ChildPair(foobar)
implicit none
class(ChildPair), intent(in) :: foobar
call foobar%foo%f(foobar%bar)
end subroutine
subroutine f_Child(foo,bar)
implicit none
class(Child), intent(in) :: foo
class(Child), intent(in) :: bar
end subroutine
end module
This is not the most elegant solution, and it requires the creation and maintenance of an entire ChildPair class for every implementation of Child.
According to operf, in ifort 19.1 this has a negligible overhead compared to a select type statement.