使用通用约束种类

Question

I can quite validly write a type like this in Haskell:

(t ~ (a, b)) => t

Which in a roundabout way says that t is some pair.

But lets say I want to do this:

type family MyConstraint t :: Constraint

data PairConstraintParam

type instance MyConstraint PairConstraintParam = ...

(t ~ MyConstraint PairConstraintParam) => t

What can I place after the type instance MyConstraint PairConstraintParam =

I tried (a,b) but GHC complained a and b were not on the RHS. It didn't seem to like forall s either.

This may seem like a silly example, there's potentially different constraints for different instances of a class, so hence this roundabout scheme. As the constraints affect and depend on parameters to a method in a class, I can't just place them in the instance head.

Answer 1

I think the equality constraint here doesn't really make sense in that form. ~ should have a sort like k -> k -> Constraint , so t in that context would need to have kind Constraint on the left side, while on the right side you need to end with * ...

However, if I have understood the problem correctly, you need to have existential type for a and b ; so maybe this is what you want:

data PairConstraintParam

data ExistentialPair :: * where
  Exists :: (a, b) -> ExistentialPair

type family MyConstraint (p :: *) (t :: *) :: Constraint where
  MyConstraint PairConstraintParam t = t ~ ExistentialPair

test :: (MyConstraint PairConstraintParam t) => t
test = Exists (1, "hi")

Meaning that "there exist a, b , such that t ~ (a, b) " (up to isomorphism). Of course, you would want to add some more constraints to actually do something useful.

Another variant I can think of is the following:

data ConstraintVariant = PairConstraint

class IsPair p where
instance IsPair (a, b)

type family ConstrainedBy (c :: ConstraintVariant) :: * -> Constraint where
  ConstrainedBy PairConstraint = IsPair

data Thing c t where
  Thing :: (c t) => t -> Thing c t

test2 :: Thing (ConstrainedBy PairConstraint) (Int, String)
test2 = Thing (1, "hi")

Which lets you recover both the constraint and the underlying type.