多态数据类型的函数

Question

数据Foo a 定义如下：

data Foo a where
  Foo :: (Typeable a, Show a) => a -> Foo a
  -- perhaps more constructors

instance Show a => Show (Foo a) where
  show (Foo a) = show a

在某些情况下：

fiveFoo :: Foo Int
fiveFoo = Foo 5

falseFoo :: Foo Bool
falseFoo = Foo False

如何定义b -> Foo a中的任何函数，例如：

getFoo :: (Show a, Typeable a) => String -> Foo a
getFoo "five" = fiveFoo
getFoo "false" = falseFoo

这里getFoo 不使用Couldn't match type ‘a’ with ‘Bool’ 进行类型检查。

我在这里唯一感兴趣的是a 属于Show，所以我可以使用getFoo，例如：

main = getLine >>= (print . getFoo)

Answer 1

您可以使用existential types 隐藏数据类型并“携带”一个类型类，例如Show。

请注意，使用像这样的存在类型在 Haskell 中被视为anti-pattern，您可能需要仔细考虑是否真的要这样做：更明确地说明您的类型通常更简单、更好、更少容易出错。

不过，话虽如此，如果您真的想这样做，以下是您将如何在示例中使用存在类型：

{-# LANGUAGE ExistentialQuantification #-}

-- This Foo can only be constructed with instances of Show as its argument.
data Foo = forall a. Show a => Foo a

-- Note that there is no "Show a => ..." context here:
-- Foo itself already carries that constraint around with it.
instance Show Foo where
  show (Foo a) = show a


getFoo :: String -> Foo
getFoo "five" = Foo 5
getFoo "false" = Foo False

main = print . getFoo =<< getLine

演示：

ghci> main
five
5
ghci> main
false
False

Answer 2

也许你想省略 Foo 的类型参数。

data Foo where
  Foo :: (Typeable a, Show a) => a -> Foo

instance Show Foo where
  show (Foo a) = show a

fiveFoo :: Foo
fiveFoo = Foo (5 :: Int) -- (Foo 5) doesn't work because of ambiguity

falseFoo :: Foo
falseFoo = Foo False

getFoo :: String -> Foo
getFoo "five" = fiveFoo
getFoo "false" = falseFoo

print $ getFoo "five" -- prints '5'
print $ getFoo "false" -- prints 'False'

Answer 3

getFoo :: (Show a, Typeable a) => String -> Foo a
getFoo "five" = fiveFoo
getFoo "false" = falseFoo

如果fiveFoo :: Foo Int 和falseFoo :: Foo Bool，您实际上是在要求getFoo 根据您在运行时提供的值返回不同的类型。你不能那样做。在 Haskell 中，所有类型都必须在编译时知道。

如果您只想将事物转换为字符串，为什么不首先将其存储为字符串呢？我猜答案是，这实际上是您要解决的实际问题的简化......（？）