On 9/24/19 10:48 AM, Andrew Tomazos via Std-Proposals wrote:
Thanks for your feedback Tom.  You'll find my questions and comments below...

On Tue, Sep 24, 2019 at 11:59 PM Tom Honermann <tom@honermann.net> wrote:
I have some sympathy for the problem this proposal purports to address.

I think the proposed distinction for initial namespace templates and namespace template extensions is not well motivated, introduces gratuitous deviation from existing template syntax, and introduces the following new problems:

1) Lookup is confusing.  Consider the following:

template<int i>
namespace N {}
int i;
namespace template N {
  void f() {
    i;  // Ambiguous, ::i, or the i parameter of N?
  }
}

I think this would be a novel and confusing lookup rule no matter which way the above question is resolved.  Some existing cases that require such semantic lookup as opposed to lexical lookup are for class members in out of line class member definitions and ADL.  For the former, some guidelines require prefixing class data members with 'm_' or similar to remind programmers that they are referencing something defined outside of the lexical context.  For the latter, well, issues with ADL are well known.

I don't see why you're reading this any differently than:

namespace N { int i; }
int i;
namespace N {
  void f() {
    i;
  }
}

Because lookup resolving to a parameter not in the lexical context is novel.  I don't believe we have any cases where that occurs today.


Anyway - let's say, for sake of argument, I agreed with you.  What change to the proposal are you suggesting?  The motivation of having the template parameters implicitly declared in namespace template extensions is so that you only have to define the library configuration once, in one source file.
There are other ways to achieve that.  For example, by defining the configuration in a class that is then used as the (sole) class non-type template parameter for the namespace.
 
2) Parameters of namespace templates can effectively never be omitted since names are not re-introduced in extensions.

The ability to omit names for unreferenced parameters within a given scope has a long history in C and C++ and is useful in some cases to prevent unintended references or to allow different names to be used in different contexts.  In particular for this proposal, I can imagine that some parameters of namespace templates would only be needed in some namespace extensions.  The traditional template declaration syntax allows the following:

template<typename, int>
namespace N {}
template<typename T, int>
namespace N {
  void foo(T);
}
template<typename, int I>
namespace N {
  int bar() { return I; }
  template<typename T>  // No possible confusion with an outer 'T'.
  void ft(T) { ... }
}

As proposed the above is ill-formed as you can only have a single initial namespace template, the remainder must be namespace template extensions - in order to maintain a single definition of the library configuration.
I understand that is what is proposed.  What I provided above is intended to illustrate the flexibility trade off that is lost.

If your point is that if we modified the proposal to have namespace template extensions redeclare their template parameters, then this would allow finer-grained name omission - then I don't think this trumps the point above. ie It's more important that we define the library configuration once.
I think the consistency argument with other templates is more important since the single configuration definition goal can be achieved in other ways.

Unrelated to the above, I think the proposal might benefit from some mechanism for a member of the namespace template to opt out of template dependency.  This would avoid having to introduce additional, effectively implementation detail namespaces like in the following example (though, perhaps this approach wouldn't be so bad either):

namespace non_dependent_things_for_N {
  void baz();
}
template<typename>
namespace N {
  using namespace non_dependent_things_for_N;
}

By what mechanism (if any) can you opt out members of class templates from template dependency?
None today.

What is your motivation for wanting to do that?

To avoid redundant template instantiations for entities that are not affected by the namespace template parameters.

Tom.

 
Tom.

On 9/24/19 2:17 AM, Andrew Tomazos via Std-Proposals wrote:
Please find attached DRAFT 1 of:

     Proposal of Namespace Templates

Feedback appreciated.
   -Andrew.