TYPE Statement (Derived Types)

Statement: Declares a variable to be of derived type. It specifies the name of the user-defined type and the types of its components.

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]

attr-list	Is one of the following: `access-spec` Is the PUBLIC or PRIVATE attribute. The attribute can only be specified if the derived-type definition is in the specification part of a module. BIND(C) EXTENDS (`parent-type-name`) where `parent-type-name` is the name of a previously defined extensible type. ABSTRACT The same `attr` must not appear more than once in any given derived-type statement. If the type definition contains or inherits a deferred binding, ABSTRACT must appear. The EXTENDS and ABSTRACT attributes apply to type extension and extended types. If ABSTRACT is specified, the type is an abstract type and it must be extensible. A derived type that does not have the SEQUENCE or BIND(C) attribute is extensible. Conversely, a derived type that has the SEQUENCE or BIND(C) attribute is not extensible.
name	Is the name of the derived data type. It must not be the same as the name of any intrinsic type, or the same as the name of a derived type that can be accessed from a module.
type-param-name-list	Is a list of type parameter names separated by commas. For more information, see Parameterized Derived-Type Declarations.
type-param-def-stmts	Is one or more INTEGER declarations of the type parameters named in the `type-param-name-list`. For more information, see Parameterized Derived-Type Declarations.
component-definition	Is one or more type declaration statements or procedure pointer statements defining the component of derived type. The first component definition can be preceded by an optional PRIVATE or SEQUENCE statement. (Only one PRIVATE or SEQUENCE statement can appear in a given derived-type definition.) If SEQUENCE is present, all derived types specified in component definitions must be sequence types. Procedure pointer component definitions are described in Procedure Pointers as Derived-Type Components. The syntax for a type declaration component definition is described below.
type-bound-procedure-part	Is a CONTAINS statement, optionally followed by a PRIVATE statement, and one or more procedure binding statements (specific, generic, or final). For more information, see Type-Bound Procedures.

A type declaration component definition takes the following form:

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

type	Is a type specifier. It can be an intrinsic type or a previously defined derived type. If the POINTER attribute follows this specifier, the type can also be any accessible derived type, including the type being defined.
attr	Is at most one of the following: An optional POINTER attribute for a pointer component An optional ALLOCATABLE attribute for a scalar component An optional DIMENSION or ALLOCATABLE attribute for an array component You cannot specify both the or ALLOCATABLE and POINTER attribute. An optional access specifier, PUBLIC or PRIVATE An optional CODIMENSION [coarray-spec] to specify a coarray An optional CONTIGUOUS attribute if the object is contiguous Each attribute can only appear once in a given component definition. If neither the POINTER nor the ALLOCATABLE attribute is specified, type must specify an intrinsic type or a previously defined derived type. If the POINTER or ALLOCATABLE attribute is specified, each component array specification a-spec must be a deferred shape specification (d-spec). If a `coarray-spec` appears, it must be a deferred specification list consisting of one or more colons (:), the component must have the ALLOCATABLE attribute, and the component must not be of type C_PTR or C_FUNPTR. A data component whose type has a coarray ultimate component must be a nonpointer nonallocatable scalar and must not be a coarray. If neither the POINTER nor the ALLOCATABLE attribute is specified, each a-spec must be an explicit-shape specification. If the CONTIGUOUS attribute is specified, the component must be an array with the POINTER attribute.
component	Is the name of the component being defined.
a-spec	Is an optional array specification, enclosed in parentheses. If POINTER or ALLOCATABLE is specified, the array is deferred shape; otherwise, it is explicit shape. In an explicit-shape specification, each bound must be a constant scalar integer expression. If component is an array and the array bounds are not specified here, they must be specified following the DIMENSION attribute.
coarray-spec	Is a deferred-coshape specification. The left bracket and right bracket are required.
char-len	Is an optional scalar integer literal constant; it must be preceded by an asterisk (*). This parameter can only be specified if the component is of type CHARACTER.
init-ex	Is an initialization expression, or for pointer components, => NULL( ). If init-ex is specified, a double colon must appear in the component definition. The equals assignment symbol (=) can only be specified for nonpointer components. The initialization expression is evaluated in the scoping unit of the type definition.

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.

Otherwise, they are of different derived types.

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

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

TYPE Statement (Derived Types)

Description

Example

See Also