After getting Dr. Wadler to correct a mistaken belief I had concerning types, I have thought about this some more. The example was: Consider the following (currently illegal in Haskell): ---------------------------------------------------- module One (Problematic) class Problematic a where difficult :: a -> a ---------------------------------------------------- module Two (trouble) imports One (Problematic) instance Problematic Int where difficult n = n+1 trouble n = difficult (difficult n) ---------------------------------------------------- module Three (confused) imports One (Problematic) imports Two (trouble) instance Problematic Int where difficult n = 2*n confused :: Int -> Int confused = trouble ---------------------------------------------------- If the overloading of `trouble' is resolved in module Two, then `confused' adds two to a number, if it is resolved in module Three, then `confused' multiplies a number by four. As it stands, it appears the overloading must be resolved in Module Three; but adding the declaration trouble :: Int -> Int allows the overloading to be resolved in module Two. I am a little confused about the example, still (even though I am willing to expose this ignorance to the world, unlike my type ignorance so graciously corrected). Trouble is not overloaded; there is a single definition for this named value. It would not occur to me to resolve this overloading in any context other than that in which it is declared. This example does not even strike me as confusing, since the value of trouble is not even in module Three, and therefore both intuitively and correctly (to my mind) the intervening instance declaration has nothing to do with things. This may be an extension of the Gofer heresy (note I said extension and not implication), which does all this as staticly as possible. At any rate, resolving overloading at the point of declaration seems to me the natural definition of all this. This explains why I stated (before) that this is yet another version of the "generalized hiding principle" which causes confusion in other, similar cases. I was assuming resolution at point of declaration, which means I was assuming too much (given that it is a point of contention, above). By the way, has anyone suggested modifying the Haskell type resolution to conform to Gofer's, now that we have tried both? If not, I (respectfully) suggest we consider it for 1.3 (or perhaps 2.0, if that is too fundamental a change). Dave Barton [EMAIL PROTECTED]