<div dir="ltr"><div>Speaking about well-known symbols for operators, I would rather propose more complex but less ambiguous solution. I think better approach is to provide some advanced mapping object, that implements following mapping:</div><div><br></div><div>(operatorName, ...argumentsTypes) <==> operatorSymbol <==> OperatorDescriptor(operatorName, ...argumentsTypes)</div><div><br></div><div>In code it may look like</div><div><br></div><div>```js</div><div>var symbol_any_plus_any = operators.symbols["_+_"]();</div><div>var symbol_point_plus_point = operators.symbols["_+_"](Point, Point);</div><div>assert(symbol_point_plus_point == operators.symbols["+"](Point, Point));</div><div>var symbol_any_plus_point = operators.symbols["_+_"]("_", Point);</div><div>var symbol_point_plus_any = operators.symbols["_+_"](Point);</div><div>assert(symbol_point_plus_any == operators.symbols["+"](Point, "_"));</div><div>var symbol_this_plus_point = operators.symbols["this+_"](Point);</div><div>var symbol_this_plus_any = operators.symbols["this+_"]("_");</div><div>assert(symbol_this_plus_any == operators.symbols["this+_"]();</div><div>// etc</div><div><br></div><div>var descriptor_any_plus_any = operators.descriptors[symbol_any_plus_any];</div><div>assert(descriptor_any_plus_any.shortName == "+" && descriptor_any_plus_any.fullName == "_+_");</div><div>// etc</div><div>```</div><div><br></div><div>If this (operatorSignature <==> operatorSymbol <==> operatorDescriptor) mapping would be implemented using [WeakMap](<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/WeakMap" target="_blank">https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/WeakMap</a>) then it should also allow types (and appropriate operators signature/descriptor records) to be garbage collected when they are no longer needed (if that situation ever happen).</div><div><br></div><div>Then definition of overloaded operator implementation may look like:</div><div><br></div><div>```js</div><div><br></div><div>var someObj = {</div><div>  /* ... some code ... */</div><div>  [operators.symbols["this+_"](Point)] : function(point) {</div><div>    /* ... implementation of (this+Point) should be here ... */</div><div>  }</div><div>};</div><div><br></div><div>const PointUtil = {</div><div>  /* ... some code ... */</div><div>  [operators.symbols["+"](Point, Point)] : function(point0, point1) {</div><div>    return new Point(point0.x + point1.x, point0.y + point1.y);</div><div>  }</div><div>};</div><div><br></div><div>```</div><div><br></div><div>And of course if we not limit our self in language syntax changes, for me it would be more pleasant if ``operator`` keyword usage was more like ``function`` keyword usage, but with **","** symbol replaced with underlying operation symbol.</div><div>So in code it should be something like:</div><div><br></div><div>```js</div><div><br></div><div>const PointUtil = {</div><div>  /* ... some code ... */</div><div>  operator ((p0:Point) + (p1:Point)) {</div><div>    return new Point(p0.x + p1.x, p0.y + p1.y);</div><div>  }</div><div>};</div><div><br></div><div>const TypelessPointUtil = { </div><div>  /* ... some code ... */</div><div>  operator (p0 + p1) {</div><div>    if ((p0 instanceof Point) && (p1 instanceof Point)) {</div><div>      return new Point(p0.x + p1.x, p0.y + p1.y);</div><div>    } else {</div><div>      // undefined can be used as a marker to delegate operation handling to outer scope in handlers chain</div><div>      // assuming that on the "out-most" level there are always available default JS operators implementations</div><div>      return undefined;</div><div>    };</div><div>  }</div><div>};</div><div><br></div><div>var someObj = {</div><div>  /* ... some code ... */</div><div>  operator ((this) + (point:Point)) {</div><div>    /* ... implementation of (this+Point) should be here ... */</div><div>  },</div><div>  operator ((num:Number) + (this)) {</div><div>    /* ... implementation of (Number+this) should be here ... */</div><div>    // for Number,Boolean,String,Function some exceptional type matching</div><div>    // should be applied - using typeof instead of instanceof operator</div><div>  }</div><div>};</div><div><br></div><div>```</div><div><br></div><div>This approach should cover more transparently left-binary and right-binary operation (on instance level) and also easily separate ``++_`` and ``_++`` operations, like: ``operator(this + x){}`` , ``operator(x + this){}`` , ``operator(++this){}`` , ``operator(this++){}`` , etc. (By the way, as I remember in C++ language operators ``++_`` and ``_++`` are distinguished in definition in some very strange way - by adding extra "dummy" boolean parameter in signature of one of them).</div><div><br></div></div>