Difference between subroutine inside module "contains" and outside module

Question

I have a large source code where subroutines in modules are defined outside the module ... end module statement (ie. not inside a contains statement). I've included a simplified module below:

module core
  implicit none

  type :: disc_status
    sequence

    real*8 :: alpha1, alpha2, alpha3

  end type disc_status
end module core

subroutine tester(input)
  use core
  type(disc_status), intent(in) :: input
  print *, input%alpha1, input%alpha2, input%alpha3
end subroutine tester

Here's an example program using the module and subroutine:

program flyingDiscSimulator

use core
implicit none

type(disc_status) :: disc

disc%alpha1 = 1.1D0
disc%alpha2 = 1.2D0
disc%alpha3 = 1.3D0

call tester(disc)

print *, 'it works'

end program flyingDiscSimulator

Normally, I end up seeing subroutines use the contains statement within a module:

module core
  implicit none

  type :: disc_status
    sequence

    real*8 :: alpha1, alpha2, alpha3

  end type disc_status

   contains
     subroutine tester(input)
       type(disc_status), intent(in) :: input
       print *, input%alpha1, input%alpha2, input%alpha3
     end subroutine tester

end module core

However, the program file referenced above doesn't require any changes to use either way of including a subroutine in a module (using gfortran anyways). Thus, there appears to be no difference in the usage of the module or it's subroutine between the two solutions. Are there any "under the hood" differences between the two styles?

score 4 · Accepted Answer · answered Dec 30 '20 at 16:30

The versions

module m
contains
  subroutine s()
  end subroutine s
end module m

and

module m
end module m

subroutine s()
end subroutine s

say completely different things, but in the case of the question the end results are much the same.

The first version here creates a module procedure s with host m; the second version has an external procedure s with no host.

Although the example of the question has the external procedure using the module, there is more generally a difference: the module procedure has access to all entities in the module (except when made inaccessible through an import statement or by being obscured by local names; the external procedure using the module has access only to those public entities.

However, come the main program the effects are different. The external subroutine and its name are global entities. Going to my second version, then

program main
  call s
end program

is a valid program which calls the external subroutine s. This subroutine reference is valid because the implicit interface for s in the main program suffices. If the external subroutine s were such than an explicit interface were required then main program here would not be allowed. It is acceptable, but not required, to have an external s statement in the main program to reinforce to the reader that the subroutine is an external one (with implicit interface). (implicit none external would make external s necessary.)

The example of the question is such that an explicit interface is not required.

A module procedure always has an explicit interface available when accessible. However, a module procedure is not a global entity and its name is not a global identifier.

Under the hood, there are implementation differences (stemming from the above): most notably compilers will often "name mangle" module procedures.

In summary, there are differences between the two approaches of the question, but they won't be noticed by the programmer in this case.

Checking my understanding: So in my example program, the `use core` statement is completely unnecessary to access the subroutine `tester`, yes? Or conversely, there is nothing connecting `tester` with the `core` module other than they happen to be in the same file? — James Wright, Dec 30 '20 at 17:40
`use core` is necessary in the `contains` version but not in the other. There is a connection between the external subroutine and the module: the subroutine depends on the module. Being in the same file provides no syntactic information: other than the compilation order and extra file there would be no difference. (Note that `use core` is actually required in both versions. You need it with the non-`contains` version to provide the definition of the argument's type. Without the `disc_status` dependency you wouldn't need the module.) — francescalus, Dec 30 '20 at 18:04

jack · Answer 2 · 2020-12-30T16:29:34.587

0

The procedure inside the module will have an explicit interface (aka the compiler knows about the arguments' characteristics). Whereas the procedure outside of the module will have an implicit interface (aka the compiler must make assumptions about the arguments).

Explicit interfaces help the compiler to find programming errors and are therefore favourable. For a more indepth discussion of advantages see for example this answer.

I am not even sure if it is valid Fortran to call tester inside the program when it is defined outside of core?

The line use core should just make the module's public objects known and the tester procedure needs its own external tester line.

edited Dec 30 '20 at 16:29

answered Dec 30 '20 at 14:44

jack

1,658
1
7
18

Yeah, I'm not sure it's valid Fortran either, which is why I'm trying to figure out how it works. The original code has been used and modified over several years on many platforms and appears to have not had any issues with it (ie. with many different compilers and generations of compilers). – James Wright Dec 30 '20 at 14:59

Difference between subroutine inside module "contains" and outside module

2 Answers2

Linked