# 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.