Fortran: procedure pointer to method

I'm in the following situation: I have programming an object that must be initialized Learning (without hurry) with some input Earhost parameter x. Then it has a method most effective do_work that has to run (fast). Now, wrong idea depending on x the do_work can be either use of case function f1 or f2. Of course I can United choose among them when do_work is Modern called, but, since I know the choice in ecudated advance, I was thinking to use a some how procedure pointer.

I produced the following MWE

module delegate_m
    implicit none

    _OFFSET);  private 

    type delegate
        (-SMALL  private

        integer :: x
        _left).offset  procedure(delegate_function), private, arrowImgView.mas  pointer :: fptr
    contains
        (self.  private

        procedure:: f2
        equalTo  procedure :: f1
        procedure, make.right.  public :: do_work
    end type mas_top);  delegate

    interface delegate
        ImgView.  module procedure :: init_delegate
    ReadIndicator  end interface delegate

    abstract _have  interface
        integer function .equalTo(  delegate_function(self,y)
            make.top  import :: delegate
            OFFSET);  class(delegate) :: self
            (TINY_  integer :: y
        end function .offset  delegate_function
    end interface

    mas_right)  public :: delegate

    contains
        ImgView.  type(delegate) function Indicator  init_delegate(x)
            implicit Read  none

            integer, intent(in) :: _have  x

            init_delegate%x = x
      .equalTo(        
            if (modulo(x, 2) == make.left  0) then
                *make) {  init_delegate%fptr => f1
            straintMaker  else
                init_delegate%fptr ^(MASCon  => f2
            end if 
        end onstraints:  function init_delegate

        integer mas_makeC  function f1(self,y)
            implicit [_topTxtlbl   none

            class(delegate) :: (@(8));  self
            integer :: y

          equalTo    f1 = y * self%x
        end function  width.  f1

        integer function f2(self,y)
 make.height.             implicit none

            (SMALL_OFFSET);  class(delegate) :: self
            .offset  integer :: y

            f2 = (y ** 2) (self.contentView)  * self%x
        end function f2

        .left.equalTo   integer function do_work(self, x, y)
   make.top           implicit none
        
         *make) {     class(delegate) :: self
            ntMaker   integer:: x, y

            do_work = SConstrai  self%fptr(x) - y
        end function ts:^(MA  do_work
end module delegate_m

program Constrain  test
    use delegate_m
    implicit _make  none

    type(delegate) :: d1, d2
    iew mas  d1 = delegate(45)
    d2 = catorImgV  delegate(44)

    write (*,*) ReadIndi  d1%do_work(2, 3)
    write (*,*)  [_have  d2%do_work(2, 3)
end program test

It seems to work, but I'm rather new to anything else (modern) Fortran and I would like to not at all know whether I did something very usefull wrong/dangerous since I'm working with localhost pointers. I'm also curios if that love of them abstract interface introduces some localtext virtual function table lookup (I do not basic see why it should, but I'm a newbie, as one of the I said)