ISO:       WG21/N0492
            ANSI:      94-0105
            Author:    John Max Skaller
            Date:      May 1994
            Reply to:  maxtal@suphys.physics.su.oz.au

"COMPLETION OF TEMPLATE FACILITIES - SUMMARY"
---------------------------------------------

The following items are possible additions to the
template facilities. The list below is intended as a guide,
not a full specification.

1) Namespace Templates.
-----------------------

Example:

  template<class T> namespace X { int x; int f() { return x; } }
  X<int>::x = 1;
  using namespace X<int>;
  cout << f();

  namespace X<int> { void g() {} }
  X<int>::g();

Semantics:

  A namespace template is similar to a class template with only
  static members. It differs in being extensible.


Uses:

  An extensible set of related functions, types and variables can be
  defined or declared in a namespace and parameterised
  using templates. Unlike classes, these do not represent an object.

Restrictions:

  None special to namespace templates.

2) Typedef Templates
--------------------


Example:

  template<class T> typedef X<T> Y<Y>; // make alias

  template<class T, class U> class map { .. }
  template<class T> typedef map<int, T> array<T>; // partial closure


  template<class T, template<class T> class set> class container { ..}
  container<float,array> x; // typedef required for passing templates

Semantics:

  A family of typedefs.

Uses:

  This is an important facility, it is necessary for reordering
  and binding a subset of the formal parameters,
  to produce a form required for passing a template to a template.

  Required for creating an alias for a template.

  Generally useful for aliasing subsets of generic families.

Restrictions:

  Each template formal must appear in both the LHS and RHS of
  the template typedef.


3) Template templates
---------------------

Example:

  template<class T> template<class U> class X;
  X<int><long> xil;

Semantics:

  Equivalent to a single template with concatented formal
  parameter lists.

Uses:

  Stylistic.

4) friend templates
-------------------

Example:

   template<class T>
   class X {


     template<class U> friend class A<U>;  //FRIEND TEMPLATE
     // A<U> is a friend of X<T> for all T and U
     // MANY TO MANY

     friend class B; // single class B is a friend of each X<T>
     // MANY TO ONE

     friend class C<T>; // single class C<T> is a friend of X<T>
     // ONE TO ONE
   }

Semantics:

  Declare a family of friends of a class.

  Note that a friend declaration in a class template
  declares a single friend. Only members are parameterised
  along with the class.


Comment: Loss of encapsualtion is possible in combination
with specialisations, however, the programmer has
explicitly granted access to a family, which is
sometimes necessary. For example:

  template<class T>
  class IntNumber {
    T value;
    template<class U> friend class FloatNumber<U>;
    template<class U> friend class IntNumber;
  public:
    template<class U> void addFloat(const FloatNumber<U>&);
    //member template
  };

  template<class U>
  class FloatNumber {
    T value;
    template<class U> friend class IntNumber<U>;
    template<class U> friend class FloatNumber; // friends
  public:
    template<class U> void addInt(const IntNumber<U>&);
    //member template
  };

All the Int and Float Number classes are friends of each other.
This may be necessary to define pairwise specialisations
of members, in this case the add methods (which are themselves
member templates).