Thanks for the feedback everyone. It appears that I gave a rash and ill-considered solution to a thorny problem, and that what may appear to me to be unnecessary restrictions are, in fact, the very things that allow important parts of the Haskell ecosystem to work. Indeed, it turns out that where necessary, the reflection-extras[1] package gives us enough tools to be able to write local instances easily, so even if we decide in the long run not to support local instances, we have that. Admittedly, the sources that were given in this discussion were publicly available, and if I'd properly searched for prior discussions, I would probably have found them. I apologize for the lack of due diligence. Therefore, I'd like to refocus this discussion on another question I raised. Is there any usecase for open type families that isn't subsumed by closed type families and associated data types? In addition, aren't signatures referring to open type families inherently unsafe due to the lack of control over the instances? Thanks for the thought-provoking discussion, Gesh [1] - https://hackage.haskell.org/package/reflection-extras