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

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

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

我建议，优先考虑重载和转换的能力将恕我直言，对于一种语言来说，这是一个非常重要的特性。在两个候选者都做同样事情的情况下，语言对模棱两可的重载大喊大叫是没有帮助的，但是在两个可能的重载具有不同含义的情况下，语言应该大喊大叫，每个重载在某些情况下都是有用的。例如，给定someFloat==someDouble 或someDouble==someLong，编译器应该发出尖叫声，因为知道两个值表示的数值是否匹配会很有用，而且知道两个值是否匹配也很有用。左侧操作数拥有右侧操作数中值的最佳可能表示形式（针对其类型）。 Java 和 C# 在这两种情况下都不会标记歧义，而是选择对第一个表达式使用第一个含义，而对第二个表达式使用第二个含义，即使这两种含义在任何一种情况下都可能有用。我建议最好拒绝这样的比较，而不是让它们实现不一致的语义。

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

附录

我简要浏览了您的建议；它看到您期望绑定是完全动态的。我使用过这样的语言（HyperTalk，大约 1988 年），它“很有趣”。例如，考虑“2X”

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

Answer 2

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

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

在具有更广泛operator overloading rules 的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 3

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

如果我在 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;
}

...编译器会准确地告诉我：error C2668: 'f' : ambiguous call to overloaded function

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

Answer 4

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