6.8.2. Undecidable (or recursive) superclasses — Glasgow Haskell Compiler 9.10.0.20240328 User's Guide

# 6.8.2. Undecidable (or recursive) superclasses

`UndecidableSuperClasses`

  Since: | 8.0.1

  Allow all superclass constraints, including those that may result in non-termination of the typechecker.

The language extension `UndecidableSuperClasses` allows much more flexible constraints in superclasses.

A class cannot generally have itself as a superclass. So this is illegal

    class C a => D a where ...
    class D a => C a where ...

GHC implements this test conservatively when type functions, or type variables, are involved. For example

    type family F a :: Constraint
    class F a => C a where ...

GHC will complain about this, because you might later add

    type instance F Int = C Int

and now we’d be in a superclass loop. Here’s an example involving a type variable

    class f (C f) => C f
    class c       => Id c

If we expanded the superclasses of `C Id` we’d get first `Id (C Id)` and thence `C Id` again.

But superclass constraints like these are sometimes useful, and the conservative check is annoying where no actual recursion is involved.

Moreover genuinely-recursive superclasses are sometimes useful. Here’s a real-life example (#10318)

    class (Frac (Frac a) ~ Frac a,
           Fractional (Frac a),
           IntegralDomain (Frac a))
        => IntegralDomain a where
     type Frac a :: Type

Here the superclass cycle does terminate but it’s not entirely straightforward to see that it does.

With the language extension `UndecidableSuperClasses` GHC lifts all restrictions on superclass constraints. If there really is a loop, GHC will only expand it to finite depth.