Question

I have two routines whose difference is only in the order of arguments, but I would like to use them through an interface, so that the proper one is invoked according to the order of the arguments when invoked. The compiler complains that it cannot distinguish them, and my guess is because if I use the syntax for named arguments at call, it won’t know which one to call. One workaround would be to use different names for the arguments, but I was wondering if there’s a way to disable named argument call style.

Example, this is the situation I am trying to handle

module Foo

    interface Bar
        module procedure Bar1
        module procedure Bar2
    end interface

contains
    subroutine Bar1(i,r)
        integer, intent(in) :: i
        real, intent(in) :: r
        print *, "bar1"
    end subroutine
    subroutine Bar2(r,i)
        real, intent(in) :: r
        integer, intent(in) :: i
        print *, "bar2"
    end subroutine

end module

program fuux
    use Foo
    integer :: i
    real :: r

    r = 5.0
    i = 3

    call Bar(i,r) ! note that if I call Bar(i=i, r=r) the compiler cannot disambiguate
                  ! so it will complain at the interface statement
end program

Answer 1

I do not know of any way to do what you suggest, or rather to do what I think you are suggesting in the phrase ‘disable named argument call style’. If this answer infuriates, disappoints or displeases in any way, post some code and we (SO I mean, I have not too many airs and graces and rarely use the royal ‘we’) might be able to suggest a cunning trick which will please you.

EDIT

No direct way to do what you want to do springs to mind. The first workround that occurs to me is to define a subroutine called bar which takes the series of arguments in a canonical order and simply calls bar1, bar2 (and any other baby bars you care to define) with the arguments in the appropriate order.