unify operator overloading

a syntax like:

operator def (a: Int) + (b: Int) -> Int:
  ...

could allow us to unify unary and binary operators. We might not want many operators which have not been popular in most programming languages. That said, it is ugly to have some exceptions to rules and it makes things harder to learn.

[johnynek]

so my new proposal is that operator ++ is exactly like concat for instance. It can appear anywhere a binding name can:

operator ++ = foo
[1] ++ [2]

def takeOp(operator /, baz, bar):
  baz / bar

match x:
   operator f: f(1)

etc…

So, operator is a key word that allows us using operator names as binds.

Then next part is that an operator without that prefix f + is parsed as Apply(Operator("+"), f).

The last part is that we will limit operators to avoid : _ , @ ( ) and . so we don’t have any ambiguity with other existing symbols.

I think with #192 it should be pretty easy to implement this (although doing that refactor was a brutal several hours…)

[johnynek]

-x could just be 0-x or neg(x) or x.neg

Simplicity and consistency are major goals here. That will inevitably leave some verbose corners.