Question: For example:

`shared_ptr<const shared_ptr<const int> > pp;`

is fairly intimidating... whereas

`const int ^ const ^ pp;`

is instantly reminiscent of the raw pointer equivalent

`const int * const * pp;`

Answer: 
Everyone missed the real reason :)

The nice notation T^ suggests action like a real pointer, which suggests conversions would work the same way. This is not the case. Templates can't support conversions. For example consider

```
T^ --> T const^

```

If you take ^ as \*, this will work. However by default for a template:

```
p<T> --> p<T const>

```

will not work: templates are not covariant in their arguments. It is **not** possible to fix this in C++ AFAIK. You can handle that one conversion, but don't forget the others:

```
derived --> base
T ** --> T const * const*

```

just for example. If you want a real type system it has to be designed my mathematicians not compiler writers.
Very unlikely. C++ is already an intimidatingly complex languages and adding one more feature with potential ambiguities (XOR operator already used) + the fact that Microsoft's CLI version of C++ uses this syntax for managed references -> chances for it happening are close to zero.