Hey everyone! for context, I have some code where I was seeing how far coerce lets me go to avoid doing wrappers for certain codes, i found i had to write the following (mapping an operation over to its newtyped sibling) ``` -- > :t QRA.wither --- forall a b f . Applicative f => (a -> f (Maybe b)) -> RAList a -> f (RAList b) --- wither :: forall a b f . (Applicative f, (forall c d . Coercible c d => Coercible (f c) (f d)) ) => (a -> f (Maybe b)) -> RAList a -> f (RAList b) wither = \f la -> coerce $ QRA.wither f $ coerce la ``` i'd much rather be able to write ``` wither :: forall a b f . (Applicative f) => (a -> f (Maybe b)) -> RAList a -> f (RAList b) wither = \f la -> coerce $ QRA.wither f $ coerce la ``` this seems like it'd be best done via something like changing the functor class definition to ``` class (forall c d . Coercible c d => Coercible (f c) (f d)) ) => Functor f where .. ``` is there any specific reason why this is not feasible? I cant think of a GADT where this wouldn't be totally safe to do (because unlike in foldable, f is in both the domain and co-domain), but maybe i'm not being imaginative enough? look forward to learning what our obstacles are to making this happen for ghc 9.2 :) -Carter