I want to construct a cache of properties computed from a reflect.Type.
(For an example application, see http://play.golang.org/p/csLP1bBXJV)

The natural representation for that is map[reflect.Type]properties, but the correctness
of that approach depends on the implementation details of reflect.Type.

The documentation for (reflect.Type).String() says, "To test for equality, compare
the Types directly."  So that gives me some indication that what I'm trying to do
is reasonable.  However, nothing in the package tells me whether I can rely on the fact
that a reflect.Type is hashable.  (In practice, it currently is.)


The other alternatives I've considered are:

    map[struct{ pkgPath, name string }]properties - fails for unnamed types.

    map[uintptr]properties using reflect.Value.UnsafeAddr(t) - seems much worse than relying on hashability.

    map[uintptr]struct{reflect.Type, properties} using a hand-rolled hash function - very, very messy.


Since reflect.Type is hashable in practice anyway, the simplest solution would be to
document that that must be the case.

Obviously that has some drawbacks - it prevents reflect.Type from ever acquiring a
non-hashable field - but that still seems preferable to adding some kind of user-side
hashing or a new method for retrieving a unique ID.

On the other hand, if reflect.Type is not hashable, it would be good to document the
preferred workaround for constructing maps with Types as keys.