函數到多態數據類型

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

也許你想忽略從富類型參數。

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 2

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

如果fiveFoo :: Foo Int和falseFoo :: Foo Bool，你基本上要求getFoo返回不同的類型取決於你在運行時間內提供哪些價值。你不能那樣做。在Haskell中，所有類型的編譯時間必須爲。

如果你只想把事情轉換成字符串，爲什麼不把它作爲一個字符串存儲呢？我猜的答案是，這實際上是對你想解決的實際問題的簡化......（？）

Answer 3

你可以使用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