In our view, a module interface (the exported part), is the set of entry points into a module. That is visibility, not accessibility. We understand that contemporary languages such as Java or C# have long experience using 'private', 'public', 'internal',
'public private', etc. to describe visibility. However, C++ has a much longer tradition in using 'public' and 'private' for accessibility. We prefer to stick that established terminology to avoid unnecessary confusion.
Note also that the proposal is trying hard to avoid talking about linkage. This is to avoid (1) elevating the notion of linkage above where it belongs; (2) the existing standard notions of linkage are poor compared to the diversity concretely available
and we do not want to prevent implementations from supplying high quality experience.
A non-exported name does not necessarily have an internal linkage. Such an entity may be internal to a module unit, or shared by a set of module units within the same module, but not available to the outside.
We anticipate that, like any declaration, a module declaration may have attributes. But since they are ignorable, we prefer to focus now on the core semantics.
In general, we are aiming for simplicity - which is required by the very nature of the problem we are tackling: programming in the large, e.g. scaling well beyond the billion lines of codes.
The point we are making is that a module interface must be described in its entirety at exactly one place. In practice, you will have a single source file, with an implementation-defined extension e.g. a.mi, that contains the interface of a given module.
In essence, they would be like your usual header files, except that you get isolation and the essential goodies we want from modules. However, the implementation of the entities declared in the interface may span several module units, e.g. conventional source
files that all declare belonging to the same module.