Can Fortran PURE functions use global parameters?

Question

It seems to me the what is called a pure function in Fortran is not considered pure enough for those who use functional programming. So here is my question. Suppose I have the following code:

MODULE basics
  IMPLICIT NONE
  INTEGER, PARAMETER      :: dp = kind(1.0d0)
  REAL(dp), PARAMETER     :: PI=3.1415926535897932_dp
  REAL(dp), PARAMETER     :: earthEquatorialRadius=6378.137_dp
END MODULE basics

MODULE myFunctions
  USE basics
  IMPLICIT NONE

  PURE REAL(dp) FUNCTION sphericalArc(angleInRadians) 
    REAL(dp),INTENT(IN)  :: angleInRadians 

    sphericalArc= 2.0*PI*earthEquatorialRadius*angleInRadians
  END FUNCTION sphericalArc
END MODULE myFunctions

The function sphericalArc has no side effects, so it's pure in that sense, but it uses global constants. It's true that the parameters PI and earthEquatorialRadius can be defined inside the function but this is undesirable since I would like to use these in other functions and subroutines. It's going to be even more tedious to make the dp type defined in each function or procedure.

So from Fortran's perspective is a function that uses global parameters defined outside of the function still considered pure and can be called from a do concurrent loop?

Answer 1

If a Fortran procedure (function or subroutine) has the pure prefix in its definition then it is a pure procedure in the sense that Fortran uses it. It can then be used in places where there is a restriction of purity. A procedure with prefix elemental and without the prefix impure is also pure.

To be allowed to be specified as pure, the procedure is subject to a number of constraints, but it is necessary for the compiler to diagnose any violation of these constraints when pure is given.

There is no constraint that a named constant from another module (or other scope) may not be referenced.

As motivation for purity in Fortran, the standard (F2008, Note 12.49) offers:

The above constraints are designed to guarantee that a pure procedure is free from side effects (modifications of data visible outside the procedure)

Referencing a named constant is not modification of data visible outside the procedure.

Answer 2

From this documentation it should be okay to use a global variable as long as it is a parameter (so the value does not change).

The execution_part and internal_subprogram_part of a pure procedure cannot refer to a dummy argument with an INTENT(IN), a global variable (or any object that is storage associated with one), or any subobject thereof, in contexts that may cause its value to change: that is, in contexts that produce side effects.