объявление класса fortran фиктивного аргумента

Да, вы можете объявить связанную с типом процедуру даже для типа abstract. Это может быть процедура с привязкой к реальному типу или просто abstract interface.

type, abstract :: a
contains
  procedure :: valuea1, valuea2
  generic value :: value => valuea1, valuea2
end type


abstract interface
  ! the headers of valuea1, valuea2 here
  ! they should have a passed dummy argument class(a)
  ! and some other argument for the generic resolution
  ! for example:

  subroutine valua1(self, x)
    class(a), intent(in) :: self
    real, intent(inout) :: x
  end subroutine

  subroutine valua2(self, x)
    class(a), intent(in) :: self
    integer, intent(inout) :: x
  end subroutine

end interface

Таким образом, вы не можете создавать переменные type(a), но можете создавать расширенные типы, которые реализуют свои собственные версии value.

Аналогично ответу @VladimirF, но с учетом вашего разъяснения, что

На самом деле мне не нужно общее разрешение; valuea1 и valuea2 принимают один и тот же тип аргументов для проблемы, которую я имею в виду, я просто хочу привязаться к valuea1 в одном расширении типа и valuea2 в другом расширении типа.

Таким образом, здесь базовый (абстрактный) тип определяет отложенную процедуру с привязкой к типу value() с интерфейсом, принимающим class(a) в качестве передаваемого аргумента. Можно добавить другие аргументы. Каждый расширяющий тип определяет/переопределяет эту связанную с типом процедуру своей собственной процедурой.

Это означает, что в нашем последнем вызове подпрограммы test_sub фиктивный аргумент class(a) имеет %value().

module types

! The base type
  type, abstract :: a
   contains
     procedure(value_if), deferred :: value
  end type a

! The interface for the type-bound procedures
  abstract interface
     subroutine value_if(var)
       import a
       class(a) var
     end subroutine value_if
  end interface

! The extending types, overriding the value subroutine

  type, extends(a) :: a1
   contains
     procedure :: value => value_a1
  end type a1

  type, extends(a) :: a2
   contains
     procedure :: value => value_a2
  end type a2

contains

  subroutine value_a1(var)
    class(a1) var
    print*, "Value of a1"
  end subroutine value_a1

  subroutine value_a2(var)
    class(a2) var
    print*, "Value of a2"
  end subroutine value_a2

end module types


program test

  use types

  type(a1) x
  type(a2) y

  call x%value
  call y%value

  call test_sub(x)
  call test_sub(y)

contains

  subroutine test_sub(var)
    class(a) var
    call var%value  ! This is defined
  end subroutine test_sub

end program test

Это производит вывод

Значение a1
Значение a2
Значение a1
Значение a2