Another thought: I think this makes the most sense for == and !=. Maybe it would be better for the other comparison operators to only work for ints and floats (not sure if that's easy to bake in, maybe it could be additional operators for floats, e.g. >.). Depending on how close you intend to match Erlang in this design.

@gfngfn Thoughts on this one? I would find it very handy to have at least polymorphic == and =!, I can change the PR to keep other comparison operators working only for ints if you prefer that.

I’m sorry for not having been available for a while including end/new-year holidays… I will welcome this modification!

I at first preferred that equality functions be defined only for values of the types on which the equality can be computable. For instance, since the equality between function abstractions is not computable in general or even does not make sense from some point of view, I did not like == to be defined on function types. This concept is basically influenced by ML or Haskell where equality functions are used as some sort of witness that signifies the computability of the equality on types (See the signature required for arguments of OCaml’s Hashtbl.Make, the equality type variable in Standard ML, or Haskell’s Eq, for example). Based on such a thought, I provided == only for integers for the time being, and considered that the equality functions should in general be given for each type separately by Float.equal, String.equal, etc.

On second thought, however, I have come to think that it is not necessary to adhere to the idea above. For example, it is cumbersome to define equality functions on tuples for each product type. Some functionality like Haskell’s deriving (Eq) could remedy this, but providing a deriving-like functionality will be a hard job. Making == polymorphic will be much simpler, and thus I would like to do so.

@gfngfn No worries!

Should I revert a part of my change and make <, >, >= and <= work only on Ints?

Oops, I forgot to mention the inequality operators in addition to ==. The same thought as that of == can apply to the inequality ones in my humble opinion.

Should I revert a part of my change and make <, >, >= and <= work only on Ints?

Not at all. I would certainly like to use your change!

By the way, is it more appropriate to compile Sesterl’s == into Erlang’s == than to compile it into =:=? Which do you think is better?

By the way, is it more appropriate to compile Sesterl’s == into Erlang’s == than to compile it into =:=? Which do you think is better?

The difference seems to be only when comparing float vs int (and values that contain them). I didn't think it matters here because I made the operators 'a -> 'a -> bool, not 'a -> 'b -> bool. But now I think maybe it would be better to use =:= and =/=.

But now I think maybe it would be better to use =:= and =/=.

PR updated to do that.