Hi!
I am aware that the signature of fromBase states that for all 'b' of Base an Extend of type 'a' must be able to be made. Yet, in my case 'a' is a parameterized class 'BaseExpose x' and since the type of Extend is provided (it is a constructor) I think it is acceptable that 'BaseExpose b' is returned as type.
I'm afraid I'm agreeing with the compiler here. When you instantiate this class class Base a => Extend a where fromBase :: Base b => b -> a so that `a` is `BaseExpose x`, then you need to implement fromBase :: Base b => b -> BaseExpose x and your fromBase' has a less general type fromBase' :: Base x => x -> BaseExpose x and that's it. It's the same issue as when you try to typecheck `id :: a -> b`. If it type-checked, you could write (pure) crashing type-correct code. I don't have enough data, but I guess you don't need `fromBase` at all. if `a` is `Base`, then it's also `Extend`, as long as you implement any extra operations. You don't need to coerce it to `Extend` with `fromBase`. BTW, as opposed to object oriented programmers, I think most of us doesn't use the class system for encapsulation, but the module system instead (with all its limitations). If the module system is not enough for you and you are ready for the bleeding edge, the Backpack may have what you need. Having said that, I think we usually err on the side of exposing too much, with all the simplicity and testing ease benefits it provides, rather than on the side of hiding too much. The user of a library is free to encapsulate more strongly in his import lists or by defining an interface module. Only the user knows his use case.