Specialization oddities

[This article was originally written for comp.std.c++,
see http://tinyurl.com/39o3wt. Since I got not a single
response I retry it (slightly modified) in this group,
in the hope that the target group is somewhat different]

I always wondered about the following restriction
differences between explicit and partial specialisations
of member templates of class templates.

Consider the following snippets (A) and (B):

(A) Explicit specialization of member template:

template<class T> class A1 {
   template<class U> class B1;
};

template<class T>
template<> // ERROR!
class A1<T>::B1<float>{};

(B) Partial specialization of member template:

template<class T> class A2 {
   template<class U> class B2;
};

template<class T>
template<class U>
class A2<T>::B2<U*>{}; // OK

The rules which forbid (A) but allow (B) are
mainly specified by

1) 14.7.3/18:

"In an explicit specialization declaration for a
member of a class template or a member template
that appears in namespace scope, the member
template and some of its enclosing class templates
may remain unspecialized, except that the
declaration shall not explicitly specialize a class
member template if its enclosing class templates
are not explicitly specialized as well.[..]"

2) 14.5.4.3/2:

"If a member template of a class template is partially
specialized, the member template partial
specializations are member templates of the enclosing
class template;[..]"

-------------------------------------------------------------------

The point I want to discuss is: How come that we
have more restrictions here for explicit specializations
compared to partial specialization?
I would understand that partial specializations of
member templates of class templates are *not*
allowed, because even explicit specializations of
such beasts are *not* allowed. But why vice versa?

I always thought that partial specialization is a more
tricky issue for a compiler than explicit specialization,
simply because I compared it with a method of pattern
matching: It's quite easy to find a special character X
lets say in a string, but more complicated to find
those characters belonging to a set which fulfills
special constraints.
This pictorial explanation was my reasoning why I
accepted that now old compilers (e.g. VC6) could
easily handle an explicit specialization, but refused to
handle a partial specialization of a class template.

1) Is this estimation of complexitity differences between
explicit and partial specialization reasonable or not?
2) If reasonable: How come that the seemingly
"inverse specialization restrictions" are ruled this way in
the Standard? Do I have a wrong view on this or is this
an oversight in the specs?

According to my expectations it's very much simpler
to find a workaround for the current restriction on
explicit specializations (see e.g. my answer in the
thread http://tinyurl.com/38jnbo) than another one
for the hypothetical situation of stronger limitations of
partial specialization. Although I could view at the
current state of affairs from a positive angle, it really
looks so unreasonable (it "sucks") that I tend to think
that this is actual a defect (modulo the conclusion that
my reasoning is simply wrong).

I would appreciate any light (a small candle would be
fine ;-) into this issue.

Thanks and Greetings from Bremen,

Daniel Kr?gler

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]