如何消除编程语言中对象/类之间的运算符定义的歧义？

Question

我正在设计自己的编程语言（称为 Lima，如果您关心的话，请访问 www.btetrud.com），并且我正在尝试了解如何实现运算符重载。我决定将运算符绑定到特定对象（它是基于原型的语言）。 （它也是一种动态语言，其中“var”就像 javascript 中的“var”——可以保存任何类型值的变量）。

例如，这将是一个带有重新定义的 + 运算符的对象：

x = 
{  int member

   operator + 
    self int[b]:
       ret b+self
    int[a] self:
       ret member+a
}

我希望它的作用相当明显。当 x 既是右操作数又是左操作数时定义该运算符（使用 self 来表示）。

问题是当您有两个对象以像这样的开放式方式定义运算符时该怎么办。例如，在这种情况下你会做什么：

A = 
{ int x
  operator +
   self var[b]:
    ret x+b
}

B = 
{ int x
  operator +
   var[a] self:
    ret x+a
}

a+b   ;; is a's or b's + operator used?

所以这个问题的一个简单答案是“好吧，不要做出模棱两可的定义”，但它并不那么简单。如果您包含一个具有 A 类型对象的模块，然后定义了 B 类型对象，该怎么办？

如何创建一种语言来防止其他对象劫持您想要对操作员执行的操作？

C++ 将运算符重载定义为类的“成员”。 C++ 如何处理这样的二义性？

Answer 1

大多数语言都会优先考虑左边的类。我相信，C++ 根本不允许您重载右侧的运算符。当您定义operator+时，您正在为该类型位于左侧的情况以及右侧的任何内容定义加法。

事实上，如果您允许运算符 + 在类型位于右侧时工作，那就没有意义了。它适用于+，但请考虑-。如果类型 A 以某种方式定义了 operator -，并且我执行了 int x - A y，我不希望调用 A 的 operator -，因为它会计算减法相反！

在具有更广泛的运算符重载规则的Python中，有一个单独的方法相反的方向。例如，当该类型位于左侧时，有一个 __sub__ 方法会重载 - 运算符，而当该类型位于右侧时，有一个 __rsub__ 方法会重载 - 运算符。这类似于在你们的语言中允许“自我”出现在左侧或右侧的功能，但它引入了歧义。

Python 优先考虑左边的内容——这在动态语言中效果更好。如果Python遇到x - y，它首先调用x.__sub__(y)来查看x是否知道如何减去y< /代码>。这可以产生一个结果，或者返回一个特殊值NotImplemented。如果 Python 发现返回了 NotImplemented，它就会尝试其他方法。它调用y.__rsub__(x)，在编程时就知道y位于右侧。如果也返回 NotImplemented，则会引发 TypeError，因为类型与该操作不兼容。

我认为这是动态语言理想的运算符重载策略。

编辑：为了给出一点总结，您遇到了一个不明确的情况，因此您实际上只有三个选择：

• 优先考虑一侧或另一侧（通常是左侧）。这可以防止具有右侧重载的类劫持具有左侧重载的类，但反之则不然。 （这在动态语言中效果最好，因为这些方法可以决定它们是否可以处理它，并动态地遵循另一种语言。）
• 使其成为一个错误（正如 @dave 在他的回答中建议的那样）。如果有不止一种可行的选择，则会出现编译器错误。 （这在静态语言中效果最好，您可以提前捕获这个东西。）
• 只允许最左边的类定义运算符重载，就像在 C++ 中一样。 （那么你的 B 类将是非法的。）

唯一的其他选择是为运算符重载引入复杂的优先级系统，但你又说你想减少认知开销。

Answer 2

我将通过说“呃，不要做出模棱两可的定义”来回答这个问题。

如果我用 C++ 重新创建您的示例（使用函数 f 而不是 + 运算符，使用 int/float 而不是 A/B，但确实没有太大区别）...

template<class t>
void f(int a, t b)
{
    std::cout << "me! me! me!";
}

template<class t>
void f(t a, float b)
{
    std::cout << "no, me!";
}

int main(void)
{
    f(1, 1.0f);
    return 0;
}

...编译器会准确地告诉我：错误 C2668：'f'：对重载函数的模糊调用

如果你创建了一种足够强大的语言，那么总是有可能在其中创建出没有意义的东西。当这种情况发生时，你可以举起双手说“这没有意义”。

Answer 3

在 C++ 中，op b 表示 a.op(b)，因此它是明确的；命令解决了它。在 C++ 中，如果要定义一个左操作数为内置类型的运算符，则该运算符必须是具有两个参数的全局函数，而不是成员；不过，操作数的顺序再次决定了调用哪个方法。定义两个操作数都是内置类型的运算符是非法的。

Answer 4

我建议给定 X + Y，编译器应该同时查找 X.op_plus(Y) 和 Y.op_add_to(X)；每个实现都应该包含一个属性，指示它是否应该是“首选”、“正常”、“后备”实现，并且还可以选择指示它是“通用”的。如果定义了两个实现，并且它们的实现具有不同的优先级（例如“首选”和“正常”），则使用类型来选择首选项。如果两者都定义为具有相同的优先级，并且两者都是“通用”，则倾向于使用 X.op_plus(Y) 形式。如果两者都定义为相同的优先级，并且它们不都是“通用的”，则标记一个错误。

我认为，恕我直言，对重载和转换进行优先级排序的能力对于语言来说是一个非常重要的功能。在两个候选者都会做同样的事情的情况下，语言对不明确的重载进行大声喧哗是没有帮助的，但是在两个可能的重载具有不同含义的情况下，语言应该大声喧哗，每个重载在某些上下文中都是有用的。例如，给定 someFloat==someDouble 或 someDouble==someLong，编译器应该发出警告，因为了解数值是否有用两个值表示的数量匹配，并且了解左侧操作数是否拥有右侧操作数中值的最佳可能表示（针对其类型）也很有用。 Java 和 C# 在这两种情况下都不会标记歧义，而是选择对第一个表达式使用第一个含义，对第二个表达式使用第二个含义，即使任一含义在这两种情况下都可能有用。我建议最好拒绝这种比较，而不是让它们实现不一致的语义。

总的来说，我建议作为一种哲学，良好的语言设计应该让程序员指出什么是重要的，什么是不重要的。如果程序员知道某些“歧义”不是问题，但其他“歧义”是问题，那么让编译器标记后者而不是前者应该很容易。

附录

我简要浏览了您的提案；它看到您期望绑定是完全动态的。我曾经使用过这样的语言（HyperTalk，大约 1988 年），它很“有趣”。例如，考虑“2X”＜1。 “3”＜ 4 < 10＜ “11”＜ “2X”。双重分派有时很有用，但仅限于具有不同语义（例如字符串和数字比较）的运算符重载仅限于对不相交的事物集进行操作的情况。在编译时禁止不明确的操作是一件好事，因为程序员将能够指定其意图。这种模糊性触发运行时错误是一件坏事，因为当错误出现时，程序员可能早已离开了。因此，除了说“不要”之外，我真的无法就如何对运算符进行运行时双重分派提供任何建议，除非在编译时将操作数限制为任何可能的重载始终具有相同语义的组合。

例如，如果您有一个抽象的“不可变数字列表”类型，其中有一个成员报告长度或返回特定索引处的数字，则您可以指定两个实例相等（如果它们具有相同的长度），并且每个实例都为他们的每个索引都返回相同的数字。虽然可以通过检查每个项目来比较任何两个实例的相等性，但如果例如一个实例是“BunchOfZeroes”类型，它只保存一个整数 N=1000000 并且实际上不存储任何项目，那么这可能会效率低下。另一个是“NCopiesOfArray”，其中包含 N=500000 和 {0,0} 作为要复制的数组。如果要比较这些类型的许多实例，可以通过让此类比较调用一个方法来提高效率，该方法在检查整个数组长度后，检查“模板”数组是否包含任何非零元素。如果不是，则可以将其报告为等于零串数组，而无需执行 1,000,000 个元素比较。请注意，通过双重分派调用此类方法不会改变程序的行为 - 它只会使其执行得更快。