你可以在haskell中重载+吗？

Question

虽然我在 Haskell 示例代码中看到了各种奇怪的东西 - 我从未见过运算符 plus 被重载。有什么特别之处吗？

假设我有一个像 Pair 这样的类型，我想要像

这样的类型

 Pair(2,4) + Pair(1,2) = Pair(3,6)

可以在haskell中做到吗？

我只是好奇，因为我知道在 Scala 中以一种相当优雅的方式是可能的。

Answer 1

是的

(+) 是Num 类型类的一部分，每个人似乎都觉得你不能为你的类型定义(*) 等，但我强烈反对。

newtype Pair a b = Pair (a,b)  deriving (Eq,Show) 

我认为Pair a b 会更好，或者我们甚至可以直接使用类型(a,b)，但是...

这很像两个 Monoid、群、环或数学中的任何东西的笛卡尔积，并且有一种定义数字结构的标准方法，使用起来很明智。

instance (Num a,Num b) => Num (Pair a b) where
   Pair (a,b) + Pair (c,d) = Pair (a+c,b+d)
   Pair (a,b) * Pair (c,d) = Pair (a*c,b*d)
   Pair (a,b) - Pair (c,d) = Pair (a-c,b-d)
   abs    (Pair (a,b)) = Pair (abs a,    abs b) 
   signum (Pair (a,b)) = Pair (signum a, signum b) 
   fromInteger i = Pair (fromInteger i, fromInteger i)

现在我们已经以一种明显的方式重载了(+)，但也完全重载了(*) 和所有其他Num 函数，以同样的、显而易见的、熟悉的数学方式为一对。我只是不明白这个问题。事实上，我认为这是一种很好的做法。

*Main> Pair (3,4.0) + Pair (7, 10.5)
Pair (10,14.5)
*Main> Pair (3,4.0) + 1    -- *
Pair (4,5.0)

* - 请注意fromInteger 应用于像1 这样的数字文字，因此在该上下文中将其解释为Pair (1,1.0) :: Pair Integer Double。这也很好用。

Answer 2

Haskell 中的重载只能使用类型类。在这种情况下，(+) 属于 Num 类型类，因此您必须为您的类型提供一个 Num 实例。

但是，Num 还包含其他功能，并且行为良好的实例应该以一致的方式实现所有这些功能，除非您的类型表示某种数字，否则这通常是没有意义的。

因此，除非是这种情况，否则我建议改为定义一个新运算符。例如，

data Pair a b = Pair a b
    deriving Show

infixl 6 |+| -- optional; set same precedence and associativity as +
Pair a b |+| Pair c d = Pair (a+c) (b+d)

然后您可以像使用任何其他运算符一样使用它：

> Pair 2 4 |+| Pair 1 2
Pair 3 6

Answer 3

我将尝试非常直接地回答这个问题，因为您热衷于在重载 (+) 上直接回答“是或否”。答案是肯定的，你可以超载它。有两种方法可以直接重载它，无需任何其他更改，另一种方法是“正确”重载它，这需要为您的数据类型创建一个 Num 实例。正确的方法在其他答案中有详细说明，所以我不会重复它。

编辑：请注意，我不推荐下面讨论的方式，只是记录它。你应该实现 Num 类型类，而不是我在这里写的任何东西。

重载 (+) 的第一种（也是最“错误的”）方法是简单地隐藏 Prelude.+ 函数，并定义您自己的函数 (+)，该函数对您的数据类型进行操作。

import Prelude hiding ((+)) -- hide the autoimport of +
import qualified Prelude as P -- allow us to refer to Prelude functions with a P prefix

data Pair a = Pair (a,a)

(+) :: Num a => Pair a -> Pair a -> Pair a -- redefinition of (+)
(Pair (a,b)) + (Pair (c,d)) = Pair ((P.+) a c,(P.+) b d ) -- using qualified (+) from Prelude

您可以在这里看到，我们必须通过一些扭曲来隐藏 (+) 的常规定义以防止被导入，但我们仍然需要一种方法来引用它，因为它是进行快速机器添加的唯一方法（这是一个原始操作）。

第二种方法（稍微少一点错误）是定义你自己的类型类，它只包含一个你命名的新运算符（+）。您仍然需要隐藏旧的 (+)，以免 Haskell 混淆。

import Prelude hiding ((+))
import qualified Prelude as P

data Pair a = Pair (a,a)

class Addable a where
   (+) :: a -> a -> a

instance Num a => Addable (Pair a) where
    (Pair (a,b)) + (Pair (c,d)) = Pair ((P.+) a c,(P.+) b d )

这比第一个选项好一点，因为它允许您在代码中使用新的 (+) 来处理许多不同的数据类型。

但是这些都不推荐，因为如您所见，访问 Num 类型类中定义的常规 (+) 运算符非常不方便。尽管 haskell 允许您重新定义 (+)，但所有 Prelude 和库都需要原始 (+) 定义。幸运的是，(+) 是在类型类中定义的，所以你可以让 Pair 成为 Num 的一个实例。这可能是最好的选择，也是其他回答者推荐的。

您遇到的问题是 Num 类型类中定义的函数可能太多（+ 是其中之一）。这只是一个历史偶然，现在 Num 的使用如此广泛，现在很难改变。不是将这些功能拆分为每个函数的单独类型类（因此可以单独覆盖它们），而是将它们全部融合在一起。理想情况下，Prelude 应该有一个 Addable 类型类和一个 Subtractable 类型类等，允许您一次为一个运算符定义一个实例，而无需实现 Num 中的所有内容。

尽管如此，事实是，如果您只想为您的 Pair 数据类型编写一个新的 (+)，那么您将面临一场艰苦的战斗。太多的其他 Haskell 代码依赖于 Num 类型类及其当前定义。

如果您正在寻找 Prelude 的蓝天重新实现以试图避免当前的一些错误，您可以查看 Numeric Prelude。您会注意到他们已经将 Prelude 重新实现为一个库，虽然这是一项艰巨的任务，但不需要编译器黑客攻击。

Answer 4

Haskell 中的重载是通过类型类实现的。要获得良好的概述，您可能需要查看this section in Learn You a Haskell。

(+) 运算符是来自Prelude 的Num 类型类的一部分：

class (Eq a, Show a) => Num a where
  (+), (*), (-) :: a -> a -> a
  negate :: a -> a
  ...

因此，如果您希望 + 的定义适用于对，则必须提供一个实例。

如果你有一个类型：

data Pair a = Pair (a, a) deriving (Show, Eq)

那么你可能有这样的定义：

instance Num a => Num (Pair a) where
  Pair (x, y) + Pair (u, v) = Pair (x+u, y+v)
  ...

将其插入ghci 会给我们：

*Main> Pair (1, 2) + Pair (3, 4)
Pair (4,6)

但是，如果您要为 + 提供一个实例，您还应该为该类型类中的所有其他函数提供一个实例，这可能并不总是有意义。

Answer 5

如果你只想要(+) 运算符而不是所有Num 运算符，可能你有一个Monoid 实例，例如Monoid 对的实例是这样的：

class (Monoid a, Monoid b) => Monoid (a, b) where
    mempty = (mempty, mempty)
    (a1, b1) `mappend` (a2, b2) = (a1 `mappend` a2, b1 `mappend` b2)

你可以让(++)成为mappend的别名，然后你可以这样写代码：

(1,2) ++ (3,4) == (4,6)
("hel", "wor") ++ ("lo", "ld") == ("hello", "world")