Nested namespace definition (revision 2)

IV. Motivation

Programmers' demand

There is clearly a need for a more concise way of defining nested namespaces than what the language offers today. The feature is asked for over and over by C++ users; see for example a few of the top web search results for a related query:

ISO C++ Standard – Future Proposals forum: nested namespace declaration
ISO C++ Standard – Future Proposals forum: Namespaces-related open questions
Stack Overflow: Is there a better way to express nested namespaces in C++ within the header
Stack Overflow: Is there a specific reason nested namespace declarations are not allowed in C++?
Stack Overflow: Multiple namespace declaration in C++
Visual Studio UserVoice: Nested namespace declarations (Note that it is currently the 20^th top voted idea out of 238 for C++.)

Quite possibly some of the users asking for this feature are novices/newcomers from other languages who used this syntax intuitively and found that their compiler doesn't accept it. This might indicate that the new syntax would not only mean saving some typing to experienced programmers, but it would also mean one confusion less to C++ learners.

Prevalence

It is not uncommon to find many deeply nested namespaces in large projects. For example, a search using the regular expression pattern (namespace\s+\w+\s*\{\s*){3,} to find nested namespace definitions at least 3 levels deep in the include directory of Boost libraries yielded 3758 matches and the greatest nesting level found this way was 7 (4 matches).

Existing practice in other languages

An analogous syntax is found and heavily used in the C# programming language. Some other languages do not even allow for nesting of namespace definitions but only for providing a hierarchical namespace specification in a single declaration (e.g. Java or PHP).

Existing practice in C++

The author is not aware of any C++ compiler supporting this feature; however Lzz, a tool that automates many onerous C++ programming tasks, supports it – from the tool's documentation:

The name of a named namespace may be qualified.
namespace A::B { typedef int I; }
is equivalent to:
namespace A { namespace B { typedef int I; } }

VI. Design Decisions

This section describes some issues related to the proposed feature and corresponding decisions based on the guidance from the EWG given at the Rapperswil meeting.

Attributes

Currently, the C++ Standard doesn't allow for specification of attributes for namespaces, but a resolution to the EWG issue #113 may lift this limitation. This proposal does not take attributes into account, but support for attributes can be added by a later proposal if found desirable.

Inline namespaces

It is not clear what is the best way to deal with inline namespaces. One possibility is that only the innermost namespace is defined inline, another one is that all the specified namespaces are inline. In either case the semantics seem to be potentially confusing, thus this proposal does not allow for inline qualified namespace definitions at all.

Namespace aliases

By analogy, qualified names could also be allowed in namespace alias definitions, e.g.

using namespace A::B::C = X;

However, use cases for qualified namespace aliases seem to be infrequent (the author didn't find any in Boost for example) so they aren't considered by this proposal.

VII. Technical Specifications

The proposed wording defines the core feature and makes use of it throughout the Standard text where applicable. It is relative to the N3797 working draft.

Core Feature

Change § 7.3.1 p. 1 [namespace.def] and § A.6 [gram.dcl] as follows:

…
namespace-name:
    original-namespace-name
    namespace-alias
original-namespace-name:
    identifier
namespace-definition:
    named-namespace-definition
    unnamed-namespace-definition
    nested-namespace-definition
named-namespace-definition:
    original-namespace-definition
    extension-namespace-definition
original-namespace-definition:
    inline_opt namespace identifier { namespace-body }
extension-namespace-definition:
    inline_opt namespace original-namespace-name { namespace-body }
unnamed-namespace-definition:
    inline_opt namespace { namespace-body }
nested-namespace-definition:
    namespace enclosing-namespace-specifier :: identifier { namespace-body }
enclosing-namespace-specifier:
    identifier
    enclosing-namespace-specifier :: identifier
namespace-body:
    declaration-seq_opt
…

Add new paragraph 10 to § 7.3.1 [namespace.def]:
A nested-namespace-definition with an enclosing-namespace-specifier E, identifier I and namespace-body B is equivalent to
namespace E { namespace I { B } }
[Example:
```
namespace A::B::C {
    int i;
}
```
The above has the same effect as:
```
namespace A {
    namespace B {
        namespace C {
            int i;
        }
    }
}
```
—end example]

Usage in the Standard

Change § 20.9.9.1.4 [func.bind.place] as follows:

namespace std::placeholders {
    namespace placeholders {
    …
    }
}

Change § 28.5.1 [re.synopt] as follows:

namespace std::regex_constants {
    namespace regex_constants {
    …
    }
}

Change § 28.5.2 [re.matchflag] as follows:

namespace std::regex_constants {
    namespace regex_constants {
    …
    }
}

Change § 28.5.3 [re.err] as follows:

namespace std::regex_constants {
    namespace regex_constants {
    …
    }
}

Change § 30.3.2 [thread.thread.this] as follows:

namespace std::this_thread {
    namespace this_thread {
    …
    }
}

Document number:	N4230
Date:	2014-10-10
Project:	Programming Language C++, Evolution Working Group
Reply-to:	Robert Kawulak <Robert Kawulak at gmail dot com>, Andrew Tomazos <Andrew Tomazos at gmail dot com>