[hmry]

Why have operators at all?

  x = x.add(step.mul(2)).mod(width)

Or in C

  x = imod(iadd(x, imul(step, 2)), width)

vs

  x = (x + 2*step) % width

For me the answer is very simple: Operators make it easier to read the code which makes it easier to spot bugs. It also makes it easier to turn formulas from textbooks into code.

If 50% of the code you're working with is using vectors and matrices, not having operators for those parts is quite annoying.

Note that you can have vector operators without overloading, e.g. Odin has built in vector and matrix types.

But personally I think it's better to give the user more power instead of only letting the compiler author pick which types to allow operators on. Like how Java overloads + but only on the String class. Why do they get to do it, but not me?

[applfanboysbgon]

Woah there, "=" is an operator! I'm afraid you're going to have to go to jail for using an operator in a no-operator zone.

[dnautics]

you actually don't want "operator overloading", you want syntactic sugar. I once proposed just a special operator syntax at the parser level, but it got rejected, but if you REALLY wanted it, you could probably do this in about 100-120 lines as a fork of the zig compiler, just hacking (a <_> b) as a special form to be transformed into @"<_>"(a, b). Requiring parentheses elides questions about operator precedence.

    const @"<+>" = @import("operator_module").plus;

    ...

    const x = (a <+> b);

[fluffybucktsnek]

I think both operator overloading and most operators themselves are syntactic sugars. Operator overloading happens to point towards specific functions, whereas arithmetic integer operators point to compiler intrinsics.

[dnautics]

no, in general overloading is not syntactic sugar, it's a feature of the language (being able to (re-)define a function in place X and have it change the function in unrelated place Y).

[fluffybucktsnek]

I don't see how it is unrelated. If have a custom type `A` with an overload on `+`, it will only affect places I used custom type `A`. If there wasn't operator overloading, I would just have to use a different notation to call the same function, but with possibly worse ergonomics (which is also why I think your solution doesn't really satisfy that, it doesn't read like algebra which is kind of the point). Given that type A is presumed to be custom, I don't see how place Y would be unrelated since it deliberately uses type `A`.

If we include operator overloading for any types, then sure. i32 + i32 might suddenly start meaning something else. But I think that's beyond the scope of what is normally asked by operator overloading.

[dnautics]

one is implementable entirely in the parser. overloading (operator or otherwise) in general is a deeper compiler feature

[benj111]

> x = (x + 2step) % width

Hmm. now. Is operator precedence not an instance of hidden flow control?

You need to know that 2step is done before adding x.

x = (x + (2step)) % width Or x = ( 2step + x) % width

Should be preferred?

Personally I try to bracket all things like this, so that it isn't hidden.

[hmry]

Yes it is control flow, but IMO it's not hidden. It's true that you need to learn that * happens before + (which usually happens in school), but I don't see how that's any different from needing to learn that `and` short-circuits, or that `if` only evaluates its body if the condition is true.

Compare to what people usually call hidden control flow (exceptions, RAII, ...) where you don't know which parts of the code will run unless you read the definitions of the classes and bodies of the functions you use. The syntax at the call site is not enough to tell.

[Decabytes]

> Why have operators at all?

I mean as an avid Lisp fan, I feel like Lisp basically answers the question of how much syntax you need in a langauge. I must admit though, not having to deal with operators precedence is really nice

  (mod (+ x (* 2 step)) width)

[kazinator]

Also, having them if you want is nice:

  1> let ((x 3) (step 2) (width 5)) ((2 * step + x) mod width)
  2

This is TXR Lisp with auto-infix and auto-compound enabled for the REPL:

  2> *listener-auto-infix-p*
  t
  3> *listener-auto-compound-p*
  t

So we can omit the outermost parentheses, and infix syntax is automatically recognized, freely intermixed with regular Lisp, as if the (ifx ...) macro were wrapped around the input.

I've come up with a very good way of handling infix in Lisp, and documented it in a decent amount of detail as well, not just as a manual for the user but anyone wanting to implement something similar.

https://www.nongnu.org/txr/txr-manpage.html#N-BEB6083E

[adrian_b]

Regarding operators, there are 3 distinct problems.

One is to allow the use of simple mathematical symbols as names for functions, instead of allowing only alphanumeric identifiers.

Most programming languages allow only a small fixed set of symbols to be used as "operators", i.e. as function names.

The better solution is to allow any Unicode character from certain categories, e.g. "Sm" and "Po" ("Symbol, math" and "Punctuation, other"), which does not have an already assigned role in the language syntax, to be used as a function name.

Most LISP variants allow the use of various kinds of character symbols as function names.

The second problem is overloading. Overloading must be treated uniformly for any kind of functions, regardless if their names are identifiers or operator symbols, i.e. not like in Java, where forbidding operator overloading was a mistake (that was an overreaction to C++, which allows the overloading of a few "operators" that are not normal functions and whose overloading should not have been allowed, e.g. the comma operator).

The overloading of operators, especially for user-defined data types is something absolutely essential for scientific and technical computing.

The majority of programmers have not been exposed to programs that contain a great amount of computations, so they are accustomed only with simple expressions that contain a few variables.

In scientific and technical computing it is very frequent to have very big expressions, which may contain a large number of operations and variables, where the variables may have various types, like complex numbers, vectors, matrices, complex vectors, complex matrices, or there may be a type system with distinct types for various physical quantities, like voltages, electric currents, capacitances and so on.

Anyone who had to write frequently such big expressions will definitely prefer, both for writing and for reading, to use overloaded operator symbols instead of long function names, which would fill most of the visual space with superfluous characters, obscuring the structure of the big expression.

The third problem is the syntax of function invocation. Most programming languages allow functions whose names are identifiers to use only prefix invocation but for some symbolic operators they allow infix invocation.

Here I also prefer the languages that do not differentiate between functions with alphanumeric names and functions with symbolic names (i.e. operators). There are languages where for any function it may be specified that it must be invoked as an infix operator, if this is desired.

Which is the best between the 3 classic solutions for expression syntax, traditional expressions with infix operators and multi-level precedence rules (like in FORTRAN and ALGOL), expressions with infix operators and a unique precedence rule for all operators (like in APL) and expressions without infix operators (like in LISP), is debatable.

Each of the 3 solutions has advantages and disadvantages, so the choice between them is a matter of personal preferences.