haskell - "overloading"能否通过 FlexibleInstances 返回不同的类型，或者匹配类型类？

Question

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

作为一个简单的测试，这里是一个 AdjusterType 数据类型的例子。它定义了一个 adjust 操作，该操作将根据它包含的是 Integer 还是 Double 来为其值添加不同的数量:

{-# 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

是否可以让 adjust 的 Integer 版本返回 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”是一个与 Integer 不匹配的固定类型变量:

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

Integer 不匹配时它期望的是什么类型...或者没有类型实际工作并且它只是一个奇怪的错误消息？ (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

Is it possible to make the Integer version of adjust return an Integer, and the Double version return a 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

What type was it expecting here that Integer isn't matching...or would no type actually work and it's just a weird error message?

adjust 的返回类型是 forall n 类型。 Num n => n，一种具有单一约束 Num 的多态类型，因此返回具体类型的函数不会进行类型检查。用 fromIntegral 包装你的函数将解决问题，因为 fromIntegral::(Integral a, Num b) => a -> b。

Is there any way to provide an overloaded behavior like above to a type class, or must it always be to a specific instance?

如果您希望该函数对每种不同的类型都有不同的行为，是的，您必须为每种类型添加一个实例。不过，您可以通过限制类的类型参数来添加一些默认行为:

{-# 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