可以通过FlexibleInstances“重载”返回不同类型，还是匹配类型类？

Question

我很好奇通过“FlexibleInstances”可以在Haskell的类型类中完成什么样的“重载”。

作为一个简单的测试，这里是AdjusterType数据类型的一个例子。它定义了一个adjust操作，将根据是否包含一个整数或双不同的量添加到它的价值：

{-# LANGUAGE FlexibleInstances #-} 

class Adjustable a where 
    adjust :: a -> Double 

data AdjusterType a = Adjuster a 
    deriving Show 

instance Adjustable (AdjusterType Integer) where 
    adjust (Adjuster a) = fromIntegral (a + 20) 

instance Adjustable (AdjusterType Double) where 
    adjust (Adjuster a) = a + 0.04 

说得多按预期工作：

Prelude> adjust (Adjuster (1000 :: Integer)) 
1020.0 

Prelude> adjust (Adjuster (3 :: Double)) 
3.04 

是否有可能使Integer版本的adjust返回一个Integer，而Double版本返回一个Double？

归纳的adjust签名和所述整数的情况下去除所述fromIntegral不起作用：

class Adjustable a where 
    adjust :: Num n => a -> n 

instance Adjustable (AdjusterType Integer) where 
    adjust (Adjuster a) = a + 20 

这产生一个错误说，“n”是一个刚性的类型的变量不匹配整数：

Couldn't match expected type ‘n’ with actual type ‘Integer’ 
    ‘n’ is a rigid type variable bound by 
     the type signature for adjust :: Num n => AdjusterType Integer -> n 
Relevant bindings include 
    adjust :: AdjusterType Integer -> n 
In the first argument of ‘(+)’, namely ‘a’ 
In the expression: a + 20 

是期待它什么类型这里整数不匹配......或将没有类型的实际工作，它只是一个奇怪的错误消息？（n为小写，所以想必知道这是不是一个数据类型）的实例规格

类型约束也不会出现参加匹配分辨率：

instance Integral i => Adjustable (AdjusterType i) where 
    adjust (Adjuster a) = fromIntegral (a + 20) 

instance RealFloat r => Adjustable (AdjusterType r) where 
    adjust (Adjuster a) = a + 0.04 

因此，这些行为像重复，就好像它们都是Adjustable (AdjusterType x))。约束仅适用于解决方案完成后。

有没有什么办法可以像上面那样向类型类提供重载行为，或者它是否必须总是针对特定的实例？

Answer 1

是否有可能使Integer版本的调整返回一个Integer，而Double版本会返回Double？

可以使Adjustable型类接受两个类型的参数，而不是一个，所以它会知道什么是AdjusterType内：

{-# LANGUAGE MultiParamTypeClasses #-} 

class Adjustable f a where 
    adjust :: f a -> a 

那么情况应该是：

instance Adjustable AdjusterType Int where 
    adjust (Adjuster a) = a + 20 

instance Adjustable AdjusterType Double where 
    adjust (Adjuster a) = a + 0.04 

还有一些结果来自ghci：

> :set +t 

> adjust (Adjuster (100 :: Int)) 
< 120 
< it :: Int 
> adjust (Adjuster (100 :: Double)) 
< 100.04 
< it :: Double 

它在这里期待什么类型的整数不匹配...或者没有类型实际工作，它只是一个奇怪的错误信息？

的adjust返回类型是forall n . Num n => n类型，多态型与单一约束Num的，所以你的函数返回的具体类型将不会打字检查。用fromIntegral包装你的功能将会解决fromIntegral :: (Integral a, Num b) => a -> b以来的问题。

有没有什么办法可以像上面那样为类型类提供重载行为，或者它是否一直是某个特定的实例？

如果您希望函数针对每种不同的类型行为不同，那么您必须为每个类型添加一个实例。您可能会虽然添加了一些默认行为，通过限制类的类型参数：

{-# LANGUAGE DeriveFunctor   #-} 
{-# LANGUAGE MultiParamTypeClasses #-} 

class Extract f where 
    extract :: f a -> a 

class (Extract f, Functor f, Num a) => Adjustable f a where 
    adjust :: f a -> a 
    adjust = extract . fmap (+20) 

data AdjusterType a = Adjuster a 
    deriving (Functor) 

instance Extract AdjusterType where 
    extract (Adjuster a) = a 

instance Adjustable AdjusterType Int where 
-- don't have to write any code here 

Answer 2

使用类型家庭提供的解决方案，特别是相关的数据类型，如下：

{-# LANGUAGE TypeFamilies, FlexibleInstances #-} 

class Adjustable a where 
    type Elem a :: * 
    adjust :: a -> Elem a 


data AdjusterType a = Adjuster a 
    deriving (Show) 


instance Adjustable (AdjusterType Integer) where 
    type Elem (AdjusterType Integer) = Integer 

    adjust (Adjuster a) = a + 20 

instance Adjustable (AdjusterType Double) where 
    type Elem (AdjusterType Double) = Double 

    adjust (Adjuster a) = a + 0.04 

main = do 
    let x = Adjuster 1 :: AdjusterType Integer 
     y = Adjuster 1 :: AdjusterType Double 
    print $ adjust x 
    print $ adjust y 

它编译和输出：

21 
1.04