Hi Kaz,

I opted not to answer but rather to post this to comp.std.c++ instead

FWIW The original context on clc++ was. Is there a WG21 proposal
regarding templated namespaces?

regards
Andy Little

Kaz Kylheku wrote:
> kwikius wrote:
> > Victor Bazarov wrote:
> > > kwikius wrote:
> > > > Victor Bazarov wrote:
> > > >> kwikius wrote:
> >
> > > Now, tell me, why can't you add inches to the original struct?
> >
> > Its a library. I can't know all the units a user might want to make use
> > of.
> >
> > > Namespaces have a certain purpose.  Mostly it's to prevent name collisions
> > > and not save typing or grouping for legibility's sake.
> >
> > Sure thats your moral position. OTOH I find it convenient to use a
> > struct for grouping and save typing. Member typedefs are a well known
> > idiom for traits classes for example.
> >
> > A namespace is reopenable which is a useful feature it has over a
> > struct.
>
> So given that it's reopenable, how would you instantiate a namespace
> template? Piece by piece, I suppose: instantiate those parts that are
> visible.
>
> I could see it being a shorthand that could save a lot of repetitive
> template syntax. E.g.
>
> template <typename T> namespace N {
>    int foo(const T &);
> }
>
> Here, uses of the template ID N::foo without template arguments would
> deduce T.
>
> Would this be allowed?
>
> template <typename T> namespace N {
>    void foo(); // no arguments
> }
>
> Here, nothing in the foo type signature depends on T. But foo could
> refer to T things in the namespace.
>
> template <typename T> namespace N {
>    T t;
>    void reset() { T = 0; }
> }
>
> I suppose it's similar to a class with a static member and static
> function:
>
> template <typename T> class C {
> public:
>     static T t;
>     static void reset() { t = 0; }
> };
>
> int C<int>::t;
>
> int main()
> {
>     C<int>::reset();
>     return 0;
> }
>
> Basically, here we are just using the class as a namespace, right? It
> has only static members. We never instantiate the class. Instantiation
> of the template is forced by the definition of the static member.
>
> You have to repeat that definition for every type.
>
> The template namespace could do away with that inconvenience, since the
> namespace could enclose a definition. But then that definition would
> have to be in scope in order to be implicitly instantiated.
>
> Classes are different from namespaces because they separate the
> declaration from the implementation. The entire declaration is visible
> at once. Where it's not visible, the class is not known. A namespace is
> not necessarily all visible at once. Moreover, if a function has a body
> in a class declaration, it's an inline function, which is not true of
> namespaces. A namespace can contain noninline functions.
>
> So there would have to be some special rules for namespace template
> instantiation, such as: 1) instantiate just the necessary parts, from
> whatever part of the templated namespace that is visible, and place the
> instantiations into the translation unit where the reference is made.
> Full function and object definitions are instantiated automatically if
> implicit instantiation takes place. If only declarations are visible,
> they are instantiated, but the definitions are not.
>
> E.g.
>
>
> // File1.cc
>
> template <type T> namespace N {
>    int def_obj = 0;
>
>    extern int decl_obj;
>
>    int def_fun()
>    {
>       return def_obj + decl_obj;
>    }
>
>    int decl_fun();
>
>    int foo;
> }
>
> // ...
>
>   N::def_fun();   // error, ambiguous
>
>   N<int>::def_fun();
>   // requests N<int>::def_fun() instantiation.
>   // also requests N<int>::def_obj instantiation, needed by the body.
>   // also requests N<int>::decl_obj instantiation, but that is just a
> decl
>   // so this won't link unless N<int>::decl_obj is generated somewhere.
>
>   N<int>::decl_fun();
>   // "instantiates" the declaration, but a definition must be
>   // made somewhere.
>
> Now suppose there is a second file:
>
> // File2.cc
>
> template <typename T> namespace N {
>    int decl_obj = 42;
> }
>
> // alternate syntax; must use template arguments on N
>
> template <typename T>
> int N<T>::decl_fun()
> {
>   return decl_obj;
> }
>
> // now we must force instantiation somehow.
>
> // How about explicit request?
> // Generates over all /visible/ N<T>.
> // E.g. does not generate N<int>::foo since
> // N<T>::foo is declared in the other translation unit,
> // which is not known here.
>
> template namespace N<int>;
>
>
>
>
>
>
> >
> > > Try asking in 'comp.std.c++', though.
> >
> > Yes. I was hoping someone might give me an instant answer though!
> >
> > regards
> > Andy Little

---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html                      ]