Specify the accessibility of entities in a module.  (These
  attributes are also called accessibility attributes.)

  The PRIVATE and PUBLIC attributes can be specified in a type
  declaration statement or in a PRIVATE or PUBLIC statement, and take
  one of the following forms:

  Type Declaration Statement:

   type, [att-ls,] PRIVATE [,att-ls] :: ent [,ent]...
   type, [att-ls,] PUBLIC  [,att-ls] :: ent [,ent]...

  Statement:

   PRIVATE [[::] ent [,ent]...]
   PUBLIC  [[::] ent [,ent]...]

    type      Is a data type specifier.

    att-ls    Is an optional list of attribute specifiers.

    ent       Is one of the following:

              A variable name
              A procedure name
              A derived type name
              A named constant
              A namelist group name

              In statement form, an entity can also be
              a generic identifier (a generic name,
              defined operator, or defined assignment).

  The PRIVATE and PUBLIC attributes can only appear in the scoping
  unit of a module.

  Only one PRIVATE or PUBLIC statement without an entity list is
  permitted in the scoping unit of a module; it sets the default
  accessibility of all entities in the module.

  If no PUBLIC or PRIVATE statements are specified in a module, the
  default is PUBLIC accessibility.  Entities with PUBLIC
  accessibility can be accessed from outside the module by means of a
  USE statement.

  If a derived type is declared PRIVATE in a module, its components
  are also PRIVATE.  The derived type and its components are
  accessible to any subprograms within the defining module through
  host association, but they are not accessible from outside the
  module.

  If the derived type is declared PUBLIC in a module, but its
  components are declared PRIVATE, any scoping unit accessing the
  module though use association (or host association) can access the
  derived-type definition, but not its components.

  If a module procedure has a dummy argument or a function result of
  a type that has PRIVATE accessibility, the module procedure must
  have PRIVATE accessibility.  If the module has a generic
  identifier, it must also be declared PRIVATE.

  If a procedure has a generic identifier, the accessibility of the
  procedure's specific name is independent of the accessibility of
  its generic identifier.  One can be declared PRIVATE and the other
  PUBLIC.

  The PRIVATE attribute is compatible with the ALLOCATABLE,
  DIMENSION, EXTERNAL, INTRINSIC, PARAMETER, POINTER, SAVE, STATIC,
  TARGET, and VOLATILE attributes.

  The PUBLIC attribute is compatible with the ALLOCATABLE, DIMENSION,
  EXTERNAL, INTRINSIC, PARAMETER, POINTER, SAVE, STATIC, TARGET, and
  VOLATILE attributes.

  EXAMPLES:

  The following examples show type declaration statements specifying
  the PUBLIC and PRIVATE attributes:

     REAL,  PRIVATE  :: A, B, C
     INTEGER, PUBLIC :: LOCAL_SUMS

  The following is an example of the PUBLIC and PRIVATE statements:

     MODULE SOME_DATA
       REAL ALL_B
       PUBLIC ALL_B
       TYPE RESTRICTED_DATA
         REAL LOCAL_C
         DIMENSION LOCAL_C(50)
       END TYPE RESTRICTED_DATA
       PRIVATE RESTRICTED_DATA
     END MODULE

  The following derived-type declaration statement indicates that the
  type is restricted to the module:

     TYPE, PRIVATE  :: DATA
       ...
     END TYPE DATA

  The following example shows a PUBLIC type with PRIVATE components:

     MODULE MATTER
       TYPE ELEMENTS
         PRIVATE
         INTEGER C, D
       END TYPE
     ...
     END MODULE MATTER

  In this case, components C and D are private to type ELEMENTS, but
  type ELEMENTS is not private to MODULE MATTER.  Any program unit
  that uses the module MATTER, can declare variables of type
  ELEMENTS, and pass as arguments values of type ELEMENTS.