TYPE Statement (Derived Types)

TYPE [[,attr-list] :: ] name [(type-param-name-list)]

   [type-param-def-stmts]

   [PRIVATE statement or SEQUENCE statement]. . .

   [component-definition]. . .

   [type-bound-procedure-part]

END TYPE [name]

A type declaration component definition takes the following form:

type[ [, attr] :: ] component[( a-spec)] [[ coarray-spec ]] [ *char-len] [ init-ex]

Description

If a name is specified following the END TYPE statement, it must be the same name that follows TYPE in the derived type statement.

A derived type can be defined only once in a scoping unit. If the same derived-type name appears in a derived-type definition in another scoping unit, it is treated independently.

A component name has the scope of the derived-type definition only. Therefore, the same name can be used in another derived-type definition in the same scoping unit.

The default accessibility attribute for a module is PUBLIC unless it has been changed by a PRIVATE statement.

The PRIVATE keyword can only be specified if the derived-type definition is in the specification part of a module.

If a type definition is PRIVATE, the type name and the structure constructor for the type are accessible only within the module containing the definition.

Two data entities have the same type if they are both declared to be of the same derived type; the derived-type definition can be accessed from a module or a host scoping unit.

If EXTENDS appears and the type being defined has a coarray ultimate component, its parent type must have a coarray ultimate component.

Data entities in different scoping units also have the same type if the following is true:

• They are declared with reference to different derived-type definitions that specify the same type name.

• All have the SEQUENCE property.

• All have the BIND attribute.

• They have no components with PRIVATE accessibility.

• They have type parameters and components that agree in order, name, and attributes.

A data component is a coarray if the component declaration contains a coarray specification. If the component declaration contains a coarray specification, it specifies the corank.

If BIND (C) is specified, the following rules apply:

• The derived type cannot be a SEQUENCE type.

• The derived type must not have type parameters.

• The derived type must not have the EXTENDS attribute.

• The derived type must not have a type-bound-procedure-part.

• Each component of the derived type must be a nonpointer, nonallocatable data component with interoperable type and type parameters.

Example

 !   DERIVED.F90
 !   Define a derived-type structure,
 !   type variables, and assign values

     TYPE member
       INTEGER age
       CHARACTER (LEN = 20) name
     END TYPE member

     TYPE (member) :: george
     TYPE (member) :: ernie

     george     = member( 33, 'George Brown' )
     ernie%age  = 56
     ernie%name = 'Ernie Brown'

     WRITE (*,*) george
     WRITE (*,*) ernie
     END

The following shows another example of a derived type:

TYPE mem_name
  SEQUENCE
  CHARACTER (LEN = 20) lastn
  CHARACTER (LEN = 20) firstn
  CHARACTER (len = 3) cos   ! this works because COS is a component name
END TYPE mem_name
TYPE member
    SEQUENCE
    TYPE (mem_name) :: name
    INTEGER age
    CHARACTER (LEN = 20) specialty
END TYPE member

In the following example, a and b are both variable arrays of derived type pair:

 TYPE (pair)
   INTEGER i, j
 END TYPE
 TYPE (pair), DIMENSION (2, 2) :: a, b(3)

The following example shows how you can use derived-type objects as components of other derived-type objects:

 TYPE employee_name
   CHARACTER(25) last_name
   CHARACTER(15) first_name
 END TYPE
 TYPE employee_addr
   CHARACTER(20) street_name
   INTEGER(2) street_number
   INTEGER(2) apt_number
   CHARACTER(20) city
   CHARACTER(2) state
   INTEGER(4) zip
 END TYPE

Objects of these derived types can then be used within a third derived-type specification, such as:

 TYPE employee_data
   TYPE (employee_name) :: name
   TYPE (employee_addr) :: addr
   INTEGER(4) telephone
   INTEGER(2) date_of_birth
   INTEGER(2) date_of_hire
   INTEGER(2) social_security(3)
   LOGICAL(2) married
   INTEGER(2) dependents
 END TYPE

The following program shows how you initialize components of a derived-type object:

TYPE list_node
   CHARACTER(20)                :: street_name = “ “
   INTEGER(2)                   :: street_number = 0
   INTEGER(2)                   :: apt_number = -1
   CHARACTER(20)                :: city = “ “
   CHARACTER(2)                 :: state = “NH”
   INTEGER(4)                   :: zip = 0
   TYPE (list_node), POINTER    :: next => NULL()
END TYPE

TYPE (list_node) :: x = list_node (zip = 03054)
PRINT *, x%state, x%zip
END

The above prints the following:

        NH 3054

Coarrays are a Fortran 2008 feature. The following example shows a derived-type definition with a coarray component:

TYPE NEW_TYPE
   REAL,ALLOCATABLE,CODIMENSION[:,:,:] :: NEW(:,:,:)
END TYPE NEW_TYPE

An object of type NEW_TYPE must be a scalar and it cannot be a pointer, allocatable, or a coarray.

The following example shows a derived-type definition containing a coarray-spec:

type t
   integer :: k
   real, allocatable :: x (:,:)[:,:]
end type t