'IsList' instance for GADT - list

Question

I have troubles implementing IsList instance for GADT which represents structure of values inside nested arrays. Here is complete code:
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
import GHC.Exts (IsList (..))
data ValType = TInt | TList
data Val (t :: ValType) where
I :: Int -> Val 'TInt
L :: [Val a] -> Val 'TList
instance Show (Val t) where
show (I i) = "I " ++ show i
show (L a) = show a
instance IsList (Val 'TList) where
type Item (Val 'TList) = forall a . Val a
fromList = L
toList = error "Not implemented!"
I see such error:
GADT.hs:20:10: error:
• Illegal polymorphic type: forall (a :: ValType). Val a
• In the type instance declaration for ‘Item’
In the instance declaration for ‘IsList (Val 'TList)’
|
20 | type Item (Val 'TList) = forall a . Val a
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
I partially understand why I have this error. But I would like know if it's possible to implement IsList instance for Val type?

Answer 1

IsList doesn't seem suited to this since the item type Item l must be determined by the list type l. However, overloading of lists can be pushed further with RebindableSyntax:
{-# LANGUAGE RebindableSyntax, OverloadedLists #-}
fromListN :: _Int -> [Val a] -> Val 'TList
fromListN _ = L
Now [[I 3, I 2]] is sugar for fromListN 1 [fromListN 2 [I 3, I 2]], which reduces to L [L [I 3, I 2]].
We can keep the original behavior using a type class like IsList, but which decouples the item and list types.
class IsList item l where
fromListN :: Int -> [item] -> l
instance IsList (Val a) (Val 'TList) where
fromListN _ = L
instance (item ~ item') => IsList item [item'] where
fromListN _ = id

Answer 2

You are throwing away information by only storing the fact that an L ... contains a list of Val as in its type. If you keep this information around
data ValType = TInt | TList ValType
data Val (t :: ValType) where
I :: Int -> Val 'TInt
L :: [Val a] -> Val ('TList a)
then it becomes possible to implement an instance for the IsList type class from the standard library:
instance IsList (Val ('TList a)) where
type Item (Val ('TList a)) = Val a
fromList = L
toList (L xs) = xs
-- (For completeness, this example requires the OverloadedLists extension)
example :: String
example = show ([I 1, I 2, I 3] :: Val ('TList TInt))
Also note that you can implement toList. Because this toList has type Val ('TList a) -> [Val a] it cannot be passed a non-list, so the above implementation is not partial. You can verify this type yourself by using a type hole: toList = _. You can also verify that an (attempt at) implementation like the following will give a type error: toList (I x) = undefined.
Every item in the list must have the same type (you cannot have mix integers with lists within a single list, for example), but this was also the case for the original code from the question.