Haskell-在另一种中使用一种数据类型

Question

Haskell newbie; I want to be able to declare Val which can be either IntVal, StringVal FloatVal and a List which can be either StringList, IntList, FloatList , whose elements are (correspondingly): StringVal, IntVal and FloatVal . My attempt so far:

data Val = IntVal Int
         | FloatVal Float
         | StringVal String deriving Show

data List = IntList [(IntVal Int)]
          | FloatList [(FloatVal Float)]
          | StringList [(StringVal String)] deriving Show

fails with the error:

    Not in scope: type constructor or class ‘IntVal’
    A data constructor of that name is in scope; did you mean DataKinds?

   data List = IntList [(IntVal Int)]

... (similarly for StringVal, FloatVal..)

what is the right way to achieve this?

PS: declaring List as data List = List [Val] ends up allowing Lists as follows: l = [(IntVal 10),(StringVal "Hello")], which I do not want to allow.

I want each element of list to be a Value of same kind

Answer 1

There is a solution using GADTs. The problem is that IntVal etc are not actually types, they are just constructors (basically functions that also support pattern matching) for the single type Val . So once you have made a Val , the information about which kind of value it is is completely lost at the type level (that is, compile time).

The trick is to tag Val with the type it contains.

data Val a where
    IntVal :: Int -> Val Int
    FloatVal :: Float -> Val Float
    StringVal :: String -> Val String

Then if you have a plain list [Val a] it will already be homogeneous. If you must:

data List = IntList [Val Int]
          | FloatList [Val Float]
          ...

which is slightly different in that it "erases" the type of list, and it can distinguish between an empty list of ints and an empty list of floats, for example. You could also use the same GADT trick with List

data List a where
    IntList :: [Val Int] -> List Int
    FloatList :: [Val Float] -> List Float
    ...

but in that case I think a better design is probably the simpler

newtype List a = List [Val a]

The trade-offs between all these different designs really depends on what you are planning to do with them.