.F90 File Format – Derived types and objects

Fortran source code

A derived type (Fortran 90) groups components into one type. Fortran 2003 added type extension, polymorphism and procedures bound to types, which together are Fortran’s object-oriented features.

Defining a type

type :: point
  real :: x = 0.0, y = 0.0                 ! default initial values
end type point

type, public :: particle
  type(point) :: position
  real, allocatable :: history(:)          ! allocatable component (Fortran 2003)
  real, pointer :: link => null()
  character(len=16) :: name = ''
  integer, private :: id                   ! hidden outside the module
end type particle

type(particle) :: p
p%position%x = 1.5
q = point(y = 2.0, x = 1.0)             ! structure constructor, components by keyword
  • components are accessed with %; a type name and its components are plain names, and the viewer colours the name after type, extends( and type( as a type
  • sequence keeps the components in the order written, so that the type can be in common or be passed to C-unaware code; bind(c) makes it C-compatible
  • private before the components hides them outside the module; type, private hides the whole type
  • a structure constructor has the type’s name and a value for each component (or name= keywords, and default values may be left out); it can be a constant when its parts are
  • type parameters (Fortran 2003): type :: buffer(k, n) with integer, kind :: k and integer, len :: n; type(buffer(4, 100)) :: b

Extension and abstract types

type, abstract :: shape
contains
  procedure(area_fn), deferred :: area      ! no body: children must provide it
end type shape

abstract interface
  function area_fn(self) result(a)
    import :: shape
    class(shape), intent(in) :: self
    real :: a
  end function area_fn
end interface

type, extends(shape) :: circle
  real :: radius
contains
  procedure :: area => circle_area        ! binds the name area to this procedure
end type circle
  • extends(parent) adds components to the parent; the child contains an inherited component named for the parent
  • abstract types cannot be made into objects; they hold deferred bindings that each non-abstract descendant overrides
  • non_overridable on a binding stops children from replacing it; final :: routine names a subroutine the compiler runs when an object is destroyed (Fortran 2003)

Type-bound procedures

type :: account
  real :: balance = 0.0
contains
  procedure :: deposit                       ! the procedure is named deposit
  procedure, pass(self) :: report            ! self is the passed-object dummy
  procedure, nopass :: bank_name             ! no passed object
  generic :: add => deposit, deposit_many  ! a generic binding
  generic :: operator(+) => merge_accounts
  generic :: assignment(=) => copy_from
  generic :: write(formatted) => write_account   ! defined output
  final :: close_account
end type account

call acct%deposit(10.0)                      ! acct is passed as the first argument
  • the object is passed as the passed-object dummy, by default the first argument, declared class(account); pass(name) picks another, and nopass passes none
  • procedure :: name binds a procedure of that name; procedure :: name => other binds another procedure under name
  • generic bindings name several specific bindings, and may be operator(…), assignment(=) or user-defined input/output (read(formatted), write(unformatted))
  • bindings are public unless the type says private after contains; procedure(interface), pointer as a component (no contains) is a procedure pointer component instead

Polymorphism

class(shape), allocatable :: s                ! may hold a circle or any other shape
class(shape), pointer :: p
class(*), allocatable :: anything              ! unlimited polymorphic

allocate(circle :: s)                          ! choose the dynamic type
allocate(s, source=other_shape)                ! copy type and value
select type (s)
type is (circle)
  print *, s%radius
class is (shape)
  print *, s%area()
end select
print *, same_type_as(a, b), extends_type_of(a, b)
  • a class(t) variable may be of type t or of any type extended from it. Calls through it use the dynamic type’s binding (dynamic dispatch)
  • class(*) may hold a value of any type; only select type and the intrinsics same_type_as, extends_type_of and storage_size can use it
  • select type branches on the dynamic type (Statements and control flow); associate gives the selected object a name of the type of its guard
  • allocate(…, source=…) and mold= allocate polymorphic variables from another object or from a type

More

  • Enumerations: enum, bind(c) (Fortran 2003) and the enumeration type of Fortran 2023 (see Types and declarations)
  • DEC structures (structure, record, union, map) predate derived types and are an extension; see Extensions and dialects
  • Types of the parallel features: team_type, event_type and lock_type of iso_fortran_env are derived types (Parallel features)