Implementing operator overloading in Javascript via a transpiler

Question

One of the problems, for some of us, with Javascript is the lack of operator overloading. This makes writing numeric libraries awkward. For instance, we might want to write something like:

var a = new BigInteger(5);
var b = new BigInteger(10);
var c = a + b;

A possible solution is to transpile a language with operator overloading to Javascript. While feasible -- by replacing operators by function calls and type checks -- the consensus seems to be that this is impossible without killing performance. CoffeeScript has rejected the idea for this reason:

https://github.com/jashkenas/coffee-script/issues/846

But are there really no clever solutions?

For instance, it might be possible hoist type checks out of tight loops or to use some other pipeline where modern JS compilers can optimize away added cruft when the types are numeric.

Ideas?

maybe you could fake static typing with hungarian notation? Your code would blow up spectacularly with no error message if you mix up even one type anywhere, of course. — evan
– evan, Commented Sep 18, 2011 at 18:15
There's an article here re. JS operator overloading... 2ality.com/2011/12/fake-operator-overloading.html — Carl Younger
– Carl Younger, Commented Jun 2, 2014 at 21:18

hugomg · Accepted Answer · 2011-09-18 19:36:25Z

2

Are you really sure you need your big numbers to be useable by old functions written with normal numbers in mind (that use the traditional operators)? If you only need the overloading for your own convenience on functions you cave control over you might be able to get by by using a different, custom operator for bignums.

For example, you could write a compiler to safely convert

var d = a <+> b <*> c;

into

var d = (a).add((b).multiply(c));

or perhaps, if you want automatic conversions...

var d = toBignum(a).add(toBignum(b).multiply(toBignum(c)));

I don't really see you being able to force overloading on an existing implementation without a big hassle. While you could teoretically replace all occurences of + with <+> and so on, current Javascript implementations are not optimized for this and I don't even want to start thinking what would happen if you tried to pass a bignum to one of the native C++ functions that are under the hood.

edit: Not needing to override the base integer class is the important point here (note how in the link you gave, overriding is the first thing the guy wants...). I don't think you will be able to find some kind "magic" optimization though as you have no control over which of the many JS implementations is being used by the client.

If you really don't like a custom operator like <+> the only way to distinguish a normal + operator (you shoudln't meddle with) from a fancy + operator (you want to do bignum stuff with) would be forcing some kind of ad-hoc typing system on top of Javascript, perhaps via comments, custom syntax or (as mentioned in a comment) hungarian notation. Just settling for a custom operator name you hate less would be less hackish, IMO.

edited Sep 18, 2011 at 19:36

answered Sep 18, 2011 at 19:13

hugomg

70.4k30 gold badges168 silver badges257 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Tristan Over a year ago

I'm not concerned about old Javascript functions. And new syntax like <+> is too much of a hack for my taste, since + is what's meant. My hope is that there is some known optimization that goes on in the compiler that can be exploited.

Tobias P. · Accepted Answer · 2011-09-18 18:39:43Z

1

Have a look how Scala implemented Operator Overloading:

They defined that every operator is a method call on an object, so your example would be:

var c = a["+"](b);

If you stop here, you could trivially implement method overload, the function would have to check the values passed by param. If you want to develop a better solution take Odersky's Programing in Scala book and some time to read all their ideas how they've solved the problem (which is a very nice solution!)

answered Sep 18, 2011 at 18:39

Tobias P.

4,6722 gold badges32 silver badges37 bronze badges

1 Comment

hugomg Over a year ago

This only works if you are redesigning the language from scratch (as was the case with Scala). You really can't turn a monomorphic operator into a polymorphic one at a whim :(

Alex Craft · Accepted Answer · 2023-07-11 12:05:22Z

0

One possible option to address performance degradation, could be to use AST transformation and transform every operator to function, like a * b => a.multiply(b).

And for rare cases for performance sensitive code, bottleneck, hint compiler that it shouldn't do that transformation, similar to how CoffeeScript syntax to emit raw JS.

answered Jul 11, 2023 at 12:05

Alex Craft

15.8k14 gold badges92 silver badges166 bronze badges

Collectives™ on Stack Overflow

Implementing operator overloading in Javascript via a transpiler

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related