Procedure pointer in variable-definition context

[ivan-pi]

I thought the following type of pattern was allowed:

module action_dict_mod
  implicit none

  abstract interface
    subroutine doit_fn()
    end subroutine
  end interface

  type :: action
    character(len=:), allocatable :: key
    procedure(doit_fn), pointer, nopass :: doit => null()
  end type

  type :: action_dict
    integer :: n = 0, capacity = 0
    type(action), allocatable :: v(:)
  contains
    procedure :: set => set_action
    procedure :: get => get_action
  end type

contains

  function set_action(dict,key) result(p)
    class(action_dict), intent(inout), target :: dict
    character(len=*), intent(in) :: key
    procedure(doit_fn), pointer :: p

! Initialization and resizing logic
    if (.not. allocated(dict%v)) then
        dict%capacity = 10
        allocate(dict%v(dict%capacity))
    else if (dict%n >= dict%capacity) then
        ! Simple doubling of capacity if full
        block
            type(action), allocatable :: temp(:)
            associate(new_capacity => dict%capacity * 2)
                allocate(temp(new_capacity))
                temp(1:dict%n) = dict%v
                call move_alloc(temp, dict%v)
                dict%capacity = new_capacity
            end associate
        end block
    end if

    ! Add new entry
    dict%n = dict%n + 1
    dict%v(dict%n)%key = trim(key)

    ! Return the pointer to the procedure inside the dictionary
    p => dict%v(dict%n)%doit

  end function


  function get_action(dict,key) result(p)
    class(action_dict), intent(in) :: dict
    character(len=*), intent(in) :: key
    procedure(doit_fn), pointer :: p

    integer :: i

    p => null()

    ! Naive linear search
    do i = 1, dict%n
        if (dict%v(i)%key == trim(key)) then
            p => dict%v(i)%doit
            return
        end if
    end do

  end function

end module

program main
  use action_dict_mod
  implicit none

  type(action_dict) :: my_actions
  procedure(doit_fn), pointer :: proc_ptr

  ! Using the F2008 pointer-function result to assign the procedure
  my_actions%set("hello") => hello_sub

  ! Retrieve and execute
  proc_ptr => my_actions%get("hello")
  if (associated(proc_ptr)) call proc_ptr()

contains

  subroutine hello_sub()
    print *, "Hello, World!"
  end subroutine

end program main

It seems like there is a restriction on this. The Intel Fortran documentation says under "Disallowed Contexts":

For the following variable-definition contexts, the Fortran Standard specifies that a "variable name" must be used and not a "variable":

• [...]
• A data pointer object or procedure pointer object in a pointer assignment statement

This appears related to (J3/24-007, 10.2.2.2):

R1034 pointer-assignment-stmt is ...
                              or proc-pointer-object => proc-target

R1039 proc-pointer-object     is proc-pointer-name
                              or proc-component-ref
R1040 proc-component-ref      is scalar-variable % procedure-component-name

Is there any reason why an expr could not be added to R1039? The constraints on expr would be the same as,

C1032 (R1041) An expr shall be a reference to a function whose result is a procedure pointer.

The design is still achievable today, by using a wrapper type for the procedure pointer, effectively changing the pointer assignment into a data-pointer assigment.

As an implementation-note, this usage pattern also benefits from the extension proposed in #354.

[ivan-pi]

The following paragraph also appears to be related (J3/24-007, 19.6.8):

Some pointers are prohibited from appearing in a syntactic context that would imply alteration of the pointer association status (19.5.2.2, 8.5.10, 8.5.15, 15.7). The following are the contexts in which the appearance of a pointer implies such alteration of its pointer association status:

• a pointer-object in a nullify-stmt;
• a data-pointer-object or proc-pointer-object in a pointer-assignment-stmt;
• an allocate-object in an allocate-stmt or deallocate-stmt;

[klausler]

I think you would need to have a left-hand side function reference that returned a pointer to a procedure pointer, and Fortran doesn't have those. But I might be misunderstanding your point; could you perhaps write a minimal program that doesn't conform today, but would conform under your proposal?

[ivan-pi]

module mwe
implicit none
procedure(), pointer, protected :: smth => foo
contains
    function get() result(p)
        procedure(), pointer :: p
        p => smth
    end function
    subroutine foo
        print *, "foo"
    end subroutine
end module

program test
use mwe

procedure(), pointer :: p => null()

p => get() ! Conforming, points to foo
if (associated(p)) call p()

get() => bar ! Prohibited

contains
    subroutine bar
        print *, "bar"
    end subroutine
end program

I thought that smth would now point to bar. It is not symmetric, we can use the function returning a procedure-pointer on the RHS, but not on the LHS.

[ivan-pi]

I see why this doesn't work. get returns the pointer to foo and not the pointer to smth. A pointer container object can be used instead:

module mwe
implicit none
type :: action
    procedure(), pointer, nopass :: a => null()
end type
contains
    ! Silly function which "forwards" the dummy argument
    function set(this) result(p)
        type(action), target :: this
        type(action), pointer :: p 
        p => this
    end function
    function get(this) result(p)
        type(action), intent(in), pointer :: this
        procedure(), pointer :: p
        p => this%a
    end function
end module

program test
use mwe
type(action), target :: say_hello
procedure(), pointer :: p_hello

set(say_hello) = action(hello)
p_hello => get(say_hello)
if (associated(p_hello)) call p_hello

contains
    subroutine hello
        print *, "hello"
    end subroutine
end program

$ flang -pedantic pointer_trouble.f90 && ./a.out
 hello
$ gfortran -pedantic pointer_trouble.f90 && ./a.out
 hello