J3/07-284
To: J3
From: Malcolm Cohen
Subject: Disposition of glossary
Date: 2007 September 27

1. Introduction
---------------
The glossary (Annex A) has been deleted.  It contained many bad items
(every page had multiple items that were incorrect, misleading, or only
partial definitions).  A number of items were simple English (why someone
thought Fortran would have a unique definition of "datum" I do not know).
A number were just unnecessary ("assignment statement").  Lots of technical
terms were missing ("assumed type parameter").

Finally, the glossary has been subsumed by the normative text of c02.

This document records the disposition of each item in the previous
glossary.

2. Categorisation
-----------------
defined - is a defined term in c02.
DELETED - word/term is
          (a) ordinary English,
          (b) universally understood,
          (c) not a defined term,
          (d) only used near its definition and the glossary version is
              bad in some way, or
          (d) not even used in the standard anyway.
MOOT - only used by a feature that has been removed
SUBSUMED by - included in or rendered unnecessary by another defined term
UNNECESSARY - does not need explanation and
              does not need to be a defined term

The main differences between "DELETED" and "UNNECESSARY" are:
(a) DELETED means it got deleted from aa.tex (aa.tex still exists, it is
    just not being included in the 007);
(b) most of the deletions were done before I decided that I would just go
    ahead and delete the whole glossary this time anyway;
(c) some of the deletions were done afterwards when I thought the entry
    was so bad that I didn't want it hanging around in any way;
(d) some of the UNNECESSARY classifications are more borderline so might
    be open to question (but even there, indexing and cross-referencing
    are probably better than making defined terms that end up hardly
    being used).

3. Item Disposition
-------------------
abstract type: defined
actual argument: defined
allocatable variable: SUBSUMED by allocatable
argument: UNNECESSARY
argument association: defined
array: defined
array element: defined
array pointer: defined
array section: defined
assignment statement: UNNECESSARY
associate name: defined
association: defined
assumed-shape array: defined
assumed-size array: defined
attribute: defined
automatic data object: defined
base type: DELETED
belong: DELETED
binding label: defined
bits compatible: MOOT
block: defined
block data program unit: defined
bounds: defined
character length parameter: SUBSUMED by length type parameter
character storage unit: defined
character string: UNNECESSARY
characteristics: defined
class: DELETED
co-array: defined
co-bounds: defined
co-indexed object: defined
co-rank: defined
co-subscript: defined
collating sequence: defined
collective subroutine: defined
common block: defined
companion processor: defined
component: defined
component order: defined
conformable: defined
conformance: DELETED
connect team: defined
connected: defined
construct: DELETED
construct association: UNNECESSARY
construct entity: defined
control mask: DELETED
data: DELETED
data entity: defined
data object: defined
data type: defined
datum: DELETED
decimal symbol: defined
declared type: defined
default initialization: defined
default-initialized: defined
deferred binding: UNNECESSARY
deferred type parameter: defined
definable: defined
defined: defined
defined assignment statement: UNNECESSARY
defined operation: UNNECESSARY
deleted feature: DELETED
derived type: defined
designator: defined
disassociated: defined
dummy argument: defined
dummy array: defined
dummy data object: defined
dummy procedure: defined
dynamic type: defined
effective item: defined
elemental: defined
entity: DELETED (both UNNECESSARY and HARMFUL)
executable construct: UNNECESSARY
executable statement: defined
explicit initialization: defined
explicit interface: defined
explicit-shape array: defined
expression: DELETED
extended type: defined
extensible type: defined
extension type: defined
extent: defined
external file: defined
external linkage: BROKEN
external procedure: defined
external subprogram: defined
external unit: defined
file: UNNECESSARY?
file storage unit: defined
final subroutine: defined
finalizable: defined
finalization: defined
function: defined
function result: defined
function subprogram: UNNECESSARY
generic identifier: defined
generic interface: defined
generic interface block: defined
global entity: UNNECESSARY
host: defined
host association: defined
host scoping unit: defined
image: defined
image index: defined
implicit interface: defined
inherit: defined
inheritance association: defined
inquiry function: defined
instance of a subprogram: UNNECESSARY
intent: UNNECESSARY
interface block: defined
interface body: defined
internal file: defined
internal procedure: defined
internal subprogram: defined
interoperable: defined
intrinsic: defined
invoke: DELETED
keyword: defined
kind type parameter: defined
label: defined (glossary version was wrong BTW)
length of a character string: DELETED
lexical token: UNNECESSARY
line: defined (probably a mistake!)
linkage association: BROKEN - UTI
literal constant: defined
local entity: DELETED
local variable: defined
main program: defined
many-one array section: DELETED
module: defined
module procedure: defined
module procedure interface: BROKEN,
  but I don't have time to write it up or fix it (probably faster
  to fix it) right now, so not defined
module subprogram: defined
name: defined
name association: UNNECESSARY
named: UNNECESSARY
named constant: defined
NaN: defined
nonexecutable statement: defined
numeric storage unit: defined
numeric type: defined
object: defined
object designator: defined
obsolescent feature: DELETED
operand: defined
operation: DELETED
operator: defined
override: UNNECESSARY
parent component: defined
parent type: defined
passed-object dummy argument: defined
pointer: defined
pointer assignment: defined
pointer assignment statement: UNNECESSARY
pointer associated: UNNECESSARY
pointer association: defined
polymorphic: defined
preconnected: defined
procedure: defined
procedure designator: defined
procedure interface: OMITTED - this is more often used as plain
  "interface", so is inconsistent (and the normative definition
  is just "interface").
processor: defined
processor dependent: defined
program: defined
program unit: defined
prototype: UNNECESSARY
pure procedure: defined
rank: defined
record: defined
reference: defined
result variable: defined
rounding mode: DELETED
scalar: defined
scope: UNNECESSARY
scoping unit: defined
section subscript: BROKEN - it's wrongly used almost everywhere.
  We need to fix the uses before worrying about definitions.
selector: UNNECESSARY
shape: defined
size: defined
specification expression: done
specification function: UNNECESSARY
standard-conforming program: defined
statement: defined
statement entity: defined
statement function: UNNECESSARY
statement label: defined
storage association: defined
storage sequence: defined
storage unit: defined
stride: UNNECESSARY
struct: UNNECESSARY
structure: defined
structure component: defined
structure constructor: defined
subcomponent: defined
submodule: defined
subobject: defined
subprogram: defined
subroutine: defined
subroutine subprogram: UNNECESSARY
subscript: UNNECESSARY
subscript triplet: UNNECESSARY
substring: UNNECESSARY
target: defined
team: defined
team synchronization: defined
transformational function: defined
type: defined
type-bound procedure: defined
type compatible: defined
type declaration statement: UNNECESSARY
type parameter: defined
type parameter order: defined
ultimate component: defined
undefined: defined
unsigned: UNNECESSARY
unspecified storage unit: defined
use association: defined
variable: defined
vector subscript: defined
void: UNNECESSARY
whole array: defined

===END===