Brad Abrams picked up on Geoff Appleby's blog entry about Overloads with different return types. Personally, I think they are both wrong 
Let's consider these overloads:
(1) Public function Add(ByVal x as int32, ByVal y as Int32) As Int32
(2) Public function Add(ByVal x as double, ByVal y as double) As double
and
(3) Public function Add(Of T)(ByVal x as T, ByVal y as T) As T
Now if you aren't convinced by (1) and (2) having different return types, then a(3) should hopefully tip the scales for you.
Overloads should, IMO, return different types where appropiate. It however should not be used willy nilly 
Personally, I think much of this discussion stems from people not using Optional parameters (and some lame languages not having full support for them). The usage of Overloads is often to mimic (albeit poorly) optional parameters, and really it should not be abused like that. Instead Optional parameters should be used in those cases as not only does code become easier to maintain, but the "missing" parameters also become more obvious to the caller, and the intellisense list they have to look at becomes a lot simpler. Overloads on the other hand should be held in reserve for such times as different sets of parameters are required (as shown above). Taking Brad's example,
(a) Public Function MyFunc(someParam as String) as MyCustomClass
(b) Public Function MyFunc(someDifferentParam as Type, someParam as String) as MyCustomClass
first, (b) should really be written the other way round,
(b) Public Function MyFunc(someParam as String, someDifferentParam as Type ) as MyCustomClass
next, (a) and (b) should be merged, especially if the current code in (a) just returns a call to (b)
(c) Public Function MyFunc(someParam as String, Optional someDifferentParam as Type =Nothing) as MyCustomClass
the beauty of (c) replacing (a) and (b) 