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.

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) { ... }
}

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;
}

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.