type family X (p :: Type) :: Type

class X (p :: Type) (a :: Type) | p -> a

type family Ext (p :: Type) :: Type

data Ast p
  = Add (Ast p) (Ast p)
  | Num Integer
  | Other (Ext p)

class EvalAst p where
  evalAst :: (Ast p -> Integer) -> Ext p -> Integer
    
data Expr
type instance Ext Expr = Void

instance EvalAst Expr where
  evalAst _ x = absurd x

data Mul p = Mul (Ast p) (Ast p)

data MulExpr
type instance Ext MulExpr = Mul MulExpr

instance EvalAst MulExpr where
  evalAst go (Mul x y) = go x * go y
  
eval :: forall p. EvalAst p => Ast p -> Integer
eval = go where
  goAst = evalAst @p go
  go (Add x y) = go x + go y
  go (Num i)   = i
  go (Other x)  = goAst x
  
main :: IO ()
main = do
  print $ eval (Add (Num 20) (Num 10) :: Ast Expr)

class Functor t => ExtF p t a | p -> t a

data AstF p a
  = ValF Int
  | AddF a a
  | OtherF (forall t. ExtF p t a => t a) deriving Functor

Couldn't match type ‘b’ with ‘a’
        arising from a functional dependency between constraints:
          ‘ExtF p t a’ arising from a use of ‘a1’ at <playground>:8:51-57
          ‘ExtF p t b’
            arising from a type expected by the context:
                           forall (t :: * -> *). ExtF p0 t a0 => t a0

class Functor f => ExtF p f | p -> f
data A p a = A (forall t. ExtF p t => t a) deriving Functor

type family ExtF' p :: * -> *
data A p a = A (Functor (ExtF' p) => ExtF' p a) 
deriving instance Functor (A p)