Haskell: Using the correct instance for a type wrapped in another type

Question

Say we have the following code, where a couple of types end up being place inside two other types, the outer-most of which is a GADT: ``` {-# LANGUAGE FlexibleInstances, GADTSyntax, GADTs, OverlappingInstances, StandaloneDeriving #-} data SomeType1 = SomeType1 deriving Show data SomeType2 = SomeType2 deriving Show class SomeClass d where instance SomeClass SomeType1 where instance SomeClass SomeType2 where data WrapperType t where WrapperType :: (SomeClass t, Show t) => t -> (WrapperType t) instance Show (WrapperType SomeType1) where show (WrapperType d) = "correct" instance Show (WrapperType t) where show (WrapperType d) = "incorrect" data ListWrap where ListWrap :: [(WrapperType d)] -> ListWrap deriving instance Show ListWrap ``` Now, writing `[WrapperType SomeType1]` gives me what I want: ``` *MyModule> [WrapperType SomeType1] [correct] ``` But as soon as I put it inside `ListWrap` I get the wrong `Show` instance picked to display the contents: ``` *MyModule> ListWrap [WrapperType…

Accepted Answer

If you look at the derived code (with `-ddump-deriv`) then you can see that the derived instance for `ListWrap` is pretty normal looking

```
instance Show ListWrap where
  showsPrec a (ListWrap b) =
    showParen (a >= 11) $ showString "ListWrap " . showsPrec 11 b
```

it's just passing the inner show down to `showsPrec` again. This suggests that the problem is that GHC is erasing the type variable `d` when you wrap it with ListWrap. Indeed, you could also write `ListWrap` as

```
data ListWrap where
  ListWrap :: forall d. [(WrapperType d)] -> ListWrap
```

which emphasizes that this is existentially typed.

We can see the error more directly by deleting the `instance Show (WrapperType t)` and observing GHC's type error

```
/Users/tel/tmp/foo.hs:33:52: Warning:
    No instance for (Show (WrapperType d))
      arising from a use of `showsPrec'
    Possible fix:
      add an instance declaration for (Show (WrapperType d))
    In the second argument of `(.)', namely `showsPrec 11 b'
    In the second argument of `($)', namely
      `showString "ListWrap " . showsPrec 11 b'
    In the expression:
      showParen (a >= 11) $ showString "ListWrap " . showsPrec 11 b
Ok, modules loaded: Main.
```

In other words, it has lost the details about the `d` type and thus cannot unify the specific `instance Show (WrapperType SomeType1)`.

Now you would think that this would imply that keeping that type information around would make the type error go away.

```
data ListWrap d where
  ListWrap :: [(WrapperType d)] -> ListWrap d

> show $ ListWrap [WrapperType SomeType1]
"ListWrap [incorrect]"
```

But it seems like the instance search is going awry as well. The only way I could find to make it work was to turn on `UndecidableInstances` and provide a suggestion for instance derivation.

```
deriving instance Show (WrapperType d) => Show (ListWrap d)
```

after which the example works

```
> show $ ListWrap [WrapperType SomeType1]
"ListWrap [correct]"
```

Haskell: Using the correct instance for a type wrapped in another type

Solution

Problem