如何接受僅限於類型類別的參數

Question

代碼如下。我想參數給我的功能，只受到類型的限制。我在它們上調用類型類的函數，然後我可以使用它們。但我正在嘗試這樣做時遇到各種錯誤。

{-# LANGUAGE RankNTypes, TypeSynonymInstances, FlexibleInstances, UndecidableInstances #-} 

class PlotValue a where 
    value :: a -> Double 
instance PlotValue Double where 
    value = id 
--instance PlotValue Int where 
    --value x = fromIntegral x 
instance (Integral a) => PlotValue a where 
    value x = fromIntegral x 
instance PlotValue String where 
    value x = 5 

type Input = (PlotValue a, PlotValue b) => (Maybe a, Maybe b) 

test :: Input -> String 
test (Just a, Just b) = (show $ value a) ++ (show $ value b) 

main = do 
    putStrLn (show (test (Just "strl", Just 6.4))) 

電流誤差（儘管他們改變取決於我試了一下）：

Test5.hs:17:5: 
    Couldn't match expected type `Input' against inferred type `(a, b)' 
    In the pattern: (Just a, Just b) 
    In the definition of `test': 
     test (Just a, Just b) = (show $ value a) ++ (show $ value b) 

Test5.hs:20:30: 
    Couldn't match expected type `a' against inferred type `[Char]' 
     `a' is a rigid type variable bound by 
      the polymorphic type 
      `forall a b. (PlotValue a, PlotValue b) => (Maybe a, Maybe b)' 
      at Test5.hs:20:19 
    In the first argument of `Just', namely `"strl"' 
    In the expression: Just "strl" 
    In the first argument of `test', namely `(Just "strl", Just 6.4)' 

Test5.hs:20:43: 
    Could not deduce (Fractional b) 
     from the context (PlotValue a, PlotValue b) 
     arising from the literal `6.4' at Test5.hs:20:43-45 
    Possible fix: 
     add (Fractional b) to the context of 
     the polymorphic type 
      `forall a b. (PlotValue a, PlotValue b) => (Maybe a, Maybe b)' 
    In the first argument of `Just', namely `6.4' 
    In the expression: Just 6.4 
    In the first argument of `test', namely `(Just "strl", Just 6.4)' 

Answer 1

修正了一些小東西。主要是，正如斯蒂芬所指出的，在類型同義詞下隱藏一個自由類型變量通常是愚蠢和不好的。

{-# LANGUAGE RankNTypes, TypeSynonymInstances, FlexibleInstances, OverlappingInstances, UndecidableInstances #-} 

class PlotValue a where 
    value :: a -> Double 
instance PlotValue Double where 
    value = id 
instance (Integral a) => PlotValue a where 
    value x = fromIntegral x 
instance PlotValue String where 
    value x = 5 

test :: (PlotValue a, PlotValue b) => (Maybe a, Maybe b) -> String 
test (Just a, Just b) = (show $ value a) ++ (show $ value b) 

main = do 
    putStrLn (show (test (Just "strl", Just (6.4::Double)))) 

Answer 2

你真的需要在這裏發明新的類型類嗎？你會想，機器很複雜。這只是包含String，可能會強迫你，但還有其他方法。看起來你只需要從標準數值類型（Int,Integer,Float,Double）到Double的一般映射。有很多方法可以解決這個問題，但d這裏取代你的value？

d :: Real a => a -> Double 
d = fromRational . toRational 

test (Just a, Just b) = show (d a) ++ " " ++ show (d b) 
test (_, _)= "Something's missing" 

-- Main> :t test 
-- test :: (Real a, Real a1) => (Maybe a, Maybe a1) -> [Char] 

double :: Double 
double = 1.0 
float :: Float 
float = 1.0 
int :: Int 
int = 1 
integer :: Integer 
integer = 2 

omnibus = d double * d float * d int/d integer 

jdouble = Just double 
jinteger = Just integer 

goodtest = (jdouble,jinteger) 
badtest = (Nothing, jinteger) 

main = print omnibus >> putStrLn (test goodtest) >> putStrLn (test badtest) 

-- Main> main 
-- 0.5 
-- 1.0 2.0 
-- Something's missing 

如果你想讓它適用於dString，那麼你要正確對待與數字的字符串。好的，一種方法是爲String定義一個Num實例，以創建一個Real實例。只是谷歌「實例數字字符串」，或見例如例如this remark of dons。下面是一個輕浮的例子：

instance Num String where 
    fromInteger = show 
    (+) = (++) 
    x * y = concatMap (const y) x 
    abs = undefined 
    signum = undefined 

instance Real String where toRational = toRational . d . length 
-- Main> fromInteger 500 * "moo " 
-- "moo moo moo " 
-- Main> d (fromInteger 500 * "moo") 
-- 12.0 

stringy = d "string" 
jstringy = Just stringy 
stringytest = (jstringy, jinteger) 

main' = print omnibus >> print stringy >> 
     putStrLn (test goodtest) >> putStrLn (test badtest) >> 
     putStrLn (test stringytest) 
-- Main> main' 
-- 0.5 
-- 5.0 
-- 1.0 2.0 
-- Something's missing 
-- 5.0 2.0 

或者，如果你想與value一個PlotValue型類，何不例如，它分別對四大主導數值類型和String？實際上，您似乎想要的Input類型實際上是類似於(Maybe Double, Maybe Double)。

注意，如果你寫

main = do 
    putStrLn (show (test (Just "strl", Just 6.4))) 

你不需要do，因爲你只需要考慮一個動作;並且您不需要「顯示」，因爲test已經生成String。

Answer 3

對於周圍的（我的眼睛）「奇怪」型代名詞饒人，我會跟GADTs去，就像這樣：

{-# LANGUAGE GADTs #-} -- in addition to the rest 
data Input where 
    Input :: (PlotValue a, PlotValue b) => Maybe a -> Maybe b -> Input 
test :: Input -> String 
test (Input (Just a) (Just b)) = (show $ value a) ++ (show $ value b) 

唯一的開銷是有相匹配，對Input構造。

（關於類和實例設計的問題已經回答了，所以我不會進入他們）