Unified operators

[joakin]

Just came across this in the rescript compiler rescript-lang/rescript#7057

It seems like this could fit Gleams simple design while improving the usability of operators on predefined types without devolving into polymorphism hell.

Here is a copypasta of the summary there

Rationale

As explained in #6477, we have the "infix explosion" problem. To relax it, I added some specialization to both type inference and primitive inspired by F#

https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/arithmetic-operators#operators-and-type-inference

The idea is, to extend the type inference rules for primitive operations defined in Pervasives to specialize them for predefined types but fall back to int if they cannot be inferred.

let t1 = 1 + 2     // => external \"+": (int, int) => int = "%addint"
let t2 = 1. + 2.   // => external \"+": (float, float) => float = "%addfloat" 
let t3 = "1" + "2" // => external \"+": (string, string) => string = "%string_concat"
let t4 = 1n + 2n   // => external \"+": (bigint, bigint) => bigint = "%addbigint"

let fn1 = (a, b) => a + b        // => external \"+": (int, int) => int = "%addint"
let fn2 = (a: float, b) => a + b // => external \"+": (float, float) => float = "%addfloat" 
let fn3 = (a, b: float) => a + b // => external \"+": (float, float) => float = "%addfloat" 

let inv1 = (a: int, b: float) => a + b  // => external \"+": (int, int) => int = "%addint"
//                                   ^ error: cannot apply float here, expected int

This doesn't make a breaking change since the existing operations are already defined on int.

However, we can introduce them as unified operators for the new codebase. They are still safe, as they are always specialized and not polymorphic.

Specialized operators:

Op Primitive supported types ready?
~+ %plus int, float, bigint ✔️
~- %neg int, float, bigint ✔️
+ %add int, float , bigint, string ✔️
- %sub int, float, bigint ✔️
* %mul int, float, bigint ✔️
/ %div int, float, bigint ✔️
mod %mod int, float, bigint ✔️
% %mod int, float, bigint #7152
** %exp int, float, bigint #7153
& %bitand (formerly %land) int, bigint
| %bitor (formerly %lor) int, bigint
^ %bitxor (formerly %lxor) int, bigint
~ %bitnot (formerly %lnot) int, bigint
<< %lsl int, bigint
>> %asr int, bigint
>>> %lsr int
abs %abs int, float, bigint
min %min int, float, bigint, string
max %max int, float, bigint, string

[lpil]

What problems would this solve for Gleam given it doesn't have the number types problem that ReScript does with its many number types?

[joakin]

As far as I understand Gleam has int and float, and in the JS target int is not bigint due to numbers not being infinite like in the beam.

From what I gather from the f# docs and the rescript PR this kind of change would allow you to get rid of the . operators in most cases. Most languages have "polymorphic" operators for number types, which makes math expressions and some code easier to read, or at least more familiar to people coming from other languages.

Even if Gleam doesn't have that many overloaded operators, there are still a bunch of them with the dot that would be nicer to read usually >. >=. <. <=. +. -. *. /..

It would also allow making the dotless operators to work in the JS target with the bigint types if you chose to, making it more ergonomic for that target to do math stuff with.

Maybe it is not worth the added complexity, up to you. Seemed interesting enough to bring it up! 🙂