Fortran 中的过程指针

假设我有以下单参数双精度函数的抽象接口

module abstract

  abstract interface
     function dp_func (x)
       double precision, intent(in) :: x
       double precision :: dp_func
     end function dp_func
  end interface

end module abstract

在另一个模块中，我定义了两个函数，一个是简单的函数g类型的dp_func还有一个更复杂的f

module fns

 contains
 double precision function f(a,b,x)
   double precision, intent(in)::a,b,x
   f=(a-b)*x 
 end function f

 double precision function g(x)
   double precision, intent(in)::x
   g=x**2 
 end function g
end module fns

现在指向g可以创建如下

program main
use abstract,fns
procedure(dp_func), pointer :: p
double precision::x=1.0D0, myA=1.D2, myB=1.D1, y
p => g
y=p(x)
end program main

但是如何创建一个指向f(myA,myB,x)，即f在固定值a and b，它可以被视为只有 1 个参数的函数，即dp_func类型？ 最终结果我希望能够写出类似的东西

p=>f(myA, myB, )
y=p(x)

下面的评论表明函数闭包 https://en.wikipedia.org/wiki/Closure_(computer_programming)不是 Fortran 标准的一部分，包装函数将是一个可能的解决方案。然而，包装器必须被初始化，这导致最终用户可能忘记调用初始化器。如何以干净、透明的方式做到这一点？

EDIT发布这个问题并用谷歌搜索“闭包和 Fortran“，我找到了这个例子

我以图片形式呈现以强调突出显示。这是在在线课程中介绍的。但我怀疑这种隐式参数设置是否是一种好的编程实践。事实上，像这样的悬空变量z在这个例子中是完美的错误来源！

您可以使用内部函数来包装您的函数，例如

program main
  use abstract
  use fns
  implicit none
  
  procedure(dp_func), pointer :: p
  double precision :: x, myA, myB, y
  
  x = 1.0D0
  myA = 1.D2
  myB = 1.D1
  
  p => g
  y=p(x)
  
  p => f2
  y = p(x) ! Calls f(1.D2, 1.D1, x)
  
  myA = 1.D3
  myB = 1.D2
  
  y = p(x) ! Calls f(1.D3, 1.D2, x)
contains
  double precision function f2(x)
    double precision, intent(in) :: x
    write(*,*) myA, myB
    f2 = f(myA,myB,x)
  end function
end program main

给定作用域中的内部函数可以使用该作用域中的变量，因此它们可以像闭包一样起作用。

隐式使用myA and myB在内部函数中f2很可能是编程错误的根源，但是，只要范围f2仍在范围内，此行为与lambda其他语言中的函数，例如等效的 python lambda：

f2 = lambda x: f(myA,myB,x)

正如 @vladimirF 所指出的，一旦范围f2超出范围（例如，如果指向f2被存储并且过程在哪里f2被声明返回）任何指向f2将会失效。这可以在这段代码中看到：

module bad
  use abstract
  use fns
  implicit none
contains

function bad_pointer() result(output)
  procedure(dp_func), pointer :: output
  
  double precision :: myA,myB
  
  myA = 1.D2
  myB = 1.D1
  
  output => f2
contains
  double precision function f2(x)
    double precision, intent(in) :: x
    write(*,*) myA, myB
    f2 = f(myA,myB,x)
  end function
end function

end module

program main
  use abstract
  use fns
  use bad
  implicit none
  
  procedure(dp_func), pointer :: p
  double precision :: y,x
  
  p => bad_pointer()
  x = 1.D0
  y = p(x)
end program

注意：对于这个简单的情况，上面的代码可能运行良好，但它依赖于未定义的行为，因此不应使用。