Hi Haskell Cafe, I'm finding that I really like type families. For instance, the GHC.List.lookup and Data.Map.lookup functions annoy me because their names clash, yet their type are so similar. With type families, I could define a more generic lookup function like this: import Data.Map as MAP import GHC.List as LIST class MapType ma where type Key ma type Item ma lookup :: Key ma -> ma -> Maybe (Item ma) instance (Ord ka) => MapType (MAP.Map ka a) where type Key (MAP.Map ka a) = ka type Item (MAP.Map ka a) = a lookup ka ma = MAP.lookup ka ma instance (Eq ka) => MapType [(ka, a)] where type Key [(ka, a)] = ka type Item [(ka, a)] = a lookup ka ma = LIST.lookup ka ma This lookup function works on both "Map ka a" and "[(ka, a)]" types and I no longer need to qualify my lookup function with the module name. The downside I suppose is that lookup is no longer a function that can be manipulated freely: *Main> let x = lookup *Main> let y = Fx.Data.Map.lookup <interactive>:1:8: Ambiguous type variable `ma' in the constraint: `Fx.Data.Map.MapType ma' arising from a use of `Fx.Data.Map.lookup' at <interactive>:1:8-25 Probable fix: add a type signature that fixes these type variable(s) A shame that. I had been hoping it would be possible to have a generic lookup function that could be used in every way the current collection of various lookup functions can be used. So much nicer if 'y' above could be bound to the Fx.Data.Map.lookup with the same type: *Main> :t Fx.Data.Map.lookup Fx.Data.Map.lookup :: forall ma. (Fx.Data.Map.MapType ma) => Fx.Data.Map.Key ma -> ma -> Maybe (Fx.Data.Map.Item ma) And then have the ambiguity resolve later when 'y' is actually used. -John