Naming rules for initializer & finalizer of procedural API

[masuday]

I have a concern about the naming rules of the initializer and finalizer of an object (or user-derived type). It is unclear for traditional APIs, while it is relatively clear for object-oriented APIs. I quickly checked MKL, NAG, and IMSL.

• MKL: new for initializer, and delete for finalizer (for random number generators)
• NAG: init for initializer, and no finalizer
• IMSL: no initializer/finalizer; having comprehensive subroutines initialized by arguments like IPARM(*)

The other question is whether it should be prefix or suffix. My suggestion is to have init for the initializer and final for the finalizer to be a suffix.

[nshaffer]

I prefer to use the default constructor where able. If the type requires a special constructor (e.g., it has allocatable or pointer components), I overload the default one. As an example:

module foo_type
  implicit none

  type :: foo
    integer :: n
    real, allocatable :: x(:)
  end type foo

  interface foo
    module procedure constructor
  end interface foo

contains

  pure function constructor(n, x) result(obj)
    integer, intent(in) :: n
    real, intent(in) :: x(n)
    type(foo) :: obj

    obj%n = n
    obj%x = x
  end function constructor
end module foo_type

In cases where more complicated initialization logic is needed or if the derived type has a large memory footprint, I prefer a subroutine prefixed by init_. If explicit finalizers are needed, I prefer prefixing the subroutine with final_.