"Illegal polymorphic or qualified type" in instance declaration (System-F style trees)

Question

I'm experimenting with implementing System-F-style data structures in Haskell.

I'll use A <B> to mean application of a term A to a type B just to make it unambiguous (also using capitals for types).

Let's say Tree <T> is the type of binary trees with values of type T. We want to find a type that can act as Tree <T>. There are three constructors:

EmptyTree <T> : (Tree <T>)
Leaf <T> : T → (Tree <T>)
Branch <T> : (Tree <T>) → (Tree <T>) → (Tree <T>)

So, by some cleverness due, I think, to Girard, we can use the following

Tree T = ∀ A. A → (T → A) → (A → A → A) → A

from which

Empty <T>
        = ΛA.λa:A.λf:(T → A).λg:(A → A → A).
            a

Leaf <T> (x:T)
        = ΛA.λa:A.λf:(T → A).λg:(A → A → A).
            f x

Branch <T> (t1:Tree <T>) (t2:Tree <T>)
        = ΛA.λa:A.λf:(T → A).λg:(A → A → A).
            g (t1 <A> a f g) (t2 <A> a f g)

I've found out about the directives needed for these things in Haskell, and I don't think I'm missing any. So in Haskell:

{-# LANGUAGE RankNTypes #-}
type T t = forall a.a -> (t -> a) -> (a -> a -> a) -> a

empty :: T t
empty = \a _ _ -> a
leaf :: t -> T t
leaf x = \_ f _ -> f x
fork :: T t -> T t -> T t
fork t1 t2 = \a f g -> g (t1 a f g) (t2 a f g)

So far, all of this compiles and seems to work. The issue arises when I try to make an instance for Show for my T t type. I've added more directives:

{-# LANGUAGE RankNTypes, TypeSynonymInstances, FlexibleInstances #-}

and a function for printing the tree

displayTree :: Show t => T t -> String
displayTree t = t displayEmpty show displayFork

with appropriate helpers displayEmpty :: String and displayFork :: String -> String -> String. This also compiles and works (up to prettiness). Now if I try to instantiate T t as an instance of Show

instance Show t => Show (T t) where
    show = displayTree

I get the following error when trying to compile:

    Illegal polymorphic or qualified type: T t
    In the instance declaration for 'Show (T t)'

I (think I) understand the need for TypeSynonymInstances and FlexibleInstances and the pragmatic reasons for their existence, but I don't understand why my type T t still can't be declared an instance of Show. Is there a way to do this, and what property of T t means that this is currently problematic in my code?

Answer 1

First, there's a trick which allows you to write some instances for universally quantified types: we remove the forall-s from the instance head, and introduce type equality constraints to whatever types we want to instantiate the variables. In our case:

{-# LANGUAGE RankNTypes, FlexibleInstances, TypeFamilies #-}

instance (a ~ String, Show t) => Show (a -> (t -> a) -> (a -> a -> a) -> a) where
  show t = t "nil" show (\l r -> "(" ++ l ++ ", " ++ r ++ ")")

-- show (fork empty (fork (leaf ()) empty)) == "(nil, ((), nil))"

This works because the instance head implicitly quantifies the variable for us. Of course, if we want to instantiate a polymorphic type to several different types then this trick might not be applicable.

On another note, if GHC allowed polymorphic types in instances, that wouldn't be useful, because GHC doesn't support impredicative instantiation (and the ImpredicativeTypes pragma doesn't actually work). For example, Show (forall a. t) doesn't imply Show [forall a. t], because [forall a. t] isn't valid to begin with. Also, class constraints are kinded in the same system as regular type constructors (except that they return in kind Constraint), so Show (forall a. t) is similarly invalid without impredicative instantiation.