Re: Delegation and generics craziness
On Mon, 11 Aug 2008, Mark Space wrote:
Tom Anderson wrote:
I may be missing something here, but why is it not just Map<K, V>?
Well, I did that up thread, but I did it quickly and then thought about
it afterwards while I was finishing posting.
What the OP actually has is a constructor that says:
public ExceptionOnDuplicateKeyMap(Map<? extends K, ? extends V> delegate) {
this.delegate = (Map<K,V>) delegate;
}
So to keep that, I had to cast.
Okay, got it.
I think it has to be <K, V>, though. If the delegate map has keys which
are narrower than K (via <? extends K>), then your map lets someone put in
a K, which won't fit in the delegate. If, on the other hand, it has keys
which are wider than K (<? super K>), then if someone does keySet(), you
return a Set<K> which could actually contain things which are not K. Thus,
the key type of the delegate has to be exactly K. The same argument
applies to the values.
This is an example of good old covariance vs contravariance. In this case,
the type parameters are neither, but invariant.
But even though the compiler accepted it, I'm not sure it's correct.
For example, if you have a ExeptionOnDuplicateKeyMap of:
ExceptionOnDuplicateKeyMap<ParentA,ParentB> m //...
you can actually assign some other type with his constructor:
= new ExceptionOnDuplicateKeyMap<ParentA, ParentB>(
new ExceptionOnDuplicateKeyMap<ChildA, ChildB>() );
which doesn't seem kosher to me. (Assume there's a no argument
constructor for the above example to compile. I don't think that
changes anything.) The type of "m" seems like it should be
<ParentA,ParentB> exactly, and not any subclass, because generics don't
inherit. But that's actually what you have, a subclass of ParentA and
ParentB inside "m".
And if someone comes along and does put(k, foo), where k is an instance of
ParentA, but not ChildA? You're hosed.
So I was wondering if the internal (delegate) type of Map<?,?> might
actually be correct and more type safe. Rather than what I posted
initially.
I can't see how <?, ?> is going to solve anything. I guess it would force
you to cast everywhere, which would make all type mismatches immediately
obvious, but it doesn't buy you any static type safety.
Generics are weird enough that figuring out the semantics can be hard
for me even if the syntax is correct. They tend to have tricky corners.
That i certainly agree with!
I think the type of "m" should be a upper bound, because that what you
actually have, but that's not what the syntax says.
It has to be both an upper and a lower bound. That's the key thing (ha
ha).
tom
--
As a matter of fact, it is estimated that 10% of all meth labs explode.