Appendix A: Modern Fortran Syntax Reference

A dense, scannable map of Modern Fortran (2018), free-form — the page to keep open in a second window while you write code. Everything here is the modern style the book teaches: implicit none everywhere, lowercase keywords, kind-parameterized reals (real(dp)), intent on every argument, arrays and modules as first-class tools. Each section names the chapter that teaches it in depth; this appendix only reminds, it does not explain.

Legacy forms (fixed-form source, COMMON, implicit typing, GOTO, assumed-size a(*), the double precision keyword, FORALL) are deliberately absent from this reference — they belong to Appendix E and Chapters 17–19. If you meet one in old code, translate it there.

Conventions below: a trailing & continues a line; ! starts a comment; => is pointer assignment.

Program units and implicit none

Every executable is a program; everything reusable lives in a module. implicit none is the non-negotiable first line of every unit (introduced in Chapter 2).

program name
  implicit none              ! always, first thing — turns off implicit typing
  ! specification part: use statements, then declarations
  ! execution part: statements
end program name             ! name must match

module name
  use kinds, only: dp        ! what this module needs
  implicit none              ! once; governs the whole module
  private                    ! hide by default
  public :: api              ! expose only the interface
contains                     ! separates specification from procedures
  ! module procedures here (they get an explicit interface for free)
end module name

submodule (heat_solver) heat_solver_impl   ! interface in the module, body here
contains
  module procedure step        ! inherits the interface declared in the parent
    ! ... body ...
  end procedure step
end submodule heat_solver_impl

Declarations: types, kinds, attributes

General form — type, then attributes, then ::, then the entities:

<type>[(kind)] [, attribute]... :: name[(dims)] [= initial-value]

The five intrinsic types

Types, kinds, and arithmetic are owned by Chapter 3.

Kinds — portable precision

integer, parameter :: dp = selected_real_kind(15, 307)  ! ≥15 digits, exponent ≥10^307
real(dp) :: x
x = 0.5_dp                                               ! every real literal takes the _dp suffix
complex(dp) :: z = (1.0_dp, -2.0_dp)

• Shortcut kinds via the intrinsic module: use, intrinsic :: iso_fortran_env, only: dp => real64 (also real32, real128, int32, int64).
• selected_int_kind(r) → an integer kind holding all values up to r decimal digits.
• Never hard-code a kind number (real(8)); the number is compiler-specific. Request the requirement.

Attributes

Also common: protected (module value, read-only outside), contiguous (Ch. 11), value and bind(c) (C interop, Ch. 14). A module variable is implicitly save; keep it private.

Operators and precedence

Precedence, highest to lowest (parentheses always win):

So a == 0 .and. b /= 0 .or. c == 0 parses as (a==0 .and. b/=0) .or. c==0. Mixed-mode arithmetic promotes the lower type per operation (integer → real → complex): 2 * 3.0_dp is 6.0_dp, but 1/2 is 0 (see gotchas). The .dots. are part of the logical operators' spelling.

Control constructs

Modern Fortran is block-structured; no goto (control flow is Chapter 4).

if (cond) then
  ! ...
else if (cond2) then
  ! ...
else
  ! ...
end if

if (cond) x = 0.0_dp          ! logical if: one guarded statement, no end if

select case (n)               ! one discrete value (integer/character/logical, not real)
case (1)
  ! ...
case (2, 4, 6)                ! a list
case (10:20)                  ! a range;  (:0) and (100:) are open
case default
  ! ...
end select                    ! exactly one block runs — no fall-through

do i = 1, n                   ! counted; add a stride: do i = 1, n, 2
  ! ...
end do

do while (cond)               ! test-at-top loop
  ! ...
end do

do concurrent (i = 1:n, mod(i,2)==0)   ! assert iterations are independent (perf: Ch. 29)
  a(i) = b(i)
end do

outer: do i = 1, n
  do j = 1, m
    if (found) exit outer     ! break out of the *outer* loop by name
  end do
end do outer

where (a > 0.0_dp)
  b = sqrt(a)
elsewhere
  b = 0.0_dp
end where

associate (u => field%temp(i,j))
  u = u + dt * lap            ! u aliases the component for the block's duration
end associate

do concurrent may carry locality specifiers (local, local_init, shared, default(none)). The old forall is obsolescent in Fortran 2018 — use where or do concurrent (Appendix E).

Arrays

Fortran's superpower: 1-based, column-major (first index varies fastest), whole-array semantics (Chapter 5).

real(dp) :: v(5)                  ! rank 1, indices 1..5
real(dp) :: a(3, 4)               ! rank 2, 3 rows × 4 columns
real(dp) :: b(-1:1)               ! custom bounds
real(dp), allocatable :: g(:,:)   ! deferred shape — sized at run time

allocate(g(nx, ny), stat=ierr)         ! sized now; check ierr == 0
allocate(g(nx, ny), source=0.0_dp)     ! allocate and initialize
deallocate(g)                          ! or let it auto-free at scope exit
if (allocated(g)) ...                  ! query allocation status

Core array intrinsics (elementwise or reducing): size, shape, rank, sum, product, maxval, minval, maxloc, minloc, count, any, all, pack, merge, matmul, dot_product, transpose, spread. Note a * b is elementwise — the matrix product is matmul(a, b).

Procedures

A function returns one value in an expression; a subroutine does work via arguments and a call. Every dummy argument gets an intent (owned by Chapter 6).

function mean(x) result(m)          ! result clause names the return variable
  real(dp), intent(in) :: x(:)      ! assumed-shape: shape travels with the array
  real(dp) :: m
  m = sum(x) / real(size(x), dp)
end function mean

subroutine describe(x, avg, sd)     ! several outputs → a subroutine
  real(dp), intent(in)  :: x(:)
  real(dp), intent(out) :: avg, sd
  ! ...
end subroutine describe
! call describe(data, a, s)

An explicit interface (automatic for module and internal procedures) is required for optional, keyword, and assumed-shape arguments. For an external procedure, write one:

interface
  subroutine ext(x)
    real(dp), intent(inout) :: x
  end subroutine ext
end interface

interface swap                       ! generic: overload by argument type
  module procedure swap_int, swap_real
end interface

Derived types and object orientation

Build your own types (Chapter 9); extend and dispatch them (Chapter 10).

type :: point
  real(dp) :: x = 0.0_dp, y = 0.0_dp   ! components, with default initialization
end type point

type(point) :: p
p = point(1.0_dp, 2.0_dp)              ! structure constructor (or point(x=..., y=...))
p%x = 3.0_dp                           ! % accesses a component

Type-bound procedures

type :: circle
  real(dp) :: r
contains
  procedure :: area => circle_area     ! binding-name => module procedure
end type circle

pure function circle_area(self) result(a)
  class(circle), intent(in) :: self    ! passed object is class(...), NEVER type(...)
  real(dp) :: a
  a = 3.14159265358979_dp * self%r**2
end function circle_area
! call it:  x = c%area()

select type (o => shape)
type is (circle)             ! exact dynamic type
  print *, o%r
class is (base_t)            ! this type or any extension
  ! ...
class default
  ! ...
end select

type(t) is monomorphic (resolved at compile time, inlinable — the default). class(t) is polymorphic (dispatched at run time; must be allocatable, pointer, or a dummy). Keep polymorphism at the coarse grain, never in a hot inner loop.

Pointers and targets

Prefer allocatable; reach for a pointer only to alias, link, or interoperate (Chapter 11).

real(dp), target  :: a
real(dp), pointer :: p => null()   ! ALWAYS initialize a pointer
p => a                             ! pointer assignment: p becomes an ALIAS for a
p = a                              ! value assignment: writes a's value THROUGH p

A pointer may only target an object declared target (or another pointer). Confusing => and = corrupts data silently; after deallocate, nullify every remaining alias.

Input/output (quick reference)

Brief on purpose — the full edit-descriptor and file-control reference is Appendix F; I/O is taught in Chapter 7.

print '(a, f8.2)', 'x = ', x          ! formatted; no leading blank
print *, 'quick debug', x             ! list-directed; adds a leading blank
write(u, '(i0)') n                    ! write to unit u with a format
read(u, *) y                          ! read one value, list-directed

open(newunit=u, file='out.dat', status='replace', action='write', &
     iostat=ios, iomsg=msg)           ! newunit picks a free unit
close(u)
inquire(file='out.dat', exist=ok)     ! ask before you open

Common gotchas

For compiler flags that catch several of these at run time (-fcheck=all, -ffpe-trap), see Appendix C.