To: J3                                                     J3/24-128r3
From: generics
Subject: Miscellaneous edits to incorporate templates
Date: 2024-June-26

References: 24-125, 24-126, 24-127

1. Introduction
===============

This paper describes many edits to the standard that will be required
in order to incorporate the syntax and semantics for templates. this
is not intended to be an exhaustive listing, but describes those that
have been identified so far.

2. Edits required for deferred arguments
========================================

* Insert new glossary term in 3.7

  [deferred argument association]
  association between an instantiation argument and a deferred
  argument (Sec. ?)

* Insert new glossary term

  [deferred argument]
  named entity that appears in a <deferred-arg-list> (Sec. ?)

* Insert new glossary term 3.34.x

  [deferred constant]
  a deferred argument with the PARAMETER attribute

  [instantiation argument]
  argument to an INSTANTIATE statement or inline instantiation

* 7.3.2.1 Type specifier syntax

  Extend R702 <type-spec>:
  " <<or>> <deferred-type>"

  Extend C703 from:
    (R702) The <derived-type-spec> shall not specify an abstract
    type (7.5.7)
  To:
    (R702) The <derived-type-spec> or <deferred-type> shall not specify
    an abstract type (7.5.7) except when used as an <instantiation-arg>.

  Extend R703 <declaration-type-spec> to include:
      <<or>> TYPE(<deferred-type>)
      <<or>> CLASS(<deferred-type>)

  Change C706 from:
    (R703) TYPE(<derived-type-spec>) shall not specify an abstract
    type (7.5.7).
  To:
    (R703) In a <declaration-type-spec> that uses the TYPE keyword,
    <derived-type-spec> or <deferred-type> shall not specify an
    abstract type (7.5.7).

  Extend C705 from:
    (R703) In a <declaration-type-spec> that uses the CLASS keyword,
    <derived-type-spec> shall specify an extensible type (7.5.7).
  To:
    (R703) In a <declaration-type-spec> that uses the CLASS keyword,
    <derived-type-spec> or <deferred-type> shall specify an extensible
    type (7.5.7).

* 7.5.2.1 Syntax of a derived-type definition

  New constraint on R728:
  "<parent-type-name> shall not be a <deferred-type>.

* 8.5.2 Accessibility attribute

  Change C817 to read as

  An access-spec shall appear only in the specification-part of a
  module or template construct.

* 8.6.1 Accessibility Statement

  Change C874 to read:

C874 (R831) Each access-name shall be the name of a module, variable,
            procedure, nonintrinsic type, named constant,
            namelist group, requirement, or template.

* 8.5.8.1 General

  Change last entry for <array-spec>

  From:
      <<or>>   <assumed-rank-spec>

  To:
      <<or>>   <assumed-or-implied-rank-spec>

* 8.5.8.2 Explicit-shape array

Note:

It may be better to modify <explicit-shape-bounds-spec> to
disambiguate <explicit-bounds-expr> for lower and upper bounds.  This
would make constraint for deferred constants clearer.

* 8.5.8.6 Implied-shape array

  Modify the first sentence from:

    An implied-shape array is a named constant that takes its shape
    from the constant-expr in its declaration.

  To:

    An implied-shape array is a named constant that takes its shape
    from a constant expression. If it is a deferred constant, it takes
    its shape from the associated instantiation argument, otherwise it
    takes its shape from the constant expression in its declaration.

  Delete the first sentence in the last paragraph which reads:

    The extent of each dimension of an implied-shape array is the same
    as the extent of the corresponding dimension of the constant-expr.

Add new section after 8.5.8.7 Assumed-rank entity, titled
"Implied-rank entity".

An implied-rank entity is an entity whose rank becomes defined only
when the template in which it appears is instantiated.

Note: Also make sure it works with SELECT GENERIC RANK and spell out
      what can be done with implied-rank entities.

  <implied-rank-spec> <<is>> ..

  Constraint:  An implied-rank entity shall be a <deferred-const>.

Examples of implied-rank entities

TEMPLATE EXAMPLE(C, S, N)
    INTEGER, DEFERRED, PARAMETER :: C(..) ! implied-shape & implied-rank
    INTEGER, DEFERRED, PARAMETER :: S(*), N
    INTEGER, PARAMETER :: B(S) = 1 ! explicit-shape & implied-rank
END TEMPLATE

* 8.5.17  RANK clause

  Replace constraint C864 which states:

     An entity declared with a rank-clause shall be a dummy data
     object or have the ALLOCATABLE or POINTER attribute.

  With:

     An entity declared with a rank-clause shall be a named constant,
     dummy data object or have the ALLOCATABLE or POINTER attribute.

  Replace the last paragraph:

    If the rank is zero the entity is scalar; otherwise, if it has
    the ALLOCATABLE or POINTER attribute, it specifies that it is a
    deferred-shape array; otherwise, it specifies that it is an
    assumed-shape array with all the lower bounds equal to one.

  With:

    If the rank is zero the entity is scalar; otherwise, if it has
    the ALLOCATABLE or POINTER attribute, it specifies that it is a
    deferred-shape array; otherwise, if it is a named constant, it
    specifies that it is an implied-shape array with all lower
    bounds equal to one; otherwise, it specifies that it is an
    assumed-shape array with all the lower bounds equal to one.

* 8.6.1 Accessibility statement

Modify C873 to read as

  An <access-stmt> shall appear only in the <specification-part> of a
  module or template construct. Only one accessibility statement with
  an omitted <access-id-list> is permitted in the <specification-part>
  of a module or template construct.

* 10.1.12 Constant expression

  Extend list in normative text for "constant expression":
  "deferred constant"

* 10.1 Expressions and Assignment

  New section 10.1.13 Deferred constant expressions

  <deferred-const-expr> <<is>> <constant-expr>

  An expression is a <deferred-const-expr> if one or more of its
  primaries is a deferred constant.

  A <deferred-const-expr> is not equal to any other <expr> unless
  <expr> is syntactically equivalent.

* 11.1.11.1 Purpose and form of the SELECT TYPE construct

  Extend R1156 to
  R1156 <type-guard-stmt>
      <<is>> TYPE IS ( <type-spec> ) [ <select-construct-name> ]
      <<or>> CLASS IS ( <derived-type-spec> ) [ <select-construct-name> ]
      <<or>> CLASS IS ( <deferred-type> ) [ <select-construct-name> ]
      <<or>> CLASS DEFAULT [ <select-construct-name> ]

  Add constraint:
    (R1156) <deferred-type> shall specify an extensible type.

* 15.5.1 Syntax of a procedure reference

UTI: spelling of <inline-instantiate> vs <inline-instantiation>

  Extend R1522 <procedure-designator>:
  " <<or>> <deferred-proc>"
  " <<or>> <inline-instantiate>"

  Extend R1524 <actual-arg> with:
  " <<or>> <deferred-proc> "
    <<or>> <inline-instantiate>

3. Edits required for templates and instantiation
=================================================

* 5.1 High level syntax

  Extend R508 <specification-construct> to include:
        <<or>> <template>
        <<or>> <requirement>
        <<or>> <instantiate-stmt>

  Extend R512 to be:
     R512 <internal-subprogram>
         <<is>> <function-subprogram>
         <<or>> <subroutine-subprogram>
         <<or>> <standalone-template-subroutine-subprogram>
         <<or>> <standalone-template-function-subprogram>

* 8.7 IMPLICIT Statement

Modify last sentence in para 3 on page 127 from:

If a mapping is not specified for a letter, the default
for a program unit or an interface body is default integer if the
letter is I, J, ..., or N and default real otherwise, and the default
for a BLOCK construct, internal subprogram, or module subprogram is
the mapping in the host scoping unit.

To:

If a mapping is not specified for a letter, the default for a program
unit or an interface body that does not appear in a deferred interface
block is default integer if the letter is I, J, ..., or N and default
real otherwise.  The default for a BLOCK construct, internal
subprogram, or module subprogram is the mapping in the host scoping
unit.  The default for an interface body inside of a deferred
interface block is as if IMPLICIT NONE(TYPE, EXTERNAL) appeared.


* 8.8p2 IMPORT Statement

  Modify sentence 2 in p2 from:

     This is the default for an interface body that is not a module
     procedure interface body.

     To:

     This is the default for an interface body that is not a module
     procedure interface body or an interface body that appears in a
     deferred interface block.

  Modify sentence 2 in p4 from:

     This is the default for a derived-type definition, internal
     subprogram, module procedure interface body, module subprogram,
     or submodule.

  To:

     This is the default for a derived-type definition, internal
     subprogram, module procedure interface body, module subprogram,
     submodule, or an interface body that appears in a deferred
     interface block.


* 14.2.1 Module syntax and semantics

Rule 1408 becomes

R1408 <module-subprogram>
    <<is>> <function-subprogram>
    <<or>> <subroutine-subprogram>
    <<or>> <separate-module-subprogram>
    <<or>> <standalone-template-subroutine-subprogram>
    <<or>> <standalone-template-function-subprogram>

* 15.4.3.2 Interface block

Change rule 1503:

   <interface-stmt> <<is>> INTERFACE [ <generic-spec> ]
                    <<or>> ABSTRACT INTERFACE

To read:
   <interface-stmt> <<is>> INTERFACE [ <generic-spec> ]
                    <<or>> ABSTRACT INTERFACE
                    <<or>> DEFERRED INTERFACE

Change final sentence in para 2 such that the sentence reads:

  An interface block without ABSTRACT, DEFERRED, or a generic
  specification is a specific interface block.


Add after para 2:

  An interface block introduced by DEFERRED INTERFACE is a deferred
  interface block. An interface body in a deferred interface block
  specifies a deferred procedure.

4. Edits to TKR compatibility
=============================

An entity whose rank is, or depends on, a deferred argument does not
have the same rank as any other entity, unless that entity has its
rank defined with a syntactically equivalent expression. If the rank of an
implied-rank entity is not declared with a rank clause, it is considered
to have no expression for its rank, and therefore does not have the same
rank as any other entity.

An entity whose kind is, or depends on, a deferred argument does not
have the same kind as any other entity, unless that entity has its
kind defined with a syntactically equivalent expression.

Note: Some examples of implied-rank entities are shown
      in the following example template. C is explicitly declared
      as implied-rank. B is implied-rank because its rank depends on
      the size of the deferred argument S. X, Y and Z are implied-rank
      because their ranks depend on the value of the deferred argument N.

  TEMPLATE EXAMPLE(C, S, N)
    INTEGER, DEFERRED, PARAMETER :: C(..) ! implied-shape & implied-rank
    INTEGER, DEFERRED, PARAMETER :: S(*), N
    INTEGER, PARAMETER :: B(S) = 1 ! explicit-shape & implied-rank
  CONTAINS
    SUBROUTINE SUB(X)
      INTEGER, RANK(N) :: X ! assumed-shape & implied-rank
      INTEGER :: Y([(i, i = 1, N)]) ! explicit-shape & implied-rank
      INTEGER, RANK(N), ALLOCATABLE :: Z ! deferred-shape & implied-rank
      call sub_explicit(C) ! valid, element order association
      ! call sub_assumed(C) ! invalid, rank expressions don't match
      ! call sub_same_rank(C) ! invalid, rank expressions don't match

      call sub_explicit(X) ! valid, element order association
      ! call sub_assumed(X) ! invalid, rank expressions don't match
      call sub_same_rank(X) ! valid, rank expressions match

      call sub_explicit(Y) ! valid, element order association
      ! call sub_assumed(Y) ! invalid, rank expressions don't match
      ! call sub_same_rank(Y) ! invalid, rank expressions don't match
    END SUBROUTINE
    SUBROUTINE SUB_EXPLICIT(X)
      INTEGER :: X(10)
    END SUBROUTINE
    SUBROUTINE SUB_ASSUMED(X)
      INTEGER :: X(:)
    END SUBROUTINE
    SUBROUTINE SUB_SAME_RANK(X)
      INTEGER, RANK(N) :: X
    END SUBROUTINE
  END TEMPLATE

===END===