Relationship between abstract type and generic interface with the same name-CodePudding

Consider the following code.

MODULE a


TYPE:: concrete

END TYPE concrete


INTERFACE concrete

PROCEDURE constructor

END INTERFACE concrete


CONTAINS


SUBROUTINE constructor

END SUBROUTINE constructor


END MODULE a

As far as I understand, in this context the generic interface concrete declares the constructor of type concrete to be the subroutine constructor (and this is the only way I know to declare a constructor). Now consider the following code.

MODULE a


TYPE, ABSTRACT:: abstract

END TYPE abstract


INTERFACE abstract

PROCEDURE what_am_i

END INTERFACE abstract


CONTAINS


SUBROUTINE what_am_i

END SUBROUTINE what_am_i


END MODULE a

Here, I have an abstract type and a generic interface with the same name, but there cannot be a constructor for the abstract type abstract, by definition.

So my question is: is there any relation between an abstract type, a generic interface with the same name, and the procedure inside such interface (in the example, the subroutine what_am_i)? If so, what is it?

CodePudding user response：

There is exactly the same relationship between the type abstract and the generic abstract as there is between the type concrete and the generic concrete.

This relationship is, simply, "they have the same name". Although a generic function with the same name as a type can be viewed as a constructor, it has no real privileged position.

The definition of a derived type implies a default structure constructor with the same name as the derived type, so that

type t
  integer i
end type t

type(t) x

x = t(1)

end

gives us an object x of that type with the expected values.

If instead, we have x=t(1) which can be resolved to a specific function f we can call that function f a constructor if it has function result an object of type t.

But there's no reason at all why f must return an object of type t. Consider

module mod
  implicit none

  type t
  end type t

  interface t
     module procedure f
  end interface t

contains

  function f()
    integer f
    f = 1
  end function f

end module mod

use mod
implicit none

print *, t()

end

It's hard to call f here a constructor.

That's it: no specific function under the generic abstract can return a constructed abstract object, but each can return something else. Just as a specific function under the generic concrete can return something not of type concrete.