Loosen requirement for free variables in constraint in class declaration

In a class declaration, Haskell requires all free variables that occur in the constraint to also occur as class parameters. Thus, the following is not allowed:

class MyClass a b | a -> b
instance MyClass Int Bool
instance MyClass a b => MyClass [a] [b]

class MyClass a b => ConvenienceClass a

Note, however, that due to functional dependencies, b is completely determined by a. There is indeed a workaround that allows the above ConvenienceClass to be defined. This requires defining a type family to witness each functional constraint:

type family MyClass_FD_Witness a
class (MyClass_FD_Witness a ~ b) => MyClass a b | a -> b

type instance MyClass_FD_Witness Int = Bool
instance MyClass Int Bool

type instance MyClass_FD_Witness [a] = [MyClass_FD_Witness a]
instance MyClass a b => MyClass [a] [b]

class MyClass a (MyClass_FD_Witness a) => Convenience a

Clearly, whenever there is a functional dependency, it is possible, in the above way, to define a type family witnessing it. However, the resulting definitions are very long and cumbersome, particularly if functional dependencies are composed, or if a dependent variable is used many times in a constraint.

To illustrate this in a real-life example, here is a line of code that I have written in an actual application:

class (MonadCurry fun (MonadArgType fun) m a, 
       Curry (CurryType (MonadArgType fun) String) (MonadArgType fun) String, 
       PrintfType (CurryType (MonadArgType fun) String)) 
    => WPrintf fun m a

What I really meant to write was:

class (MonadCurry fun arg m a, 
       Curry fun' arg String, 
       PrintfType fun') 
    => WPrintf fun m a

The relevant functional dependencies are:

class MonadCurry fun args m res 
    | args m res -> fun, fun -> m args res

class Curry fun args res | args res -> fun

It would be desirable (and, I believe, sound for the above reason) to have a language option that relaxes the requirement on type variables occurring in constraints of class declaration, so that each such type variable must only be reachable from parameters of the class via functional dependencies.