You point is that the (C Int) dictionary has (C String) as a superclass, and (C String) has (C Int) as a superclass. So the two instances are mutually recursive, but that's ok. That is not unreasonable. But it is dangerous. Consider class C [a] => C a Then any dictionary for (C a) would contain a dictionary for (C [a]) which would contain a dictionary for C [[a]], and so on. Haskell is lazy so we might even be able to build this infinite dictionary, but it *is* infinite. It's a bit like the "recursive instance" stuff introduced in "Scrap your boilerplate with class". After 5 mins thought I can't see a reason why this could not be made to work. But it'd take work to do. If you have a compelling application maybe you can open a feature request ticket, describing it, and referring this thread? Has anyone else come across this? Simon From: glasgow-haskell-users-bounces@haskell.org [mailto:glasgow-haskell-users-bounces@haskell.org] On Behalf Of Ryan Trinkle Sent: 20 July 2011 17:37 To: glasgow-haskell-users@haskell.org Subject: Superclass Cycle via Associated Type The following code doesn't compile, but it seems sensible enough to me. Is this a limitation of GHC or is there something I'm missing? class C (A x) => C x where type A x :: * instance C Int where type A Int = String instance C String where type A String = Int The error I get is: SuperclassCycle.hs:1:1: Cycle in class declarations (via superclasses): SuperclassCycle.hs:(1,1)-(2,15): class C (A x) => C x where { type family A x :: *; } Ryan