It's occurred to me that one could write a class C t which is satisfied whenever (A t) or (B t) is satisfied like so: --- data Satisfied type family IsSatisfiable :: Constraint -> Type class A t class B t class C' t ta tb instance A t => C' t Satisfied tb where ... instance B t => C' t ta Satisfied where ... instance (A t, B t) => C' t Satisfied Satisfied where ... class C' t ( IsSatisfiable (A t)) ( IsSatisfiable (B t)) => C t --- We may need overlapping instances (with all the caveats that come with it) but it should be fine otherwise. "IsSatisfiable" here is defined as follows: IsSatisfiable c = Satisfied -- (if c is satisfiable) IsSatisfiable c = IsSatisfiable c -- (if c is not satisfiable) That's all that's needed. And it seems to be a reasonable type function. I note classes are open, so perhaps it could be dangerous to state that a constraint is not satisfiable (because it might be in another part of a program) but simply not reducing if we can't satisfy the constraint locally should be fine I think. At worst we'll get a compile error, but we shouldn't get inconsistent types. Is there anyway to implement this type function, or alternatively an approach which allows this type of "inherit from two classes" idea?